spring源码（十五）--getBean方法

所有的getBean方法调用，不管是在哪个类中，都是调用的AbstractBeanFactory中的getBean方法。
getBean方法又调用了doGetBean（也在这个类中，并且没有被子类覆盖）
doGetBean方法：

1. 通过name（name可能是别名，所以要处理下）获取beanName（对于一个类而言，是唯一的）
2. 从singletonObjects（一个map）中获取单例的bean
3. bean！=null，也就是取到了，那么判断是不是工厂类，如果是，则替换成getObject()方法的返回值
4. bean==null，也就是没取到，则调用createBean方法创建bean，然后回到第三步的判断
5. 对bean做一些处理。

---

getObjectForBeanInstance方法的作用：

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

protected  T doGetBean(String name, Class requiredType, final Object[] args, boolean typeCheckOnly) throws BeansException {
        final String beanName = this.transformedBeanName(name);
        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 + "'");
                }
            }
			//缓存中有，而且这次获取没有传递参数，那么这里就可以返回了。当然，要做类型转换的判断
            bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, (RootBeanDefinition)null);
        } else {
            if(this.isPrototypeCurrentlyInCreation(beanName)) {
                throw new BeanCurrentlyInCreationException(beanName);
            }

            BeanFactory parentBeanFactory = this.getParentBeanFactory();
            if(parentBeanFactory != null && !this.containsBeanDefinition(beanName)) {
                String nameToLookup = this.originalBeanName(name);
                if(args != null) {
                    return parentBeanFactory.getBean(nameToLookup, args);
                }

                return parentBeanFactory.getBean(nameToLookup, requiredType);
            }

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

            try {
                final RootBeanDefinition mbd = this.getMergedLocalBeanDefinition(beanName);
                this.checkMergedBeanDefinition(mbd, beanName, args);
                String[] dependsOn = mbd.getDependsOn();
                String[] var11;
                if(dependsOn != null) {
                    var11 = dependsOn;
                    int var12 = dependsOn.length;

                    for(int var13 = 0; var13 < var12; ++var13) {
                        String dep = var11[var13];
                        if(this.isDependent(beanName, dep)) {
                            throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
                        }

                        this.registerDependentBean(dep, beanName);
                        this.getBean(dep);
                    }
                }

                if(mbd.isSingleton()) {
                    sharedInstance = this.getSingleton(beanName, new ObjectFactory