spring-beans深入源码之获取Bean的过程解析

上一篇博文大致说完了Bean Definition 从xml文件的载入过程，真正需要bean的时候还是要从BeanFactory get获取的。接下来看一下bean的get过程。
查看test方法

TestBean bean = (TestBean) this.beanFactory.getBean("childWithList");

这里的this.beanFactory 是上面setUp方法中创建的

this.beanFactory = new DefaultListableBeanFactory();

可以知道 setUp方法装配了bean definition到了BeanFactory中，最后你需要的用到bean的时候还是需要从BeanFactory中获取。
继续debug进入到

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

继续进入到获取bean的主要方法

bean获取的主要方法

第一行 final String beanName = transformedBeanName(name); 是对你传入的bean的name的转换，代码内部用到了 BeanFactoryUtils.transformedBeanName(name)方法，该方法主要是去掉以 String FACTORY_BEAN_PREFIX = "&";开头的bean的name，截取&后面的部分，最后会查看 private final Map aliasMap = new ConcurrentHashMap(16);别名map中是否已经存在这个bean name 存在则沿用以前的bean name。接着继续获取bean 这里有一段代码注释 // Eagerly check singleton cache for manually registered singletons. 大致意思就是先从已经注册到BeanFactory的单例的map里面去获取这个bean name的单例bean， Object sharedInstance = getSingleton(beanName);.主要的方法代码：

protected Object getSingleton(String beanName, boolean allowEarlyReference) {
        Object singletonObject = this.singletonObjects.get(beanName);
        if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
            synchronized (this.singletonObjects) {
                singletonObject = this.earlySingletonObjects.get(beanName);
                if (singletonObject == null && allowEarlyReference) {
                    ObjectFactory singletonFactory = this.singletonFactories.get(beanName);
                    if (singletonFactory != null) {
                        singletonObject = singletonFactory.getObject();
                        this.earlySingletonObjects.put(beanName, singletonObject);
                        this.singletonFactories.remove(beanName);
                    }
                }
            }
        }
        return (singletonObject != NULL_OBJECT ? singletonObject : null);
    }

看代码就是去从map中获取到该bean，获取不到则返回null，这里有几个map 需要注意下

/** Cache of singleton objects: bean name --> bean instance */
    private final Map singletonObjects = new ConcurrentHashMap(64);

    /** Names of beans that are currently in creation */
    private final Set singletonsCurrentlyInCreation =
            Collections.newSetFromMap(new ConcurrentHashMap(16));

/** Cache of early singleton objects: bean name --> bean instance */
    private final Map earlySingletonObjects = new HashMap(16);

/** Cache of singleton factories: bean name --> ObjectFactory */
    private final Map> singletonFactories = new HashMap>(16);

看代码，先去从singletonObjects中去获取，该map 存贮的是已经实例化完成的单例bean，获取到则返回，获取不到则继续看singletonsCurrentlyInCreation这个map ，这个map存贮的是正在创建的单例bean，因为是单例模式所以肯定不能创建重复啊，这时候会涉及到一个同步语句synchronized (this.singletonObjects) 锁住的是 singletonObjects避免在从早些时候的beanfatory获取该bean的时候有别的线程创建了该bean 注册到 singletonObjectsmap中。然后从earlySingletonObjects中获取该bean 获取不到的试试会去尝试 获取名称为该name的ObjectFactory，因为创建一个bean的时候可以单独为该bean创建一个ObjectFactory来存贮这个bean，若获取到ObjectFactory则获取这个bean ，然后会把这个bean加入到earlySingletonObjects中，从singletonFactories将其移除掉，因为这个bean将成为过去时即早些时候创建的bean。最后返回。

回到doGetBean方法，在取到的情况下会走getObjectForBeanInstance方法。这个我们待会修改下test代码再说，先看取不到bean的情况下会走

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.
            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 {
                final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
                checkMergedBeanDefinition(mbd, beanName, args);

                // Guarantee initialization of beans that the current bean depends on.
                String[] dependsOn = mbd.getDependsOn();
                if (dependsOn != null) {
                    for (String dependsOnBean : dependsOn) {
                        if (isDependent(beanName, dependsOnBean)) {
                            throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                                    "Circular depends-on relationship between '" + beanName + "' and '" + dependsOnBean + "'");
                        }
                        registerDependentBean(dependsOnBean, beanName);
                        getBean(dependsOnBean);
                    }
                }

                // Create bean instance.
                if (mbd.isSingleton()) {
                    sharedInstance = getSingleton(beanName, new ObjectFactory