spring源码-----doGetBean（）----创建bean《1》

//当你认真得看源码可能有些迷惑    自己手动写上一遍思路清晰    

//在spring中我们平时用到的getbean（）这个方法实际上是调用的AbstractBeanFactory这个抽象工厂中得getbean方法
public Object getBean(String name) throws BeansException {
//看源码 我们首先看其返回值   如下返回得是doGetBean这个方法
        return this.doGetBean(name, null, null, false);
        }
//接下来我们看这个doGetBean这个方法
protected <T> T doGetBean(
final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly) throws BeansException {

 //获取name对应的真正beanName
//有这么几种情况 传入得参数有可能是某个参数得别名，也有可能是FactoryBean的name  //根据具体得实例去解析最终的得name
final String beanName = this.transformedBeanName(name);

        Object bean;

      //   在创建单例bean的时候会存在依赖注入的情况，而在创建依赖的时候为了避免循环依赖
       //  Spring创建bean的原则是不等bean创建完成就会将创建bean的ObjectFactory提前曝光（将对应的ObjectFactory加入到缓存）
      //   一旦下一个bean创建需要依赖上一个bean，则直接使用ObjectFactory对象
        // 获取单例
        Object sharedInstance = this.getSingleton(beanName);
        if (sharedInstance != null && args == null) {
        // 实例已经存在
        if (logger.isDebugEnabled()) {
        if (this.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 = this.getObjectForBeanInstance(sharedInstance, name, beanName, null);
        } else {
        // 单例实例不存在
        if (this.isPrototypeCurrentlyInCreation(beanName)) {
         // 只有在单例模式下才会尝试解决循环依赖问题
         // 对于原型模式，如果存在循环依赖，也就是满足this.isPrototypeCurrentlyInCreation(beanName)，抛出异常
        throw new BeanCurrentlyInCreationException(beanName);
        }

        // 获取parentBeanFactory实例
        BeanFactory parentBeanFactory = this.getParentBeanFactory();
        // 如果在beanDefinitionMap中（即所有已经加载的类中）不包含目标bean，则尝试从parentBeanFactory中获取
        if (parentBeanFactory != null && !this.containsBeanDefinition(beanName)) {
        String nameToLookup = this.originalBeanName(name);  // 获取name对应的真正beanName，如果是factoryBean，则加上“&”前缀
        if (args != null) {
        // 递归到BeanFactory中寻找
        return (T) parentBeanFactory.getBean(nameToLookup, args);
        } else {
        return parentBeanFactory.getBean(nameToLookup, requiredType);
        }
        }

        // 如果不仅仅是做类型检查，标记bean的状态已经创建，即将beanName加入alreadyCreated集合中
        if (!typeCheckOnly) {
        this.markBeanAsCreated(beanName);
        }

        try {
 //将存储XML配置的GenericBeanDefinition实例转换成RootBeanDefinition实例，方便后续处理
 // 如果存在父bean，则同时合并父bean的相关属性
final RootBeanDefinition mbd = this.getMergedLocalBeanDefinition(beanName);
        // 检查bean是否是抽象的，如果是则抛出异常
        this.checkMergedBeanDefinition(mbd, beanName, args);

        // 加载当前bean依赖的bean
        String[] dependsOn = mbd.getDependsOn();
        if (dependsOn != null) {
        // 存在依赖，递归实例化依赖的bean
        for (String dep : dependsOn) {
        if (this.isDependent(beanName, dep)) {
        // 检查dep是否依赖beanName，从而导致循环依赖
        throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
        }
        // 缓存依赖调用
        this.registerDependentBean(dep, beanName);
        this.getBean(dep);
        }
        }

        // 完成加载依赖的bean后，实例化mbd自身
        if (mbd.isSingleton()) {
        // scope == singleton
        sharedInstance = this.getSingleton(beanName, new ObjectFactory<Object>() {
@Override
public Object getObject() throws BeansException {
        try {
        return createBean(beanName, mbd, args);
        } catch (BeansException ex) {
        // 清理工作，从单例缓存中移除
        destroySingleton(beanName);
        throw ex;
        }
        }
        });
        bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
        } else if (mbd.isPrototype()) {
        // scope == prototype
        Object prototypeInstance;
        try {
        // 设置正在创建的状态
        this.beforePrototypeCreation(beanName);
        // 创建bean
        prototypeInstance = this.createBean(beanName, mbd, args);
        } finally {
        this.afterPrototypeCreation(beanName);
        }
        // 返回对应的实例
        bean = this.getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
        } else {
        // 其它范围得实例
        String scopeName = mbd.getScope();
final Scope scope = this.scopes.get(scopeName);
        if (scope == null) {
        throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
        }
        try {
        Object scopedInstance = scope.get(beanName, new ObjectFactory<Object>() {
        @Override
        public Object getObject() throws BeansException {
        beforePrototypeCreation(beanName);
        try {
        return createBean(beanName, mbd, args);
        } finally {
        afterPrototypeCreation(beanName);
        }
        }
        });
        // 返回对应的实例
        bean = this.getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
        } catch (IllegalStateException ex) {
        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", ex);
        }
        }
        } catch (BeansException ex) {
        cleanupAfterBeanCreationFailure(beanName);
        throw ex;
        }
        }

        // 检查需要的类型是否符合bean的实际类型，对应getBean时指定的需要类型
        if (requiredType != null && bean != null && !requiredType.isAssignableFrom(bean.getClass())) {
        try {
        // 执行类型转换，转换成对应的类型
        return this.getTypeConverter().convertIfNecessary(bean, requiredType);
        } catch (TypeMismatchException ex) {
        if (logger.isDebugEnabled()) {
        logger.debug("Failed to convert bean '" + name + "' to required type '" + ClassUtils.getQualifiedName(requiredType) + "'", ex);
        }
        throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
        }
        }
        到这里才是真正意义上返回一个bean而已
        return (T) bean;
        }