Spring源码解析（四）Bean的实例化和依赖注入

// Instantiate all remaining (non-lazy-init) singletons.
finishBeanFactoryInitialization(beanFactory);

/**
     * Return an instance, which may be shared or independent, of the specified bean.
     * @param name the name of the bean to retrieve
     * @param requiredType the required type of the bean to retrieve
     * @param args arguments to use if creating a prototype using explicit arguments to a
     * static factory method. It is invalid to use a non-null args value in any other case.
     * @param typeCheckOnly whether the instance is obtained for a type check,
     * not for actual use
     * @return an instance of the bean
     * @throws BeansException if the bean could not be created
     */
    @SuppressWarnings("unchecked")
    protected <T> T doGetBean(
            final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)
            throws BeansException {
        //如果name已&开头，去掉&
        final String beanName = transformedBeanName(name);
        Object bean;

        // Eagerly check singleton cache for manually registered singletons.
        /**1.先在单例缓存中查找*/
        Object sharedInstance = getSingleton(beanName);
        if (sharedInstance != null && args == null) {
            if (logger.isDebugEnabled()) {
                if (isSingletonCurrentlyInCreation(beanName)) {
                    logger.debug("Returning eagerly cached instance of singleton bean ‘" + beanName +
                            "‘ that is not fully initialized yet - a consequence of a circular reference");
                }
                else {
                    logger.debug("Returning cached instance of singleton bean ‘" + beanName + "‘");
                }
            }
            /**2.判断返回instance本身还是要返回FacotryBean*/
            bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
        }

        else {
            // Fail if we‘re already creating this bean instance:
            // We‘re assumably within a circular reference.
            //判断是否不是循环引用
            if (isPrototypeCurrentlyInCreation(beanName)) {
                throw new BeanCurrentlyInCreationException(beanName);
            }

            // Check if bean definition exists in this factory.
            BeanFactory parentBeanFactory = getParentBeanFactory();
            if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
                // Not found -> check parent.
                String nameToLookup = originalBeanName(name);
                if (args != null) {
                    // Delegation to parent with explicit args.
                    return (T) parentBeanFactory.getBean(nameToLookup, args);
                }
                else {
                    // No args -> delegate to standard getBean method.
                    return parentBeanFactory.getBean(nameToLookup, requiredType);
                }
            }
            //标记bean已被创建
            if (!typeCheckOnly) {
                markBeanAsCreated(beanName);
            }

            try {
                final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
                checkMergedBeanDefinition(mbd, beanName, args);

                // Guarantee initialization of beans that the current bean depends on.
                /**3.如果bean依赖于其他bean先初始化，先初始化依赖的bean*/
                String[] dependsOn = mbd.getDependsOn();
                if (dependsOn != null) {
                    for (String dependsOnBean : dependsOn) {
                        getBean(dependsOnBean);
                        /**4.记录两个bean相互依赖关系，被依赖的bean在销毁前，要先要销毁依赖它的bean*/
                        registerDependentBean(dependsOnBean, beanName);
                    }
                }

                // Create bean instance.
                /**
                 * 5.创建单例bean,scope="singleton"
                 */
                if (mbd.isSingleton()) {
                    sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
                        public Object getObject() throws BeansException {
                            try {
                                return createBean(beanName, mbd, args);
                            }
                            catch (BeansException ex) {
                                // Explicitly remove instance from singleton cache: It might have been put there
                                // eagerly by the creation process, to allow for circular reference resolution.
                                // Also remove any beans that received a temporary reference to the bean.
                                destroySingleton(beanName);
                                throw ex;
                            }
                        }
                    });
                    bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
                }
                /**
                 * 6.创建原型bean,scope="prototype"
                 */
                else if (mbd.isPrototype()) {
                    // It‘s a prototype -> create a new instance.
                    Object prototypeInstance = null;
                    try {
                        beforePrototypeCreation(beanName);
                        prototypeInstance = createBean(beanName, mbd, args);
                    }
                    finally {
                        afterPrototypeCreation(beanName);
                    }
                    bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
                }
                /**
                 * 7. scope=request/session/globalSession
                 */
                else {
                    String scopeName = mbd.getScope();
                    final Scope scope = this.scopes.get(scopeName);
                    if (scope == null) {
                        throw new IllegalStateException("No Scope registered for scope ‘" + scopeName + "‘");
                    }
                    try {
                        Object scopedInstance = scope.get(beanName, new ObjectFactory<Object>() {
                            public Object getObject() throws BeansException {
                                beforePrototypeCreation(beanName);
                                try {
                                    return createBean(beanName, mbd, args);
                                }
                                finally {
                                    afterPrototypeCreation(beanName);
                                }
                            }
                        });
                        bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
                    }
                    catch (IllegalStateException ex) {
                        throw new BeanCreationException(beanName,
                                "Scope ‘" + scopeName + "‘ is not active for the current thread; " +
                                "consider defining a scoped proxy for this bean if you intend to refer to it from a singleton",
                                ex);
                    }
                }
            }
            catch (BeansException ex) {
                cleanupAfterBeanCreationFailure(beanName);
                throw ex;
            }
        }

        // Check if required type matches the type of the actual bean instance.
        if (requiredType != null && bean != null && !requiredType.isAssignableFrom(bean.getClass())) {
            try {
                return getTypeConverter().convertIfNecessary(bean, requiredType);
            }
            catch (TypeMismatchException ex) {
                if (logger.isDebugEnabled()) {
                    logger.debug("Failed to convert bean ‘" + name + "‘ to required type [" +
                            ClassUtils.getQualifiedName(requiredType) + "]", ex);
                }
                throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
            }
        }
        return (T) bean;
    }

@Override
    protected Object createBean(final String beanName, final RootBeanDefinition mbd, final Object[] args)
            throws BeanCreationException {

        if (logger.isDebugEnabled()) {
            logger.debug("Creating instance of bean ‘" + beanName + "‘");
        }
        // Make sure bean class is actually resolved at this point.
        /**1.解析Bean的Class*/
        resolveBeanClass(mbd, beanName);

        // Prepare method overrides.
        try {
            /**2.方法注入准备*/
            mbd.prepareMethodOverrides();
        }
        catch (BeanDefinitionValidationException ex) {
            throw new BeanDefinitionStoreException(mbd.getResourceDescription(),
                    beanName, "Validation of method overrides failed", ex);
        }

        try {
            // Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
            /**3.BeanPostProcesser第一个扩展点,可以返回一个代理类*/
            Object bean = resolveBeforeInstantiation(beanName, mbd);
            if (bean != null) {
                return bean;
            }
        }
        catch (Throwable ex) {
            throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                    "BeanPostProcessor before instantiation of bean failed", ex);
        }
        /**4.执行spring创建bena实例的流程*/
        Object beanInstance = doCreateBean(beanName, mbd, args);
        if (logger.isDebugEnabled()) {
            logger.debug("Finished creating instance of bean ‘" + beanName + "‘");
        }
        return beanInstance;
    }

  1 protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args) {
  2         // Instantiate the bean.
  3        
  4         BeanWrapper instanceWrapper = null;
  5         if (mbd.isSingleton()) {
  6             instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
  7         }
  8         if (instanceWrapper == null) {
  9             /**5.创建bean实例*/
 10             instanceWrapper = createBeanInstance(beanName, mbd, args);
 11         }
 12         final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);
 13         Class<?> beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);
 14 
 15         // Allow post-processors to modify the merged bean definition.
 16         /**
 17          * 6.MergedBeanDefinitionPostProcessor合并父子类属性,例如：List属性
 18          */
 19         synchronized (mbd.postProcessingLock) {
 20             if (!mbd.postProcessed) {
 21                 applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
 22                 mbd.postProcessed = true;
 23             }
 24         }
 25 
 26         // Eagerly cache singletons to be able to resolve circular references
 27         // even when triggered by lifecycle interfaces like BeanFactoryAware.
 28         /**
 29          * 7.及早暴露单例bean引用，解决循环引用
 30          */
 31         boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
 32                 isSingletonCurrentlyInCreation(beanName));
 33         if (earlySingletonExposure) {
 34             if (logger.isDebugEnabled()) {
 35                 logger.debug("Eagerly caching bean ‘" + beanName +
 36                         "‘ to allow for resolving potential circular references");
 37             }
 38             //创建匿名内部类，匿名内部类会讲beanName、mbd，bean（final修饰）拷贝一份到内部类，已保证当前方法执行完成后局部变量退栈后内部类还可以访问。
 39             addSingletonFactory(beanName, new ObjectFactory<Object>() {
 40                 public Object getObject() throws BeansException {
 41                     return getEarlyBeanReference(beanName, mbd, bean);
 42                 }
 43             });
 44         }
 45 
 46         // Initialize the bean instance.
 47         Object exposedObject = bean;
 48         try {
 49             /**
 50              * 8.依赖注入
 51              */
 52             populateBean(beanName, mbd, instanceWrapper);
 53             if (exposedObject != null) {
 54                 /**
 55                  * 9.执行自定义BeanProcesser和init-method
 56                  */
 57                 exposedObject = initializeBean(beanName, exposedObject, mbd);
 58             }
 59         }
 60         catch (Throwable ex) {
 61             if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
 62                 throw (BeanCreationException) ex;
 63             }
 64             else {
 65                 throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
 66             }
 67         }
 68 
 69         if (earlySingletonExposure) {
 70             Object earlySingletonReference = getSingleton(beanName, false);
 71             if (earlySingletonReference != null) {
 72                 if (exposedObject == bean) {
 73                     exposedObject = earlySingletonReference;
 74                 }
 75                 else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
 76                     String[] dependentBeans = getDependentBeans(beanName);
 77                     Set<String> actualDependentBeans = new LinkedHashSet<String>(dependentBeans.length);
 78                     for (String dependentBean : dependentBeans) {
 79                         if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
 80                             actualDependentBeans.add(dependentBean);
 81                         }
 82                     }
 83                     if (!actualDependentBeans.isEmpty()) {
 84                         throw new BeanCurrentlyInCreationException(beanName,
 85                                 "Bean with name ‘" + beanName + "‘ has been injected into other beans [" +
 86                                 StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
 87                                 "] in its raw version as part of a circular reference, but has eventually been " +
 88                                 "wrapped. This means that said other beans do not use the final version of the " +
 89                                 "bean. This is often the result of over-eager type matching - consider using " +
 90                                 "‘getBeanNamesOfType‘ with the ‘allowEagerInit‘ flag turned off, for example.");
 91                     }
 92                 }
 93             }
 94         }
 95 
 96         // Register bean as disposable.
 97         try {
 98             /**
 99              * 10.注册DestructionAwareBeanPostProcessors和destroy-method
100              */
101             registerDisposableBeanIfNecessary(beanName, bean, mbd);
102         }
103         catch (BeanDefinitionValidationException ex) {
104             throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
105         }
106 
107         return exposedObject;
108     }

 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         /**5.1 通过静态方法来实例化bean*/
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                 if (mbd.resolvedConstructorOrFactoryMethod != null) {
20                     resolved = true;
21                     autowireNecessary = mbd.constructorArgumentsResolved;
22                 }
23             }
24         }
25         /**5.2 暂时不知道什么时候会走这???????*/
26         if (resolved) {
27             if (autowireNecessary) {
28                 return autowireConstructor(beanName, mbd, null, null);
29             }
30             else {
31                 return instantiateBean(beanName, mbd);
32             }
33         }
34 
35         // Need to determine the constructor...
36         /**5.3 BeanPostProcessor的又一个扩展点：SmartInstantiationAwareBeanPostProcessor。
37          *  检测Bean的构造器，可以检测出多个候选构造器，再有相应的策略决定使用哪一个，
38          *  如AutowiredAnnotationBeanPostProcessor实现将自动扫描通过@Autowired/@Va
39          */
40         Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
41         /**5.4 通过构造器实例化bean，包括autowire=constructor 和<constructor-arg></constructor-arg>*/
42         if (ctors != null ||
43                 mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR ||
44                 mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args))  {
45             return autowireConstructor(beanName, mbd, ctors, args);
46         }
47 
48         // No special handling: simply use no-arg constructor.
49         /**5.5 通过无参构造器实例化bean*/
50         return instantiateBean(beanName, mbd);
51     }

 1     /**
 2      * Populate the bean instance in the given BeanWrapper with the property values
 3      * from the bean definition.
 4      * @param beanName the name of the bean
 5      * @param mbd the bean definition for the bean
 6      * @param bw BeanWrapper with bean instance
 7      */
 8     protected void populateBean(String beanName, RootBeanDefinition mbd, BeanWrapper bw) {
 9         PropertyValues pvs = mbd.getPropertyValues();
10 
11         if (bw == null) {
12             if (!pvs.isEmpty()) {
13                 throw new BeanCreationException(
14                         mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
15             }
16             else {
17                 // Skip property population phase for null instance.
18                 return;
19             }
20         }
21 
22         // Give any InstantiationAwareBeanPostProcessors the opportunity to modify the
23         // state of the bean before properties are set. This can be used, for example,
24         // to support styles of field injection.
25         boolean continueWithPropertyPopulation = true;
26         /**
27          * 扩展点3：通过InstantiationAwareBeanPostProcessor给属性赋值
28          */
29         if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
30             for (BeanPostProcessor bp : getBeanPostProcessors()) {
31                 if (bp instanceof InstantiationAwareBeanPostProcessor) {
32                     InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
33                     if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
34                         continueWithPropertyPopulation = false;
35                         break;
36                     }
37                 }
38             }
39         }
40 
41         if (!continueWithPropertyPopulation) {
42             return;
43         }
44 
45         if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME ||
46                 mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
47             MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
48 
49             // Add property values based on autowire by name if applicable.
50             if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) {
51                 //根据Name自动装配
52                 autowireByName(beanName, mbd, bw, newPvs);
53             }
54 
55             // Add property values based on autowire by type if applicable.
56             if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
57                 //根据Type自动装配
58                 autowireByType(beanName, mbd, bw, newPvs);
59             }
60 
61             pvs = newPvs;
62         }
63 
64         boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
65         boolean needsDepCheck = (mbd.getDependencyCheck() != RootBeanDefinition.DEPENDENCY_CHECK_NONE);
66 
67         if (hasInstAwareBpps || needsDepCheck) {
68             PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
69             if (hasInstAwareBpps) {
70                 /**
71                  * InstantiationAwareBeanPostProcesser在属性注入之前的扩展点
72                  */
73                 for (BeanPostProcessor bp : getBeanPostProcessors()) {
74                     if (bp instanceof InstantiationAwareBeanPostProcessor) {
75                         InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
76                         pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
77                         if (pvs == null) {
78                             return;
79                         }
80                     }
81                 }
82             }
83             /**是否需要依赖检查*/
84             if (needsDepCheck) {
85                 checkDependencies(beanName, mbd, filteredPds, pvs);
86             }
87         }
88         /**属性注入*/
89         applyPropertyValues(beanName, mbd, bw, pvs);
90     }

 1                 //省略..... 2                 if (System.getSecurityManager() != null) {
 3                     try {
 4                         AccessController.doPrivileged(new PrivilegedExceptionAction<Object>() {
 5                             public Object run() throws Exception {
 6                                 writeMethod.invoke(object, value);
 7                                 return null;
 8                             }
 9                         }, acc);
10                     }
11                     catch (PrivilegedActionException ex) {
12                         throw ex.getException();
13                     }
14                 }
15                 else {
16                     writeMethod.invoke(this.object, value);
17                 }
18             }

　　　　　　　　  //省略.....

 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             /**1.为实现Aware接口的bean设置一些相应的资源**/
12             invokeAwareMethods(beanName, bean);
13         }
14 
15         Object wrappedBean = bean;
16         if (mbd == null || !mbd.isSynthetic()) {
17             /**2.调用BeanPostProcesser postProcessBeforeInitialization方法*/
18             wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
19         }
20 
21         try {
22             /**3.调用InitializingBean的afterPropertiesSet方法
23              *   调用自定义init-method
24              */
25             invokeInitMethods(beanName, wrappedBean, mbd);
26         }
27         catch (Throwable ex) {
28             throw new BeanCreationException(
29                     (mbd != null ? mbd.getResourceDescription() : null),
30                     beanName, "Invocation of init method failed", ex);
31         }
32 
33         if (mbd == null || !mbd.isSynthetic()) {
34             /**
35              * 4.调用BeanPostProcesser postProcessAfterInitialization方法
36              */
37             wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
38         }
39         return wrappedBean;
40     }

 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             //单例
 5             if (mbd.isSingleton()) {
 6                 // Register a DisposableBean implementation that performs all destruction
 7                 // work for the given bean: DestructionAwareBeanPostProcessors,
 8                 // DisposableBean interface, custom destroy method.
 9                 registerDisposableBean(beanName,
10                         new DisposableBeanAdapter(bean, beanName, mbd, getBeanPostProcessors(), acc));
11             }
12             else {
13                 // A bean with a custom scope...
14                 Scope scope = this.scopes.get(mbd.getScope());
15                 if (scope == null) {
16                     throw new IllegalStateException("No Scope registered for scope ‘" + mbd.getScope() + "‘");
17                 }
18                 scope.registerDestructionCallback(beanName,
19                         new DisposableBeanAdapter(bean, beanName, mbd, getBeanPostProcessors(), acc));
20             }
21         }
22     }

public void registerDisposableBean(String beanName, DisposableBean bean) {
        synchronized (this.disposableBeans) {
            this.disposableBeans.put(beanName, bean);
        }
    }

public DisposableBeanAdapter(Object bean, String beanName, RootBeanDefinition beanDefinition,
            List<BeanPostProcessor> postProcessors, AccessControlContext acc) {

        Assert.notNull(bean, "Disposable bean must not be null");
        this.bean = bean;
        this.beanName = beanName;
        this.invokeDisposableBean =
                (this.bean instanceof DisposableBean && !beanDefinition.isExternallyManagedDestroyMethod("destroy"));
        this.nonPublicAccessAllowed = beanDefinition.isNonPublicAccessAllowed();
        this.acc = acc;
        String destroyMethodName = inferDestroyMethodIfNecessary(bean, beanDefinition);
        if (destroyMethodName != null && !(this.invokeDisposableBean && "destroy".equals(destroyMethodName)) &&
                !beanDefinition.isExternallyManagedDestroyMethod(destroyMethodName)) {
            this.destroyMethodName = destroyMethodName;
            this.destroyMethod = determineDestroyMethod();
            if (this.destroyMethod == null) {
                if (beanDefinition.isEnforceDestroyMethod()) {
                    throw new BeanDefinitionValidationException("Couldn‘t find a destroy method named ‘" +
                            destroyMethodName + "‘ on bean with name ‘" + beanName + "‘");
                }
            }
            else {
                Class<?>[] paramTypes = this.destroyMethod.getParameterTypes();
                if (paramTypes.length > 1) {
                    throw new BeanDefinitionValidationException("Method ‘" + destroyMethodName + "‘ of bean ‘" +
                            beanName + "‘ has more than one parameter - not supported as destroy method");
                }
                else if (paramTypes.length == 1 && !paramTypes[0].equals(boolean.class)) {
                    throw new BeanDefinitionValidationException("Method ‘" + destroyMethodName + "‘ of bean ‘" +
                            beanName + "‘ has a non-boolean parameter - not supported as destroy method");
                }
            }
        }
        this.beanPostProcessors = filterPostProcessors(postProcessors);
    }