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

This article shows you how to use Spring source code to analyze circular dependencies, the content is concise and easy to understand, can definitely brighten your eyes, through the detailed introduction of this article, I hope you can get something.

Let's move on today to talk about the solution to circular dependency, which is to create an ObjectFactory for bean.

ObjectFactory

Boolean earlySingletonExposure = (mbd.isSingleton () & & this.allowCircularReferences & & isSingletonCurrentlyInCreation (beanName)); if (earlySingletonExposure) {if (logger.isDebugEnabled ()) {logger.debug ("Eagerly caching bean'" + beanName + "'to allow for resolving potential circular references") } / / to avoid late cyclic dependency, you can add the instance creation ObjectFactory to the factory before bean initialization is completed / * getEarlyBeanReference (beanName, mbd, bean) method: * rely on references to bean again, mainly using SmartInstantiationAwareBeanPostProcessor * where the familiar AOP weaves advice into bean dynamically, and returns bean directly if not Do no processing * / addSingletonFactory (beanName, ()-> getEarlyBeanReference (beanName, mbd, bean)) }

This code is not very complex, but many people do not understand the role of this code, and it is difficult to understand the meaning of this code only from this function. We need to think about the dependency solution of Spring from a global point of view. EarlySingletonExposure: literally, it is a single case of early exposure. We will not define its scientific name for the time being. We are interested in what conditions affect this value.

Mbd.isSingleton (): there is not much to explain whether this RootBeanDefinition represents a singleton.

This.allowCircularReferences: whether circular dependency is allowed, I'm sorry, I can't find out how to configure it in the configuration file, but a setting function is provided in AbstractRefreshableApplicationContext, which can be set by hard coding or can be configured by custom namespace. The hard coding code is as follows.

ClassPathXmlApplicationContext bf = ClassPathXmlApplicationContext ("aspectTest.xml"); bt.setAllowBeanDefinitionOverriding (false)

IsSingletonCurrentlylncreation (beanName): whether the bean is being created. In Spring, there is a special property that defaults to the singletonsCurrentlylnCreation of DefaultSingletonBeanRegistry to record the loading status of the bean. The beanName is recorded in the property before the creation of the bean, and the beanName is removed from the property after the creation of the bean. So we follow the code all the way, but we don't have much impression of the record of this property. Where is this state recorded? The recording position of different scope is different. We take singleton as an example. The function of recording attributes under singleton is in beforeSingletonCreation (beanName) and afterSingletonCreation (beanName) of DefaultSingletonBeanRegistry's public Object getSingleton (String beanName, ObjectFactory singletonFactory) function. In these two functions, this.singletonCurrentlylnCreation.add (beanName) and this.singletonCurrentlylnCreation.remove (beanName) are used to record and remove the state.

After the above analysis, we know whether the variable earl earlySingletonExposure is a singleton, whether circular dependency is allowed, and whether it corresponds to the synthesis of the conditions being created by the bean. The addSingletonFactory operation is performed when all three conditions are met, so what is the purpose of adding SingletonFactory? When will it be called again?

Let's take the simplest AB circular dependency as an example. Class A contains attribute class B, and class B contains attribute class A. the process of initializing beanA is shown in the following figure:

When creating class A, the beanName corresponding to class An is first recorded, and the creation factory of beanA is added to the cache, and B is recursively created again when populating the property of A, that is, when the populate method is called. Similarly, because the An attribute also exists in B, An is initialized again in the populate method of instantiating B, that is, at the end of the graph, getBean (A) is called. The key is that here, interested students can find out how to implement this code. As we have said before, instead of directly de-instantiating An in this function, we first check whether there is a corresponding bean or ObjectFactory in the cache that has been created. At this time, we have already created the ObjectFactory of A, so we will not execute it backwards, but call ObjectFactory directly to create A. The most important thing here is the implementation of ObjectFactory.

/ * getEarlyBeanReference (beanName, mbd, bean) method: * rely on references to bean again, mainly using SmartInstantiationAwareBeanPostProcessor * where the familiar AOP weaves advice into bean dynamically, and returns bean directly without any processing * / addSingletonFactory (beanName, ()-> getEarlyBeanReference (beanName, mbd, bean))

The code of getEarlyBeanReference is as follows:

Protected Object getEarlyBeanReference (String beanName, RootBeanDefinition mbd, Object bean) {Object exposedObject = bean; if (! mbd.isSynthetic () & & hasInstantiationAwareBeanPostProcessors ()) {for (BeanPostProcessor bp: getBeanPostProcessors ()) {if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp; exposedObject = ibp.getEarlyBeanReference (exposedObject, beanName);}} return exposedObject;}

There is not much logical processing in the getEarlyBeanReference function, or there is no other processing work except the call of the post-processor. According to the above analysis, we can basically sort out the solution of spring to deal with circular dependencies. When creating dependency An in B, we use the instantiation method provided by ObjectFactory to break the filling of attributes in A, so that the A held in B is only A that has just been initialized and has not filled any attributes. The step of initializing A takes place at the beginning of the creation of A, but because An and An in B represent the same attribute address, the attribute padding created in A can naturally be obtained through An in B. in this way, the problem of circular dependency is solved.

The above is how to use Spring source code to resolve circular dependencies. Have you learned any knowledge or skills? If you want to learn more skills or enrich your knowledge reserve, you are 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.