spring源码05——AbstractBeanFactory.doGetBean

类名：AbstractBeanFactory

protected <T> T doGetBean(String name, Class<T> requiredType, final Object[] args, boolean typeCheckOnly) throws BeansException {
		//格式化名称
        final String beanName = this.transformedBeanName(name);
		//尝试从缓存中获取Bean，解决循环依赖；
        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);
            }
			//以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 {
			//获取最终的合并的BeanDefinition
                final RootBeanDefinition mbd = this.getMergedLocalBeanDefinition(beanName);
                this.checkMergedBeanDefinition(mbd, beanName, args);
				//检查依赖，并且注入依赖；这里的依赖指的是depen-on依赖和Autowired没关系
                String[] dependsOn = mbd.getDependsOn();
                String[] arr$;
                if (dependsOn != null) {
                    arr$ = dependsOn;
                    int len$ = dependsOn.length;

                    for(int i$ = 0; i$ < len$; ++i$) {
                        String dependsOnBean = arr$[i$];
                        this.getBean(dependsOnBean);
                        this.registerDependentBean(dependsOnBean, beanName);
                    }
                }
				//单例情况下创建bean
                if (mbd.isSingleton()) {
                    sharedInstance = this.getSingleton(beanName, new ObjectFactory<Object>() {
                        public Object getObject() throws BeansException {
                            try {
							//创建bean
                                return AbstractBeanFactory.this.createBean(beanName, mbd, args);
                            } catch (BeansException var2) {
                                AbstractBeanFactory.this.destroySingleton(beanName);
                                throw var2;
                            }
                        }
                    });
					//factoryBean中创建bean
                    bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
					//多实例的情况
                } else if (mbd.isPrototype()) {
                    arr$ = null;

                    Object prototypeInstance;
                    try {
                        this.beforePrototypeCreation(beanName);
                        prototypeInstance = this.createBean(beanName, mbd, args);
                    } finally {
                        this.afterPrototypeCreation(beanName);
                    }

                    bean = this.getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
					//其他scope情况下创建bean，比如scope=session	
                } else {
				
                    String scopeName = mbd.getScope();
                    Scope scope = (Scope)this.scopes.get(scopeName);
                    if (scope == null) {
                        throw new IllegalStateException("No Scope registered for scope '" + scopeName + "'");
                    }

                    try {
                        Object scopedInstance = scope.get(beanName, new ObjectFactory<Object>() {
                            public Object getObject() throws BeansException {
                                AbstractBeanFactory.this.beforePrototypeCreation(beanName);

                                Object var1;
                                try {
                                    var1 = AbstractBeanFactory.this.createBean(beanName, mbd, args);
                                } finally {
                                    AbstractBeanFactory.this.afterPrototypeCreation(beanName);
                                }

                                return var1;
                            }
                        });
                        bean = this.getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
                    } catch (IllegalStateException var21) {
                        throw new BeanCreationException(beanName, "Scope '" + scopeName + "' is not active for the current thread; " + "consider defining a scoped proxy for this bean if you intend to refer to it from a singleton", var21);
                    }
                }
            } catch (BeansException var23) {
                this.cleanupAfterBeanCreationFailure(beanName);
                throw var23;
            }
        }

        if (requiredType != null && bean != null && !requiredType.isAssignableFrom(bean.getClass())) {
            try {
                return this.getTypeConverter().convertIfNecessary(bean, requiredType);
            } catch (TypeMismatchException var22) {
                if (this.logger.isDebugEnabled()) {
                    this.logger.debug("Failed to convert bean '" + name + "' to required type [" + ClassUtils.getQualifiedName(requiredType) + "]", var22);
                }

                throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
            }
        } else {
            return bean;
        }
    }

1、final String beanName = this.transformedBeanName(name);

格式化名称

2、Object sharedInstance = this.getSingleton(beanName);

尝试从缓存中获取Bean，通过三级缓存和提前曝光解决循环依赖

3、BeanFactory parentBeanFactory = this.getParentBeanFactory();

以beanName为参数，从父容器中进行溯源查找；

4、final RootBeanDefinition mbd = this.getMergedLocalBeanDefinition(beanName);

获取最终的合并的BeanDefinition

5、 String[] dependsOn = mbd.getDependsOn();

检查依赖，并且注入依赖；这里的依赖指的是depen-on依赖和Autowired没关系

6、if (mbd.isSingleton()){…}

根据不同的scope场景创建bean

7、AbstractBeanFactory.this.createBean(beanName, mbd, args);

spring源码06——AbstractAutowireCapableBeanFactory.doCreateBean
创建bean
调用链：
AbstractAutowireCapableBeanFactory.createBean(String beanName, RootBeanDefinition mbd, Object[] args)
AbstractAutowireCapableBeanFactory.doCreateBean(final String beanName, final RootBeanDefinition mbd, Object[] args)