Spring IOC容器依赖注入

　　当IOC容器完成了bean资源的定位、载入和注册以后，开始对管理的bean进行依赖注入。

　　IOC容器依赖注入的过程是用户第一次向IOC容器索取bean时触发的，当然也有例外，也就是我们可以在BeanDefinition信息中通过lazy-init属性来让容器完成对bean的预实例化。这个预实例化实际上也是一个完成依赖注入的过程，但是它是在初始化过程中完成的。

　　当用户向IOC容器索取bean时，在BeanFactory中有一个getBean的接口定义，这个接口的实现就是触发依赖注入发生的地方，下面从DefaultListableBeanFactory的基类AbstractBeanFactory入手看看getBean的实现，源码：

    public Object getBean(String name) throws BeansException {
        return this.doGetBean(name, (Class)null, (Object[])null, false);
    }

    public <T> T getBean(String name, Class<T> requiredType) throws BeansException {
        return this.doGetBean(name, requiredType, (Object[])null, false);
    }

    public Object getBean(String name, Object... args) throws BeansException {
        return this.doGetBean(name, (Class)null, args, false);
    }

    public <T> T getBean(String name, Class<T> requiredType, Object... args) throws BeansException {
        return this.doGetBean(name, requiredType, args, false);
    }

　　//这里是实际取得Bean的地方，也是触发依赖注入发生的地方
    protected <T> T doGetBean(String name, Class<T> requiredType, final Object[] args, boolean typeCheckOnly) throws BeansException {
        final String beanName = this.transformedBeanName(name);
　　　　　//先从缓存中取得bean，处理那些已经被创建过的单例模式的bean，对这种bean的请求不需要重复的创建
        Object sharedInstance = this.getSingleton(beanName);
        Object bean;
        if(sharedInstance != null && args == null) {
            if(this.logger.isDebugEnabled()) {
                if(this.isSingletonCurrentlyInCreation(beanName)) {
                    this.logger.debug("Returning eagerly cached instance of singleton bean \'" + beanName + "\' that is not fully initialized yet - a consequence of a circular reference");
                } else {
                    this.logger.debug("Returning cached instance of singleton bean \'" + beanName + "\'");
                }
            }
　　　　　　　//这里的getObjectForBeanInstance完成的是FactoryBean的相关处理，以取得FactoryBean的生产结果
            bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, (RootBeanDefinition)null);
        } else {
            if(this.isPrototypeCurrentlyInCreation(beanName)) {
                throw new BeanCurrentlyInCreationException(beanName);
            }
　　　　　　　//这里对IOC容器中的BeanDefinition是否存在进行检查，检查是否能在当前BeanFactory中取得需要的bean
　　　　　　　//如果在当前的工厂中取不到，则到双亲的BeanFactory中去取，如果当前的双亲工厂取不到，那就顺着双亲BeanFactory链一直向上找
            BeanFactory ex = this.getParentBeanFactory();
            if(ex != null && !this.containsBeanDefinition(beanName)) {
                String var24 = this.originalBeanName(name);
                if(args != null) {
                    return ex.getBean(var24, args);
                }

                return ex.getBean(var24, requiredType);
            }

            if(!typeCheckOnly) {
                this.markBeanAsCreated(beanName);
            }

            try {
　　　　　　　　　　//根据bean名字取得BeanDefinition
                final RootBeanDefinition ex1 = this.getMergedLocalBeanDefinition(beanName);
                this.checkMergedBeanDefinition(ex1, beanName, args);
　　　　　　　　　 //获取当前bean的所有依赖bean，这样会触发getBean的递归调用，知道取到一个没有任何依赖的bean为止
                String[] dependsOn = ex1.getDependsOn();
                String[] scopeName;
                if(dependsOn != null) {
                    scopeName = dependsOn;
                    int scope = dependsOn.length;

                    for(int ex2 = 0; ex2 < scope; ++ex2) {
                        String dep = scopeName[ex2];
                        if(this.isDependent(beanName, dep)) {
                            throw new BeanCreationException(ex1.getResourceDescription(), beanName, "Circular depends-on relationship between \'" + beanName + "\' and \'" + dep + "\'");
                        }

                        this.registerDependentBean(dep, beanName);
                        this.getBean(dep);
                    }
                }
　　　　　　　　　　//这里通过调用createBean方法创建Singleton bean的实例，这里有一个回调函数getObject，会在getSingleton中调用ObjectFactory的createBean
                if(ex1.isSingleton()) {
                    sharedInstance = this.getSingleton(beanName, new ObjectFactory() {
                        public Object getObject() throws BeansException {
                            try {
                                return AbstractBeanFactory.this.createBean(beanName, ex1, args);
                            } catch (BeansException var2) {
                                AbstractBeanFactory.this.destroySingleton(beanName);
                                throw var2;
                            }
                        }
                    });
                    bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, ex1);
                } else if(ex1.isPrototype()) {//这里是创建prototype bean的地方
                    scopeName = null;

                    Object var25;
                    try {
                        this.beforePrototypeCreation(beanName);
                        var25 = this.createBean(beanName, ex1, args);
                    } finally {
                        this.afterPrototypeCreation(beanName);
                    }

                    bean = this.getObjectForBeanInstance(var25, name, beanName, ex1);
                } else {
                    String var26 = ex1.getScope();
                    Scope var27 = (Scope)this.scopes.get(var26);
                    if(var27 == null) {
                        throw new IllegalStateException("No Scope registered for scope name \'" + var26 + "\'");
                    }

                    try {
                        Object var28 = var27.get(beanName, new ObjectFactory() {
                            public Object getObject() throws BeansException {
                                AbstractBeanFactory.this.beforePrototypeCreation(beanName);

                                Object var1;
                                try {
                                    var1 = AbstractBeanFactory.this.createBean(beanName, ex1, args);
                                } finally {
                                    AbstractBeanFactory.this.afterPrototypeCreation(beanName);
                                }

                                return var1;
                            }
                        });
                        bean = this.getObjectForBeanInstance(var28, name, beanName, ex1);
                    } catch (IllegalStateException var21) {
                        throw new BeanCreationException(beanName, "Scope \'" + var26 + "\' 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", var21);
                    }
                }
            } catch (BeansException var23) {
                this.cleanupAfterBeanCreationFailure(beanName);
                throw var23;
            }
        }
　　　　//对创建的bean进行类型检查，如果没有问题，就返回这个bean，这个bean已经是包含了依赖关系的bean
        if(requiredType != null && bean != null && !requiredType.isAssignableFrom(bean.getClass())) {
            try {
                return this.getTypeConverter().convertIfNecessary(bean, requiredType);
            } catch (TypeMismatchException var22) {
                if(this.logger.isDebugEnabled()) {
                    this.logger.debug("Failed to convert bean \'" + name + "\' to required type \'" + ClassUtils.getQualifiedName(requiredType) + "\'", var22);
                }

                throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
            }
        } else {
            return bean;
        }
    }

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

　　getBean是依赖注入的起点，之后会调用createBean，在这个过程中，Bean对象会根据BeanDefinition定义的要求生成。在AbstractAutowireCapableBeanFactory中实现了这个createBean，createBean不但生成了需要的bean，还对bean初始化进行了处理，比如实现了在BeanDefinition中的init-method属性定义，Bean后置处理器等，具体过程如下图所示：

　　　　

接着看createBean源码：

protected Object createBean(String beanName, RootBeanDefinition mbd, Object[] args) throws BeanCreationException {
        if(this.logger.isDebugEnabled()) {
            this.logger.debug("Creating instance of bean \'" + beanName + "\'");
        }

        RootBeanDefinition mbdToUse = mbd;
　　　　　//这里判断需要创建的bean是否可以实例化，这个类是否可以通过类加载器类载入
        Class resolvedClass = this.resolveBeanClass(mbd, beanName, new Class[0]);
        if(resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
            mbdToUse = new RootBeanDefinition(mbd);
            mbdToUse.setBeanClass(resolvedClass);
        }

        try {
            mbdToUse.prepareMethodOverrides();
        } catch (BeanDefinitionValidationException var7) {
            throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(), beanName, "Validation of method overrides failed", var7);
        }

        Object beanInstance;
        try {
　　　　　　　//如果bean配置了PostProcessor，那么这里返回的是一个proxy
            beanInstance = this.resolveBeforeInstantiation(beanName, mbdToUse);
            if(beanInstance != null) {
                return beanInstance;
            }
        } catch (Throwable var8) {
            throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName, "BeanPostProcessor before instantiation of bean failed", var8);
        }
　　　　　//这里是创建bean的调用
        beanInstance = this.doCreateBean(beanName, mbdToUse, args);
        if(this.logger.isDebugEnabled()) {
            this.logger.debug("Finished creating instance of bean \'" + beanName + "\'");
        }

        return beanInstance;
    }
　　//接着到doCreateBean中去看看bean是怎样生成的
    protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, Object[] args) throws BeanCreationException {
        // 这个BeanWrapper是用来持有创建出来的bean对象的
　　　　　BeanWrapper instanceWrapper = null;
　　　　　//如果是singleton，先把缓存中的同名bean清除
        if(mbd.isSingleton()) {
            instanceWrapper = (BeanWrapper)this.factoryBeanInstanceCache.remove(beanName);
        }

　　　　　//这里是创建bean的地方，由createBeanInstance来完成
        if(instanceWrapper == null) {
            instanceWrapper = this.createBeanInstance(beanName, mbd, args);
        }

        final Object bean = instanceWrapper != null?instanceWrapper.getWrappedInstance():null;
        Class beanType = instanceWrapper != null?instanceWrapper.getWrappedClass():null;
        mbd.resolvedTargetType = beanType;
        Object earlySingletonExposure = mbd.postProcessingLock;
        synchronized(mbd.postProcessingLock) {
            if(!mbd.postProcessed) {
                try {
                    this.applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
                } catch (Throwable var17) {
                    throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Post-processing of merged bean definition failed", var17);
                }

                mbd.postProcessed = true;
            }
        }

        boolean var20 = mbd.isSingleton() && this.allowCircularReferences && this.isSingletonCurrentlyInCreation(beanName);
        if(var20) {
            if(this.logger.isDebugEnabled()) {
                this.logger.debug("Eagerly caching bean \'" + beanName + "\' to allow for resolving potential circular references");
            }

            this.addSingletonFactory(beanName, new ObjectFactory() {
                public Object getObject() throws BeansException {
                    return AbstractAutowireCapableBeanFactory.this.getEarlyBeanReference(beanName, mbd, bean);
                }
            });
        }

　　　　　//这里是bean初始化的地方，依赖注入往往在这里发生，这个exposedObject在初始化处理完成以后会返回作为依赖注入完成后的bean
        Object exposedObject = bean;
        try {
            this.populateBean(beanName, mbd, instanceWrapper);
            if(exposedObject != null) {
                exposedObject = this.initializeBean(beanName, exposedObject, mbd);
            }
        } catch (Throwable var18) {
            if(var18 instanceof BeanCreationException && beanName.equals(((BeanCreationException)var18).getBeanName())) {
                throw (BeanCreationException)var18;
            }

            throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Initialization of bean failed", var18);
        }

        if(var20) {
            Object ex = this.getSingleton(beanName, false);
            if(ex != null) {
                if(exposedObject == bean) {
                    exposedObject = ex;
                } else if(!this.allowRawInjectionDespiteWrapping && this.hasDependentBean(beanName)) {
                    String[] dependentBeans = this.getDependentBeans(beanName);
                    LinkedHashSet actualDependentBeans = new LinkedHashSet(dependentBeans.length);
                    String[] var12 = dependentBeans;
                    int var13 = dependentBeans.length;

                    for(int var14 = 0; var14 < var13; ++var14) {
                        String dependentBean = var12[var14];
                        if(!this.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.");
                    }
                }
            }
        }

        try {
            this.registerDisposableBeanIfNecessary(beanName, bean, mbd);
            return exposedObject;
        } catch (BeanDefinitionValidationException var16) {
            throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Invalid destruction signature", var16);
        }
    }

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

　　

protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, Object[] args) {
　　　　　//确认需要创建的bean实例的类可以实例化
        Class beanClass = this.resolveBeanClass(mbd, beanName, new Class[0]);
        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());
        } else if(mbd.getFactoryMethodName() != null) {//使用工厂方法对bean进行实例化
            return this.instantiateUsingFactoryMethod(beanName, mbd, args);
        } else {
            boolean resolved = false;
            boolean autowireNecessary = false;
            if(args == null) {
                Object ctors = mbd.constructorArgumentLock;
                synchronized(mbd.constructorArgumentLock) {
                    if(mbd.resolvedConstructorOrFactoryMethod != null) {
                        resolved = true;
                        autowireNecessary = mbd.constructorArgumentsResolved;
                    }
                }
            }

            if(resolved) {
                return autowireNecessary?this.autowireConstructor(beanName, mbd, (Constructor[])null, (Object[])null):this.instantiateBean(beanName, mbd);
            } else {
　　　　　　　　　 //使用构造函数进行实例化
                Constructor[] ctors1 = this.determineConstructorsFromBeanPostProcessors(beanClass, beanName);
　　　　　　　　　　//instantiateBean使用默认的构造函数对bean进行实例化
                return ctors1 == null && mbd.getResolvedAutowireMode() != 3 && !mbd.hasConstructorArgumentValues() && ObjectUtils.isEmpty(args)?this.instantiateBean(beanName, mbd):this.autowireConstructor(beanName, mbd, ctors1, args);
            }
        }
    }

　　到这里已经分析了实例化bean对象的大致过程，感兴趣的朋友可以继续深入的分析具体的方法。下面我们来看下，在实例化bean对象生成的基础上，spring是如何对这些bean对象进行处理的，也就是bean对象生成以后，怎样把bean对象的依赖关系设置好，完成整个依赖注入的过程。这个过程涉及对各种bean对象的属性的处理过程（即依赖关系处理的过程），这些依赖关系处理的依据就是已经解析得到的BeanDefinition。主要在populateBean方法里面，看下源码：

　　

protected void populateBean(String beanName, RootBeanDefinition mbd, BeanWrapper bw) {
　　　　　//这里取得在BeanDefinition中设置的property值，这些Property来自对BeanDefinition的解析
        Object pvs = mbd.getPropertyValues();
        if(bw == null) {
            if(!((PropertyValues)pvs).isEmpty()) {
                throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
            }
        } else {
            boolean continueWithPropertyPopulation = true;
            if(!mbd.isSynthetic() && this.hasInstantiationAwareBeanPostProcessors()) {
                Iterator hasInstAwareBpps = this.getBeanPostProcessors().iterator();

                while(hasInstAwareBpps.hasNext()) {
                    BeanPostProcessor needsDepCheck = (BeanPostProcessor)hasInstAwareBpps.next();
                    if(needsDepCheck instanceof InstantiationAwareBeanPostProcessor) {
                        InstantiationAwareBeanPostProcessor filteredPds = (InstantiationAwareBeanPostProcessor)needsDepCheck;
                        if(!filteredPds.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
                            continueWithPropertyPopulation = false;
                            break;
                        }
                    }
                }
            }

            if(continueWithPropertyPopulation) {
                if(mbd.getResolvedAutowireMode() == 1 || mbd.getResolvedAutowireMode() == 2) {
                    MutablePropertyValues hasInstAwareBpps1 = new MutablePropertyValues((PropertyValues)pvs);
                    
　　　　　　　　　　　　//这里是对autowire注入的处理，可以根据bean的名字或类型
　　　　　　　　　　　　if(mbd.getResolvedAutowireMode() == 1) {
                        this.autowireByName(beanName, mbd, bw, hasInstAwareBpps1);
                    }

                    if(mbd.getResolvedAutowireMode() == 2) {
                        this.autowireByType(beanName, mbd, bw, hasInstAwareBpps1);
                    }

                    pvs = hasInstAwareBpps1;
                }

                boolean hasInstAwareBpps2 = this.hasInstantiationAwareBeanPostProcessors();
                boolean needsDepCheck1 = mbd.getDependencyCheck() != 0;
                if(hasInstAwareBpps2 || needsDepCheck1) {
                    PropertyDescriptor[] filteredPds1 = this.filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
                    if(hasInstAwareBpps2) {
                        Iterator var9 = this.getBeanPostProcessors().iterator();

                        while(var9.hasNext()) {
                            BeanPostProcessor bp = (BeanPostProcessor)var9.next();
                            if(bp instanceof InstantiationAwareBeanPostProcessor) {
                                InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor)bp;
                                pvs = ibp.postProcessPropertyValues((PropertyValues)pvs, filteredPds1, bw.getWrappedInstance(), beanName);
                                if(pvs == null) {
                                    return;
                                }
                            }
                        }
                    }

                    if(needsDepCheck1) {
                        this.checkDependencies(beanName, mbd, filteredPds1, (PropertyValues)pvs);
                    }
                }
　　　　　　　　　 //对属性注入
                this.applyPropertyValues(beanName, mbd, bw, (PropertyValues)pvs);
            }
        }
    }
//通过applyPropertyValues了解具体的对属性进行解析然后注入的过程

protected void applyPropertyValues(String beanName, BeanDefinition mbd, BeanWrapper bw, PropertyValues pvs) {
    if(pvs != null && !pvs.isEmpty()) {
        MutablePropertyValues mpvs = null;
        if(System.getSecurityManager() != null && bw instanceof BeanWrapperImpl) {
            ((BeanWrapperImpl)bw).setSecurityContext(this.getAccessControlContext());
        }

        List original;
        if(pvs instanceof MutablePropertyValues) {
            mpvs = (MutablePropertyValues)pvs;
            if(mpvs.isConverted()) {
                try {
                    bw.setPropertyValues(mpvs);
                    return;
                } catch (BeansException var18) {
                    throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Error setting property values", var18);
                }
            }

            original = mpvs.getPropertyValueList();
        } else {
            original = Arrays.asList(pvs.getPropertyValues());
        }

        Object converter = this.getCustomTypeConverter();
        if(converter == null) {
            converter = bw;
        }
　　　　 //注意这个BeanDefinitionValueResolver的解析是在这个valueResolver中完成的
        BeanDefinitionValueResolver valueResolver = new BeanDefinitionValueResolver(this, beanName, mbd, (TypeConverter)converter);
　　　　　//这里为解析值创建一个副本，副本的数据将会被注入到bean中
        ArrayList deepCopy = new ArrayList(original.size());
        boolean resolveNecessary = false;
        Iterator ex = original.iterator();

        while(true) {
            while(ex.hasNext()) {
                PropertyValue pv = (PropertyValue)ex.next();
                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 = this.convertForProperty(resolvedValue, propertyName, bw, (TypeConverter)converter);
                    }

                    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();
            }

            try {
　　　　　　　　　　//这里是依赖注入发生的地方，会在BeanWrapperImpl中完成
                bw.setPropertyValues(new MutablePropertyValues(deepCopy));
                return;
            } catch (BeansException var19) {
                throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Error setting property values", var19);
            }
        }
    }
}

　　在bean的创建和对象依赖注入的过程中，需要依据BeanDefinition中的信息来递归的完成依赖注入。从上面的几个递归过程中可以看到，这些递归都是以getBean为入口的。一个递归是在上下文体系中查找需要的bean和创建bean的递归调用；另一个递归是在依赖注入时，通过递归调用容器的getBean方法，得到当前bean的依赖bean，同时也触发对依赖bean的创建和注入。对bean的属性进行依赖注入时，解析的过程也是一个递归过程。这样根据依赖关系，一层一层的完成bean的创建和注入，知道最后完成当前bean的创建，有了这个顶层bean的创建和对它属性依赖注入的完成，意味着和当前bean相关的整个依赖链的注入也完成了。