Spring4 IOC容器依赖注入源码

目录：

1. spring4中IOC容器依赖注入
   （1） AbstractBeanFactory类之getBean方法获取被IOC容器管理的bean
   （2） AbstractAutowireCapableBeanFactory类之createBean方法创建bean实例对象
   （3） AbstractAutowireCapableBeanFactory类之doCreateBean方法，创建一个bean实例（无参构造器、有参构造器、工厂类注入）、属性填充、bean销毁等
   （4） AbstractAutowireCapableBeanFactory类之createBeanInstance方法根据不同实例化策略创建bean实例（工厂方法，有无参构造器）
   （5） AbstractAutowireCapableBeanFactory类之instantiateBean方法无参数构造器创建bean
   （6） SimpleInstantiationStrategy类之instantiate方法实例化bean
   （7） AbstractAutowireCapableBeanFactory类之populateBean方法，bean属性的依赖注入
   （8） AbstractAutowireCapableBeanFactory类之applyPropertyValues方法解析并注入属性值
   （9） BeanWrapperImpl类之setPropertyValue方法真正注入属性值
   （10）spring4中IOC容器依赖注入步骤总结

spring4中IOC容器依赖注入

1. AbstractBeanFactory类之getBean方法获取被IOC容器管理的bean

// 通过指定的Class获取Class类型的Bean
@Override
public  T getBean(String name, Class requiredType) throws BeansException {
    return doGetBean(name, requiredType, null, false);
}

@SuppressWarnings("unchecked")
protected  T doGetBean(
        final String name, final Class requiredType, final Object[] args, boolean typeCheckOnly)
        throws BeansException {
    // 通过指定的name获取对应的beanName
    final String beanName = transformedBeanName(name);
    Object bean;

    // 从缓存中获取创建过的单例Bean
    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 + "'");
            }
        }
        // 获取Bean对应的实例 
        bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
    }

    else {
        // 如果beanName使用原型模式创建，将抛出异常
        if (isPrototypeCurrentlyInCreation(beanName)) {
            throw new BeanCurrentlyInCreationException(beanName);
        }

        // 检查Bean定义是否已经存在，首先获取父类的bean工厂
        BeanFactory parentBeanFactory = getParentBeanFactory();
        // 父类bean管理工厂不为空并且beanDefinitionMap包含beanName
        if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
            //解析指定Bean名称的原始名称 
            String nameToLookup = originalBeanName(name);
            // 如果传递参数不为空
            if (args != null) {
                // 父类bean管理工厂获取bean
                return (T) parentBeanFactory.getBean(nameToLookup, args);
            }
            else {如果传递参数为空
                // 父类bean管理工厂获取bean
                return parentBeanFactory.getBean(nameToLookup, requiredType);
            }
        }

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

        try {
            // 通过bean名称获取父级别的bean定义
            final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName); 
            checkMergedBeanDefinition(mbd, beanName, args);
            // 获取当前BeanDefinition依赖的beanName
            String[] dependsOn = mbd.getDependsOn();
            // 如果依赖beanName的数组不为空
            if (dependsOn != null) {
                // 遍历依赖beanName的数组
                for (String dep : dependsOn) {
                    if (isDependent(beanName, dep)) {
                        throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                                "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
                    }
                    // 把被依赖Bean注册给当前依赖的Bean
                    registerDependentBean(dep, beanName);
                    // 递归调用getBean方法，获取当前Bean的依赖Bean 
                    getBean(dep);
                }
            }

            // 创建单例Bean的实例对象
            if (mbd.isSingleton()) {
                // 获取到单例bean（匿名内部类方式实现） 
                sharedInstance = getSingleton(beanName, new ObjectFactory