前面分析了bean解析的过程，知道了bean都是以beandefinition的形式放在bean factory里面的。下面来看一下bean具体的获取过程。

Spring 提供了一个获取bean的工具方法：

WebApplicationContextUtils.getRequiredWebApplicationContext(ServletContext sc).getBean(String beanName);

OK,稍微追踪了一下代码，发现着落在了AbstraceBeanFactory下面：

Java代码  

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

   doGetBean….呃，好长的方法。慢慢研究一下。

   Object sharedInstance = getSingleton(beanName);

   这个方法首先去已经缓存了的Singleton里面寻找，如果没有，就到手工注入的singleton缓存里面寻找，如果没有，

   再到缓存的FactoryBean类型的singleton里面寻找，如果还没有…继续doGetBean里面的下一步。

   接下来如果当前beanfactory有parent,就到parentBeanFactory里面寻找，如果找不到，继续…

   接下来就是获取spring里面当初解析出来的bean模板：RootBeanDefinition。然后

   在当前factory下面注册一下依赖关系，下面就到了关键的步骤了，根据bean是singleton还是Prototype或者其他什么scope类型来分别定义bean的获取过程。下面以singleton为例来进行分析。

   注意一下代码：

Java代码  

1. if (mbd.isSingleton()) {  
2.                 sharedInstance = getSingleton(beanName, new ObjectFactory() {  
3.                     public Object getObject() throws BeansException {  
4.                         try {  
5.                             return createBean(beanName, mbd, args);  
6.                         }  
7.                         catch (BeansException ex) {  
8.                             // Explicitly remove instance from singleton cache: It might have been put there  
9.                             // eagerly by the creation process, to allow for circular reference resolution.  
10.                             // Also remove any beans that received a temporary reference to the bean.  
11.                             destroySingleton(beanName);  
12.                             throw ex;  
13.                         }  
14.                     }  
15.                 });  
16.                 bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);  
17.             }  

    可见bean的生成委托给了createBean(name,mdb,args)方法。

    这个方法的实现是在子类AbstractAutowireCapableBeanFactory里面。

Java代码  

1. protected Object createBean(final String beanName, final RootBeanDefinition mbd, final Object[] args)  
2.             throws BeanCreationException {  
3.   
4.         if (logger.isDebugEnabled()) {  
5.             logger.debug(“Creating instance of bean ‘” + beanName + “‘”);  
6.         }  
7.         // Make sure bean class is actually resolved at this point.  
8.         resolveBeanClass(mbd, beanName);  
9.   
10.         // Prepare method overrides.  
11.         try {  
12.             mbd.prepareMethodOverrides();  
13.         }  
14.         catch (BeanDefinitionValidationException ex) {  
15.             throw new BeanDefinitionStoreException(mbd.getResourceDescription(),  
16.                     beanName, “Validation of method overrides failed”, ex);  
17.         }  
18.   
19.         try {  
20.             // Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.  
21.             Object bean = resolveBeforeInstantiation(beanName, mbd);  
22.             if (bean != null) {  
23.                 return bean;  
24.             }  
25.         }  
26.         catch (Throwable ex) {  
27.             throw new BeanCreationException(mbd.getResourceDescription(), beanName,  
28.                     “BeanPostProcessor before instantiation of bean failed”, ex);  
29.         }  
30.   
31.         Object beanInstance = doCreateBean(beanName, mbd, args);  
32.         if (logger.isDebugEnabled()) {  
33.             logger.debug(“Finished creating instance of bean ‘” + beanName + “‘”);  
34.         }  
35.         return beanInstance;  
36.     }  

   从上面的代码可以看出，先调用了resolveBeforeInstantiation方法。如果返回一个非空对象，那么就直接返回这个对象。 于是分析一下这个方法：

Java代码  

1. protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {  
2.         Object bean = null;  
3.         if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {  
4.             // Make sure bean class is actually resolved at this point.  
5.             if (mbd.hasBeanClass() && !mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {  
6.                 bean = applyBeanPostProcessorsBeforeInstantiation(mbd.getBeanClass(), beanName);  
7.                 if (bean != null) {  
8.                     bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);  
9.                 }  
10.             }  
11.             mbd.beforeInstantiationResolved = (bean != null);  
12.         }  
13.         return bean;  
14.     }  

  是不是似曾相识哪？那就对了 ！ Aop的实现的核心啊，回想一下AbstractAutoProxyCreator，就是实现了InstantiationAwareBeanPostProcessor接口。从AbstractAutoProxyCreator的postProcessBeforeInstantiation代码可以很容易的看出，如果bean需要代理，那么返回一个代理类，否则返回Null.

 结合当前代码，那就是如果产生了代理类，那么试着调用beanpostprocessors的postProcessAfterInitialization方法，然后返回这个代理类。从这里也可以看出，如果被代理的类定义了postProcessBeforeInitialization,init等方法，将根本没有调用的机会！ 所以被代理类在实现BeanPostProcessor,InitilizingBean等接口时要非常小心。否则可能发现有些方法根本没有回调。

当然了，不一定非要产生代理类，也有可能有其他的实现了InstantiationAwareBeanPostProcessor接口的类也返回非空，这里就不详细分析。我大致看了一下，至少我看的几个实现了InstantiationAwareBeanPostProcessor接口的类是返回null的，除了AbstractAutoProxyCreator.

下面继续。如果调用InstantiationAwareBeanPostProcessor后依然返回Null,那么就继续下面的步骤，也就是激动人心的bean的instantiation过程了！这里是调用了doCreateBean(beanName, mbd, args)方法：

Java代码  

1. protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args) {  
2.         // Instantiate the bean.  
3.         BeanWrapper instanceWrapper = null;  
4.         if (mbd.isSingleton()) {  
5.             instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);  
6.         }  
7.         if (instanceWrapper == null) {  
8.             instanceWrapper = createBeanInstance(beanName, mbd, args);  
9.         }  
10.         final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);  
11.         Class beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);  
12.   
13.         // Allow post-processors to modify the merged bean definition.  
14.         synchronized (mbd.postProcessingLock) {  
15.             if (!mbd.postProcessed) {  
16.                 applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);  
17.                 mbd.postProcessed = true;  
18.             }  
19.         }  
20.   
21.         // Eagerly cache singletons to be able to resolve circular references  
22.         // even when triggered by lifecycle interfaces like BeanFactoryAware.  
23.         boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&  
24.                 isSingletonCurrentlyInCreation(beanName));  
25.         if (earlySingletonExposure) {  
26.             if (logger.isDebugEnabled()) {  
27.                 logger.debug(“Eagerly caching bean ‘” + beanName +  
28.                         “‘ to allow for resolving potential circular references”);  
29.             }  
30.             addSingletonFactory(beanName, new ObjectFactory() {  
31.                 public Object getObject() throws BeansException {  
32.                     return getEarlyBeanReference(beanName, mbd, bean);  
33.                 }  
34.             });  
35.         }  
36.   
37.         // Initialize the bean instance.  
38.         Object exposedObject = bean;  
39.         try {  
40.             populateBean(beanName, mbd, instanceWrapper);  
41.             if (exposedObject != null) {  
42.                 exposedObject = initializeBean(beanName, exposedObject, mbd);  
43.             }  
44.         }  
45.         catch (Throwable ex) {  
46.             if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {  
47.                 throw (BeanCreationException) ex;  
48.             }  
49.             else {  
50.                 throw new BeanCreationException(mbd.getResourceDescription(), beanName, “Initialization of bean failed”, ex);  
51.             }  
52.         }  
53.   
54.         if (earlySingletonExposure) {  
55.             Object earlySingletonReference = getSingleton(beanName, false);  
56.             if (earlySingletonReference != null) {  
57.                 if (exposedObject == bean) {  
58.                     exposedObject = earlySingletonReference;  
59.                 }  
60.                 else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {  
61.                     String[] dependentBeans = getDependentBeans(beanName);  
62.                     Set<String> actualDependentBeans = new LinkedHashSet<String>(dependentBeans.length);  
63.                     for (String dependentBean : dependentBeans) {  
64.                         if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {  
65.                             actualDependentBeans.add(dependentBean);  
66.                         }  
67.                     }  
68.                     if (!actualDependentBeans.isEmpty()) {  
69.                         throw new BeanCurrentlyInCreationException(beanName,  
70.                                 “Bean with name ‘” + beanName + “‘ has been injected into other beans [“ +  
71.                                 StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +  
72.                                 “] in its raw version as part of a circular reference, but has eventually been “ +  
73.                                 “wrapped. This means that said other beans do not use the final version of the “ +  
74.                                 “bean. This is often the result of over-eager type matching – consider using “ +  
75.                                 “‘getBeanNamesOfType’ with the ‘allowEagerInit’ flag turned off, for example.”);  
76.                     }  
77.                 }  
78.             }  
79.         }  
80.   
81.         // Register bean as disposable.  
82.         try {  
83.             registerDisposableBeanIfNecessary(beanName, bean, mbd);  
84.         }  
85.         catch (BeanDefinitionValidationException ex) {  
86.             throw new BeanCreationException(mbd.getResourceDescription(), beanName, “Invalid destruction signature”, ex);  
87.         }  
88.   
89.         return exposedObject;  
90.     }  

    汗～又是一个长方法。慢慢分析。

    这个方法大致分为这么几步：

    1. 产生一个beanwrapper.

    2. 调用实现了MergedBeanDefinitionPostProcessors接口的类

    3. populateBean

    4. 初始化bean

    5. 注册产生的bean

    下面分别就前几个步骤进行分析。

   1.  产生beanwrapper

Java代码  

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.         if (mbd.resolvedConstructorOrFactoryMethod != null && args == null) {  
16.             if (mbd.constructorArgumentsResolved) {  
17.                 return autowireConstructor(beanName, mbd, null, null);  
18.             }  
19.             else {  
20.                 return instantiateBean(beanName, mbd);  
21.             }  
22.         }  
23.   
24.         // Need to determine the constructor…  
25.         Constructor[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);  
26.         if (ctors != null ||  
27.                 mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR ||  
28.                 mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args))  {  
29.             return autowireConstructor(beanName, mbd, ctors, args);  
30.         }  
31.   
32.         // No special handling: simply use no-arg constructor.  
33.         return instantiateBean(beanName, mbd);  
34.     }  

   在这里可以看出，如果为bean定义了factoryMehtod或者constructor，那么将分别根据factoryMethod或construcgtor完成bean的初始化。否则调用如下方法：

Java代码  

1. protected BeanWrapper instantiateBean(final String beanName, final RootBeanDefinition mbd) {  
2.         try {  
3.             Object beanInstance;  
4.             final BeanFactory parent = this;  
5.             if (System.getSecurityManager() != null) {  
6.                 beanInstance = AccessController.doPrivileged(new PrivilegedAction<Object>() {  
7.                     public Object run() {  
8.                         return getInstantiationStrategy().instantiate(mbd, beanName, parent);  
9.                     }  
10.                 }, getAccessControlContext());  
11.             }  
12.             else {  
13.                 beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent);  
14.             }  
15.             BeanWrapper bw = new BeanWrapperImpl(beanInstance);  
16.             initBeanWrapper(bw);  
17.             return bw;  
18.         }  
19.         catch (Throwable ex) {  
20.             throw new BeanCreationException(mbd.getResourceDescription(), beanName, “Instantiation of bean failed”, ex);  
21.         }  
22.     }  

    这里有一个InstantiationStrategy接口，这个接口定了bean初始化的策略。比如在

    当前类AbstractAutowireCapableBeanFactory下面一开始就定义了一个变量：

Java代码  

1. private InstantiationStrategy instantiationStrategy = new CglibSubclassingInstantiationStrategy();  

   可见，默认的初始化策略是CglibSubclassingInstantiationStrategy。

    这个策略的特殊之处就在于如果bean需要有method injection,那么就通过cglib代理的方式产生原本的bean class的一个子类从而实现method override.

   OK，至此BeanWrapper的生成基本清晰了。

下面就是实现了MergedBeanDefinitionPostProcessors的类的调用了。这个接口的具体意思我还不是很清楚。稍后研究一下补全。

然后就是populateBean. 这个方法就是把BeanDefinition里面维护的bean的属性populate到beanwrapper里面。

接下来就是bean的初始化：

 if (exposedObject != null) {
                exposedObject = initializeBean(beanName, exposedObject, mbd);

了解bean的初始化流程还是蛮有意义的：

Java代码  

1. protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) {  
2.         if (System.getSecurityManager() != null) {  
3.             AccessController.doPrivileged(new PrivilegedAction<Object>() {  
4.                 public Object run() {  
5.                     invokeAwareMethods(beanName, bean);  
6.                     return null;  
7.                 }  
8.             }, getAccessControlContext());  
9.         }  
10.         else {  
11.             invokeAwareMethods(beanName, bean);  
12.         }  
13.           
14.         Object wrappedBean = bean;  
15.         if (mbd == null || !mbd.isSynthetic()) {  
16.             wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);  
17.         }  
18.   
19.         try {  
20.             invokeInitMethods(beanName, wrappedBean, mbd);  
21.         }  
22.         catch (Throwable ex) {  
23.             throw new BeanCreationException(  
24.                     (mbd != null ? mbd.getResourceDescription() : null),  
25.                     beanName, “Invocation of init method failed”, ex);  
26.         }  
27.   
28.         if (mbd == null || !mbd.isSynthetic()) {  
29.             wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);  
30.         }  
31.         return wrappedBean;  
32.     }  

   可见初始化顺序是： XXAware接口的实现->postProcessBeforeInitialization->InitializingBean的afterPropertiesSet-> custom Init方法->postProcessAfterInitialization

  OK.这就是bean初始化的顺序啦！

  最后当然就是bean的注册了！

Java代码  

1. protected void registerDisposableBeanIfNecessary(String beanName, Object bean, RootBeanDefinition mbd) {  
2.         AccessControlContext acc = (System.getSecurityManager() != null ? getAccessControlContext() : null);  
3.         if (!mbd.isPrototype() && requiresDestruction(bean, mbd)) {  
4.             if (mbd.isSingleton()) {  
5.                 // Register a DisposableBean implementation that performs all destruction  
6.                 // work for the given bean: DestructionAwareBeanPostProcessors,  
7.                 // DisposableBean interface, custom destroy method.  
8.                 registerDisposableBean(beanName,  
9.                         new DisposableBeanAdapter(bean, beanName, mbd, getBeanPostProcessors(), acc));  
10.             }  
11.             else {  
12.                 // A bean with a custom scope…  
13.                 Scope scope = this.scopes.get(mbd.getScope());  
14.                 if (scope == null) {  
15.                     throw new IllegalStateException(“No Scope registered for scope ‘” + mbd.getScope() + “‘”);  
16.                 }  
17.                 scope.registerDestructionCallback(beanName,  
18.                         new DisposableBeanAdapter(bean, beanName, mbd, getBeanPostProcessors(), acc));  
19.             }  
20.         }  
21.     }  

   这里面涉及到了bean以及与scope相关的生命周期的管理，需要单独分析一下。下篇文章再分析。