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

Editor to share with you what Spring ways to solve circular dependence, I believe that most people do not know much, so share this article for your reference, I hope you can learn a lot after reading this article, let's go to know it!

Circular dependency is a circular nested reference in N classes. If this circular dependency occurs in the way of new objects in daily development, the program will loop until memory overflow reports.

Spring is if you solve circular dependencies.

The first one: constructor parameter cyclic dependence

The Spring container will place each Bean identifier being created in a "currently created Bean pool", and the Bean identifier will remain in this pool throughout the creation process.

So if you find yourself already in the "currently created Bean pool" during the Bean creation process, you will throw a BeanCurrentlyInCreationException exception to indicate a circular dependency; for the created Bean, it will be cleared from the "currently created Bean pool".

First, let's initialize the three Bean.

Public class StudentA {private StudentB studentB; public void setStudentB (StudentB studentB) {this.studentB = studentB;} public StudentA () {} public StudentA (StudentB studentB) {this.studentB = studentB;}} public class StudentB {private StudentC studentC; public void setStudentC (StudentC studentC) {this.studentC = studentC } public StudentB () {} public StudentB (StudentC studentC) {this.studentC = studentC;}} public class StudentC {private StudentA studentA; public void setStudentA (StudentA studentA) {this.studentA = studentA;} public StudentC () {} public StudentC (StudentA studentA) {this.studentA = studentA;}}

OK, the above are three very basic classes, StudentA has a parameter structure is StudentB. The parametric construct of StudentB is StudentC,StudentC, and the parametric construct is StudentA, which creates a case of circular dependency.

We all hand over these three Bean to Spring management and instantiate them with parameter constructs.

Here is the test class:

Public class Test {public static void main (String [] args) {ApplicationContext context = new ClassPathXmlApplicationContext ("com/zfx/student/applicationContext.xml"); / / System.out.println (context.getBean ("a", StudentA.class));}}

The error message of the execution result is:

Caused by: org.springframework.beans.factory.BeanCurrentlyInCreationException: Error creating bean with name 'a': Requested bean is currently in creation: Is there an unresolvable circular reference?

If you understand the opening sentence, this error should not be surprised. The Spring container first creates a singleton StudentA,StudentA dependency StudentB, and then puts An in the "currently create Bean pool".

At this point, create the StudentB,StudentB dependency StudentC, and then put B in the "currently create Bean pool", and then create the StudentC,StudentC and rely on StudentA.

However, the Student is already in the pool, so an error will be reported. Because the Bean in the pool is not initialized, the error will be relied on, and the initialized Bean will be removed from the pool.

Second: single example of setter mode, default mode

If we want to talk about setter injection, we'd better look at a picture of Bean instantiation in Spring first.

As the first two steps in the figure know: Spring first instantiates the Bean object and then sets the object properties, why does the bean in Spring default singleton? this article suggests that you take a look at it.

Follow Wechat official account: Java technology stack, reply: spring in the background, you can get N of the latest Spring tutorials that I have sorted out, all of which are practical information.

Modify the configuration file to be injected in set mode

Here is the test class:

Public class Test {public static void main (String [] args) {ApplicationContext context = new ClassPathXmlApplicationContext ("com/zfx/student/applicationContext.xml"); System.out.println (context.getBean ("a", StudentA.class));}}

The print result is as follows:

Com.zfx.student.StudentA@1fbfd6

Why don't you report it wrong with set?

Combined with the above figure, Spring first instantiates the Bean object with construction, then Spring puts the instantiated object into a Map, and Spring provides a method to get the instantiated object reference with this unset property.

Combined with our example, when Spring instantiates StudentA, StudentB, and StudentC, it will immediately set the properties of the object. If StudentA relies on StudentB, it will go to Map to retrieve the singleton StudentB object that exists in it, and so on, there will be no problem of looping.

The following is the implementation method in the Spring source code. The following source code is in the DefaultSingletonBeanRegistry.java class in the Bean package of Spring

/ * * Cache of singleton objects: bean name-> bean instance (Map collection of cache singleton instantiated objects) * / private final Map singletonObjects = new ConcurrentHashMap (64); / * * Cache of singleton factories: bean name-> ObjectFactory (singleton factory Bean cache collection) * / private final Map singletonFactories = new HashMap (16); / * Cache of early singleton objects: bean name-> bean instance (early singleton object cache collection) * / private final Map earlySingletonObjects = new HashMap (16) / * * Set of registered singletons, containing the bean names in registration order (collection of instantiated object names for singletons) * / private final Set registeredSingletons = new LinkedHashSet (64); / * * add singleton instances * solve the problem of circular references * Add the given singleton factory for building the specified singleton * if necessary. *

To be called for eager registration of singletons, e.g. To be able to * resolve circular references. * @ param beanName the name of the bean * @ param singletonFactory the factory for the singleton object * / protected void addSingletonFactory (String beanName, ObjectFactory singletonFactory) {Assert.notNull (singletonFactory, "Singleton factory must not be null"); synchronized (this.singletonObjects) {if (! this.singletonObjects.containsKey (beanName)) {this.singletonFactories.put (beanName, singletonFactory); this.earlySingletonObjects.remove (beanName); this.registeredSingletons.add (beanName) }}}

The third kind: setter mode prototype, prototype

Modify the configuration file to:

Scope= "prototype" means that an instance object is created for each request.

The difference between the two is that stateful bean uses Prototype scope, while stateless singleton singleton scope is generally used.

Test case:

Public class Test {public static void main (String [] args) {ApplicationContext context = new ClassPathXmlApplicationContext ("com/zfx/student/applicationContext.xml"); / / an instance of Spring management must be obtained at this time, because now scope= "prototype" instantiates the object System.out.println (context.getBean ("a", StudentA.class)) only when it requests it;}}

Print the results:

Caused by: org.springframework.beans.factory.BeanCurrentlyInCreationException: Error creating bean with name 'a': Requested bean is currently in creation: Is there an unresolvable circular reference?

Why is the prototype pattern wrong?

Dependency injection cannot be done for the "prototype" scope Bean,Spring container because the Bean,Spring container of the "prototype" scope is not cached, so a Bean being created cannot be exposed in advance.

These are all the contents of the article "what are the ways for Spring to solve circular dependencies?" Thank you for reading! I believe we all have a certain understanding, hope to share the content to help you, if you want to learn more knowledge, welcome to follow the industry information channel!

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.