还在机械地打代码？只知道如何使用，却不知道做了什么，那么你注定只能是一个码农。Spring 框架几乎集成一半 Javaweb 开发的江山，但是你只知道如何写，不知道为什么要这么写，也不知道要如何优化。

本场 Chat 将让大家了解 Spring 的运行原理、深度解析 IOC 和 AOP、最后你还可以自己写一个小型 Spring 框架！

实录提要：

• 阅读源码的正确姿势/最佳实践是什么？
• Spring 源码哪本书比较好？
• 设计模式应该主要掌握哪几种？
• 如何进行统一加解密使用 Spring（还要考虑到上传文件返回文件数据的请款）？
• 模块化思想是什么？
• Spring 源码那么多的类，类之间调用比较复杂，从哪里开始看比较好？

目录

• 一、说说我自己
• 二、IOC入门篇之概念理解
• 三、深入理解IOC核心类
• 四、IOC体系结构源码剖析

说说我自己

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

• 入门篇 -- 读文章 对这个知识有一定的了解，了解大概的发展趋势以及使用复杂程度，达到基本可以使用程度。
• 掌握篇 -- 看网上的教程 对这个知识使用并了解一些出现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是最基础的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 实现类体系结构:

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);@Overridepublic 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;}// 移除别名@Overridepublic void removeAlias(String alias) {    String name = this.aliasMap.remove(alias);    if (name == null) {        throw new IllegalStateException("No alias '" + alias + "' registered");    }}// 是否是别名@Overridepublic boolean isAlias(String name) {    return this.aliasMap.containsKey(name);}// 获取所有别名@Overridepublic 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();    }}

AbstractBeanFactory

public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport    implements ConfigurableBeanFactory {// 父工厂的引用private BeanFactory parentBeanFactory;// 类加载器private ClassLoader beanClassLoader = ClassUtils.getDefaultClassLoader();// 临时类加载器private ClassLoader tempClassLoader;// 是否缓存加载beanprivate boolean cacheBeanMetadata = true;// bean的表达形式private BeanExpressionResolver beanExpressionResolver;// 转换服务，用来替代属性编辑器的private ConversionService conversionService;// 属性编辑登记员集合，容量为4的LinkedHashSetprivate 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>();// bean后置处理器集合private final List<BeanPostProcessor> beanPostProcessors = new ArrayList<BeanPostProcessor>();// 标记是否有处理器被注册private boolean hasInstantiationAwareBeanPostProcessors;// 标记是否处理器被销毁private boolean hasDestructionAwareBeanPostProcessors;// 范围标识符和Scope实例的对应的Mapprivate final Map<String, Scope> scopes = new HashMap<String, Scope>(8);// 安全相关(不看了)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() {}public AbstractBeanFactory(BeanFactory parentBeanFactory) {    this.parentBeanFactory = parentBeanFactory;}// 获取beanpublic Object getBean(String name) throws BeansException {    return doGetBean(name, null, null, false);}// 获取beanpublic <T> T getBean(String name, Class<T> requiredType) throws BeansException {    return doGetBean(name, requiredType, null, false);}// 获取beanpublic Object getBean(String name, Object... args) throws BeansException {    return doGetBean(name, null, args, false);}// 提供创建时需要参数列表的getBeanpublic <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 {    // 获取转化后的beanName    final String beanName = transformedBeanName(name);    Object bean;    // 尝试从单例集合取这个bean    Object sharedInstance = getSingleton(beanName);    if (sharedInstance != null && args == null) {        // 允许degbug输出日志        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 + "'");            }        }        //// 根据给定的实例是否为工厂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;}// 判断本容器是否包含指定beanpublic 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);        }    }}// 重写了，得到别名的方法。@Overridepublic 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 StringUtils.toStringArray(aliases);}// ---------------------------------------------------------------------// Implementation of HierarchicalBeanFactory interface// ---------------------------------------------------------------------// 返回本Bean工厂的父Bean工厂public BeanFactory getParentBeanFactory() {    return this.parentBeanFactory;}// 是否在本容器中（就是说，并不是工厂bean生产出来的）public boolean containsLocalBean(String name) {    String beanName = transformedBeanName(name); // 转换后的名字    // （是否为单例或有对应的Bean定义） 且（不是工厂Bean生产出来的 或 本身就是工厂bean）    return ((containsSingleton(beanName) || containsBeanDefinition(beanName))            && (!BeanFactoryUtils.isFactoryDereference(name)                    || isFactoryBean(beanName)));}// ---------------------------------------------------------------------// Implementation of ConfigurableBeanFactory interface// ---------------------------------------------------------------------public void setParentBeanFactory(BeanFactory parentBeanFactory) {    if (this.parentBeanFactory != null            && this.parentBeanFactory != parentBeanFactory) {        throw new IllegalStateException("Already associated with parent BeanFactory: "                + this.parentBeanFactory);    }    this.parentBeanFactory = parentBeanFactory;}public void setBeanClassLoader(ClassLoader beanClassLoader) {    this.beanClassLoader = (beanClassLoader != null ? beanClassLoader            : ClassUtils.getDefaultClassLoader());}public ClassLoader getBeanClassLoader() {    return this.beanClassLoader;}public void setTempClassLoader(ClassLoader tempClassLoader) {    this.tempClassLoader = tempClassLoader;}public ClassLoader getTempClassLoader() {    return this.tempClassLoader;}public void setCacheBeanMetadata(boolean cacheBeanMetadata) {    this.cacheBeanMetadata = cacheBeanMetadata;}public boolean isCacheBeanMetadata() {    return this.cacheBeanMetadata;}public void setBeanExpressionResolver(BeanExpressionResolver resolver) {    this.beanExpressionResolver = resolver;}public BeanExpressionResolver getBeanExpressionResolver() {    return this.beanExpressionResolver;}public void setConversionService(ConversionService conversionService) {    this.conversionService = conversionService;}public ConversionService getConversionService() {    return this.conversionService;}public void addPropertyEditorRegistrar(PropertyEditorRegistrar registrar) {    Assert.notNull(registrar, "PropertyEditorRegistrar must not be null");    this.propertyEditorRegistrars.add(registrar);}/** * Return the set of PropertyEditorRegistrars. */public Set<PropertyEditorRegistrar> getPropertyEditorRegistrars() {    return this.propertyEditorRegistrars;}public void registerCustomEditor(Class<?> requiredType,        Class<? extends PropertyEditor> propertyEditorClass) {    Assert.notNull(requiredType, "Required type must not be null");    Assert.isAssignable(PropertyEditor.class, propertyEditorClass);    this.customEditors.put(requiredType, propertyEditorClass);}public void copyRegisteredEditorsTo(PropertyEditorRegistry registry) {    registerCustomEditors(registry);}/** * Return the map of custom editors, with Classes as keys and PropertyEditor classes * as values. */public Map<Class<?>, Class<? extends PropertyEditor>> getCustomEditors() {    return this.customEditors;}public void setTypeConverter(TypeConverter typeConverter) {    this.typeConverter = typeConverter;}// 得到通用的类型转换器protected TypeConverter getCustomTypeConverter() {    return this.typeConverter;}// 得到类型转换器public TypeConverter getTypeConverter() {    TypeConverter customConverter = getCustomTypeConverter();    if (customConverter != null) {        return customConverter;    }    else {// 若本容器未注册类型转换器，就创建一个简单的类型转换器        SimpleTypeConverter typeConverter = new SimpleTypeConverter();        typeConverter.setConversionService(getConversionService());        registerCustomEditors(typeConverter);        return typeConverter;    }}public void addEmbeddedValueResolver(StringValueResolver valueResolver) {    Assert.notNull(valueResolver, "StringValueResolver must not be null");    this.embeddedValueResolvers.add(valueResolver);}public String resolveEmbeddedValue(String value) {    String result = value;    for (StringValueResolver resolver : this.embeddedValueResolvers) {        if (result == null) {            return null;        }        result = resolver.resolveStringValue(result);    }    return result;}public void addBeanPostProcessor(BeanPostProcessor beanPostProcessor) {    Assert.notNull(beanPostProcessor, "BeanPostProcessor must not be null");    this.beanPostProcessors.remove(beanPostProcessor);    this.beanPostProcessors.add(beanPostProcessor);    if (beanPostProcessor instanceof InstantiationAwareBeanPostProcessor) {        this.hasInstantiationAwareBeanPostProcessors = true;    }    if (beanPostProcessor instanceof DestructionAwareBeanPostProcessor) {        this.hasDestructionAwareBeanPostProcessors = true;    }}public int getBeanPostProcessorCount() {    return this.beanPostProcessors.size();}/** * Return the list of BeanPostProcessors that will get applied to beans created with * this factory. */public List<BeanPostProcessor> getBeanPostProcessors() {    return this.beanPostProcessors;}/** * Return whether this factory holds a InstantiationAwareBeanPostProcessor that will * get applied to singleton beans on shutdown. *  * @see #addBeanPostProcessor * @see org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessor */protected boolean hasInstantiationAwareBeanPostProcessors() {    return this.hasInstantiationAwareBeanPostProcessors;}/** * Return whether this factory holds a Destruction