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

This article is about how to use spring source code to analyze spring bean circular dependency, the editor thinks it is very practical, so I share it with you to learn. I hope you can get something after reading this article.

Spring bean circular dependency

Spring bean circular dependency should be a difficult piece of knowledge in the spring source code. Let's analyze it with the code sequence diagram to see how spring elegantly handles spring bean's circular dependency.

What is the circular dependency of bean

We all know spring's IOC and DI, which can help us create objects and help us automatically inject objects that need to be managed by spring. Then there will be a situation where you need to rely on B in object A, and depend on An in object B, of course, there can be more object dependencies, and a closed loop is formed between them, as shown in the figure below.

When spring initializes bean A, it is found that bean A depends on bean B, then de-instantiates bean B, and when instantiating bean B, it finds that bean B depends on bean A. this falls into an infinite loop and may eventually lead to memory overflow. Of course, this is just one of our ideas, and spring certainly won't let that happen. Spring provides an elegant way to solve the problem of circular dependency between bean by introducing a three-level caching mechanism. In addition, not all circular dependencies can be solved by spring, and spring cannot be solved by the following two ways

Dependencies are implemented through constructors.

Scope is prototype, that is, the case of the prototype

Before we officially begin, let's talk about the three-level cache and definition of spring. Let's take a look at how it is defined in the code.

/ * Cache of singleton objects: bean name to bean instance. * / private final Map singletonObjects = new ConcurrentHashMap; / * * Cache of singleton factories: bean name to ObjectFactory. * / private final Map test code

Use ClassPathXmlApplicationContext to initialize bean

Public class BeanTest {public static void main (String [] args) {ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext ("classpath:applicationContext.xml"); Object beanA = applicationContext.getBean ("beanA"); System.out.println (beanA);}} source code analysis cyclic dependency sequence diagram

Before analyzing the source code, let's take a look at the timing diagram of spring circular dependency. for later analysis of the source code, it will be of great help that the original file can be downloaded here.

ClassPathXmlApplicationContext.java

We called the parameterized constructor of ClassPathXmlApplicationContext and finally called the following construct. Three things have been accomplished here:

Super (parent) initializes the parent class

SetConfigLocations (configLocations) sets local configuration information

Refresh () completes initialization of the spring container

Here we focus on the third method, because the initialization of spring bean is done here.

Public ClassPathXmlApplicationContext (String [] configLocations, boolean refresh, @ Nullable ApplicationContext parent) throws BeansException {/ / initialize the parent class super (parent); / / set the local configuration information setConfigLocations (configLocations) / / initialize the Spring container if (refresh) {refresh ();}} AbstractApplicationContext.java

As mentioned above, the refresh method initializes the spring container, so this is a core method. This includes initialization operations for beanFactory and bean. Because there are many methods, each method is annotated. We will not repeat them one by one. Here we focus on finishBeanFactoryInitialization (), which does a few operations.

Initialize all remaining non-lazily loaded singleton bean

Initialize the creation of a singleton Bean instance with non-lazy loading mode (no properties are set)

Fill attribute

Initialize method calls (such as calling afterPropertiesSet methods, init-method methods)

Call BeanPostProcessor (post processor) to postprocess the instance bean, so let's take a look at this method next.

Public void refresh () throws BeansException, IllegalStateException {/ / object lock synchronized (this.startupShutdownMonitor) {/ / pre-processing before refresh, indicating what you need to do before you actually do the refresh operation: prepareRefresh (); / * get the BeanFactory The default implementation is that DefaultListableBeanFactory loads BeanDefition and registers to BeanDefitionRegistry * / ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory (); / / preparation of BeanFactory (BeanFactory makes some settings, such as context's classloader, etc.) prepareBeanFactory (beanFactory) Try {/ / BeanFactory post-processing work postProcessBeanFactory (beanFactory) after the completion of the preparation work; / / instantiate the Bean of the BeanFactoryPostProcessor interface and call the interface method invokeBeanFactoryPostProcessors (beanFactory) / / register BeanPostProcessor (post processor of Bean), execute registerBeanPostProcessors (beanFactory) before and after creating bean, etc. / / initialize MessageSource component (do internationalization function) Message binding, message parsing); initMessageSource (); / initialize event dispatcher initApplicationEventMulticaster (); / / subclass overrides this method to customize the logic when the container is refreshed For example, create a WEB server such as Tomcat,Jetty onRefresh (); / / register the listener of the application. Is to register the listener bean registerListeners () that implements the ApplicationListener interface; / * Instantiate all remaining (non-lazy-init) singletons. Initialize all remaining non-lazy load singleton bean initialization to create a non-lazy load singleton Bean instance (no property is set) populate property initialization method calls (such as calling the afterPropertiesSet method, Init-method method) call BeanPostProcessor (post processor) to perform post processing on instance bean * / finishBeanFactoryInitialization (beanFactory) / / complete the refresh of context. It mainly calls the onRefresh () method of LifecycleProcessor and publishes the event (ContextRefreshedEvent) finishRefresh ();} catch (BeansException ex) {destroyBeans (); cancelRefresh (ex); throw ex } finally {resetCommonCaches ();}

At the end of this method, the preInstantiateSingletons () method of beanFactory is called, and then the preInstantiateSingletons () method is tracked.

Protected void finishBeanFactoryInitialization (ConfigurableListableBeanFactory beanFactory) {if (beanFactory.containsBean (CONVERSION_SERVICE_BEAN_NAME) & & beanFactory.isTypeMatch (CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {beanFactory.setConversionService (beanFactory.getBean (CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) } if (! beanFactory.hasEmbeddedValueResolver ()) {beanFactory.addEmbeddedValueResolver (strVal-> getEnvironment (). ResolvePlaceholders (strVal));} / / Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early. String [] weaverAwareNames = beanFactory.getBeanNamesForType (LoadTimeWeaverAware.class, false, false); for (String weaverAwareName: weaverAwareNames) {getBean (weaverAwareName);} / / Stop using the temporary ClassLoader for type matching. BeanFactory.setTempClassLoader (null); / / Allow for caching all bean definition metadata, not expecting further changes. BeanFactory.freezeConfiguration (); / / Instantiate all remaining (non-lazy-init) singletons. / / instantiate all immediately loaded singleton bean beanFactory.preInstantiateSingletons ();} DefaultListableBeanFactory.java

PreInstantiateSingletons () gets the name of all the bean that needs to be managed by spring, and then needs to traverse to create the bean. The core method is getBean (beanName), which initializes the bean according to the obtained bean name, so next we track the getBean (beanName).

Public void preInstantiateSingletons () throws BeansException {if (logger.isTraceEnabled ()) {logger.trace ("Pre-instantiating singletons in" + this);} / / get the names of all bean List beanNames = new ArrayList (this.beanDefinitionNames) / / trigger initialization of all non-delayed load singleton bean. The main step is getBean for (String beanName: beanNames) {RootBeanDefinition bd = getMergedLocalBeanDefinition (beanName). If (! bd.isAbstract () & & bd.isSingleton () & &! bd.isLazyInit ()) {if (isFactoryBean (beanName)) {Object bean = getBean (FACTORY_BEAN_PREFIX + beanName) / / if it is FactoryBean, add & if (bean instanceof FactoryBean) {final FactoryBean factory = (FactoryBean) bean; boolean isEagerInit If (System.getSecurityManager ()! = null & & factory instanceof SmartFactoryBean) {isEagerInit = AccessController.doPrivileged ((PrivilegedAction)) ((SmartFactoryBean) factory):: isEagerInit GetAccessControlContext () } else {isEagerInit = (factory instanceof SmartFactoryBean & & ((SmartFactoryBean) factory) .isEagerInit () } if (isEagerInit) {getBean (beanName) } else {/ / instantiate the current bean GetBean (beanName) } for (String beanName: beanNames) {Object singletonInstance = getSingleton (beanName); if (singletonInstance instanceof SmartInitializingSingleton) {final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance If (System.getSecurityManager ()! = null) {AccessController.doPrivileged ((PrivilegedAction) ()-> {smartSingleton.afterSingletonsInstantiated (); return null }, getAccessControlContext ();} else {smartSingleton.afterSingletonsInstantiated () }} start processing circular dependencies

Part of the source code has been deleted for ease of reading.

GetBean () is called in the above method, and getBean () calls doGetBean (). After laying the groundwork, it is only here that the real source logic related to circular dependency begins. We talked about the three-level cache of spring. Here, the getSingleton (beanName) method is called first according to bean name, and its overloaded method is called in the getSingleton (beanName) method. Let's assume that the bean we want to find is beanA,spring first find the beanA we want from the first-level cache. If we can't find it, go to the second-level cache. We can't find the second-level cache to get it from the first-level cache. Of course, since it has just been loaded, it is not available in the third-tier cache. So the code continues to execute.

Public Object getBean (String name) throws BeansException {return doGetBean (name, null, null, false);} protected T doGetBean (final String name, @ Nullable final Class requiredType, @ Nullable final Object [] args, boolean typeCheckOnly) throws BeansException {/ / parse beanName if it starts with & and removes the &, if the alias gets the real name final String beanName = transformedBeanName (name) / / attempt to get bean Object sharedInstance = getSingleton (beanName) from the primary, secondary and tertiary cache; / / return if (sharedInstance! = null & & args = = null) {/ / processing for FactoryBean bean = getObjectForBeanInstance (sharedInstance, name, beanName, null) if it already exists } else {/ / if it is of type prototype and circular dependency is enabled, an exception if (isPrototypeCurrentlyInCreation (beanName)) {throw new BeanCurrentlyInCreationException (beanName) is thrown } try {final RootBeanDefinition mbd = getMergedLocalBeanDefinition (beanName) / / create a singleton bean if (mbd.isSingleton ()) {sharedInstance = getSingleton (beanName) ()-> {try {/ / create bean return createBean (beanName, mbd, args) } catch (BeansException ex) {destroySingleton (beanName); throw ex ); bean = getObjectForBeanInstance (sharedInstance, name, beanName, mbd) }} return (T) bean;} public Object getSingleton (String beanName) {return getSingleton (beanName, true) } protected Object getSingleton (String beanName, boolean allowEarlyReference) {/ / first get Object singletonObject = this.singletonObjects.get (beanName) from the first-level cache singletonObjects / / isSingletonCurrentlyInCreation (beanName) determines whether the current singleton bean is being created if (singletonObject = = null & & isSingletonCurrentlyInCreation (beanName)) {synchronized (this.singletonObjects) {/ / the first-level cache does not get singletonObject = this.earlySingletonObjects.get (beanName) from the second-level cache earlySingletonObjects If (singletonObject = = null & & allowEarlyReference) {/ / the secondary cache did not get ObjectFactory singletonFactory = this.singletonFactories.get (beanName) from the tertiary cache singletonFactories. If (singletonFactory! = null) {singletonObject = singletonFactory.getObject () / / put it into the second-tier cache if any in the third-level cache, and delete this.earlySingletonObjects.put (beanName, singletonObject); this.singletonFactories.remove (beanName) from the first-level cache } return singletonObject;}

Then the doGetBean () method above goes down and another overloaded method of getSingleton () is called, and you can see that the second parameter is an ObjectFactory interface, and here spring uses an lambda expression to implement the getObject () method. Call the passed lambda expression singletonFactory.getObject () to create the bean.

Public Object getSingleton (String beanName, ObjectFactory singletonFactory) {Assert.notNull (beanName, "Bean name must not be null"); synchronized (this.singletonObjects) {Object singletonObject = this.singletonObjects.get (beanName) If (singletonObject = = null) {/ / whether it is being destroyed Exception if (this.singletonsCurrentlyInDestruction) {throw new BeanCreationNotAllowedException (beanName) "Singleton bean creation not allowed while singletons of this factory are in destruction" + "(Do not request a bean from a BeanFactory in a destroy method implementation!)") } if (logger.isDebugEnabled ()) {logger.debug ("Creating shared instance of singleton bean'" + beanName + "'") } / / after verification, to actually start creating an object, first identify that the bean is being created, because the spingbean creation process is complex and there are many steps, and you need to identify beforeSingletonCreation (beanName); boolean newSingleton = false Boolean recordSuppressedExceptions = (this.suppressedExceptions = = null); if (recordSuppressedExceptions) {this.suppressedExceptions = new LinkedHashSet () } try {/ / incoming call, lamda expression using singletonObject = singletonFactory.getObject (); newSingleton = true } catch (IllegalStateException ex) {/ / Has the singleton object implicitly appeared in the meantime-> / if yes, proceed with it since the exception indicates that state. SingletonObject = this.singletonObjects.get (beanName); if (singletonObject = = null) {throw ex }} catch (BeanCreationException ex) {if (recordSuppressedExceptions) {for (Exception suppressedException: this.suppressedExceptions) {ex.addRelatedCause (suppressedException) }} throw ex } finally {if (recordSuppressedExceptions) {this.suppressedExceptions = null } afterSingletonCreation (beanName);} if (newSingleton) {addSingleton (beanName, singletonObject) }} return singletonObject;}}

Next, let's take a look at how the createBean (beanName, mbd, args) method in the lambda expression is implemented. CreateBean () actually calls doCreateBean (), which is what really works. Here, we first call createBeanInstance (beanName, mbd, args) to instantiate the beanA, then put it into the three-level cache, and then call populateBean (beanName, mbd, instanceWrapper) to populate the beanA attributes. In our case, we actually populate the beanB. Let's continue to see what is done in the filling method.

Protected Object createBean (String beanName, RootBeanDefinition mbd, @ Nullable Object [] args) throws BeanCreationException {/ / get Bd RootBeanDefinition mbdToUse = mbd; / /.... Try {/ / enter, really create bean Object beanInstance = doCreateBean (beanName, mbdToUse, args); if (logger.isTraceEnabled ()) {logger.trace ("Finished creating instance of bean'" + beanName + "'") } return beanInstance;} catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {throw ex;}} protected Object doCreateBean (final String beanName, final RootBeanDefinition mbd, final @ Nullable Object [] args) throws BeanCreationException {/ / Instantiate the bean. BeanWrapper instanceWrapper = null; if (mbd.isSingleton ()) {instanceWrapper = this.factoryBeanInstanceCache.remove (beanName);} if (instanceWrapper = = null) {/ / create a Bean instance, only call the constructor, but the property instanceWrapper = createBeanInstance (beanName, mbd, args) has not been set } boolean earlySingletonExposure = (mbd.isSingleton () & & this.allowCircularReferences & & isSingletonCurrentlyInCreation (beanName)) If (earlySingletonExposure) {if (logger.isTraceEnabled ()) {logger.trace ("Eagerly caching bean'" + beanName + "'to allow for resolving potential circular references") } addSingletonFactory (beanName, ()-> getEarlyBeanReference (beanName, mbd, bean);} / /. Object exposedObject = bean; try {/ / Bean attribute populates populateBean (beanName, mbd, instanceWrapper); / / call initialization method, apply BeanPostProcessor post processor exposedObject = initializeBean (beanName, exposedObject, mbd);} / /. Return exposedObject;}

PopulateBean () finally calls applyPropertyValues (beanName, mbd, bw, pvs), applyPropertyValues (beanName, mbd, bw, pvs) method calls resolveValueIfNecessary (pv, originalValue), resolveValueIfNecessary (pv, originalValue) calls resolveReference (argName, ref), finally comes to the critical point, we can see in resolveReference (argName, ref), and call getBean (refName) method to get beanB. Ah, what's going on? why are we back to where we started? Haha, don't worry, let's continue the analysis. Now that the getBean () method is called, we might as well look back (I won't post the code again). GetBean () continues to call the doGetBean () method, then continues to call the getSingleton () method to get the beanB from the cache, then finds that the beanB is no longer in the cache, and then starts to create the beanB. Create a beanB to instantiate first, and then put it into the cache, and then call populateBean () to populate the attribute (that is, populate the dependent beanA). We mentioned earlier that beanA was instantiated before instantiating beanB and put it into the three-level cache, so we can use it here. It's still a doll, but it's enough. At this point, after the beanB attribute is populated, you can grow up and become the completed bean. At this point, put beanB into the cache pool, and we can go back and populate the properties of beanA. At this point, beanA and beanB have completed their entire bean creation process.

Protected void populateBean (String beanName, RootBeanDefinition mbd, @ Nullable BeanWrapper bw) {/ /. If (pvs! = null) {applyPropertyValues (beanName, mbd, bw, pvs);} protected void applyPropertyValues (String beanName, BeanDefinition mbd, BeanWrapper bw, PropertyValues pvs) {/ /. For (PropertyValue pv: original) {if (pv.isConverted ()) {deepCopy.add (pv);} else {String propertyName = pv.getName (); Object originalValue = pv.getValue () / / Object resolvedValue = valueResolver.resolveValueIfNecessary (pv, originalValue); Object convertedValue = resolvedValue / /...}} / /.} public Object resolveValueIfNecessary (Object argName, @ Nullable Object value) {if (value instanceof RuntimeBeanReference) {RuntimeBeanReference ref = (RuntimeBeanReference) value; return resolveReference (argName, ref) } / /...} private Object resolveReference (Object argName, RuntimeBeanReference ref) {try {Object bean; String refName = ref.getBeanName (); refName = String.valueOf (doEvaluate (refName)) If (ref.isToParent ()) {bean = this.beanFactory.getParentBeanFactory () .getBean (refName);} else {bean = this.beanFactory.getBean (refName) This.beanFactory.registerDependentBean (refName, this.beanName);} if (bean instanceof NullBean) {bean = null;} return bean } catch (BeansException ex) {} above is how to use spring source code to analyze spring bean circular dependency. The editor believes that there are some knowledge points that we may see or use in our daily work. I hope you can learn more from this article. For more details, please 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.