Spring技术内幕——Spring Framework的IOC容器实现（4）

前面分析了BeanDefinition在IOC容器中的载入和解析过程。在这些动作完成以后，用户定义的BeanDefinition信息已经在容器内建立起了自己的数据结构以及相应的数据表示，但此时这些数据不能供IOC容器直接使用，需要在IOC容器中对这些BeanDefinition数据进行注册。这个注册为IOC容器提供了更友好的使用方式，在DefaultListableBeanFactory中，是通过HashMap来持有载入的BeanDefinition，这个HashMap的定义在DefaultListableBeanFactory中可以看到，如下：

/** Map from serialized id to factory instance */    private static final Map<String, Reference<DefaultListableBeanFactory>> serializableFactories =            new ConcurrentHashMap<String, Reference<DefaultListableBeanFactory>>(8);

在DefaultListableBeanFactory中实现了BeanDefinitionRegistry的接口，这个接口的实现完成了BeanDefinition向容器的注册。这个注册过程不复杂，就是把解析得到的BeanDefinition设置到HashMap中去。需要注意的是，如果遇到同名的BeanDefinition，进行处理的时候需要依据allowBeanDefinitionOverriding的配置来完成，代码如下：

//---------------------------------------------------------------------    // Implementation of BeanDefinitionRegistry interface    //---------------------------------------------------------------------    public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)            throws BeanDefinitionStoreException {        Assert.hasText(beanName, "Bean name must not be empty");        Assert.notNull(beanDefinition, "BeanDefinition must not be null");        if (beanDefinition instanceof AbstractBeanDefinition) {            try {                ((AbstractBeanDefinition) beanDefinition).validate();            }            catch (BeanDefinitionValidationException ex) {                throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,                        "Validation of bean definition failed", ex);            }        }        // 注册过程需要synchronized，保证数据的一致性        synchronized (this.beanDefinitionMap) {            // 这里检查是不是有相同名字的BeanDefinition已经在IOC容器中注册了，如果有相同名字的BeanDefinition            // 但又不允许覆盖，那会抛出异常            Object oldBeanDefinition = this.beanDefinitionMap.get(beanName);            if (oldBeanDefinition != null) {                if (!this.allowBeanDefinitionOverriding) {                    throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,                            "Cannot register bean definition [" + beanDefinition + "] for bean '" + beanName +                            "': There is already [" + oldBeanDefinition + "] bound.");                }                else {                    if (this.logger.isInfoEnabled()) {                        this.logger.info("Overriding bean definition for bean '" + beanName +                                "': replacing [" + oldBeanDefinition + "] with [" + beanDefinition + "]");                    }                }            }            // 这是正常注册BeanDefinition的过程，把Bean的名字存入到BeanDefinitionNames的同时，把BeanName作为            // Map的key，把beanDefinition作为value存入到IOC容器持有的beanDefinitionMap中去            else {                this.beanDefinitionNames.add(beanName);                this.frozenBeanDefinitionNames = null;            }            this.beanDefinitionMap.put(beanName, beanDefinition);        }        resetBeanDefinition(beanName);    }

完成BeanDefinition的注册，就完成了IOC容器的初始化过程。此时，在使用IOC容器DefaultListableBeanFactory中已经建立了整个Bean的配置信息，而且这些BeanDefinition已经可以被容器使用了，他们都在BeanDefinitionMap里被检索和使用。容器的作用就是对这些信息进行处理和维护，这些信息时容器建立以来反转的基础，下面我们看看依赖注入是怎么完成的。
4、IOC容器的依赖注入
上面对IOC容器的初始化进行了详细的分析，这个初始化过程完成的主要工作是在IOC容器中建立BeanDefinition的数据映射。在此过程中并没有看到IOC容器对Bean依赖关系进行注入，接下来分析一下IOC容器是怎样对Bean的依赖关系进行注入的。
假设当前IOC容器已经载入了用户定义的Bean信息，开始分析依赖注入的原理。首先，注意到依赖注入的过程是用户第一次想IOC容器索要Bean时触发的，当然，也有例外，也就是我们可以在BeanDefinition信息中通过控制lazy-init属性来让容器完成Bean的预实例化。这个预实例化实际上也是一个完成依赖注入的过程，但他是在初始化的过程中完成的，稍后我们会详细分析这个预实例化处理。当用户向IOC容器索要Bean时，如果读者还有印象那一定还记得在基本的IOC容器接口BeanFactory中有一个getBean的接口定义，这个接口的实现就是触发依赖注入发生的地方。下面从DefaultListableBeanFactory的基类 AbstractBeanFactory入手去看看getBean的实现，代码如下:

    //---------------------------------------------------------------------    // Implementation of BeanFactory interface    //---------------------------------------------------------------------    // AbstractBeanFactory extends FactoryBeanRegistrySupport implements ConfigurableBeanFactory    public Object getBean(String name) throws BeansException {        return doGetBean(name, null, null, false);    }    public <T> T getBean(String name, Class<T> requiredType) throws BeansException {        return doGetBean(name, requiredType, null, false);    }    public Object getBean(String name, Object... args) throws BeansException {        return doGetBean(name, null, args, false);    }

下面是实际取得Bean的地方，也是触发依赖注入发生的地方

    /**     * 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 {        final String beanName = transformedBeanName(name);        Object bean;        // 先冲缓存中取得Bean，处理那些已经被创建过的单件模式的Bean，这个Bean的请求不需要重复创建        // Eagerly check singleton cache for manually registered singletons.        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 + "'");                }            }            // 这里的getObjectForBeanInstance完成的是FactoryBean的相关处理，以取得FactoryBean的产生效果            // BeanFactory和FactoryBean的区别已经在前面讲过            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.            // 这里对IOC容器中的BeanDefinition是否存在进行检查，检查是否能在当前的BeanFactory中取得需要的Bean，如果            // 当前的工厂中取不到，则到双亲BeanFactory中去取，如果当前的双亲工厂取不到，那就顺着BeanFactory链            // 一直向上找            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);                }            }            if (!typeCheckOnly) {                markBeanAsCreated(beanName);            }            try {                // 这里根据Bean的名字取得BeanDefinition                final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);                checkMergedBeanDefinition(mbd, beanName, args);                // 获取当前的Bean的所有依赖Bean，这样会触发getBean的递归调用，直到取到一个没有任何依赖的Bean为止                // Guarantee initialization of beans that the current bean depends on.                String[] dependsOn = mbd.getDependsOn();                if (dependsOn != null) {                    for (String dependsOnBean : dependsOn) {                        getBean(dependsOnBean);                        registerDependentBean(dependsOnBean, beanName);                    }                }                // Create bean instance.                // 这里通过调用createBean方法创建SingleTon Bean的实例，这里有一个回调函数getObject，会在getSingleTon                // 中调用ObjectFactory的createBean                // 下面会进入到createBean中进行详细分析                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);                }                // 创建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);                }                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.        // 对创建的Bean进行类型检查，如果没有问题就返回新建的Bean，这个Bean已经是包含了依赖关系的Bean        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;    }

这是依赖注入的入口，在这里出发了依赖注入，而依赖注入的发生是在容器中的BeanDefinition数据已经建立好的前提下进行的。“程序=数据+算法”，很经典，前面的BeanDefinition就是数据，下面看看这些数据是怎样为依赖注入服务的。虽然依赖注入的过程不涉及复杂的算法问题，但这个过程也不简单，我们都知道，对于IOC容器的使用，Spring提供了许多的参数配置，每一个参数配置实际上代表了一个IOC容器的实现特性，这些特性的实现很多都需要在依赖注入的过程中或者对Bean进行生命周期管理的过程 中完成。尽管可以用最简单的的方式来描述IOC容器，将他视为一个HashMap，但只能是这个hashMap，但只能说这个HashMap是容器的最基本的数据结构，而不是IOC容器的全部。Spring IOC容器作为一个产品，其价值体现在一系列相关的产品特性上，这些产品特性以依赖反转模式的实现为核心，为用户更好的使用依赖反转提供便利，从而实现了一个完整的IOC容器产品。这些产品特性的实现并不是一个简单的过程，他提供了一个成熟的IOC容器产品共用户使用。所以，尽管Spring IOC容器没有什么独特的算法，但却可以看出是一个成功的软件工程产品，有许多值得我们学习的地方。下面看一个依赖注入的大致过程：

重点来说，getBean是依赖注入的起点，之后会调用createBean，下面通过createBean代码来了解这个实现过程。在这个过程中，Bean对象会一局BeanDefinition定义的要求生成。在AbstractAutowireCapableBeanFactory中实现了这个createBean，createBean不但生成了需要的Bean，还对Bean初始化进行了处理，比如实现了在BeanDefinition中的init-method属性定义，Bean后置处理器等。具体代码如下：

    /**     * Central method of this class: creates a bean instance,     * populates the bean instance, applies post-processors, etc.     * @see #doCreateBean     * class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory implements      * AutowireCapableBeanFactory     */    @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.        // 这里需要判断需要创建的Bean是否可以实例化，这个类是否可以通过类装载器来载入        resolveBeanClass(mbd, beanName);        // Prepare method overrides.        try {            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.            // 如果Bean配置了PostProcessor，那么这里返回的是一个proxy            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);        }        // 这里是创建Bean的调用        Object beanInstance = doCreateBean(beanName, mbd, args);        if (logger.isDebugEnabled()) {            logger.debug("Finished creating instance of bean '" + beanName + "'");        }        return beanInstance;    }

接着到doCreateBean中看看Bean是怎样生成的

/**     * Actually create the specified bean. Pre-creation processing has already happened     * at this point, e.g. checking [email protected] postProcessBeforeInstantiation} callbacks.     * <p>Differentiates between default bean instantiation, use of a     * factory method, and autowiring a constructor.     * @param beanName the name of the bean     * @param mbd the merged bean definition for the bean     * @param args arguments to use if creating a prototype using explicit arguments to a     * static factory method. This parameter must be [email protected] null} except in this case.     * @return a new instance of the bean     * @throws BeanCreationException if the bean could not be created     * @see #instantiateBean     * @see #instantiateUsingFactoryMethod     * @see #autowireConstructor     */    protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args) {        // Instantiate the bean.        // 这个BeanWrapper是用来持有创建出来的Bean对象的        BeanWrapper instanceWrapper = null;        // 如果是SingleTon，先把缓存中的同名Bean清除        if (mbd.isSingleton()) {            instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);        }        // 这是创建Bean的地方，由createBeanInstance来完成        if (instanceWrapper == null) {            instanceWrapper = createBeanInstance(beanName, mbd, args);        }        final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);        Class<?> beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);        // Allow post-processors to modify the merged bean definition.        synchronized (mbd.postProcessingLock) {            if (!mbd.postProcessed) {                applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);                mbd.postProcessed = true;            }        }        // Eagerly cache singletons to be able to resolve circular references        // even when triggered by lifecycle interfaces like BeanFactoryAware.        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");            }            addSingletonFactory(beanName, new ObjectFactory<Object>() {                public Object getObject() throws BeansException {                    return getEarlyBeanReference(beanName, mbd, bean);                }            });        }        // Initialize the bean instance.        // 这里是对Bean初始化、依赖注入往往这里发生，这个exposedObject在初始化处理完成以后会返回        // 作为依赖注入完成后的Bean        Object exposedObject = bean;        try {            populateBean(beanName, mbd, instanceWrapper);            if (exposedObject != null) {                exposedObject = initializeBean(beanName, exposedObject, mbd);            }        }        catch (Throwable ex) {            if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {                throw (BeanCreationException) ex;            }            else {                throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);            }        }        if (earlySingletonExposure) {            Object earlySingletonReference = getSingleton(beanName, false);            if (earlySingletonReference != null) {                if (exposedObject == bean) {                    exposedObject = earlySingletonReference;                }                else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {                    String[] dependentBeans = getDependentBeans(beanName);                    Set<String> actualDependentBeans = new LinkedHashSet<String>(dependentBeans.length);                    for (String dependentBean : dependentBeans) {                        if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {                            actualDependentBeans.add(dependentBean);                        }                    }                    if (!actualDependentBeans.isEmpty()) {                        throw new BeanCurrentlyInCreationException(beanName,                                "Bean with name '" + beanName + "' has been injected into other beans [" +                                StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +                                "] in its raw version as part of a circular reference, but has eventually been " +                                "wrapped. This means that said other beans do not use the final version of the " +                                "bean. This is often the result of over-eager type matching - consider using " +                                "'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");                    }                }            }        }        // Register bean as disposable.        try {            registerDisposableBeanIfNecessary(beanName, bean, mbd);        }        catch (BeanDefinitionValidationException ex) {            throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);        }        return exposedObject;    }

在这里我们看到与依赖注入关系特别密切的方法有createBeanInstance何populateBean,下面分被介绍着两个方法。在createBeanInstance中生成了Bean所包含的Java对象，这个对象的生成有很多种不同的方式，可以通过工厂方法生成，也可以通过容器的autowire特性生成，这些生成方式都是由相关的BeanDefinition来指定的。代码如下：

/**     * Create a new instance for the specified bean, using an appropriate instantiation strategy:     * factory method, constructor autowiring, or simple instantiation.     * @param beanName the name of the bean     * @param mbd the bean definition for the bean     * @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.     * @return BeanWrapper for the new instance     * @see #instantiateUsingFactoryMethod     * @see #autowireConstructor     * @see #instantiateBean     */    protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, Object[] args) {        // Make sure bean class is actually resolved at this point.        // 确认需要创建的Bean实例的类可以实例化        Class<?> beanClass = resolveBeanClass(mbd, beanName);        // 这里使用工厂方法对Bean进行实例化        if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {            throw new BeanCreationException(mbd.getResourceDescription(), beanName,                    "Bean class isn't public, and non-public access not allowed: " + beanClass.getName());        }        if (mbd.getFactoryMethodName() != null)  {            return instantiateUsingFactoryMethod(beanName, mbd, args);        }        // Shortcut when re-creating the same bean...        boolean resolved = false;        boolean autowireNecessary = false;        if (args == null) {            synchronized (mbd.constructorArgumentLock) {                if (mbd.resolvedConstructorOrFactoryMethod != null) {                    resolved = true;                    autowireNecessary = mbd.constructorArgumentsResolved;                }            }        }        if (resolved) {            if (autowireNecessary) {                return autowireConstructor(beanName, mbd, null, null);            }            else {                return instantiateBean(beanName, mbd);            }        }        // Need to determine the constructor...        // 使用构造函数进行实例化        Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);        if (ctors != null ||                mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR ||                mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args))  {            return autowireConstructor(beanName, mbd, ctors, args);        }        // No special handling: simply use no-arg constructor.        // 使用默认的构造函数对Bean进行实例化        return instantiateBean(beanName, mbd);    }

下面看看最常见的实例化过程instantiateBean

    /**     * Instantiate the given bean using its default constructor.     * @param beanName the name of the bean     * @param mbd the bean definition for the bean     * @return BeanWrapper for the new instance     */    protected BeanWrapper instantiateBean(final String beanName, final RootBeanDefinition mbd) {        // 使用默认的实例化策略对Bean进行实例化，默认的实例化策略时CglibSubclassingInstantiationStrategy        // 也就是使用Cglib来对Bean进行实例化，接着再看CglibSubclassingInstantiationStraegy的实现        try {            Object beanInstance;            final BeanFactory parent = this;            if (System.getSecurityManager() != null) {                beanInstance = AccessController.doPrivileged(new PrivilegedAction<Object>() {                    public Object run() {                        return getInstantiationStrategy().instantiate(mbd, beanName, parent);                    }                }, getAccessControlContext());            }            else {                beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent);            }            BeanWrapper bw = new BeanWrapperImpl(beanInstance);            initBeanWrapper(bw);            return bw;        }        catch (Throwable ex) {            throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Instantiation of bean failed", ex);        }    }

这里用CGLIB对Bean进行实例化，CGLIB是一个常用的字节码生成器的类库，他提供了一些列的API来提供生成和转换Java字节码功能。在Spring AOP中也使用了CGLIB对Java的字节码进行增强。在IOC容器中，要了解怎样使用CGLIB来生成Bean对象，需要看一下SimpleInstantiationStrategy类，这个Strategy是Spring用来生成Bean对象的默认类，他提供了两种实例化Java对象的方法，一种是通过BeanUtils，他使用了JVM的反射功能，一种是前面提到的CGLIB来生成，代码如下：

public Object instantiate(RootBeanDefinition beanDefinition, String beanName, BeanFactory owner) {        // Don't override the class with CGLIB if no overrides.        if (beanDefinition.getMethodOverrides().isEmpty()) {            // 这里取得指定的构造器或者生成的对象的工程方法来对Bean进行实例化            Constructor<?> constructorToUse;            synchronized (beanDefinition.constructorArgumentLock) {                constructorToUse = (Constructor<?>) beanDefinition.resolvedConstructorOrFactoryMethod;                if (constructorToUse == null) {                    final Class<?> clazz = beanDefinition.getBeanClass();                    if (clazz.isInterface()) {                        throw new BeanInstantiationException(clazz, "Specified class is an interface");                    }                    try {                        if (System.getSecurityManager() != null) {                            constructorToUse = AccessController.doPrivileged(new PrivilegedExceptionAction<Constructor>() {                                public Constructor<?> run() throws Exception {                                    return clazz.getDeclaredConstructor((Class[]) null);                                }                            });                        }                        else {                            constructorToUse =  clazz.getDeclaredConstructor((Class[]) null);                        }                        beanDefinition.resolvedConstructorOrFactoryMethod = constructorToUse;                    }                    catch (Exception ex) {                        throw new BeanInstantiationException(clazz, "No default constructor found", ex);                    }                }            }            // 通过BeanUtils进行实例化，这个BeanUtils的实例化通过Constructor来实例化Bean            // 在BeanUtils中可以看到具体的调用ctor.newInstance(args)            return BeanUtils.instantiateClass(constructorToUse);        }        else {            // Must generate CGLIB subclass.            // 使用CGLIB来实例化对象            return instantiateWithMethodInjection(beanDefinition, beanName, owner);        }    }

在cglibSubclassingInstantiationStrategy中可以看到具体的实例化过程和CGLIB的使用方法，这里就不对CGLIB的使用进行过多的阐述了，如果读者有兴趣，可以去阅读CGLIB的使用文档，这里的Enhancer类，已经是CGLIB类了，通过这个Enhancer生成Java对象，使用Enhancer的create方法，代码如下：

       /**         * Create a new instance of a dynamically generated subclasses implementing the         * required lookups.         * @param ctor constructor to use. If this is {@code null}, use the         * no-arg constructor (no parameterization, or Setter Injection)         * @param args arguments to use for the constructor.         * Ignored if the ctor parameter is {@code null}.         * @return new instance of the dynamically generated class         * class CglibSubclassingInstantiationStrategy extends SimpleInstantiationStrategy         */        // 使用CGLIB的Enhancer生成Java对象        public Object instantiate(Constructor<?> ctor, Object[] args) {            // 生成Enhancer对象，并为Enhancer对象设置生成Java对象的参数，比如基类、回调方法等            Enhancer enhancer = new Enhancer();            enhancer.setSuperclass(this.beanDefinition.getBeanClass());            enhancer.setNamingPolicy(SpringNamingPolicy.INSTANCE);            enhancer.setCallbackFilter(new CallbackFilterImpl());            enhancer.setCallbacks(new Callback[] {                    NoOp.INSTANCE,                    new LookupOverrideMethodInterceptor(),                    new ReplaceOverrideMethodInterceptor()            });            // 使用CGLIB的create生成实例化的Bean对象            return (ctor != null ? enhancer.create(ctor.getParameterTypes(), args) : enhancer.create());        }

到这里已经分析了实例化Bean对象的整个过程，在实例化Bean对象生成的基础上，再介绍Spring是怎样对这些对象进行处理的，也就是Bean对象生成以后，怎样把这些Bean对象的依赖关系设置好，完成整个依赖注入过程。这个过程涉及对各种Bean对象的属性处理过程（依赖关系的处理过程）这些依赖关系处理的一局就是已经解析得到的BeanDefinition。要详细了解这个过程，需要回到前面的populateBean方法，在AbstractAutowireCapableBeanFactory中，代码如下：

/**     * Populate the bean instance in the given BeanWrapper with the property values     * from the bean definition.     * @param beanName the name of the bean     * @param mbd the bean definition for the bean     * @param bw BeanWrapper with bean instance     */    protected void populateBean(String beanName, RootBeanDefinition mbd, BeanWrapper bw) {        // 这里取得在BeanDefinition中设置的property值，这个property来自对BeanDefinition的解析        // 具体的解析过程可以参看对载入和解析的BeanDefinition分析        PropertyValues pvs = mbd.getPropertyValues();        if (bw == null) {            if (!pvs.isEmpty()) {                throw new BeanCreationException(                        mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");            }            else {                // Skip property population phase for null instance.                return;            }        }        // Give any InstantiationAwareBeanPostProcessors the opportunity to modify the        // state of the bean before properties are set. This can be used, for example,        // to support styles of field injection.        boolean continueWithPropertyPopulation = true;        if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {            for (BeanPostProcessor bp : getBeanPostProcessors()) {                if (bp instanceof InstantiationAwareBeanPostProcessor) {                    InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;                    if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {                        continueWithPropertyPopulation = false;                        break;                    }                }            }        }        if (!continueWithPropertyPopulation) {            return;        }        // 开始依赖注入过程，先处理autowire的注入        if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME ||                mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {            MutablePropertyValues newPvs = new MutablePropertyValues(pvs);            // Add property values based on autowire by name if applicable.            // 这里是对autowire注入的处理，可以根据Bean的名字或者类型            if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) {                autowireByName(beanName, mbd, bw, newPvs);            }            // Add property values based on autowire by type if applicable.            if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {                autowireByType(beanName, mbd, bw, newPvs);            }            pvs = newPvs;        }        boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();        boolean needsDepCheck = (mbd.getDependencyCheck() != RootBeanDefinition.DEPENDENCY_CHECK_NONE);        if (hasInstAwareBpps || needsDepCheck) {            PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);            if (hasInstAwareBpps) {                for (BeanPostProcessor bp : getBeanPostProcessors()) {                    if (bp instanceof InstantiationAwareBeanPostProcessor) {                        InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;                        pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);                        if (pvs == null) {                            return;                        }                    }                }            }            if (needsDepCheck) {                checkDependencies(beanName, mbd, filteredPds, pvs);            }        }        // 对属性进行注入        applyPropertyValues(beanName, mbd, bw, pvs);

通过applyPropertyValues了解具体的对属性进行解析然后注入过程

/**     * Apply the given property values, resolving any runtime references     * to other beans in this bean factory. Must use deep copy, so we     * don't permanently modify this property.     * @param beanName the bean name passed for better exception information     * @param mbd the merged bean definition     * @param bw the BeanWrapper wrapping the target object     * @param pvs the new property values     */    protected void applyPropertyValues(String beanName, BeanDefinition mbd, BeanWrapper bw, PropertyValues pvs) {        if (pvs == null || pvs.isEmpty()) {            return;        }        MutablePropertyValues mpvs = null;        List<PropertyValue> original;        if (System.getSecurityManager() != null) {            if (bw instanceof BeanWrapperImpl) {                ((BeanWrapperImpl) bw).setSecurityContext(getAccessControlContext());            }        }        if (pvs instanceof MutablePropertyValues) {            mpvs = (MutablePropertyValues) pvs;            if (mpvs.isConverted()) {                // Shortcut: use the pre-converted values as-is.                try {                    bw.setPropertyValues(mpvs);                    return;                }                catch (BeansException ex) {                    throw new BeanCreationException(                            mbd.getResourceDescription(), beanName, "Error setting property values", ex);                }            }            original = mpvs.getPropertyValueList();        }        else {            original = Arrays.asList(pvs.getPropertyValues());        }        TypeConverter converter = getCustomTypeConverter();        if (converter == null) {            converter = bw;        }        // 这个BeanDefinitionValueResolver对BeanDefinition的解析是在这个valueResolver中完成        BeanDefinitionValueResolver valueResolver = new BeanDefinitionValueResolver(this, beanName, mbd, converter);        // Create a deep copy, resolving any references for values.        // 这里为解析值创建一个副本，副本的数据将会被注入到bean中        List<PropertyValue> deepCopy = new ArrayList<PropertyValue>(original.size());        boolean resolveNecessary = false;        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;                boolean convertible = bw.isWritableProperty(propertyName) &&                        !PropertyAccessorUtils.isNestedOrIndexedProperty(propertyName);                if (convertible) {                    convertedValue = convertForProperty(resolvedValue, propertyName, bw, converter);                }                // Possibly store converted value in merged bean definition,                // in order to avoid re-conversion for every created bean instance.                if (resolvedValue == originalValue) {                    if (convertible) {                        pv.setConvertedValue(convertedValue);                    }                    deepCopy.add(pv);                }                else if (convertible && originalValue instanceof TypedStringValue &&                        !((TypedStringValue) originalValue).isDynamic() &&                        !(convertedValue instanceof Collection || ObjectUtils.isArray(convertedValue))) {                    pv.setConvertedValue(convertedValue);                    deepCopy.add(pv);                }                else {                    resolveNecessary = true;                    deepCopy.add(new PropertyValue(pv, convertedValue));                }            }        }        if (mpvs != null && !resolveNecessary) {            mpvs.setConverted();        }        // Set our (possibly massaged) deep copy.        // 这里是发生依赖注入的地方，会在BeanWrapperImpl中完成        try {            bw.setPropertyValues(new MutablePropertyValues(deepCopy));        }        catch (BeansException ex) {            throw new BeanCreationException(                    mbd.getResourceDescription(), beanName, "Error setting property values", ex);        }    }

未完待续……