上一篇分析了BeanFactory體系的2個類，SimpleAliasRegistry和DefaultSingletonBeanRegistry——Spring源碼分析——BeanFactory體系之抽象類、類分析（一），今天繼續分析。

一、工廠Bean注冊支持——FactoryBeanRegistrySupport

廢話不多說，直接看我注釋的源碼：

/* * Copyright 2002-2012 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * *      http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */package org.springframework.beans.factory.support;import java.security.accessControlContext;import java.security.AccessController;import java.security.PrivilegedAction;import java.security.PrivilegedActionException;import java.security.PrivilegedExceptionAction;import java.util.Map;import java.util.concurrent.ConcurrentHashMap;import org.springframework.beans.BeansException;import org.springframework.beans.factory.BeanCreationException;import org.springframework.beans.factory.BeanCurrentlyInCreationException;import org.springframework.beans.factory.FactoryBean;import org.springframework.beans.factory.FactoryBeanNotInitializedException;/** * Support base class for singleton registries which need to handle * {@link org.springframework.beans.factory.FactoryBean} instances, * integrated with {@link DefaultSingletonBeanRegistry}'s singleton management. * * <p>Serves as base class for {@link AbstractBeanFactory}. * * @author Juergen Hoeller * @since 2.5.1 */public abstract class FactoryBeanRegistrySupport extends DefaultSingletonBeanRegistry {    /** 工廠Bean生產的單例的集合: FactoryBean name --> object */    private final Map<String, Object> factoryBeanObjectCache = new ConcurrentHashMap<String, Object>(16);    //返回指定FactoryBean的類型    protected Class getTypeForFactoryBean(final FactoryBean factoryBean) {        try {            if (System.getSecurityManager() != null) {//如果當前系統存在安全管理器                return AccessController.doPrivileged(new PrivilegedAction<Class>() {//那么返回factoryBean的類型這個操作不做權限檢查，直接調用                    public Class run() {                        return factoryBean.getObjectType();                    }                }, getAccessControlContext());            }            else {//不存在安全管理器，就直接調用！                return factoryBean.getObjectType();            }        }        catch (Throwable ex) {            logger.warn("FactoryBean threw exception from getObjectType, despite the contract saying " +                    "that it should return null if the type of its object cannot be determined yet", ex);            return null;        }    }    //根據FactoryBean名，返回其生產的Object，從緩存中取    protected Object getCachedObjectForFactoryBean(String beanName) {        Object object = this.factoryBeanObjectCache.get(beanName);        return (object != NULL_OBJECT ? object : null);    }    //從工廠Bean中取實例，實際調用下面的doGetObjectFromFactoryBean方法。    protected Object getObjectFromFactoryBean(FactoryBean factory, String beanName, boolean shouldPostProcess) {        if (factory.isSingleton() && containsSingleton(beanName)) {//若工廠是單例，且本容器包含beanName對應的單例類            synchronized (getSingletonMutex()) {//以所有的單例集合為鎖                Object object = this.factoryBeanObjectCache.get(beanName);//根據beanName從factoryBeanObjectCache中取                if (object == null) {//若取不到                    object = doGetObjectFromFactoryBean(factory, beanName, shouldPostProcess);                    this.factoryBeanObjectCache.put(beanName, (object != null ? object : NULL_OBJECT));//放進factoryBeanObjectCache                }                return (object != NULL_OBJECT ? object : null);            }        }        else {//否則，直接            return doGetObjectFromFactoryBean(factory, beanName, shouldPostProcess);        }    }    //從工廠Bean中取實例    private Object doGetObjectFromFactoryBean(            final FactoryBean factory, final String beanName, final boolean shouldPostProcess)            throws BeanCreationException {        Object object;        //跟getTypeForFactoryBean的實現一樣。        try {            if (System.getSecurityManager() != null) {//若系統存在安全管理器                AccessControlContext acc = getAccessControlContext();//得到當前容器的安全訪問上下文                try {//返回factoryBean的類型這個操作不做權限檢查，直接調用                    object = AccessController.doPrivileged(new PrivilegedExceptionAction<Object>() {                        public Object run() throws Exception {                                return factory.getObject();                            }                        }, acc);                }                catch (PrivilegedActionException pae) {                    throw pae.getException();                }            }            else {//否則直接取                object = factory.getObject();            }        }        catch (FactoryBeanNotInitializedException ex) {            throw new BeanCurrentlyInCreationException(beanName, ex.toString());        }        catch (Throwable ex) {            throw new BeanCreationException(beanName, "FactoryBean threw exception on object creation", ex);        }        //如果從beanFactory取不到，且這個實例即將被創建，拋出異常        if (object == null && isSingletonCurrentlyInCreation(beanName)) {            throw new BeanCurrentlyInCreationException(                    beanName, "FactoryBean which is currently in creation returned null from getObject");        }        //若取不到，且這個實例允許前處理        if (object != null && shouldPostProcess) {            try {                object = postProcessObjectFromFactoryBean(object, beanName);//這里簡單返回，前處理的功能留給子類重寫            }            catch (Throwable ex) {                throw new BeanCreationException(beanName, "Post-processing of the FactoryBean's object failed", ex);            }        }        return object;    }    //這里簡單返回Object，留給子類重寫    protected Object postProcessObjectFromFactoryBean(Object object, String beanName) throws BeansException {        return object;    }    //如果這個Object是FactoryBean類型，就轉換成FactoryBean返回    protected FactoryBean getFactoryBean(String beanName, Object beanInstance) throws BeansException {        if (!(beanInstance instanceof FactoryBean)) {            throw new BeanCreationException(beanName,                    "Bean instance of type [" + beanInstance.getClass() + "] is not a FactoryBean");        }        return (FactoryBean) beanInstance;    }    //移除單例類這個方法重寫，父類的移除之外，還要移除factoryBeanObjectCache中的。    @Override    protected void removeSingleton(String beanName) {        super.removeSingleton(beanName);        this.factoryBeanObjectCache.remove(beanName);    }    //返回當前容器的安全訪問上下文    protected AccessControlContext getAccessControlContext() {        return AccessController.getContext();    }}

具體：

　　1、1個不可變的實例屬性ConcurrentHashMap來存放工廠Bean生產的單例的集合：FactoryBean name --> object。

　　2、1個方法返回指定FactoryBean的類型的方法。

　　3、1個根據FactoryBean名，返回其生產的Object的方法。

　　4、2個從工廠Bean中取實例的方法。實際是一個方法調用另一個，取不到則返回空。

　　5、1個postProcessObjectFromFactoryBean的方法，留給子類重寫。

　　6、1個取工廠Bean的方法——如果這個Object是FactoryBean類型，就轉換成FactoryBean返回

　　7、1個重寫父類的removeSingleton方法，移除單例的時候，父類的移除之外，還要移除factoryBeanObjectCache中的。

　　8、1個返回當前容器的安全訪問上下文的方法。

總結：

　　這個類FactoryBeanRegistrySupport，類如其名，實現了對工廠Bean注冊的支持。值得注意的是，這個類有較多類似如下的寫法：

    if (System.getSecurityManager() != null) {//如果當前系統存在安全管理器                return AccessController.doPrivileged(new PrivilegedAction<Class>() {                    public Class run() {                        //實際處理                    }                }, getAccessControlContext());            }            else {//不存在安全管理器，就直接調用！                //實際處理            }        

　　這個方法的意思是，如果當前系統存在安全管理器，那么接下來的操作不做權限檢查，直接調用。而如果不存在，OK，那當然是直接調用了。這是JDK層面的一個系統安全管理工具，某些情況下，可以避免系統進行安全檢查。這里稍作了解即可。在學習JVM的時候可仔細了解原理。

　　除此之外，這里可以了解一下這個類比較重要的方法doGetObjectFromFactoryBean，是從工廠Bean中取實例的方法，源碼已經給出，這里重點指出一下，不必折疊了：

//從工廠Bean中取實例，shouldPostProcess指的是是否允許提前處理    private Object doGetObjectFromFactoryBean(            final FactoryBean factory, final String beanName, final boolean shouldPostProcess)            throws BeanCreationException {        Object object;        //跟getTypeForFactoryBean的實現一樣。        try {            if (System.getSecurityManager() != null) {//若系統存在安全管理器                AccessControlContext acc = getAccessControlContext();//得到當前容器的安全訪問上下文                try {//返回factoryBean的類型這個操作不做權限檢查，直接調用                    object = AccessController.doPrivileged(new PrivilegedExceptionAction<Object>() {                        public Object run() throws Exception {                                return factory.getObject();                            }                        }, acc);                }                catch (PrivilegedActionException pae) {                    throw pae.getException();                }            }            else {//否則直接取                object = factory.getObject();            }        }        catch (FactoryBeanNotInitializedException ex) {            throw new BeanCurrentlyInCreationException(beanName, ex.toString());        }        catch (Throwable ex) {            throw new BeanCreationException(beanName, "FactoryBean threw exception on object creation", ex);        }        //如果從beanFactory取不到，且這個實例即將被創建，拋出異常        if (object == null && isSingletonCurrentlyInCreation(beanName)) {            throw new BeanCurrentlyInCreationException(                    beanName, "FactoryBean which is currently in creation returned null from getObject");        }        //若取不到，并非即將創建、且這個實例允許前處理        if (object != null && shouldPostProcess) {            try {                object = postProcessObjectFromFactoryBean(object, beanName);//這里簡單返回，前處理的功能留給子類重寫            }            catch (Throwable ex) {                throw new BeanCreationException(beanName, "Post-processing of the FactoryBean's object failed", ex);            }        }        return object;    }

　　相信上面已經解釋的很清楚了。

二、最重要的抽象類——AbstractBeanFactory

　　（PS：這個類的方法實在是多的駭人，看得我實在是頭都大了。不多看到后面，發現很多方法其實也就是那么回事。源碼注釋了大部分，且看看咯！）

public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport implements ConfigurableBeanFactory {    //父工廠的引用    private BeanFactory parentBeanFactory;    //類加載器    private ClassLoader beanClassLoader = ClassUtils.getDefaultClassLoader();    //臨時類加載器    private ClassLoader tempClassLoader;    /** Whether to cache bean metadata or rather reobtain it for every access */    private boolean cacheBeanMetadata = true;    //Bean表達式分解器，用來分解Bean定義中的表達式    private BeanExpressionResolver beanExpressionResolver;    //轉換服務，用來替代屬性編輯器的    private ConversionService conversionService;    //屬性編輯登記員集合，容量為4的LinkedHashSet    private final Set<PropertyEditorRegistrar> propertyEditorRegistrars =            new LinkedHashSet<PropertyEditorRegistrar>(4);    //通用的類型轉換器，重寫了默認的屬相編輯器機制    private TypeConverter typeConverter;    //默認的屬性編輯器集合    private final Map<Class<?>, Class<? extends PropertyEditor>> customEditors =            new HashMap<Class<?>, Class<? extends PropertyEditor>>(4);    //嵌入值轉換器集合    private final List<StringValueResolver> embeddedValueResolvers = new LinkedList<StringValueResolver>();    //BeanPostProcessor處理器集合    private final List<BeanPostProcessor> beanPostProcessors = new ArrayList<BeanPostProcessor>();    //標記是否有InstantiationAwareBeanPostProcessors實例被注冊    private boolean hasInstantiationAwareBeanPostProcessors;    //標記是否有DestructionAwareBeanPostProcessors實例被注冊    private boolean hasDestructionAwareBeanPostProcessors;    //范圍標識符和Scope實例的對應的Map    private final Map<String, Scope> scopes = new HashMap<String, Scope>(8);    //安全上下文Provider，可以得到安全管理器的安全上下文    private SecurityContextProvider securityContextProvider;    //合并后的Bean根定義的集合    private final Map<String, RootBeanDefinition> mergedBeanDefinitions =            new ConcurrentHashMap<String, RootBeanDefinition>(64);    //至少被創建過一次的Bean的集合    private final Map<String, Boolean> alreadyCreated = new ConcurrentHashMap<String, Boolean>(64);    //當前正在創建的原型，當前線程相關    private final ThreadLocal<Object> prototypesCurrentlyInCreation =            new NamedThreadLocal<Object>("Prototype beans currently in creation");    //空構造方法    public AbstractBeanFactory() {    }    //指定父Bean工廠的構造方法    public AbstractBeanFactory(BeanFactory parentBeanFactory) {        this.parentBeanFactory = parentBeanFactory;    }    //---------------------------------------------------------------------    // 3個getBean，BeanFactory接口的實現方法，實質是在調用doGetBean    //---------------------------------------------------------------------    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);    }    //    提供創建時需要參數列表的getBean    public <T> T getBean(String name, Class<T> requiredType, Object... args) throws BeansException {        return doGetBean(name, requiredType, args, false);    }    //從容器中獲取bean的基本方法。    @SuppressWarnings("unchecked")    protected <T> T doGetBean(            final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)            throws BeansException {        final String beanName = transformedBeanName(name);//在aliasMap中取得的標準名        Object bean;        // Eagerly check singleton cache for manually registered singletons.        Object sharedInstance = getSingleton(beanName);//首先在單例集合中取        if (sharedInstance != null && args == null) {//如果取得到，沒有指定參數            if (logger.isDebugEnabled()) {//若Log允許調試                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 + "'");                }            }            ////根據給定的實例是否為工廠Bean，返回它自己或工廠Bean創建的實例            bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);        }        else {            if (isPrototypeCurrentlyInCreation(beanName)) {//如果正在被創建，就拋出異常                throw new BeanCurrentlyInCreationException(beanName);            }            BeanFactory parentBeanFactory = getParentBeanFactory();//取本容器的父容器            if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {//若存在父容器，且本容器不存在對應的Bean定義                String nameToLookup = originalBeanName(name);//取原始的Bean名                if (args != null) {//若參數列表存在                    // 那么用父容器根據原始Bean名和參數列表返回                    return (T) parentBeanFactory.getBean(nameToLookup, args);                }                else {                    // 參數列表不要求，那就直接根據原始名稱和要求的類型返回                    return parentBeanFactory.getBean(nameToLookup, requiredType);                }            }            //如果不需要類型檢查，標記其已經被創建            if (!typeCheckOnly) {                markBeanAsCreated(beanName);            }            //根據beanName取其根Bean定義            final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);            checkMergedBeanDefinition(mbd, beanName, args);            String[] dependsOn = mbd.getDependsOn();//得到這個根定義的所有依賴            if (dependsOn != null) {                for (String dependsOnBean : dependsOn) {                    getBean(dependsOnBean);//注冊這個Bean                    //注冊一個Bean和依賴于它的Bean（后參數依賴前參數）                    registerDependentBean(dependsOnBean, beanName);                }            }            // 如果Bean定義是單例，就在返回單例            if (mbd.isSingleton()) {                sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {                    public Object getObject() throws BeansException {                        try {                            return createBean(beanName, mbd, args);                        }                        catch (BeansException ex) {                            destroySingleton(beanName);                            throw ex;                        }                    }                });                //根據給定的實例是否為工廠Bean，返回它自己或工廠Bean創建的實例                bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);            }            //如果是原型            else if (mbd.isPrototype()) {                // It's a prototype -> create a new instance.                Object prototypeInstance = null;                try {                    beforePrototypeCreation(beanName);//原型創建前，與當前線程綁定                    prototypeInstance = createBean(beanName, mbd, args);                }                finally {                    afterPrototypeCreation(beanName);//原型創建后，與當前線程解除綁定                }                bean = 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 '" + scopeName + "'");                }                try {//根據范圍創建實例                    Object scopedInstance = scope.get(beanName, new ObjectFactory<Object>() {                        public Object getObject() throws BeansException {                            beforePrototypeCreation(beanName);                            try {                                return createBean(beanName, mbd, args);//原型創建前，與當前線程綁定                            }                            finally {                                ////原型創建后，與當前線程解除綁定                                afterPrototypeCreation(beanName);                            }                        }                    });                    //根據給定的實例是否為工廠Bean，返回它自己或工廠Bean創建的實例                    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);                }            }        }        //判斷要求的類型是否和Bean實例的類型正在匹配        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;    }        //判斷本容器是否包含指定bean    public boolean containsBean(String name) {        String beanName = transformedBeanName(name);        //    （如果是否包含單例 或 包含Bean定義）且 （為工廠Bean的產物 或 本身就是工廠bean），就返回true        if (containsSingleton(beanName) || containsBeanDefinition(beanName)) {            return (!BeanFactoryUtils.isFactoryDereference(name) || isFactoryBean(name));        }        // 如果不包含單例且不包含Bean定義，就從父類去查找        BeanFactory parentBeanFactory = getParentBeanFactory();        return (parentBeanFactory != null && parentBeanFactory.containsBean(originalBeanName(name)));    }    //判斷指定Bean是否為單例    public boolean isSingleton(String name) throws NoSuchBeanDefinitionException {        String beanName = transformedBeanName(name);        Object beanInstance = getSingleton(beanName, false);//首先從單例集合中取        if (beanInstance != null) {//取不到，就判斷它是不是FactoryBean的實例            if (beanInstance instanceof FactoryBean) {    //    如果是，要求它是工廠Bean產生的實例或這個工廠bean是單例                return (BeanFactoryUtils.isFactoryDereference(name) || ((FactoryBean<?>) beanInstance).isSingleton());            }            else {//    如果不是，要求它不是工廠Bean產生的實例                return !BeanFactoryUtils.isFactoryDereference(name);            }        }//若雖然取不到，但是單例集合中包含它的名字，說明它是單例        else if (containsSingleton(beanName)) {            return true;        }        else {            //從父工廠中去查詢Bean定義            BeanFactory parentBeanFactory = getParentBeanFactory();            if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {                //父工廠找不到Bean定義，那就在父工廠根據原始名去查是否為單例                return parentBeanFactory.isSingleton(originalBeanName(name));            }            //返回一個合并后的根Bean定義            RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);            // In case of FactoryBean, return singleton status of created object if not a dereference.            //若該根定義是單例            if (mbd.isSingleton()) {                if (isFactoryBean(beanName, mbd)) {    //若該根定義為工廠Bean                    if (BeanFactoryUtils.isFactoryDereference(name)) {//判斷是否為工廠產生的實例                        return true;                    }                    //取對應的工廠，判斷該工廠Bean是否為單例                    FactoryBean<?> factoryBean = (FactoryBean<?>) getBean(FACTORY_BEAN_PREFIX + beanName);                    return factoryBean.isSingleton();                }                else {    //    是否不為工廠Bean產生的實例（此時，即，該根定義不為工廠Bean，且不為工廠Bean產生的實例的時候，由于根定義是單例，那么它就是單例）                    return !BeanFactoryUtils.isFactoryDereference(name);                }            }            else {                return false;            }        }    }    //判斷是否為原型    public boolean isPrototype(String name) throws NoSuchBeanDefinitionException {        String beanName = transformedBeanName(name);        BeanFactory parentBeanFactory = getParentBeanFactory();//得到父工廠        //若父工廠中的定義為原型，就為原型        if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {            return parentBeanFactory.isPrototype(originalBeanName(name));        }        //若合并后的根定義為原型，且不是工廠Bean產生的實例、或本身是工廠Bean，那么就為原型        RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);        if (mbd.isPrototype()) {            return (!BeanFactoryUtils.isFactoryDereference(name) || isFactoryBean(beanName, mbd));        }        else {            if (BeanFactoryUtils.isFactoryDereference(name)) {//若為工廠Bean產生的實例                return false;            }            if (isFactoryBean(beanName, mbd)) {//若為工廠Bean，取它產生的Bean，判斷SmartFactoryBean                final FactoryBean<?> factoryBean = (FactoryBean<?>) getBean(FACTORY_BEAN_PREFIX + beanName);                if (System.getSecurityManager() != null) {                    return AccessController.doPrivileged(new PrivilegedAction<Boolean>() {                        public Boolean run() {                            return ((factoryBean instanceof SmartFactoryBean && ((SmartFactoryBean<?>) factoryBean).isPrototype()) ||                                    !factoryBean.isSingleton());                        }                    }, getAccessControlContext());                }                else {                    return ((factoryBean instanceof SmartFactoryBean && ((SmartFactoryBean<?>) factoryBean).isPrototype()) ||                            !factoryBean.isSingleton());                }            }            else {                return false;            }        }    }    //判斷類型是否匹配    public boolean isTypeMatch(String name, Class<?> targetType) throws NoSuchBeanDefinitionException {        String beanName = transformedBeanName(name);        Class<?> typeToMatch = (targetType != null ? targetType : Object.class);        Object beanInstance = getSingleton(beanName, false);//取name對應的單例        if (beanInstance != null) {            if (beanInstance instanceof FactoryBean) {//若為工廠Bean                //若不是工廠Bean產生的實例                if (!BeanFactoryUtils.isFactoryDereference(name)) {                    //取工廠Bean的類型與targetType進行對比                    Class<?> type = getTypeForFactoryBean((FactoryBean<?>) beanInstance);                    return (type != null && ClassUtils.isAssignable(typeToMatch, type));                }                else {                    return ClassUtils.isAssignableValue(typeToMatch, beanInstance);                }            }            //不是工廠Bean，那就直接判斷            else {                return !BeanFactoryUtils.isFactoryDereference(name) &&                        ClassUtils.isAssignableValue(typeToMatch, beanInstance);            }        }        //單例表中，對應的Key沒有值，也不包含Bean定義，說明沒有注冊，返回false        else if (containsSingleton(beanName) && !containsBeanDefinition(beanName)) {            return false;        }        //以下是包含Bean定義的情況        else {            //先查父類的Bean定義            BeanFactory parentBeanFactory = getParentBeanFactory();            if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {                // No bean definition found in this factory -> delegate to parent.                return parentBeanFactory.isTypeMatch(originalBeanName(name), targetType);            }                        //直接查合并后的根定義            RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);            //構建類型數組            Class[] typesToMatch = (FactoryBean.class.equals(typeToMatch) ?                    new Class[] {typeToMatch} : new Class[] {FactoryBean.class, typeToMatch});            // Check decorated bean definition, if any: We assume it'll be easier            // to determine the decorated bean's type than the proxy's type.            //得到Bean定義的持有者            BeanDefinitionHolder dbd = mbd.getDecoratedDefinition();            if (dbd != null && !BeanFactoryUtils.isFactoryDereference(name)) {//若為Bean工廠生成的實例，先得到根定義                RootBeanDefinition tbd = getMergedBeanDefinition(dbd.getBeanName(), dbd.getBeanDefinition(), mbd);                Class<?> targetClass = predictBeanType(dbd.getBeanName(), tbd, typesToMatch);//得到預測的根定義                if (targetClass != null && !FactoryBean.class.isAssignableFrom(targetClass)) {                    return typeToMatch.isAssignableFrom(targetClass);                }            }            Class<?> beanType = predictBeanType(beanName, mbd, typesToMatch);//預測后的類型            if (beanType == null) {                return false;            }            if (FactoryBean.class.isAssignableFrom(beanType)) {//BeanFactory是否為其子類                if (!BeanFactoryUtils.isFactoryDereference(name)) {//若不為工廠Bean的產物                    // If it's a FactoryBean, we want to look at what it creates, not the factory class.                    beanType = getTypeForFactoryBean(beanName, mbd);                    if (beanType == null) {                        return false;                    }                }            }            else if (BeanFactoryUtils.isFactoryDereference(name)) {//若為工廠類Bean的產物                beanType = predictBeanType(beanName, mbd, FactoryBean.class);//預測類型                if (beanType == null || !FactoryBean.class.isAssignableFrom(beanType)) {                    return false;                }            }            return typeToMatch.isAssignableFrom(beanType);        }    }    //返回類型    public Class<?> getType(String name) throws NoSuchBeanDefinitionException {        String beanName = transformedBeanName(name);        // Check manually registered singletons.        Object beanInstance = getSingleton(beanName, false);        if (beanInstance != null) {            if (beanInstance instanceof FactoryBean && !BeanFactoryUtils.isFactoryDereference(name)) {                return getTypeForFactoryBean((FactoryBean<?>) beanInstance);            }            else {                return beanInstance.getClass();            }        }        else if (containsSingleton(beanName) && !containsBeanDefinition(beanName)) {            // null instance registered            return null;        }        else {            // No singleton instance found -> check bean definition.            BeanFactory parentBeanFactory = getParentBeanFactory();            if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {                // No bean definition found in this factory -> delegate to parent.                return parentBeanFactory.getType(originalBeanName(name));            }            RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);            // Check decorated bean definition, if any: We assume it'll be easier            // to determine the decorated bean's type than the proxy's type.            BeanDefinitionHolder dbd = mbd.getDecoratedDefinition();            if (dbd != null && !BeanFactoryUtils.isFactoryDereference(name)) {                RootBeanDefinition tbd = getMergedBeanDefinition(dbd.getBeanName(), dbd.getBeanDefinition(), mbd);                Class<?> targetClass = predictBeanType(dbd.getBeanName(), tbd);                if (targetClass != null && !FactoryBean.class.isAssignableFrom(targetClass)) {                    return targetClass;                }            }            Class<?> beanClass = predictBeanType(beanName, mbd);            // Check bean class whether we're dealing with a FactoryBean.            if (beanClass != null && FactoryBean.class.isAssignableFrom(beanClass)) {                if (!BeanFactoryUtils.isFactoryDereference(name)) {                    // If it's a FactoryBean, we want to look at what it creates, not at the factory class.                    return getTypeForFactoryBean(beanName, mbd);                }                else {                    return beanClass;                }            }            else {                return (!BeanFactoryUtils.isFactoryDereference(name) ? beanClass : null);            }        }    }    //重寫了，得到別名的方法。    @Override    public String[] getAliases(String name) {        String beanName = transformedBeanName(name);        List<String> aliases = new ArrayList<String>();        boolean factoryPrefix = name.startsWith(FACTORY_BEAN_PREFIX);        String fullBeanName = beanName;        if (factoryPrefix) {            fullBeanName = FACTORY_BEAN_PREFIX + beanName;        }        if (!fullBeanName.equals(name)) {            aliases.add(fullBeanName);        }        String[] retrievedAliases = super.getAliases(beanName);        for (String retrievedAlias : retrievedAliases) {            String alias = (factoryPrefix ? FACTORY_BEAN_PREFIX : "") + retrievedAlias;            if (!alias.equals(name)) {                aliases.add(alias);            }        }        if (!containsSingleton(beanName) && !containsBeanDefinition(beanName)) {            BeanFactory parentBeanFactory = getParentBeanFactory();            if (parentBeanFactory != null) {                aliases.addAll(Arrays.asList(parentBeanFactory.getAliases(fullBeanName)));            }        }        return StringU