spring IOC源码分析（3）

1.IOC容器的依赖注入

        Spring中，依赖注入是在用户第一次向IOC容器索要Bean时触发的（通过getBean方法）。

       在BeanFactory中我们看到getBean（String…）函数，它的具体实现在AbstractBeanFactory中：

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

        可以看到具体的注入过程转移到doGetBean（String…）中，在这个方法中，它首先从缓存中取，如果单件模式的bean已经被创建，则这种bean请求不需要重复的创建，调用

bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);

        跟踪进入getObjectForBeanInstance（…,null）,可以知道因为最后的RootBeanDefinition参数是null，所以执行的是：

if (mbd == null) {
    object = getCachedObjectForFactoryBean(beanName);
}

        而getCachedObjectForFactoryBean(beanName)中实现，其实现很简单，就是在缓存的bean map中查找bean返回。

        继续回到doGetBean（String…）方法中：

         //取当前bean的所有依赖bean，这样就会触发getBean的递归调用，直至取到一个没有任何依赖的bean为止
    String[] dependsOn = mbd.getDependsOn();
    if (dependsOn != null) {
        for (String dependsOnBean : dependsOn) {
            getBean(dependsOnBean);
                      //注册依赖的bean实例，具体实现过程在DefaultSingletonBeanRegistry中实现，其实就是将依赖的bean添加到依赖的hashmap中
            registerDependentBean(dependsOnBean, beanName);
        }
    }
    //通过调用createBean来，创建单例bean的实例
    if (mbd.isSingleton()) {
        sharedInstance = getSingleton(beanName, new ObjectFactory() {
           public Object getObject() throws BeansException {
             try {
              return createBean(beanName, mbd, args);
             }
             catch (BeansException ex) {
            destroySingleton(beanName);
            throw ex;
             }
                }
            });
            bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
    }
    //同样调用createBean创建prototype的bean实例
    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);
}

        继续看createBean（…），可以看到在AbstractBeanFactory中它只是个抽象类，具体的实现交给其子类（又见模板模式），进入子类AbstractAutowireCapableBeanFactory中看createBean的具体实现：

Object beanInstance = doCreateBean(beanName, mbd, args);

        其具体的实现转到doCreateBean（String…）,这里我们看到与依赖注入关系比较密切的方法有createBeanInstance和populateBean。

BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
    instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
    instanceWrapper = createBeanInstance(beanName, mbd, args);
}

// Initialize the bean instance.
Object exposedObject = bean;
try {
    populateBean(beanName, mbd, instanceWrapper);
    if (exposedObject != null) {
        exposedObject = initializeBean(beanName, exposedObject, mbd);
    }
}

        在createBeanInstance中生成了Bean所包含的Java对象，这个对象的生成有很多不同的方式，可以通过工厂方法生成，也可以通过容器的autowire特性生成，生成的方式由相关联的BeanDefinition来指定，进入createBeanInstance方法，有：

return instantiateUsingFactoryMethod(beanName, mbd, args);

return instantiateBean(beanName, mbd);

        上面是其中的两个实例化方法，上面的是在BeanDefinition的FactoryMethod存在的情况下，使用工厂方法对bean进行实例化。下面一个是使用默认的构造函数对bean进行实例化。我们进入instantiateBean(beanName,mbd)，可以看到有：

return getInstantiationStrategy().instantiate(mbd, beanName, parent);

        因为getInstantiationStrategy()返回的默认的实例化策略，而默认的实例化策略是CglibSubclassingInstantiationStrategy，也即用cglib来对bean进行实例化。CGLIB是一个常用的字节码生成器的类库，它提供了一系列的API来提供Java的字节码生成和转换功能。

        我们再次回到doCreateBean（）中的populateBean方法，看看在实例化Bean对象生成的基础上，spring怎样把这些bean对象的依赖关系设置好，完成整个依赖注入过程。在populateBean中，先是取得在BeanDefinition中设置的property值，这些property来自对BeanDefinition的解析，接着便开始进行依赖注入过程：

//开始进行依赖注入过程，先处理autowire的注入
if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME ||mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
            MutablePropertyValues newPvs = new MutablePropertyValues(pvs);

            //根据bean的名字进行autowire过程
            if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) {
                autowireByName(beanName, mbd, bw, newPvs);
            }

            //根据类型type进行autowire的过程
            if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
                autowireByType(beanName, mbd, bw, newPvs);
            }

            pvs = newPvs;
}

         最后在通过applyPropertyValues对属性进行注入：

applyPropertyValues(beanName, mbd, bw, pvs);

         接着我们到applyPropertyValues中去看具体的对属性进行解析然后注入的过程，在其中会调用BeanDefinitionValueResolver对BeanDefinition进行解析，

BeanDefinitionValueResolver valueResolver = new BeanDefinitionValueResolver(this, beanName, mbd, converter);

         接着为解析值创建一个拷贝，拷贝的数据将会被注入到bean中，它会先对PropertyValue判断，如果其没有经过转换则会调用resolveValueIfNecessary进行解析，然后注入到property中。下面到BeanDefinitionValueResolver中去看一下解析过程的实现，在函数resolveValueIfNecessary中包含了所有对注入类型的处理，以RuntimeBeanReference（其是在对BeanDefinition进行解析时生成的数据对象）为例：

if (value instanceof RuntimeBeanReference) {
    RuntimeBeanReference ref = (RuntimeBeanReference) value;
    return resolveReference(argName, ref);
}
//当注入类型为RuntimeBeanReference时，进入resolveReference（…）：
private Object resolveReference(Object argName, RuntimeBeanReference ref) {
        try {
            //从RuntimeBeanReference取得reference的名字
            String refName = ref.getBeanName();
            refName = String.valueOf(evaluate(refName));
            //如果ref是在双亲的IOC容器中，那就到双亲IOC容器中去取
            if (ref.isToParent()) {
                if (this.beanFactory.getParentBeanFactory() == null) {
                    //抛出异常BeanCreationException
                                             ……
                }
                return this.beanFactory.getParentBeanFactory().
                                     getBean(refName);
            }
            else {
                                    //在当前IOC容器中去取bean
                Object bean = this.beanFactory.getBean(refName);
                                this.beanFactory.registerDependentBean(refName, this.beanName);
                return bean;
            }
}

        在上面的实现中，无论是到双亲的IOC容器中去取，还是在当前IOC容器中取，都会触发一个getBean的过程，这就触发了相应的依赖注入的发生。

        这就完成了resolve的过程，为依赖注入准备好了条件。但真正的把Bean对象设置到它所依赖的另一个Bean的属性中去的地方是在BeanWrapper的setPropertyValues中（在分析populateBean的时候有提到），其中处理的属性是各种各样的。setPropertyValues的具体实现是在BeanWrapper的子类BeanWrapperImpl中：

        在doCreateBean中执行完populateBean，完成Bean的生成和依赖注入以后，开始对Bean进行初始化，这个初始化过程包含了对后置处理器的postProcessBeforeInitializtion回调，具体实现在initializeBean方法中：

Object wrappedBean = bean;
if (mbd == null || !mbd.isSynthetic()) {
    wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
}

try {
    invokeInitMethods(beanName, wrappedBean, mbd);
}
catch (Throwable ex) {
    //抛出异常BeanCreationException
}

if (mbd == null || !mbd.isSynthetic()) {
    wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
return wrappedBean;