深入浅出解读 Spring 源码：IOC

发表于 2019年06月22日 · 阅读量加载中...

说说我自己

我给大家介绍一下我的学习方法。学习的三种阶段：入门、掌握、精通。

入门篇 – 读文章对这个知识有一定的了解，了解大概的发展趋势以及使用复杂程度，达到基本可以使用程度。
掌握篇 – 看网上的教程对这个知识使用并了解一些出现bug解决方案，扩展使用途径。
精通篇 – 对知识体系结构已有完整认知需要读别人写的书加上自己亲自打代码时间完全了解这个知识发展渊源。

我也是和大家一样，大三来北京在一个小公司实习，我还是一个专科生，我并不是什么大神，只是在spring方面花费比大家多一些时间而已。

送给所有有梦想的我们一句话：相信自己，力量在心中！！

IOC入门篇之概念理解

控制反转(IoC)：概念的描述：

Martin Fowler提出，那些方面的控制被反转了？ - 他给出的结论：依赖对象的获取被反转了，基于这个结论他为控制反转创造了一个由两个或多各类批次之间的合作来实现业务逻辑的，这是的每一个对象都需要与其合作的对象（也就是他依赖的对象）的引用。如果这个获取过程要考自身实现，那么如果如你所见，这将导致代码高度耦合难以测试。–《摘自维基百科》

我是这样理解IOC容器：以水桶为例，有大的，小的，有金的，银的，各种各样。IOC容器也如此，每种不同的容器有自己功能，但是他们有一个是不能改变的，那就是装水，我们所学习的IOC容器也一样。

IOC是Inversion of Control的缩写，由于引进了中间位置的第三方，也就是IOC容器使得没有关联关系的类有了一个共同的关系–被ICO容器所管理，所以说IOC容器起到了粘合剂的作用。

DI是Dependency Injection的所写，是指通过引入IOC容器，利用类与类相关的依赖关系，注入的方式，实现代码重用以及对象之间的解耦合。（说到解耦合，三大框架都是为了解耦合，面试时候千万别说解耦合，说具体，哈哈。）

IOC的好处，初始化的过程中就不可避免的会写大量的new，只需要维护XML或注解，不需要大量的修改代码，IOC容器是分层的，从最底层BeanFactory网上找（后面源码解读会详细讲解），实现类与类之间的解耦合，可以将代码分离，每个人只需要写自己的部分，利于团队协作。

复合IOC规范的产品: Spring、Guice、Pico Container、Avalon、HiveMind；重量级的有EJB，JBoss，Jdon等等。以上除了Spring别的都没用过，出去面试吹一下也没啥^-^

使用IOC容器的小缺点: 引入第三方工具，对性能，初始化等速度均有影响，需要配置一大堆（springboot简化了好多，推荐大家从基于xml的spring学起），通过反射机制创建对象，效率较低~~~实际没影响。

深入理解IOC核心类

BeanFactory的基本类体系结构：

BeanFactory的基本类体系结构

如图所示：BeanFactory是最基础的IOC底层，定义了一些bean的基本属性，XMLBeanFactory算比较高级的IOC容器了，IOC容器是分层的，每一层都有自己需要做的功能，一下将简略展示IOC各个容器的功能。

BeanFactory 负责获取bean，封装判断bean容器是否包含bean，判断bean是否为单利/指定类型，获取类的别名，类型匹配等。
ListanleBeanFactory 继承自BeanFactory 封装bean的一些基本属性信息，如类的个数，类型，别名等，可以根据条件获取指定bean。
AutowireCapableBeanFactory 继承自BeanFactory 封装提供一系列自动装噢诶bean的策略，自动注入初始化以及bean的前/后处理器，分解依赖等。
HierarchicalBeanFactory 继承自BeanFactory 封装两个方法，一个获取bean工厂的父工厂，另一个判断本地工厂是否包含指定bean。
SinglentonRegistry 定义对单例注册及获取是否包含等判断。
ConfigurableBeanFactory 提供配置Factory的方法。
AliaRegistry 提供对bean的别名的增删改查操作。
BeanDefinitionRegister 使用BeanDefinition修饰bean，提供对BeanDefinition的增删改操作。
ConfigurableBeanFactory 提供配置bean的方法。
ConfigurableListableBeanFactory 配置清单BeanFactory指定忽略类型，接口等。
AbstractAutowireCapableBeanFactory 综合AbstractBeanFactory，对接自动装配bean。
DefaultListableBeanFactory 综合上面的功能，主要针对bean的注册。

IOC体系结构源码剖析

XmlBeanFactory 实现类体系结构:

XmlBeanFactory 实现类体系结构

Spring 5.x 源码下载

你也可以到github上下载gradle构架的Spring 然后把你的eclipse配置gradle 安装插件项目。

SimpleAliasRegistry

public class SimpleAliasRegistry implements AliasRegistry {

// 包含别名的map 就我了解 所有包含并发操作的都是用currentHashMap 推荐大家也使用
private final Map<String, String> aliasMap = new ConcurrentHashMap<String, String>(16);


@Override
public void registerAlias(String name, String alias) {
    Assert.hasText(name, "'name' must not be empty");
    Assert.hasText(alias, "'alias' must not be empty");
    // 若别名和实际bean名字相同，移除别名
    if (alias.equals(name)) {
        this.aliasMap.remove(alias);
    }
    else {
        // 获取bean的真实名
        String registeredName = this.aliasMap.get(alias);
        if (registeredName != null) {
            if (registeredName.equals(name)) {
                // An existing alias - no need to re-register
                return;
            }
            if (!allowAliasOverriding()) {
                throw new IllegalStateException("Cannot register alias '" + alias + "' for name '" +
                        name + "': It is already registered for name '" + registeredName + "'.");
            }
        }
        checkForAliasCircle(name, alias);// 当bean名字与name相同 检查别名是否相同 相同抛出异常 已存在的别名
        this.aliasMap.put(alias, name); 
    }
}
// SO WHAT ?    
protected boolean allowAliasOverriding() {
    return true;
}
// checkForAliasCircle调用的 上文指出
public boolean hasAlias(String name, String alias) {
    for (Map.Entry<String, String> entry : this.aliasMap.entrySet()) {
        String registeredName = entry.getValue();
        if (registeredName.equals(name)) {
            String registeredAlias = entry.getKey();
            return (registeredAlias.equals(alias) || hasAlias(registeredAlias, alias));
        }
    }
    return false;
}
// 移除别名
@Override
public void removeAlias(String alias) {
    String name = this.aliasMap.remove(alias);
    if (name == null) {
        throw new IllegalStateException("No alias '" + alias + "' registered");
    }
}
// 是否是别名
@Override
public boolean isAlias(String name) {
    return this.aliasMap.containsKey(name);
}
// 获取所有别名
@Override
public String[] getAliases(String name) {
    List<String> result = new ArrayList<String>();
    synchronized (this.aliasMap) {
        retrieveAliases(name, result);
    }
    return StringUtils.toStringArray(result);
}

// 找出所有name对应的别名 存入List<String>
private void retrieveAliases(String name, List<String> result) {
    for (Map.Entry<String, String> entry : this.aliasMap.entrySet()) {
        String registeredName = entry.getValue();
        if (registeredName.equals(name)) {
            String alias = entry.getKey();
            result.add(alias);
            retrieveAliases(alias, result);
        }
    }
}

// 处理所有的别名，如果处理正确，把原来的用解析后的替换
public void resolveAliases(StringValueResolver valueResolver) {
    Assert.notNull(valueResolver, "StringValueResolver must not be null");
    synchronized (this.aliasMap) {
        Map<String, String> aliasCopy = new HashMap<String, String>(this.aliasMap);
        for (String alias : aliasCopy.keySet()) {
            String registeredName = aliasCopy.get(alias);
            String resolvedAlias = valueResolver.resolveStringValue(alias);
            String resolvedName = valueResolver.resolveStringValue(registeredName);
            if (resolvedAlias == null || resolvedName == null || resolvedAlias.equals(resolvedName)) {
                this.aliasMap.remove(alias);
            }
            else if (!resolvedAlias.equals(alias)) {
                String existingName = this.aliasMap.get(resolvedAlias);
                if (existingName != null) {
                    if (existingName.equals(resolvedName)) {
                        // Pointing to existing alias - just remove placeholder
                        this.aliasMap.remove(alias);
                        break;
                    }
                    throw new IllegalStateException(
                            "Cannot register resolved alias '" + resolvedAlias + "' (original: '" + alias +
                            "') for name '" + resolvedName + "': It is already registered for name '" +
                            registeredName + "'.");
                }
                checkForAliasCircle(resolvedName, resolvedAlias);
                this.aliasMap.remove(alias);
                this.aliasMap.put(resolvedAlias, resolvedName);
            }
            else if (!registeredName.equals(resolvedName)) {
                this.aliasMap.put(alias, resolvedName);
            }
        }
    }
}

// 若当前map中存在别名和name相同 抛异常
protected void checkForAliasCircle(String name, String alias) {
    if (hasAlias(alias, name)) {
        throw new IllegalStateException("Cannot register alias '" + alias +
                "' for name '" + name + "': Circular reference - '" +
                name + "' is a direct or indirect alias for '" + alias + "' already");
    }
}


//根据name这个Key，在aliasMap中不断循环的取对应的value，如果取得到，就继续根据这个value取值，不断循环继续。直到取不到，就把这个在aliasMap中无对应值的key返回。

public String canonicalName(String name) {
    String canonicalName = name;
    // Handle aliasing...
    String resolvedName;
    do {
        resolvedName = this.aliasMap.get(canonicalName);
        if (resolvedName != null) {
            canonicalName = resolvedName;
        }
    }
    while (resolvedName != null);
    return canonicalName;
    }
}

DefaultSingletonBeanRegistry

public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {
    // 看看人家 代码写的多规范 我要学习
    protected static final Object NULL_OBJECT = new Object();

    // 定义记录log日志
    protected final Log logger = LogFactory.getLog(getClass());

    // 单例bean缓存
    private final Map<String, Object> singletonObjects = new ConcurrentHashMap<String, Object>(256);

    // 单例工厂缓存
    private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<String, ObjectFactory<?>>(16);

    // 没注册之前存放单例记录
    private final Map<String, Object> earlySingletonObjects = new HashMap<String, Object>(16);

    // 注册过的单例
    private final Set<String> registeredSingletons = new LinkedHashSet<String>(256);

    // 使用ConcurrentHashMap<T,Boolean> -- set<T> 底层我看过 那个Boolean属性true 包含
    // 这样的Set集合是采用锁分段的机制 对高并发操作优化
    // 即将创建的单例类
    private final Set<String> singletonsCurrentlyInCreation =
            Collections.newSetFromMap(new ConcurrentHashMap<String, Boolean>(16));

    // 正在创建的单例类
    private final Set<String> inCreationCheckExclusions =
            Collections.newSetFromMap(new ConcurrentHashMap<String, Boolean>(16));

    // 异常集合
    private Set<Exception> suppressedExceptions;

    // 单例类是否真正被销毁
    private boolean singletonsCurrentlyInDestruction = false;

    // disposable接口的实例
    private final Map<String, Object> disposableBeans = new LinkedHashMap<String, Object>();

    // bean名称和bean所有包含的Bean的名称的map
    private final Map<String, Set<String>> containedBeanMap = new ConcurrentHashMap<String, Set<String>>(16);

    // bean名称和所有依赖于Bean的名称的map
    private final Map<String, Set<String>> dependentBeanMap = new ConcurrentHashMap<String, Set<String>>(64);

    // bean名称和bean所依赖的所有名称的map
    private final Map<String, Set<String>> dependenciesForBeanMap = new ConcurrentHashMap<String, Set<String>>(64);

    // 注册单例类 重复注册抛异常
    @Override
    public void registerSingleton(String beanName, Object singletonObject) throws IllegalStateException {
        Assert.notNull(beanName, "'beanName' must not be null");
        synchronized (this.singletonObjects) {
            Object oldObject = this.singletonObjects.get(beanName);
            if (oldObject != null) {
                throw new IllegalStateException("Could not register object [" + singletonObject +
                        "] under bean name '" + beanName + "': there is already object [" + oldObject + "] bound");
            }
            addSingleton(beanName, singletonObject);
        }
    }

    // 从earlySingletonObjects，singletonFactories移除
    // 注册bean以及将bean添加到earlySingletonObjects
    protected void addSingleton(String beanName, Object singletonObject) {
        synchronized (this.singletonObjects) {
            this.singletonObjects.put(beanName, (singletonObject != null ? singletonObject : NULL_OBJECT));
            this.singletonFactories.remove(beanName);// 
            this.earlySingletonObjects.remove(beanName);
            this.registeredSingletons.add(beanName);
        }
    }

    // 注册一个单例工厂类，注册后从earlySingletonObjects移除
    protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
        Assert.notNull(singletonFactory, "Singleton factory must not be null");
        synchronized (this.singletonObjects) {
            if (!this.singletonObjects.containsKey(beanName)) {
                this.singletonFactories.put(beanName, singletonFactory);
                this.earlySingletonObjects.remove(beanName);
                this.registeredSingletons.add(beanName);
            }
        }
    }

    @Override
    public Object getSingleton(String beanName) {
        return getSingleton(beanName, true);
    }

    // 获取单例类
    protected Object getSingleton(String beanName, boolean allowEarlyReference) {
        Object singletonObject = this.singletonObjects.get(beanName);
        if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
            synchronized (this.singletonObjects) {
                singletonObject = this.earlySingletonObjects.get(beanName);
                if (singletonObject == null && allowEarlyReference) {// 不存在且正在创建中
                    ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);// 从缓存工厂获取单例工厂
                    if (singletonFactory != null) {
                        //  单例工厂创建单例对象
                        singletonObject = singletonFactory.getObject();
                        // 压进去
                        this.earlySingletonObjects.put(beanName, singletonObject);
                        this.singletonFactories.remove(beanName);
                    }
                }
            }
        }
        return (singletonObject != NULL_OBJECT ? singletonObject : null);
    }

    // 获取指定的单例Bean
    public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
        Assert.notNull(beanName, "'beanName' must not be null");
        synchronized (this.singletonObjects) {
            Object singletonObject = this.singletonObjects.get(beanName);
            // 如果从当前的单例缓存中没找到指定bean
            if (singletonObject == null) {
                if (this.singletonsCurrentlyInDestruction) {//当前单例正在摧毁
                    throw new BeanCreationNotAllowedException(beanName,
                            "Singleton bean creation not allowed while 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 + "'");
                }
                beforeSingletonCreation(beanName);// 单例类创建之前执行
                boolean newSingleton = false;
                boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
                if (recordSuppressedExceptions) {
                    this.suppressedExceptions = new LinkedHashSet<Exception>();
                }
                try {
                    singletonObject = singletonFactory.getObject();
                    newSingleton = true;
                }
                catch (IllegalStateException ex) {
                    // Has the singleton object implicitly appeared in the meantime ->
                    // if yes, proceed with it since the exception indicates that state.
                    singletonObject = this.singletonObjects.get(beanName);
                    if (singletonObject == null) {
                        throw ex;
                    }
                }
                catch (BeanCreationException ex) {
                    if (recordSuppressedExceptions) {
                        for (Exception suppressedException : this.suppressedExceptions) {
                            ex.addRelatedCause(suppressedException);
                        }
                    }
                    throw ex;
                }
                finally {
                    if (recordSuppressedExceptions) {
                        this.suppressedExceptions = null;
                    }
                    afterSingletonCreation(beanName);
                }
                if (newSingleton) {
                    addSingleton(beanName, singletonObject);
                }
            }
            return (singletonObject != NULL_OBJECT ? singletonObject : null);
        }
    }
    // 添加异常
    protected void onSuppressedException(Exception ex) {
        synchronized (this.singletonObjects) {
            if (this.suppressedExceptions != null) {
                this.suppressedExceptions.add(ex);
            }
        }
    }

    // 根据名称移除本容器中缓存的对应的单例Bean以及所有关联移除
    protected void removeSingleton(String beanName) {
        synchronized (this.singletonObjects) {
            this.singletonObjects.remove(beanName);
            this.singletonFactories.remove(beanName);
            this.earlySingletonObjects.remove(beanName);
            this.registeredSingletons.remove(beanName);
        }
    }
    // 判断容器是否包含单例bean
    @Override
    public boolean containsSingleton(String beanName) {
        return this.singletonObjects.containsKey(beanName);
    }
    // 获取所有单例类名字
    @Override
    public String[] getSingletonNames() {
        synchronized (this.singletonObjects) {
            return StringUtils.toStringArray(this.registeredSingletons);
        }
    }
    // 获取单例类个数
    @Override
    public int getSingletonCount() {
        synchronized (this.singletonObjects) {
            return this.registeredSingletons.size();
        }
    }

    // 设置bean创建状态
    public void setCurrentlyInCreation(String beanName, boolean inCreation) {
        Assert.notNull(beanName, "Bean name must not be null");
        if (!inCreation) {
            this.inCreationCheckExclusions.add(beanName);
        }
        else {
            this.inCreationCheckExclusions.remove(beanName);
        }
    }
    // 当前是否正在被创建
    public boolean isCurrentlyInCreation(String beanName) {
        Assert.notNull(beanName, "Bean name must not be null");
        return (!this.inCreationCheckExclusions.contains(beanName) && isActuallyInCreation(beanName));
    }
    // 是否在被创建
    protected boolean isActuallyInCreation(String beanName) {
        return isSingletonCurrentlyInCreation(beanName);
    }
    // 
    public boolean isSingletonCurrentlyInCreation(String beanName) {
        return this.singletonsCurrentlyInCreation.contains(beanName);
    }

    // 单例类创建之前调用
    protected void beforeSingletonCreation(String beanName) {
        // 若即将创建的类不在正在创建的集合中，向将要即将创建的类加入
        if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.add(beanName)) {
            throw new BeanCurrentlyInCreationException(beanName);
        }
    }

    // 单例类创建之后调用
    protected void afterSingletonCreation(String beanName) {
        // 若即将创建的类正在创建的集合中，向将要即将创建的类移除
        if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.remove(beanName)) {
            throw new IllegalStateException("Singleton '" + beanName + "' isn't currently in creation");
        }
    }


    // 向disposable注册实例
    public void registerDisposableBean(String beanName, DisposableBean bean) {
        synchronized (this.disposableBeans) {
            this.disposableBeans.put(beanName, bean);
        }
    }

    // 注册一个子类 -> 父类
    public void registerContainedBean(String containedBeanName, String containingBeanName) {
        // A quick check for an existing entry upfront, avoiding synchronization...
        Set<String> containedBeans = this.containedBeanMap.get(containingBeanName);
        // 已存在 return
        if (containedBeans != null && containedBeans.contains(containedBeanName)) {
            return;
        }

        // No entry yet -> fully synchronized manipulation of the containedBeans Set
        synchronized (this.containedBeanMap) {
            containedBeans = this.containedBeanMap.get(containingBeanName);
            if (containedBeans == null) {
                containedBeans = new LinkedHashSet<String>(8);// 初始化
                // containingBeanName 父类 containedBeans 孩子集合
                this.containedBeanMap.put(containingBeanName, containedBeans);
            }
            containedBeans.add(containedBeanName);// 孩子进窝
        }
        registerDependentBean(containedBeanName, containingBeanName);// 添加依赖关系·
    }

    // 给beanName添加dependentBeanName依赖
    public void registerDependentBean(String beanName, String dependentBeanName) {
        // A quick check for an existing entry upfront, avoiding synchronization...
        String canonicalName = canonicalName(beanName);
        Set<String> dependentBeans = this.dependentBeanMap.get(canonicalName);
        // 已存在 ruturn
        if (dependentBeans != null && dependentBeans.contains(dependentBeanName)) {
            return;
        }

        // 和上面一样
        synchronized (this.dependentBeanMap) {
            dependentBeans = this.dependentBeanMap.get(canonicalName);
            if (dependentBeans == null) {
                dependentBeans = new LinkedHashSet<String>(8);
                this.dependentBeanMap.put(canonicalName, dependentBeans);
            }
            dependentBeans.add(dependentBeanName);
        }
        synchronized (this.dependenciesForBeanMap) {
            Set<String> dependenciesForBean = this.dependenciesForBeanMap.get(dependentBeanName);
            if (dependenciesForBean == null) {
                dependenciesForBean = new LinkedHashSet<String>(8);
                this.dependenciesForBeanMap.put(dependentBeanName, dependenciesForBean);
            }
            dependenciesForBean.add(canonicalName);
        }
    }

    // 是否依赖关系
    protected boolean isDependent(String beanName, String dependentBeanName) {
        return isDependent(beanName, dependentBeanName, null);
    }

    private boolean isDependent(String beanName, String dependentBeanName, Set<String> alreadySeen) {
        if (alreadySeen != null && alreadySeen.contains(beanName)) {
            return false;
        }
        String canonicalName = canonicalName(beanName);
        Set<String> dependentBeans = this.dependentBeanMap.get(canonicalName);
        if (dependentBeans == null) {
            return false;
        }
        if (dependentBeans.contains(dependentBeanName)) {
            return true;
        }
        for (String transitiveDependency : dependentBeans) {
            if (alreadySeen == null) {
                alreadySeen = new HashSet<String>();
            }
            alreadySeen.add(beanName);
            if (isDependent(transitiveDependency, dependentBeanName, alreadySeen)) {
                return true;
            }
        }
        return false;
    }

    // 是否有依赖bean
    protected boolean hasDependentBean(String beanName) {
        return this.dependentBeanMap.containsKey(beanName);
    }

    // 根据beanName获取所有依赖bean
    public String[] getDependentBeans(String beanName) {
        Set<String> dependentBeans = this.dependentBeanMap.get(beanName);
        if (dependentBeans == null) {
            return new String[0];
        }
        return StringUtils.toStringArray(dependentBeans);
    }

    // 根据beanName获取所有所依赖
    public String[] getDependenciesForBean(String beanName) {
        Set<String> dependenciesForBean = this.dependenciesForBeanMap.get(beanName);
        if (dependenciesForBean == null) {
            return new String[0];
        }
        return dependenciesForBean.toArray(new String[dependenciesForBean.size()]);
    }
    // 销毁所有单例
    public void destroySingletons() {
        if (logger.isDebugEnabled()) {
            logger.debug("Destroying singletons in " + this);
        }
        synchronized (this.singletonObjects) {
            this.singletonsCurrentlyInDestruction = true;
        }

        String[] disposableBeanNames;
        synchronized (this.disposableBeans) {
            disposableBeanNames = StringUtils.toStringArray(this.disposableBeans.keySet());
        }
        for (int i = disposableBeanNames.length - 1; i >= 0; i--) {
            destroySingleton(disposableBeanNames[i]);
        }
        // 清空相关数据
        this.containedBeanMap.clear();
        this.dependentBeanMap.clear();
        this.dependenciesForBeanMap.clear();

        synchronized (this.singletonObjects) {
            this.singletonObjects.clear();
            this.singletonFactories.clear();
            this.earlySingletonObjects.clear();
            this.registeredSingletons.clear();
            this.singletonsCurrentlyInDestruction = false;
        }
    }

    // 销毁某个单例类
    public void destroySingleton(String beanName) {
        // Remove a registered singleton of the given name, if any.
        removeSingleton(beanName);

        // Destroy the corresponding DisposableBean instance.
        DisposableBean disposableBean;
        synchronized (this.disposableBeans) {
            disposableBean = (DisposableBean) this.disposableBeans.remove(beanName);
        }
        destroyBean(beanName, disposableBean);
    }

    // 删除之前添加的各种依赖
    protected void destroyBean(String beanName, DisposableBean bean) {
        // Trigger destruction of dependent beans first...
        Set<String> dependencies = this.dependentBeanMap.remove(beanName);
        if (dependencies != null) {
            if (logger.isDebugEnabled()) {
                logger.debug("Retrieved dependent beans for bean '" + beanName + "': " + dependencies);
            }
            for (String dependentBeanName : dependencies) {
                destroySingleton(dependentBeanName);
            }
        }

        // Actually destroy the bean now...
        if (bean != null) {
            try {
                bean.destroy();
            }
            catch (Throwable ex) {
                logger.error("Destroy method on bean with name '" + beanName + "' threw an exception", ex);
            }
        }

        // Trigger destruction of contained beans...
        Set<String> containedBeans = this.containedBeanMap.remove(beanName);
        if (containedBeans != null) {
            for (String containedBeanName : containedBeans) {
                destroySingleton(containedBeanName);
            }
        }

        // Remove destroyed bean from other beans' dependencies.
        synchronized (this.dependentBeanMap) {
            for (Iterator<Map.Entry<String, Set<String>>> it = this.dependentBeanMap.entrySet().iterator(); it.hasNext();) {
                Map.Entry<String, Set<String>> entry = it.next();
                Set<String> dependenciesToClean = entry.getValue();
                dependenciesToClean.remove(beanName);
                if (dependenciesToClean.isEmpty()) {
                    it.remove();
                }
            }
        }

        // Remove destroyed bean's prepared dependency information.
        this.dependenciesForBeanMap.remove(beanName);
    }

    // 
    public final Object getSingletonMutex() {
        return this.singletonObjects;
    }

}

AbstractBeanFactory

   =
    public abstract class FactoryBeanRegistrySupport extends DefaultSingletonBeanRegistry {

    // 存放工厂生产的单例集（查询的结果暂存，像hibernate或mybatis的调用缓存思路一致）
    private final Map<String, Object> factoryBeanObjectCache = new ConcurrentHashMap<>(16);



    // 返回指定beanFactory工厂的类型
    /**
        public interface FactoryBean<T> {
        T getObject() throws Exception;
        boolean isSingleton();      
        }
    */
    protected Class<?> getTypeForFactoryBean(final FactoryBean<?> factoryBean) {
        try {
            // 安全相关检查 我不去了解了
            if (System.getSecurityManager() != null) {
                return AccessController.doPrivileged((PrivilegedAction<Class<?>>) () ->
                        factoryBean.getObjectType(), getAccessControlContext());
            }
            else {
                return factoryBean.getObjectType();
            }
        }
        catch (Throwable ex) {
            // Thrown from the FactoryBean's getObjectType implementation.
            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;
        }
    }

    // 根据工厂名返回其生产的对象
    @Nullable
    protected Object getCachedObjectForFactoryBean(String beanName) {
        return this.factoryBeanObjectCache.get(beanName);
    }

    // 从Factory取对象 第三个参数 是否触发Post处理
    protected Object getObjectFromFactoryBean(FactoryBean<?> factory, String beanName, boolean shouldPostProcess) {
        if (factory.isSingleton() && containsSingleton(beanName)) {
            synchronized (getSingletonMutex()) {
                Object object = this.factoryBeanObjectCache.get(beanName);
                if (object == null) {
                    // 从BeanFactory调用方法获取bean
                    object = doGetObjectFromFactoryBean(factory, beanName);
                    Object alreadyThere = this.factoryBeanObjectCache.get(beanName);
                    if (alreadyThere != null) {
                        object = alreadyThere;
                    }
                    else {
                        if (shouldPostProcess) {
                            try {
                                object = postProcessObjectFromFactoryBean(object, beanName);
                            }
                            catch (Throwable ex) {
                                throw new BeanCreationException(beanName,
                                        "Post-processing of FactoryBean's singleton object failed", ex);
                            }
                        }
                        // 将对象放入缓存单例对象
                        this.factoryBeanObjectCache.put(beanName, object);
                    }
                }
                return object;
            }
        }
        else {
            Object object = doGetObjectFromFactoryBean(factory, beanName);
            if (shouldPostProcess) {
                try {
                    object = postProcessObjectFromFactoryBean(object, beanName);
                }
                catch (Throwable ex) {
                    throw new BeanCreationException(beanName, "Post-processing of FactoryBean's object failed", ex);
                }
            }
            return object;
        }
    }

    // 从单例工厂获取bean
    private Object doGetObjectFromFactoryBean(final FactoryBean<?> factory, final String beanName)
            throws BeanCreationException {

        Object object;
        try {
            // 安全判断
            if (System.getSecurityManager() != null) {
                AccessControlContext acc = getAccessControlContext();
                try {
                    object = AccessController.doPrivileged((PrivilegedExceptionAction<Object>) () ->
                            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);
        }

        if (object == null) {
            if (isSingletonCurrentlyInCreation(beanName)) {
                throw new BeanCurrentlyInCreationException(
                        beanName, "FactoryBean which is currently in creation returned null from getObject");
            }
            object = new NullBean();
        }
        return object;
    }

    // 交给子类处理
    protected Object postProcessObjectFromFactoryBean(Object object, String beanName) throws BeansException {
        return object;
    }

    // beanInstance是BeanFactory类型？是返回
    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;
    }

    // 移除 beanName
    @Override
    protected void removeSingleton(String beanName) {
        super.removeSingleton(beanName);
        this.factoryBeanObjectCache.remove(beanName);
    }

    // 销毁 所有
    @Override
    public void destroySingletons() {
        super.destroySingletons();
        this.factoryBeanObjectCache.clear();
    }

    protected AccessControlContext getAccessControlContext() {
        return AccessController.getContext();
    }
}