4.1Spring源码解析——getBean方法的实现

 getBean方法在BeanFactory中实现，实现的类有5个

实现类图.png

在这5个类中AbstractBeanFactory完成了getBean()方法的具体实现

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

    public <T> T getBean(String name, Class<T> requiredType) throws BeansException {
        return doGetBean(name, requiredType, null, false);
    }

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

    public <T> T getBean(String name, Class<T> requiredType, Object... args) throws BeansException {
        return doGetBean(name, requiredType, args, false);
    }

 这几个方法最终调用的是doGetBean方法

protected <T> T doGetBean(
            final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)
            throws BeansException {
        //去除&符号，因为当配置文件中<bean>的class属性配置的实现类是FactoryBean时，通过getBean()方法返回的不是FactoryBean本身，
        //而是FactoryBean#getObject()方法所返回的对象，相当于FactoryBean#getObject()代理了getBean()方法，如果希望获取FactoryBean的实例，需要在beanName前加上“&”符号，即getBean("&beanName")
        //在这里要获取的是bean的实例，所以要去掉&符号
        final String beanName = transformedBeanName(name);
        Object bean;

        // Eagerly check singleton cache for manually registered singletons.
//-------------------------------------方法1------------------------------------------//
        //从缓存中获取单利的bean
        Object sharedInstance = getSingleton(beanName);
//-------------------------------------方法1------------------------------------------//
        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 + "'");
                }
            }
                  //从已经加载的object中获取bean
            //-------------------------------------方法2------------------------------------------//
            bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
              //-------------------------------------方法2------------------------------------------//
        }
        else {
            // Fail if we're already creating this bean instance:
            // We're assumably within a circular reference.
            //检查要获取的bean是不是当前线程正在创建中的bean
            if (isPrototypeCurrentlyInCreation(beanName)) {
                throw new BeanCurrentlyInCreationException(beanName);
            }
            // Check if bean definition exists in this factory.
             //检查当前BeanFactory的父类BeanFactory是不是不为空，并且要获取的bean不包含在当前BeanFactory中
            BeanFactory parentBeanFactory = getParentBeanFactory();
            if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
                // Not found -> check parent.
                //还原要获取的bean的beanName
                String nameToLookup = originalBeanName(name);
                //调用parentBeanFactory获取bean  
                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);
                }
            }
            //typeCheckOnly默认为false
            if (!typeCheckOnly) {
                  //如果当前bean不在正在创建中的bean的缓存集合（alreadyCreated）中，就加进去
                markBeanAsCreated(beanName);
            }
            try {
                  //合并要获取的bean的属性并把属性赋值给一个RootBeanDefinition
                final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
          //检查合并之后的RootBeanDefinition的是不是抽象的，还会检查如果获取bean的参数不空的情况下，bean的类型是singleton的就会报错，因为单利情况下bean都是一样的，只有prototype情况下才能不一致
                checkMergedBeanDefinition(mbd, beanName, args);
                // Guarantee initialization of beans that the current bean depends on.
            //获取当前bean依赖的bean的名称的数组
                String[] dependsOn = mbd.getDependsOn();
            //如果依赖不为空就先加载依赖到的bean
                if (dependsOn != null) {
                    for (String dependsOnBean : dependsOn) {
                        getBean(dependsOnBean);
                //将要获取的bean的beanName和所依赖到的bean的beanName之间的关系缓存起来
                        registerDependentBean(dependsOnBean, beanName);
                    }
                }
                // Create bean instance.
                //开始创建单利bean实例
                if (mbd.isSingleton()) {
          //--------------------------------------方法4------------------------------//
                    sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
                        public Object getObject() throws BeansException {
                            try {
                //--------------------------------------方法3------------------------------//
                                return createBean(beanName, mbd, args);
              //--------------------------------------方法3------------------------------//
                            }
                            catch (BeansException ex) {
                                // Explicitly remove instance from singleton cache: It might have been put there
                                // eagerly by the creation process, to allow for circular reference resolution.
                                // Also remove any beans that received a temporary reference to the bean.
                                destroySingleton(beanName);
                                throw ex;
                            }
                        }
                    });
      //--------------------------------------方法4------------------------------//
                    bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
                }
        //不是单例的情况
                else if (mbd.isPrototype()) {
                    // It's a prototype -> create a new instance.
                    Object prototypeInstance = null;
                    try {
                  //将需要创建的bean的beanName放到ThreadLocal中
                        beforePrototypeCreation(beanName);
                        prototypeInstance = createBean(beanName, mbd, args);
                    }
                    finally {
                //将需要创建的bean的beanName从ThreadLocal中移除
                        afterPrototypeCreation(beanName);
                    }
                    bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
                }
      //其余类型bean
                else {
                    String scopeName = mbd.getScope();
                    final 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 {
                      //将需要创建的bean的beanName放到ThreadLocal中
                                beforePrototypeCreation(beanName);
                                try {
                                    return createBean(beanName, mbd, args);
                                }
                                finally {
                    //将需要创建的bean的beanName从ThreadLocal中移除
                                    afterPrototypeCreation(beanName);
                                }
                            }
                        });
                        bean = 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;
            }
        }

        // Check if required type matches the type of the actual bean instance.
        if (requiredType != null && bean != null && !requiredType.isAssignableFrom(bean.getClass())) {
            try {
                return 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());
            }
        }
        return (T) bean;
    }

 对上面的标注的方法分别进行解析：

• 1. getSingleton方法 DefaultSingletonBeanRegistry类中
     getSingleton方法的详解
     单例在Spring的同一个容器内只会被创建一次，后续在获取bean，就直接从单例缓存中获取了。这里也只是尝试获取，首先尝试从缓存中加载，如果加载不成功则再次尝试从singletonFactories中加载。因为在创建单例bean 的时候会存在依赖注入的情况，而在创建依赖的时候为了避免循环依赖，在Spring中创建bean 的原则是不等bean创建完就会将创建bean 的ObjectFactory提早曝光加入到缓存中，一旦下一个bean创建时候需要依赖上一个bean则直接使用ObjectFactory。
• 2. getObjectForBeanInstance方法 AbstractBeanFactory类中
     getObjectForBeanInstance方法的详解
     如果从缓存中得到了bean的原始状态，则需要对bean进行实例化。缓存中记录的只是最原始的bean状态，并不一定是我们最终想要的bean。
     假如我们需要对工厂bean进行处理，那么这里得到的其实是工厂bean的初始状态，但是我们正真需要的是工程bean中定义的factory-method方法中返回的bean，而getObjectForBeanInstance就是完成这个工作的
• 3.获取单例对象时候调用DefaultSingletonBeanRegistry类getSingleton方法的第二个参数ObjectFactory实现了ObjectFactory接口的getObject方法，调用的createBean方法
  createBean方法的详解
• 4. public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) 方法
     这个方法与上面的getSingleton不同之处在于这个方法是在创建了bean对象，并初始化之后调用的，作用是从bean对象中获取单例的bean同时放到单例缓存中

    public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
        Assert.notNull(beanName, "'beanName' must not be null");
        synchronized (this.singletonObjects) {
            //在已经注册了的单例map集合（singletonObjects）中获取特定beanName的bean
            Object singletonObject = this.singletonObjects.get(beanName);
            if (singletonObject == null) {
                if (this.singletonsCurrentlyInDestruction) {
                    throw new BeanCreationNotAllowedException(beanName,
                            "Singleton bean creation not allowed while the singletons of this factory are in destruction " +
                            "(Do not request a bean from a BeanFactory in a destroy method implementation!)");
                }
                if (logger.isDebugEnabled()) {
                    logger.debug("Creating shared instance of singleton bean '" + beanName + "'");
                }
                //singletonObjects中获取不到bean的时候，说明是新创建的bean，这个时候需要先检查满足其中一个
                //1.当前创建检查中排除的beanName集合中包含这个创建中的单例beanName
                //2.当前正在创建的单例beanName集合中不包含这个单例bean的beanName
                beforeSingletonCreation(beanName);
                boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
                if (recordSuppressedExceptions) {
                    this.suppressedExceptions = new LinkedHashSet<Exception>();
                }
                try {
                    //从创建的bean中获取bean对象
                    singletonObject = singletonFactory.getObject();
                }
                catch (BeanCreationException ex) {
                    if (recordSuppressedExceptions) {
                        for (Exception suppressedException : this.suppressedExceptions) {
                            ex.addRelatedCause(suppressedException);
                        }
                    }
                    throw ex;
                }
                finally {
                    if (recordSuppressedExceptions) {
                        this.suppressedExceptions = null;
                    }
                    //从当前正在创建的单例beanName集合中删除当前的beanName
                    afterSingletonCreation(beanName);
                }
                //加入到单例缓存中
                addSingleton(beanName, singletonObject);
            }
            //返回单例对象
            return (singletonObject != NULL_OBJECT ? singletonObject : null);
        }
    }