【Spring源码学习】getBean （上）

学习和了解下spring中genBean函数具体的细节,其中包含了@value是如何和配置文件中的键值对关联上以及实例类的引用，这两部分打算分为上下两篇文章去详细介绍下。本文先介绍注解的值是如何和bean绑定并且填充的。

接下来使用如下的小demo具体学习和了解下。

public class Student {

    @Value("${name}")
    private String className;
    // 使用了@value注解，其中名称是name
    // 我们本章就是具体学习这个值是怎么样的方式，在什么时候注入进去的

    @Override
    public String toString() {
        return "Student{" +
                "className='" + className + '\'' +
                '}';
    }
}

public class Bootstrap {

    public static void main(String[] args){
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("context.xml");

        Student student = (Student)applicationContext.getBean("student");
        // getBean 入口
        System.out.println(student.toString());
    }
}

name = CS-2
// 配置了name这个键值对，最后被填入Student类中

在具体分析源码之前想象下如果我们是这个项目的开发者，我们需要考虑到哪些问题？

• 现在已知的存在不同类型（scope）的bean被存储在容器中
• 把获取的bean列表 循环一遍依次实例化、填充数据
• 如果存在引用的则需要在实例化之前先行实例化引用类
• 各种不同类型的容器，例如实例化好的，正在实例化的、正在被销毁的、已经消耗的
• 填充数据这部分操作得支持@value等类似操作
• 对外提供各种接口，便于用户可以自定义操作bean（例如BeanPostProcess）
• 相互引用的情况，A引用B，B引用A该如何解决
• 各种缓存容器，提高效率
• 还有可能存在的并发问题

接下来就看看具体的源码细节，在哪些地方会解决我们的疑惑

AbstractBeanFactory 类的doGetBean函数

protected  T doGetBean(
        final String name, final Class requiredType, final Object[] args, boolean typeCheckOnly)
        throws BeansException {

    final String beanName = transformedBeanName(name);
    // 根据传入的bean的名称获取实际的beanName
    // 在这里其实就是看起是否为工厂bean还是bean工厂
    // 后续会有一篇重点分析下工厂bean和bean工厂的差异
    Object bean;

    // Eagerly check singleton cache for manually registered singletons.
    Object sharedInstance = getSingleton(beanName);
    // 从已经创建好的singletonObjects集合中验证是否已经存在该实例，已经存在了就没必要再调用生成了，不过需要注意到单例才是这样的，针对非单例的bean不是这样的
    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 = getObjectForBeanInstance(sharedInstance, name, beanName, null);
    }

    else {
        // 如果是当前处理的beanName已经在prototype容器中（同一个线程）被处理，则抛出异常
        // 看源码会发现是存储在ThreadLocal中的
        if (isPrototypeCurrentlyInCreation(beanName)) {
            throw new BeanCurrentlyInCreationException(beanName);
        }

        BeanFactory parentBeanFactory = getParentBeanFactory();
        if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
            // 如果父类存在而且当前需要处理的beanName还不在容器中
            // 需要由父类去调用生成相关的实例对象
            String nameToLookup = originalBeanName(name);
            // 这个originalBeanName就是去掉name中存在的多于的&，至多只保留一个&
            if (args != null) {
                return (T) parentBeanFactory.getBean(nameToLookup, args);
            }
            else {
                // 没有参数
                return parentBeanFactory.getBean(nameToLookup, requiredType);
            }
        }

        if (!typeCheckOnly) {
          // 传入的默认typeCheckOnly是false，把当前的beanName加入到准备实例化的alreadyCreated的容器中，存在并发的情况，源码使用了synchronized
            markBeanAsCreated(beanName);
        }
        
        // 上述步骤完成，对一个普通的bean而言就是加入到准备实例化的容器中

        try {
            final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
            // 综合beanName本身映射的beandefinition和可能存在的父类beandefinition的属性
            // 存储到一个全新的对象RootBeanDefinition中
            checkMergedBeanDefinition(mbd, beanName, args);

            // 当前bean引用的其他bean，那很明显需要先实例化依赖的bean，再实例化本身
            String[] dependsOn = mbd.getDependsOn();
            if (dependsOn != null) {
                for (String dep : dependsOn) {
                    if (isDependent(beanName, dep)) {
                       // 如果当前beanName和dep存在相互依赖的情况，抛出异常
                       // 可是有个问题，不知道大家想到没有？
                        throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                                "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
                    }
                    registerDependentBean(dep, beanName);
                    // 往当前的dependentBeanMap和dependenciesForBeanMap填入依赖关系
                    // 其中dependentBeanMap 是存储的当前对象依赖什么
                    // dependenciesForBeanMap 是被谁依赖被当前对象所依赖
                    getBean(dep);
                    // 每一个依赖的bean实例化
                }
            }
            
            // 以上完成了bean的依赖问题，那就开始实例化本身了

            if (mbd.isSingleton()) {
                 // 是单例类型
                sharedInstance = getSingleton(beanName, new ObjectFactory