Shulou(Shulou.com)06/02 Report--

This article mainly introduces "how to solve circular dependence by Spring". In daily operation, I believe many people have doubts about how to solve the problem of circular dependence by Spring. The editor consulted all kinds of materials and sorted out simple and easy-to-use operation methods. I hope it will be helpful for you to answer the doubts of "how to solve circular dependence by Spring". Next, please follow the editor to study!

Introduction

First, let's talk about what circular dependency is. Spring needs to inject B when initializing An and A when initializing B. after Spring starts, both Bean have to be initialized.

There are two scenarios for Spring's circular dependencies

Cyclic dependence of constructor

Circular dependency of attributes

The circular dependency of the constructor, you can use the @ Lazy annotation in the constructor to delay loading. When injecting dependencies, you inject the proxy object first, and then create the object to complete the injection when it is used for the first time

The circular dependency of attributes is mainly solved by three map.

Cyclic dependence of constructor

@ Component public class ConstructorA {private ConstructorB constructorB; @ Autowired public ConstructorA (ConstructorB constructorB) {this.constructorB = constructorB;}} @ Component public class ConstructorB {private ConstructorA constructorA; @ Autowired public ConstructorB (ConstructorA constructorA) {this.constructorA = constructorA;}} @ Configuration @ ComponentScan ("com.javashitang.dependency.constructor") public class ConstructorConfig {} public class ConstructorMain {public static void main (String [] args) {AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext (ConstructorConfig.class) System.out.println (context.getBean (ConstructorA.class)); System.out.println (context.getBean (ConstructorB.class));}}

When you run ConstructorMain's main method, an exception is reported on the first line, indicating that Spring cannot initialize all Bean, that is, the above form of circular dependency Spring cannot be solved.

We can solve the problem by adding @ Lazy annotations to the parameters of the ConstructorA or ConstructorB constructor

@ Autowired public ConstructorB (@ Lazy ConstructorA constructorA) {this.constructorA = constructorA;}

Because we are mainly concerned with the circular dependency of attributes, the circular dependency of the constructor is not analyzed too much.

Circular dependency of attributes

First demonstrate what is the circular dependency of an attribute.

@ Component public class FieldA {@ Autowired private FieldB fieldB;} @ Component public class FieldB {@ Autowired private FieldA fieldA;} @ Configuration @ ComponentScan ("com.javashitang.dependency.field") public class FieldConfig {} public class FieldMain {public static void main (String [] args) {AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext (FieldConfig.class); / / com.javashitang.dependency.field.FieldA@3aa9e816 System.out.println (context.getBean (FieldA.class)) / / com.javashitang.dependency.field.FieldB@17d99928 System.out.println (context.getBean (FieldB.class));}}

The Spring container starts normally, and the Bean of FieldA and FieldB can be obtained.

The circular dependency of attributes is often asked in interviews. Generally speaking, it's not complicated, but it involves the initialization process of Spring Bean, so it feels complicated. I'll write a demo to demonstrate the whole process.

The initialization process of Spring's Bean is actually quite complicated. In order to facilitate the understanding of Demo, I divided the initialization process of Spring Bean into two parts.

The instantiation process of bean, that is, calling the constructor to create the object

The initialization process of bean, that is, populating various properties of bean

When the initialization process of bean is complete, the bean can be created normally.

Let's start to write the Demo,ObjectFactory interface to produce Bean, just like the interface defined in Spring.

Public interface ObjectFactory {T getObject ();} public class DependencyDemo {/ / initialized Bean private final Map singletonObjects = new ConcurrentHashMap; / / the factory corresponding to the Bean being initialized, when the object has been instantiated private final Map fieldClass = field.getType (); field.set (object, getBean (fieldClass));} / / initialized singletonObjects.put (beanName, object); singletonsCurrentlyInCreation.remove (beanName); return (T) object } / * allowEarlyReference parameter means whether Spring allows circular dependencies. The default is true * so when allowEarlyReference is set to false, when the project has circular dependencies, it will fail * / public Object getSingleton (String beanName, boolean allowEarlyReference) {Object singletonObject = this.singletonObjects.get (beanName) If (singletonObject = = null & & isSingletonCurrentlyInCreation (beanName)) {synchronized (this.singletonObjects) {if (singletonObject = = null & & allowEarlyReference) {ObjectFactory singletonFactory = this.singletonFactories.get (beanName); if (singletonFactory! = null) {singletonObject = singletonFactory.getObject ();} return singletonObject } / * determine whether bean is being initialized * / public boolean isSingletonCurrentlyInCreation (String beanName) {return this.singletonsCurrentlyInCreation.contains (beanName);}}

Test a wave

Public static void main (String [] args) throws Exception {DependencyDemo dependencyDemo = new DependencyDemo (); / / pretended scanned object Class [] classes = {A.class, B.class}; / / pretended project initialization of all bean for (Class aClass: classes) {dependencyDemo.getBean (aClass);} / true System.out.println (dependencyDemo.getBean (B.class). GetA () = dependencyDemo.getBean (A.class)) / / true System.out.println (dependencyDemo.getBean (A.class) .getB () = = dependencyDemo.getBean (B.class));}

Isn't it easy? We only used two map to solve the circular dependency of Spring.

Circular dependencies can be handled with two Map, so why does Spring use three Map?

The reason is also simple: when we get the corresponding ObjectFactory from singletonFactories based on BeanName, and then call the method getObject () to return the corresponding Bean. In our example, the implementation of ObjectFactory is very simple, that is, the instantiated object is returned directly, but it is not so simple in Spring. The execution process is more complicated. In order to avoid getting ObjectFactory and then calling getObject () every time, we just cache the object created by ObjectFactory directly, which can improve the efficiency.

For example, A depends on B and C, B and C also depend on A, if there is no cache, then both B and C will call the getObject () method of the corresponding ObjectFactory of A. If you do the cache, you only need to call B or C once.

Knowing the idea, let's change the above code and add a cache.

Public class DependencyDemo {/ / initialized Bean private final Map singletonObjects = new ConcurrentHashMap; / / the factory corresponding to the Bean being initialized, when the object has been instantiated private final Map fieldClass = field.getType (); field.set (object, getBean (fieldClass));} singletonObjects.put (beanName, object); singletonsCurrentlyInCreation.remove (beanName); earlySingletonObjects.remove (beanName); return (T) object } / * allowEarlyReference parameter means whether Spring allows circular dependencies. Default is true * / public Object getSingleton (String beanName, boolean allowEarlyReference) {Object singletonObject = this.singletonObjects.get (beanName); if (singletonObject = = null & & isSingletonCurrentlyInCreation (beanName)) {synchronized (this.singletonObjects) {singletonObject = this.earlySingletonObjects.get (beanName); if (singletonObject = = null & allowEarlyReference) {ObjectFactory singletonFactory = this.singletonFactories.get (beanName) If (singletonFactory! = null) {singletonObject = singletonFactory.getObject (); this.earlySingletonObjects.put (beanName, singletonObject); this.singletonFactories.remove (beanName);} return singletonObject;}}

The implementation of getSingleton we wrote is exactly the same as that of org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#getSingleton (java.lang.String, boolean). This method will be mentioned in almost all articles that analyze Spring circular dependencies, this time you understand how it works.

At this point, the study of "how to solve circular dependency by Spring" is over. I hope to be able to solve your doubts. The collocation of theory and practice can better help you learn, go and try it! If you want to continue to learn more related knowledge, please continue to follow the website, the editor will continue to work hard to bring you more practical articles!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.