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

This article is about how the Spring source code solves the circular dependency of Bean. The editor thinks it is very practical, so share it with you as a reference and follow the editor to have a look.

First of all, it is important to understand that circular dependencies are supported only for Bean,spring of (singleton) singleton type scop.

Bean with (prototype) prototype type scope is not supported. It creates a new instance each time it is called. When instantiating bean, spring instantiates various attribute dependencies of bean. If TestA TestB is a prototype type and interdependencies, there will be new TestA, new TestB first, and then unlimited nesting of dolls when you go to new TestA.

The instantiation process of interdependence between two singleton testA testB

The Spring container creates a singleton "testA" bean, first creating a bean based on a no-parameter constructor, exposing a "ObjectFactory" to return a bean that is being created in advance, and putting the "testA" identifier into the "currently creating bean pool", and then injecting "testB" into the setter.

The Spring container creates a singleton "testB" bean, which first creates a bean according to the no-parameter constructor, and exposes a "ObjectFactory" to return a bean that is being created in advance, and puts the "testB" identifier into the "currently creating bean pool", and then carries out setter injection "testA". At this time, a "testA" bean being created has been exposed in advance by exposing "ObjectFactory", so it is injected directly, the creation of testB is completed, and the testA is injected. Then complete the creation of the testA.

Implementation in source code

First, take a look at the three most important map in the process of creating a Bean

The following three Map are all from DefaultSingletonBeanRegistry

Map singletonObjects = new ConcurrentHashMap; Map singletonFactory = this.singletonFactories.get (beanName); if (singletonFactory! = null) {singletonObject = singletonFactory.getObject (); this.earlySingletonObjects.put (beanName, singletonObject); this.singletonFactories.remove (beanName);} return singletonObject;}

3.1and 3.2will be obtained repeatedly later. For the first time, because isSingletonCurrentlyInCreation (beanName) returns false, it returns null.

4. The getSingleton method in the DefaultSingletonBeanRegistry class is called to get the ObjectFactory,2.2.

Public Object getSingleton (String beanName, ObjectFactory singletonFactory) {synchronized (this.singletonObjects) {Object singletonObject = this.singletonObjects.get (beanName); if (singletonObject = = null) {beforeSingletonCreation (beanName); boolean newSingleton = false; try {/ / 4.0.1 singletonObject = singletonFactory.getObject (); newSingleton = true;} finally {afterSingletonCreation (beanName);} if (newSingleton) {/ / 4.0.2 addSingleton (beanName, singletonObject);}} return singletonObject }} protected void addSingleton (String beanName, Object singletonObject) {synchronized (this.singletonObjects) {this.singletonObjects.put (beanName, singletonObject); this.singletonFactories.remove (beanName); this.earlySingletonObjects.remove (beanName); this.registeredSingletons.add (beanName);}}

This aspect focuses on the analysis of beforeSingletonCreation, afterSingletonCreation and addSingleton.

4.1 beforeSingletonCreation method and afterSingletonCreation method in DefaultSingletonBeanRegistry

Protected void beforeSingletonCreation (String beanName) {if (! this.inCreationCheckExclusions.contains (beanName) & &! this.singletonsCurrentlyInCreation.add (beanName)) {throw new BeanCurrentlyInCreationException (beanName);}} protected void afterSingletonCreation (String beanName) {if (! this.inCreationCheckExclusions.contains (beanName) & &! this.singletonsCurrentlyInCreation.remove (beanName)) {throw new IllegalStateException ("Singleton'" + beanName + "'isn't currently in creation");}}

Important: the purpose of these two methods is to add and delete the currently created Bean for the set collection of singletonsCurrentlyInCreation, laying the groundwork for subsequent processing. The addSingleton method is mainly for the maintenance of Bean cache map.

4.2 now go back to the 4.0.1 method in step 4, singletonObject = singletonFactory.getObject (). This line of code is where the instance object is actually obtained. How did singletonFactory get it? this goes back to step 2.3 in step 2. A singletonFactory of type ObjectFactory is returned through the createBean method. Here's how createBean creates Bean:

Protected Object createBean (String beanName, RootBeanDefinition mbd, @ Nullable Object [] args) throws BeanCreationException {try {Object beanInstance = doCreateBean (beanName, mbdToUse, args); return beanInstance }} / / anyone who has seen some spring source code should understand that what spring really does starts with doXXX, and here is no exception / / I believe everyone already understands that the real creation of Bean is implemented by the doCreateBean method. Let's continue to analyze the method protected Object doCreateBean (String beanName, RootBeanDefinition mbd, @ Nullable Object [] args) throws BeanCreationException {BeanWrapper instanceWrapper = null; if (instanceWrapper = = null) {instanceWrapper = createBeanInstance (beanName, mbd, args). } Object bean = instanceWrapper.getWrappedInstance (); boolean earlySingletonExposure = (mbd.isSingleton () & & this.allowCircularReferences & & isSingletonCurrentlyInCreation (beanName)); if (earlySingletonExposure) {addSingletonFactory (beanName, ()-> getEarlyBeanReference (beanName, mbd, bean));} Object exposedObject = bean; try {/ / 4.3 populate Bean's attributes, depending on bean is the populateBean (beanName, mbd, instanceWrapper) initialized here; exposedObject = initializeBean (beanName, exposedObject, mbd) } if (earlySingletonExposure) {/ / 4.4get the instance in the cache again. Note that the first is earlySingletonObjects map, the second is singletonFactories map getting Object earlySingletonReference = getSingleton (beanName, false); if (earlySingletonReference! = null) {if (exposedObject = = bean) {exposedObject = earlySingletonReference;}} return exposedObject;} / / isSingletonCurrentlyInCreation method public boolean isSingletonCurrentlyInCreation (String beanName) {return this.singletonsCurrentlyInCreation.contains (beanName) } / / addSingletonFactoryprotected 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);}} important process carding

1.doCreateBean is mainly divided into two parts, the first part through instanceWrapper to get an example of BeanFactory, internally implemented by reflection, here we do not do much analysis, variable earlySingletonExposure, it is obtained from three parts, the first two are easy to understand, the third part is a collection of singletonsCurrentlyInCreation that we have laid the groundwork in 4.1. Since it has been set up in 4.1, earlySingletonExposure must be true, so addSingletonFacatory assigns a value to singletonFactories map and completes the mapping of beanName-> ObjectFactory

In the 2.populateBean method, the injection of the Bean dependency attribute is completed, so when the code reaches 4.3, the creation of the testA stops, goes back to the first step to get the testB, then creates the testB, and finally goes to 4.3 again, completing the mapping of the ObjectFactory of testA and testB, putting them into the singletonFactories map cache.

3. When you create a testB, you will initialize the dependency testA of testB again. At this time, you will go to the first step to get it. When you go to 2.1again, because the ObjectFactory of testA is valuable, you can get the singletonObject of testA through it. At this time, you put the instance of testA into earlySingletonObjects, but the testA instance is incomplete at this time, and the initialization of attribute testB dependency has not been completed yet. Finally, return the singletonObject reference of testA, complete the initialization of testB's dependency testA, and then go to 4.4 to obtain the cache of testB, which is still not available. Then go back to 4.0.2, add testB to singletonObjects map cache, and remove the cache of testB in singletonFactories. Here, testB actually has no value in earlySingletonObjects. Of course, it will also be removed, because the value has already been obtained in singletonObjects, so the other two auxiliary map do not need to retain data.

4. After initializing the testB and putting it in the singletonObjects cache, go on and go back to 4.3. continue to create the testA and continue to obtain the testA from the cache at 4.4. Because the testA has been put into the earlySingletonObjects map before, the testA instance can be obtained directly.

5. If you keep going, you will come to 4.0.2 again, but this time it is for testA. The addSingleton method will put the instance of testA into the singletonObjects map cache, remove the testA of singletonFactories and earlySingletonObjects map cache at the same time, and instantiate testA and testB.

Thank you for reading! On "Spring source code is how to solve the circular dependence of Bean" this article is shared here, I hope the above content can be of some help to you, so that you can learn more knowledge, if you think the article is good, you can share it out for more people to see it!

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.