spring源码阅读-- 容器启动之创建bean

Posted 2020-11-02 hanjiehu

　　通过《spring源码阅读（3）-- 容器启动之BeanFactoryPostProcessor》一文了解到了spring对扩展点BeanFactoryPostProcessor是如何处理的，接下来看看spring是如何创建bean的。进入AbstractApplicationContext.refresh方法

 1     public void refresh() throws BeansException, IllegalStateException {
 2         synchronized (this.startupShutdownMonitor) {
 3             prepareRefresh();
 4             ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
 5             prepareBeanFactory(beanFactory);
 6 
 7             try {
 8                 postProcessBeanFactory(beanFactory);
 9                 invokeBeanFactoryPostProcessors(beanFactory);
10                 registerBeanPostProcessors(beanFactory);
11                 initMessageSource();
12                 initApplicationEventMulticaster();
13                 onRefresh();
14                 registerListeners();
15                 finishBeanFactoryInitialization(beanFactory);
16                 finishRefresh();
17             }
18 
19             catch (BeansException ex) {
20                 if (logger.isWarnEnabled()) {
21                     logger.warn("Exception encountered during context initialization - " +
22                             "cancelling refresh attempt: " + ex);
23                 }
24                 destroyBeans();
25                 cancelRefresh(ex);
26                 throw ex;
27             }
28 
29             finally {
30                 resetCommonCaches();
31             }
32         }
33     }

 　　spring在创建bean前，会先注册BeanPostProcessor（BeanPostProcessor是spring对外暴露的另一个扩展点，会在spring创建bean前后调用相应的方法，具体参考《Spring探秘|妙用BeanPostProcessor》），然后初始化spring事件传播相关功能。spring bean的创建入口在finishBeanFactoryInitialization方法，spring在容器初始化时，会先初始化lazy-init=false和单例的bean。

 1     protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
 2         // Initialize conversion service for this context.
 3         if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
 4                 beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
 5             beanFactory.setConversionService(
 6                     beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
 7         }
 8 
 9         // Register a default embedded value resolver if no bean post-processor
10         // (such as a PropertyPlaceholderConfigurer bean) registered any before:
11         // at this point, primarily for resolution in annotation attribute values.
12         if (!beanFactory.hasEmbeddedValueResolver()) {
13             beanFactory.addEmbeddedValueResolver(new StringValueResolver() {
14                 @Override
15                 public String resolveStringValue(String strVal) {
16                     return getEnvironment().resolvePlaceholders(strVal);
17                 }
18             });
19         }
20 
21         // Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.
22         String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
23         for (String weaverAwareName : weaverAwareNames) {
24             getBean(weaverAwareName);
25         }
26 
27         // Stop using the temporary ClassLoader for type matching.
28         beanFactory.setTempClassLoader(null);
29 
30         // Allow for caching all bean definition metadata, not expecting further changes.
31         beanFactory.freezeConfiguration();
32 
33         // Instantiate all remaining (non-lazy-init) singletons.
34         beanFactory.preInstantiateSingletons();
35     }

 　　finishBeanFactoryInitialization方法里首先判断是否有包含conversionService名字的bean，如果有先创建。由于我们在配置bean的属性时，都是以字符串的形式来配置，如下

1 <bean id="test" class="com.zksite.spring.test.SpringBeanTest">
2         <property name="num" value="1"></property>
3 </bean>

　　但num的类型不一定是String，有可能是Integer、Boolean、BigDecimal等，conversionService的作用就是将配置的字符串转为实际的类型，关于更多的conversionService的使用可以参考其他网上资料。

　　接着finishBeanFactoryInitialization方法12行，首先判断beanFactory是否有EmbeddedValueResolver，如果没有，添加一个StringValueResolver。由于DefaultListableBeanFactory实现了ConfigurableBeanFactory，所以当没有EmbeddedValueResolver时调用resolveEmbeddedValue方法是获取环境变量。一般我们项目里都会配置指定的配置文件，那么当配置了指定的配置文件时，可以通过resolveEmbeddedValue("${name}")的形式获取配置文件的内容，更多时候我们会通过@Value注解获取配置文件的内容，当然这需要更多的配置。

　　接着创建实现了LoadTimeWeaverAware接口的bean（先忽略LoadTimeWeaverAware的内容），然后缓存所有的bean name。beanFactory.preInstantiateSingletons()开始创建所有的单例bean，进入preInstantiateSingletons方法，方法里首先遍历beanNames去创建bean，然后回调实现了SmartInitializingSingleton接口的bean的afterSingletonsInstantiated方法

 1     public void preInstantiateSingletons() throws BeansException {
 2         if (this.logger.isDebugEnabled()) {
 3             this.logger.debug("Pre-instantiating singletons in " + this);
 4         }
 5 
 6         // Iterate over a copy to allow for init methods which in turn register new bean definitions.
 7         // While this may not be part of the regular factory bootstrap, it does otherwise work fine.
 8         List<String> beanNames = new ArrayList<String>(this.beanDefinitionNames);
 9 
10         // Trigger initialization of all non-lazy singleton beans...
11         for (String beanName : beanNames) {
12             RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
13             if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
14                 if (isFactoryBean(beanName)) {
15                     final FactoryBean<?> factory = (FactoryBean<?>) getBean(FACTORY_BEAN_PREFIX + beanName);
16                     boolean isEagerInit;
17                     if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
18                         isEagerInit = AccessController.doPrivileged(new PrivilegedAction<Boolean>() {
19                             @Override
20                             public Boolean run() {
21                                 return ((SmartFactoryBean<?>) factory).isEagerInit();
22                             }
23                         }, getAccessControlContext());
24                     }
25                     else {
26                         isEagerInit = (factory instanceof SmartFactoryBean &&
27                                 ((SmartFactoryBean<?>) factory).isEagerInit());
28                     }
29                     if (isEagerInit) {
30                         getBean(beanName);
31                     }
32                 }
33                 else {
34                     getBean(beanName);
35                 }
36             }
37         }
38 
39         // Trigger post-initialization callback for all applicable beans...
40         for (String beanName : beanNames) {
41             Object singletonInstance = getSingleton(beanName);
42             if (singletonInstance instanceof SmartInitializingSingleton) {
43                 final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
44                 if (System.getSecurityManager() != null) {
45                     AccessController.doPrivileged(new PrivilegedAction<Object>() {
46                         @Override
47                         public Object run() {
48                             smartSingleton.afterSingletonsInstantiated();
49                             return null;
50                         }
51                     }, getAccessControlContext());
52                 }
53                 else {
54                     smartSingleton.afterSingletonsInstantiated();
55                 }
56             }
57         }
58     }

　　循环体里首选获取合并的BeanDefinition，为什么需要获取合并后的BeanDefinition呢？其实只有当我们在配置bean时，如果指定了parent属性时，getMergedLocalBeanDefinition方法里会递归获取父级BeanDefinition，然后通过getMergedLocalBeanDefinition返回的RootBeanDefinition判断是否不是抽象的bean并且是单例和非懒加载的，如果这三者都成立，那么再判断是否是一个FactoryBean(FactoryBean是一个特殊的bean，通过beanName获取得到的不是FactoryBean本身，最终返回的bean是通过回调FactoryBean.getObject返回的)，接着调用getBean方法，getBean方法是通过调用doGetBean方法，直接进入doGetBean方法

  1     protected <T> T doGetBean(
  2             final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)
  3             throws BeansException {
  4 
  5         final String beanName = transformedBeanName(name);
  6         Object bean;
  7 
  8         // Eagerly check singleton cache for manually registered singletons.
  9         Object sharedInstance = getSingleton(beanName);
 10         if (sharedInstance != null && args == null) {
 11             if (logger.isDebugEnabled()) {
 12                 if (isSingletonCurrentlyInCreation(beanName)) {
 13                     logger.debug("Returning eagerly cached instance of singleton bean ‘" + beanName +
 14                             "‘ that is not fully initialized yet - a consequence of a circular reference");
 15                 }
 16                 else {
 17                     logger.debug("Returning cached instance of singleton bean ‘" + beanName + "‘");
 18                 }
 19             }
 20             bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
 21         }
 22 
 23         else {
 24             // Fail if we‘re already creating this bean instance:
 25             // We‘re assumably within a circular reference.
 26             if (isPrototypeCurrentlyInCreation(beanName)) {
 27                 throw new BeanCurrentlyInCreationException(beanName);
 28             }
 29 
 30             // Check if bean definition exists in this factory.
 31             BeanFactory parentBeanFactory = getParentBeanFactory();
 32             if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
 33                 // Not found -> check parent.
 34                 String nameToLookup = originalBeanName(name);
 35                 if (args != null) {
 36                     // Delegation to parent with explicit args.
 37                     return (T) parentBeanFactory.getBean(nameToLookup, args);
 38                 }
 39                 else {
 40                     // No args -> delegate to standard getBean method.
 41                     return parentBeanFactory.getBean(nameToLookup, requiredType);
 42                 }
 43             }
 44 
 45             if (!typeCheckOnly) {
 46                 markBeanAsCreated(beanName);
 47             }
 48 
 49             try {
 50                 final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
 51                 checkMergedBeanDefinition(mbd, beanName, args);
 52 
 53                 // Guarantee initialization of beans that the current bean depends on.
 54                 String[] dependsOn = mbd.getDependsOn();
 55                 if (dependsOn != null) {
 56                     for (String dependsOnBean : dependsOn) {
 57                         if (isDependent(beanName, dependsOnBean)) {
 58                             throw new BeanCreationException(mbd.getResourceDescription(), beanName,
 59                                     "Circular depends-on relationship between ‘" + beanName + "‘ and ‘" + dependsOnBean + "‘");
 60                         }
 61                         registerDependentBean(dependsOnBean, beanName);
 62                         getBean(dependsOnBean);
 63                     }
 64                 }
 65 
 66                 // Create bean instance.
 67                 if (mbd.isSingleton()) {
 68                     sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
 69                         @Override
 70                         public Object getObject() throws BeansException {
 71                             try {
 72                                 return createBean(beanName, mbd, args);
 73                             }
 74                             catch (BeansException ex) {
 75                                 // Explicitly remove instance from singleton cache: It might have been put there
 76                                 // eagerly by the creation process, to allow for circular reference resolution.
 77                                 // Also remove any beans that received a temporary reference to the bean.
 78                                 destroySingleton(beanName);
 79                                 throw ex;
 80                             }
 81                         }
 82                     });
 83                     bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
 84                 }
 85 
 86                 else if (mbd.isPrototype()) {
 87                     // It‘s a prototype -> create a new instance.
 88                     Object prototypeInstance = null;
 89                     try {
 90                         beforePrototypeCreation(beanName);
 91                         prototypeInstance = createBean(beanName, mbd, args);
 92                     }
 93                     finally {
 94                         afterPrototypeCreation(beanName);
 95                     }
 96                     bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
 97                 }
 98 
 99                 else {
100                     String scopeName = mbd.getScope();
101                     final Scope scope = this.scopes.get(scopeName);
102                     if (scope == null) {
103                         throw new IllegalStateException("No Scope registered for scope name ‘" + scopeName + "‘");
104                     }
105                     try {
106                         Object scopedInstance = scope.get(beanName, new ObjectFactory<Object>() {
107                             @Override
108                             public Object getObject() throws BeansException {
109                                 beforePrototypeCreation(beanName);
110                                 try {
111                                     return createBean(beanName, mbd, args);
112                                 }
113                                 finally {
114                                     afterPrototypeCreation(beanName);
115                                 }
116                             }
117                         });
118                         bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
119                     }
120                     catch (IllegalStateException ex) {
121                         throw new BeanCreationException(beanName,
122                                 "Scope ‘" + scopeName + "‘ is not active for the current thread; consider " +
123                                 "defining a scoped proxy for this bean if you intend to refer to it from a singleton",
124                                 ex);
125                     }
126                 }
127             }
128             catch (BeansException ex) {
129                 cleanupAfterBeanCreationFailure(beanName);
130                 throw ex;
131             }
132         }
133 
134         // Check if required type matches the type of the actual bean instance.
135         if (requiredType != null && bean != null && !requiredType.isAssignableFrom(bean.getClass())) {
136             try {
137                 return getTypeConverter().convertIfNecessary(bean, requiredType);
138             }
139             catch (TypeMismatchException ex) {
140                 if (logger.isDebugEnabled()) {
141                     logger.debug("Failed to convert bean ‘" + name + "‘ to required type [" +
142                             ClassUtils.getQualifiedName(requiredType) + "]", ex);
143                 }
144                 throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
145             }
146         }
147         return (T) bean;
148     }

　　这个方法有点长，方法里第一步调用transformedBeanName改造bean name，transformedBeanName首先判断name是以“&”开头，如果是去掉，返回真正的bane name,接着判断传入的name是否是别名，bean的创建都是通过bean name去创建，所以通过transformedBeanName方法返回的是最终的bean name。得到bean name之后，首先尝试通过getSingleton方法获取bean，这是为了解决循环依赖，这里先不看是具体怎么解决循环依赖的，后面会提到。如果通过getSingleton方法返回的对象不为空，进去getObjectForBeanInstance()方法，getObjectForBeanInstance处理的主要内容是针对当前的bean是一个FactoryBean，关于FactoryBean先残忍得忽略。

　　当getSingleton返回的的对象为空时，开始创建bean，如果当前的beanFactory的parentFactory不为空，那么创建bean是会委派给parentFactory去做。创建前会做一些前置检查，分别有判断当前创建的bean是否正在创建，是否是一个抽象bean。当这些检查通过时，首先初始化当前bean依赖的bean。不管是单例的bean还是原型的bean都是通过createBean方法去创建，只不过当是一个单例的bean时，可能在创建前后会做一些其它处理，例如解决循环依赖和将已创建的bean缓存。进入DefaultSingletonBeanRegistry.getSingleton方法，DefaultSingletonBeanRegistry是SingletonBeanRegistry的默认实现，通过类名发现这是一个单例bean的注册中心，SingletonBeanRegistry接口定义了单例bean的注册,和获取单例bean等接口，但真正的创建bean，SingletonBeanRegistry没有定义而是由AbstractBeanFactory定义，实现是AbstractAutowireCapableBeanFactory，我们当前使用的DefaultListableBeanFactory都直接或间接实现了这些接口。

 1     public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
 2         Assert.notNull(beanName, "‘beanName‘ must not be null");
 3         synchronized (this.singletonObjects) {
 4             Object singletonObject = this.singletonObjects.get(beanName);
 5             if (singletonObject == null) {
 6                 if (this.singletonsCurrentlyInDestruction) {
 7                     throw new BeanCreationNotAllowedException(beanName,
 8                             "Singleton bean creation not allowed while the singletons of this factory are in destruction " +
 9                             "(Do not request a bean from a BeanFactory in a destroy method implementation!)");
10                 }
11                 if (logger.isDebugEnabled()) {
12                     logger.debug("Creating shared instance of singleton bean ‘" + beanName + "‘");
13                 }
14                 beforeSingletonCreation(beanName);
15                 boolean newSingleton = false;
16                 boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
17                 if (recordSuppressedExceptions) {
18                     this.suppressedExceptions = new LinkedHashSet<Exception>();
19                 }
20                 try {
21                     singletonObject = singletonFactory.getObject();
22                     newSingleton = true;
23                 }
24                 catch (IllegalStateException ex) {
25                     // Has the singleton object implicitly appeared in the meantime ->
26                     // if yes, proceed with it since the exception indicates that state.
27                     singletonObject = this.singletonObjects.get(beanName);
28                     if (singletonObject == null) {
29                         throw ex;
30                     }
31                 }
32                 catch (BeanCreationException ex) {
33                     if (recordSuppressedExceptions) {
34                         for (Exception suppressedException : this.suppressedExceptions) {
35                             ex.addRelatedCause(suppressedException);
36                         }
37                     }
38                     throw ex;
39                 }
40                 finally {
41                     if (recordSuppressedExceptions) {
42                         this.suppressedExceptions = null;
43                     }
44                     afterSingletonCreation(beanName);
45                 }
46                 if (newSingleton) {
47                     addSingleton(beanName, singletonObject);
48                 }
49             }
50             return (singletonObject != NULL_OBJECT ? singletonObject : null);
51         }
52     }

View Code

 

　　方法里首先从singletonObjects这个Map里面获取，如果当前获取的bean已创建，singletonObjects返回的的值不为空，然后直接返回给上层。当从singletonObjects获取不到指定的值时，这时需要创建一个，创建前调用beforeSingletonCreation，这个方法里有两个作用，分别是判断当前创建的bean是否正在创建和使用一个set将当前创建的bean name保存起来为了解决循环依赖。然后调用singletonFactory.getObject创建bean，当创建bean成功时会删除之前使用set保存的当前创建bean name并将bean缓存在一个map里。singletonFactory.getObject是通过调用AbstractAutowireCapableBeanFactory.createBean创建bean实例，进入createBean方法

 1     protected Object createBean(String beanName, RootBeanDefinition mbd, Object[] args) throws BeanCreationException {
 2         if (logger.isDebugEnabled()) {
 3             logger.debug("Creating instance of bean ‘" + beanName + "‘");
 4         }
 5         RootBeanDefinition mbdToUse = mbd;
 6 
 7         // Make sure bean class is actually resolved at this point, and
 8         // clone the bean definition in case of a dynamically resolved Class
 9         // which cannot be stored in the shared merged bean definition.
10         Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
11         if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
12             mbdToUse = new RootBeanDefinition(mbd);
13             mbdToUse.setBeanClass(resolvedClass);
14         }
15 
16         // Prepare method overrides.
17         try {
18             mbdToUse.prepareMethodOverrides();
19         }
20         catch (BeanDefinitionValidationException ex) {
21             throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
22                     beanName, "Validation of method overrides failed", ex);
23         }
24 
25         try {
26             // Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
27             Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
28             if (bean != null) {
29                 return bean;
30             }
31         }
32         catch (Throwable ex) {
33             throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
34                     "BeanPostProcessor before instantiation of bean failed", ex);
35         }
36 
37         Object beanInstance = doCreateBean(beanName, mbdToUse, args);
38         if (logger.isDebugEnabled()) {
39             logger.debug("Finished creating instance of bean ‘" + beanName + "‘");
40         }
41         return beanInstance;
42     }

 

　　方法里首先调用resolveBeanClass方法获取bean的calss，通过查看resolveBeanClass方法，可以发现，bean的class属性可以配置为spl表达式。接着就是校验lookup-method和replaced-method，检查创建的bean是否有指定的方法。当这些准备工作做完时，尝试通过配置的InstantiationAwareBeanPostProcessor去创建实例， 如果存在InstantiationAwareBeanPostProcessor并创建了实例，调用所有的BeanPostProcessor.postProcessAfterInitialization完成bean的创建并返回。如果没有调用doCreateBean执行创建bean实例。

1         BeanWrapper instanceWrapper = null;
2         if (mbd.isSingleton()) {
3             instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
4         }
5         if (instanceWrapper == null) {
6             instanceWrapper = createBeanInstance(beanName, mbd, args);
7         }

　　方法里首先通过缓存获取BeanWrapper实例，spring使用BeanWrapper定义了一个标准javaBean的操作。如果缓存不存在调用createBeanInstance方法创建实例。进入createBeanInstance方法

 1     protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, Object[] args) {
 2         // Make sure bean class is actually resolved at this point.
 3         Class<?> beanClass = resolveBeanClass(mbd, beanName);
 4 
 5         if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
 6             throw new BeanCreationException(mbd.getResourceDescription(), beanName,
 7                     "Bean class isn‘t public, and non-public access not allowed: " + beanClass.getName());
 8         }
 9 
10         if (mbd.getFactoryMethodName() != null)  {
11             return instantiateUsingFactoryMethod(beanName, mbd, args);
12         }
13 
14         // Shortcut when re-creating the same bean...
15         boolean resolved = false;
16         boolean autowireNecessary = false;
17         if (args == null) {
18             synchronized (mbd.constructorArgumentLock) {
19                 //resolvedConstructorOrFactoryMethod用于缓存构造方法或者factoryMethod
20                 //只有当创建的bean是scope=prototype,并且在第二次getBean时resolvedConstructorOrFactoryMethod的值才不会为空
21                 if (mbd.resolvedConstructorOrFactoryMethod != null) {
22                     resolved = true;
23                     //constructorArgumentsResolved用于标识是否解决了构造器法参数
24                     autowireNecessary = mbd.constructorArgumentsResolved;
25                 }
26             }
27         }
28         if (resolved) {
29             if (autowireNecessary) {
30                 return autowireConstructor(beanName, mbd, null, null);
31             }
32             else {
33                 return instantiateBean(beanName, mbd);
34             }
35         }
36 
37         // Need to determine the constructor...
38         Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
39         if (ctors != null ||
40                 mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR ||
41                 mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args))  {
42             return autowireConstructor(beanName, mbd, ctors, args);
43         }
44 
45         // No special handling: simply use no-arg constructor.
46         return instantiateBean(beanName, mbd);
47     }

　　从实现逻辑可以看出，创建bean实例的有三种方式：工厂方法、自动装配构造器实例化、默认构造器实例化，分别对应不同的方法：

　　　　instantiateUsingFactoryMethod：当配置了factory-method属性时

 　　　  autowireConstructor：当配置了constructor-arg属性时

　　　　instantiateBean：使用默认的构造器创建实例

　　　　instantiateUsingFactoryMethod方法和autowireConstructor放在创建流程其实差不多，大体流程以下，更详细可以参考源码

　　　　1.找出对应的方法或构造器

　　　　2.获取方法参数值数组

　　　　3.计算参数与值的权重，获取最优构造器或方法。(具体实现挺有意思的)

　　　　4.当获取到构造器或方法后，通过CglibSubclassingInstantiationStrategy创建实例，具体和instantiateBean方法一样。

　　instantiateBean默认构造器实例化

 　　　　当使用的是默认的构造器实例化时，会使用BeanFactory持有的CglibSubclassingInstantiationStrategy实例去创建实例。如果当前的bean使用了方法注入会使用cglib生生成代理对象并返回。否则直接获取默认的无参构造器，然后通过构造器创建实例并返回。

　　至此spring已经完成了单例bean的初始化。当bean初始化后，如果当前的bean是一个单例的bean，spring会马上将bean临时缓存起来，用于解决循环依赖，由此可以看出，spring只对视单例的bean提供循环依赖的支持。

 1 　　　　boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
 2                 isSingletonCurrentlyInCreation(beanName));
 3         if (earlySingletonExposure) {
 4             if (logger.isDebugEnabled()) {
 5                 logger.debug("Eagerly caching bean ‘" + beanName +
 6                         "‘ to allow for resolving potential circular references");
 7             }
 8             addSingletonFactory(beanName, new ObjectFactory<Object>() {
 9                 @Override
10                 public Object getObject() throws BeansException {
11                     return getEarlyBeanReference(beanName, mbd, bean);
12                 }
13             });
14         }

　　当解决完循环依赖之后，接着便是属性的注入和回调前后置处理。

1  //属性注入
2  populateBean(beanName, mbd, instanceWrapper);
3  if (exposedObject != null) {
4       //处理回调
5   　　exposedObject = initializeBean(beanName, exposedObject, mbd);
6  }