GitChat的博客
GitChat的博客

深入浅出解读 Spring 源码：IOC/AOP 篇

还在机械地打代码？只知道如何使用，却不知道做了什么，那么你注定只能是一个码农。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的基本类体系结构：

深入浅出解读 Spring 源码：IOC/AOP 篇_第1张图片

如图所示：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 源码：IOC/AOP 篇_第2张图片

Spring 5.x 源码下载

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

SimpleAliasRegistry

public class SimpleAliasRegistry implements AliasRegistry {// 包含别名的map 就我了解 所有包含并发操作的都是用currentHashMap 推荐大家也使用private final Map aliasMap = new ConcurrentHashMap(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 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 result = new ArrayList();    synchronized (this.aliasMap) {        retrieveAliases(name, result);    }    return StringUtils.toStringArray(result);}// 找出所有name对应的别名 存入Listprivate void retrieveAliases(String name, List result) {    for (Map.Entry 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 aliasCopy = new HashMap(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 singletonObjects = new ConcurrentHashMap(256);    // 单例工厂缓存    private final Map> singletonFactories = new HashMap>(16);    // 没注册之前存放单例记录    private final Map earlySingletonObjects = new HashMap(16);    // 注册过的单例    private final Set registeredSingletons = new LinkedHashSet(256);    // 使用ConcurrentHashMap -- set 底层我看过 那个Boolean属性true 包含    // 这样的Set集合是采用锁分段的机制 对高并发操作优化    // 即将创建的单例类    private final Set singletonsCurrentlyInCreation =            Collections.newSetFromMap(new ConcurrentHashMap(16));    // 正在创建的单例类    private final Set inCreationCheckExclusions =            Collections.newSetFromMap(new ConcurrentHashMap(16));    // 异常集合    private Set suppressedExceptions;    // 单例类是否真正被销毁    private boolean singletonsCurrentlyInDestruction = false;    // disposable接口的实例    private final Map disposableBeans = new LinkedHashMap();    // bean名称和bean所有包含的Bean的名称的map    private final Map> containedBeanMap = new ConcurrentHashMap>(16);    // bean名称和所有依赖于Bean的名称的map    private final Map> dependentBeanMap = new ConcurrentHashMap>(64);    // bean名称和bean所依赖的所有名称的map    private final Map> dependenciesForBeanMap = new ConcurrentHashMap>(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();                }                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 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(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 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(8);                this.dependentBeanMap.put(canonicalName, dependentBeans);            }            dependentBeans.add(dependentBeanName);        }        synchronized (this.dependenciesForBeanMap) {            Set dependenciesForBean = this.dependenciesForBeanMap.get(dependentBeanName);            if (dependenciesForBean == null) {                dependenciesForBean = new LinkedHashSet(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 alreadySeen) {        if (alreadySeen != null && alreadySeen.contains(beanName)) {            return false;        }        String canonicalName = canonicalName(beanName);        Set 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();            }            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 dependentBeans = this.dependentBeanMap.get(beanName);        if (dependentBeans == null) {            return new String[0];        }        return StringUtils.toStringArray(dependentBeans);    }    // 根据beanName获取所有所依赖    public String[] getDependenciesForBean(String beanName) {        Set 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 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 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>> it = this.dependentBeanMap.entrySet().iterator(); it.hasNext();) {                Map.Entry> entry = it.next();                Set 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 factoryBeanObjectCache = new ConcurrentHashMap<>(16);    // 返回指定beanFactory工厂的类型    /**        public interface FactoryBean {        T getObject() throws Exception;        boolean isSingleton();              }    */    protected Class getTypeForFactoryBean(final FactoryBean factoryBean) {        try {            // 安全相关检查 我不去了解了            if (System.getSecurityManager() != null) {                return AccessController.doPrivileged((PrivilegedAction>) () ->                        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) () ->                            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 propertyEditorRegistrars = new LinkedHashSet(        4);// 类型转换器private TypeConverter typeConverter;// 默认的属性编辑器集合private final Map, Class> customEditors = new HashMap, Class>(        4);// 嵌入值转换器集合private final List embeddedValueResolvers = new LinkedList();// bean后置处理器集合private final List beanPostProcessors = new ArrayList();// 标记是否有处理器被注册private boolean hasInstantiationAwareBeanPostProcessors;// 标记是否处理器被销毁private boolean hasDestructionAwareBeanPostProcessors;// 范围标识符和Scope实例的对应的Mapprivate final Map scopes = new HashMap(8);// 安全相关(不看了)private SecurityContextProvider securityContextProvider;// 合并后的Bean根定义的集合private final Map mergedBeanDefinitions = new ConcurrentHashMap(        64);// 被创建过得bean集合private final Map alreadyCreated = new ConcurrentHashMap(        64);// 当前正在创建的原型，当前线程相关private final ThreadLocal prototypesCurrentlyInCreation = new NamedThreadLocal(        "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 getBean(String name, Class 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 getBean(String name, Class requiredType, Object... args)        throws BeansException {    return doGetBean(name, requiredType, args, false);}// 从容器中获取bean的基本方法。@SuppressWarnings("unchecked")protected  T doGetBean(final String name, final Class 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() {                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() {                            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() {                    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 aliases = new ArrayList();    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 getPropertyEditorRegistrars() {    return this.propertyEditorRegistrars;}public void registerCustomEditor(Class requiredType,        Class 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> 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 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 DestructionAwareBeanPostProcessor that will get * applied to singleton beans on shutdown. *  * @see #addBeanPostProcessor * @see org.springframework.beans.factory.config.DestructionAwareBeanPostProcessor */protected boolean hasDestructionAwareBeanPostProcessors() {    return this.hasDestructionAwareBeanPostProcessors;}public void registerScope(String scopeName, Scope scope) {    Assert.notNull(scopeName, "Scope identifier must not be null");    Assert.notNull(scope, "Scope must not be null");    if (SCOPE_SINGLETON.equals(scopeName) || SCOPE_PROTOTYPE.equals(scopeName)) {        throw new IllegalArgumentException(                "Cannot replace existing scopes 'singleton' and 'prototype'");    }    this.scopes.put(scopeName, scope);}public String[] getRegisteredScopeNames() {    return StringUtils.toStringArray(this.scopes.keySet());}public Scope getRegisteredScope(String scopeName) {    Assert.notNull(scopeName, "Scope identifier must not be null");    return this.scopes.get(scopeName);}/** * Set the security context provider for this bean factory. If a security manager is * set, interaction with the user code will be executed using the privileged of the * provided security context. */public void setSecurityContextProvider(SecurityContextProvider securityProvider) {    this.securityContextProvider = securityProvider;}/** * Delegate the creation of the access control context to the * {@link #setSecurityContextProvider SecurityContextProvider}. */@Overridepublic AccessControlContext getAccessControlContext() {    return (this.securityContextProvider != null            ? this.securityContextProvider.getAccessControlContext()            : AccessController.getContext());}public void copyConfigurationFrom(ConfigurableBeanFactory otherFactory) {    Assert.notNull(otherFactory, "BeanFactory must not be null");    setBeanClassLoader(otherFactory.getBeanClassLoader());    setCacheBeanMetadata(otherFactory.isCacheBeanMetadata());    setBeanExpressionResolver(otherFactory.getBeanExpressionResolver());    if (otherFactory instanceof AbstractBeanFactory) {        AbstractBeanFactory otherAbstractFactory = (AbstractBeanFactory) otherFactory;        this.customEditors.putAll(otherAbstractFactory.customEditors);        this.propertyEditorRegistrars.addAll(                otherAbstractFactory.propertyEditorRegistrars);        this.beanPostProcessors.addAll(otherAbstractFactory.beanPostProcessors);        this.hasInstantiationAwareBeanPostProcessors = this.hasInstantiationAwareBeanPostProcessors                || otherAbstractFactory.hasInstantiationAwareBeanPostProcessors;        this.hasDestructionAwareBeanPostProcessors = this.hasDestructionAwareBeanPostProcessors                || otherAbstractFactory.hasDestructionAwareBeanPostProcessors;        this.scopes.putAll(otherAbstractFactory.scopes);        this.securityContextProvider = otherAbstractFactory.securityContextProvider;    }    else {        setTypeConverter(otherFactory.getTypeConverter());    }}// 返回合并后的bean定义（父Bean定义和子Bean定义合并）public BeanDefinition getMergedBeanDefinition(String name) throws BeansException {    String beanName = transformedBeanName(name);    // Efficiently check whether bean definition exists in this factory.    // 若Bean定义不存在，且本容器父工厂为ConfigurableBeanFactory的实例，让父工厂来调用这个方法    if (!containsBeanDefinition(beanName)            && getParentBeanFactory() instanceof ConfigurableBeanFactory) {        return ((ConfigurableBeanFactory) getParentBeanFactory()).getMergedBeanDefinition(                beanName);    }    // 否则直接从本地合并后的Bean定义中取    return getMergedLocalBeanDefinition(beanName);}public boolean isFactoryBean(String name) throws NoSuchBeanDefinitionException {    String beanName = transformedBeanName(name);    Object beanInstance = getSingleton(beanName, false);    if (beanInstance != null) {        return (beanInstance instanceof FactoryBean);    }    else if (containsSingleton(beanName)) {        // null instance registered        return false;    }    // No singleton instance found -> check bean definition.    if (!containsBeanDefinition(beanName)            && getParentBeanFactory() instanceof ConfigurableBeanFactory) {        // No bean definition found in this factory -> delegate to parent.        return ((ConfigurableBeanFactory) getParentBeanFactory()).isFactoryBean(name);    }    return isFactoryBean(beanName, getMergedLocalBeanDefinition(beanName));}@Overridepublic boolean isActuallyInCreation(String beanName) {    return isSingletonCurrentlyInCreation(beanName)            || isPrototypeCurrentlyInCreation(beanName);}// 判断指定的原型是否正在被创建protected boolean isPrototypeCurrentlyInCreation(String beanName) {    Object curVal = this.prototypesCurrentlyInCreation.get();    return (curVal != null && (curVal.equals(beanName)            || (curVal instanceof Set && ((Set) curVal).contains(beanName))));}// 原型创建前回调，需要子类重写@SuppressWarnings("unchecked")protected void beforePrototypeCreation(String beanName) {    Object curVal = this.prototypesCurrentlyInCreation.get();    if (curVal == null) {// 原型创建状态与当前线程绑定        this.prototypesCurrentlyInCreation.set(beanName);    }    else if (curVal instanceof String) {        Set beanNameSet = new HashSet(2);        beanNameSet.add((String) curVal);        beanNameSet.add(beanName);        this.prototypesCurrentlyInCreation.set(beanNameSet);    }    // 这里多余了。。。    else {        Set beanNameSet = (Set) curVal;        beanNameSet.add(beanName);    }}// 创建原型后，从当前线程解除绑定@SuppressWarnings("unchecked")protected void afterPrototypeCreation(String beanName) {    Object curVal = this.prototypesCurrentlyInCreation.get();    if (curVal instanceof String) {        this.prototypesCurrentlyInCreation.remove();    }    else if (curVal instanceof Set) {        Set beanNameSet = (Set) curVal;        beanNameSet.remove(beanName);        if (beanNameSet.isEmpty()) {            this.prototypesCurrentlyInCreation.remove();        }    }}public void destroyBean(String beanName, Object beanInstance) {    destroyBean(beanName, beanInstance, getMergedLocalBeanDefinition(beanName));}/** * Destroy the given bean instance (usually a prototype instance obtained from this * factory) according to the given bean definition. *  * @param beanName the name of the bean definition * @param beanInstance the bean instance to destroy * @param mbd the merged bean definition */protected void destroyBean(String beanName, Object beanInstance,        RootBeanDefinition mbd) {    new DisposableBeanAdapter(beanInstance, beanName, mbd, getBeanPostProcessors(),            getAccessControlContext()).destroy();}public void destroyScopedBean(String beanName) {    RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);    if (mbd.isSingleton() || mbd.isPrototype()) {        throw new IllegalArgumentException("Bean name '" + beanName                + "' does not correspond to an object in a mutable scope");    }    String scopeName = mbd.getScope();    Scope scope = this.scopes.get(scopeName);    if (scope == null) {        throw new IllegalStateException(                "No Scope SPI registered for scope '" + scopeName + "'");    }    Object bean = scope.remove(beanName);    if (bean != null) {        destroyBean(beanName, bean, mbd);    }}// ---------------------------------------------------------------------// Implementation methods// ---------------------------------------------------------------------// 变换后的Bean名称（先去掉BeanFactory前缀，然后在aliasMap中取标准名）protected String transformedBeanName(String name) {    return canonicalName(BeanFactoryUtils.transformedBeanName(name));}// 返回原始的Bean名protected String originalBeanName(String name) {    String beanName = transformedBeanName(name);    if (name.startsWith(FACTORY_BEAN_PREFIX)) {        beanName = FACTORY_BEAN_PREFIX + beanName;    }    return beanName;}/** * Initialize the given BeanWrapper with the custom editors registered with this * factory. To be called for BeanWrappers that will create and populate bean * instances. * 
 * The default implementation delegates to {@link #registerCustomEditors}. Can be * overridden in subclasses. *  * @param bw the BeanWrapper to initialize */protected void initBeanWrapper(BeanWrapper bw) {    bw.setConversionService(getConversionService());    registerCustomEditors(bw);}/** * Initialize the given PropertyEditorRegistry with the custom editors that have been * registered with this BeanFactory. * 
 * To be called for BeanWrappers that will create and populate bean instances, and for * SimpleTypeConverter used for constructor argument and factory method type * conversion. *  * @param registry the PropertyEditorRegistry to initialize */protected void registerCustomEditors(PropertyEditorRegistry registry) {    PropertyEditorRegistrySupport registrySupport = (registry instanceof PropertyEditorRegistrySupport            ? (PropertyEditorRegistrySupport) registry : null);    if (registrySupport != null) {        registrySupport.useConfigValueEditors();    }    if (!this.propertyEditorRegistrars.isEmpty()) {        for (PropertyEditorRegistrar registrar : this.propertyEditorRegistrars) {            try {                registrar.registerCustomEditors(registry);            }            catch (BeanCreationException ex) {                Throwable rootCause = ex.getMostSpecificCause();                if (rootCause instanceof BeanCurrentlyInCreationException) {                    BeanCreationException bce = (BeanCreationException) rootCause;                    if (isCurrentlyInCreation(bce.getBeanName())) {                        if (logger.isDebugEnabled()) {                            logger.debug("PropertyEditorRegistrar ["                                    + registrar.getClass().getName()                                    + "] failed because it tried to obtain currently created bean '"                                    + ex.getBeanName() + "': " + ex.getMessage());                        }                        onSuppressedException(ex);                        continue;                    }                }                throw ex;            }        }    }    if (!this.customEditors.isEmpty()) {        for (Map.Entry, Class> entry : this.customEditors.entrySet()) {            Class requiredType = entry.getKey();            Class editorClass = entry.getValue();            registry.registerCustomEditor(requiredType,                    BeanUtils.instantiateClass(editorClass));        }    }}// 返回一个合并后的根Bean定义（父Bean定义和子Bean定义合并）（从当前容器取）protected RootBeanDefinition getMergedLocalBeanDefinition(String beanName)        throws BeansException {    // Quick check on the concurrent map first, with minimal locking.    RootBeanDefinition mbd = this.mergedBeanDefinitions.get(beanName);// 首先直接从合并根定义集合中取    if (mbd != null) {        return mbd;    }    // 根据bean名和其对应的Bean定义，取其根Bean根定义    return getMergedBeanDefinition(beanName, getBeanDefinition(beanName));}// 根据Bean名和Bean定义取其Bean根定义protected RootBeanDefinition getMergedBeanDefinition(String beanName,        BeanDefinition bd) throws BeanDefinitionStoreException {    return getMergedBeanDefinition(beanName, bd, null);// 调用重载方法}// 根据Bean名称返回根定义（若给定的Bean定义为子Bean定义，那么合并它的父Bean定义）protected RootBeanDefinition getMergedBeanDefinition(String beanName,        BeanDefinition bd, BeanDefinition containingBd)        throws BeanDefinitionStoreException {    synchronized (this.mergedBeanDefinitions) {        RootBeanDefinition mbd = null;        // 若给定的Bean定义并没有包含子Bean定义，那么直接根据Bean名取根定义        if (containingBd == null) {            mbd = this.mergedBeanDefinitions.get(beanName);        }        if (mbd == null) {// 若取不到            if (bd.getParentName() == null) {// 若Bean定义没有父类，就很简单了                if (bd instanceof RootBeanDefinition) {// 若Bean定义是RootBeanDefinition的实例，克隆、强转后返回                    mbd = ((RootBeanDefinition) bd).cloneBeanDefinition();                }                else {// 否则，根据Bean定义，来构造一个根Bean定义                    mbd = new RootBeanDefinition(bd);                }            }            else {// 若Bean定义有父类                    // Child bean definition: needs to be merged with parent.                BeanDefinition pbd;                try {                    String parentBeanName = transformedBeanName(bd.getParentName());// 取其父Bean定义的名字                    if (!beanName.equals(parentBeanName)) {// 若Bean名字并不是bd的父Bean的名字                        pbd = getMergedBeanDefinition(parentBeanName);// 根据父Bean定义名称来返回合并后的bean定义                    }                    else {// 如果beanName对应的Bean就是bd的父Bean                        if (getParentBeanFactory() instanceof ConfigurableBeanFactory) {// 若父Bean工厂为ConfigurableBeanFactory的实例                            // 那么强转成ConfigurableBeanFactory后再调用合并方法                            pbd = ((ConfigurableBeanFactory) getParentBeanFactory()).getMergedBeanDefinition(                                    parentBeanName);                        }                        else {// 若父Bean工厂不是ConfigurableBeanFactory的实例，就抛出异常                            throw new NoSuchBeanDefinitionException(                                    bd.getParentName(),                                    "Parent name '" + bd.getParentName()                                            + "' is equal to bean name '" + beanName                                            + "': cannot be resolved without an AbstractBeanFactory parent");                        }                    }                }                catch (NoSuchBeanDefinitionException ex) {                    throw new BeanDefinitionStoreException(                            bd.getResourceDescription(), beanName,                            "Could not resolve parent bean definition '"                                    + bd.getParentName() + "'",                            ex);                }                // 深度复制                mbd = new RootBeanDefinition(pbd);// 根据Bean定义生成一个根Bean定义                mbd.overrideFrom(bd);// 将Bean定义的属性复制进自己的定义（根Bean定义）中            }            if (!StringUtils.hasLength(mbd.getScope())) {// 如果根Bean定义未设置范围                mbd.setScope(RootBeanDefinition.SCOPE_SINGLETON);// 那么设置其范围为单例            }            // 若本根Bean定义包含Bean定义、本根Bean定义为单例且包含的Bean定义并不是单例            if (containingBd != null && !containingBd.isSingleton()                    && mbd.isSingleton()) {                mbd.setScope(containingBd.getScope());// 那么将本根Bean定义的范围设置为包含的Bean定义的范围            }            // 若本根Bean定义不包含Bean定义，且是缓存Bean元数据（重写前均为true）且Bean定义是否有资格缓存（默认实现是，这个Bean已经创建便有资格）            if (containingBd == null && isCacheBeanMetadata()                    && isBeanEligibleForMetadataCaching(beanName)) {                this.mergedBeanDefinitions.put(beanName, mbd);// 放进mergedBeanDefinitions中            }        }        return mbd;    }}// 检查Bean定义，抛出异常protected void checkMergedBeanDefinition(RootBeanDefinition mbd, String beanName,        Object[] args) throws BeanDefinitionStoreException {    if (mbd.isAbstract()) {        throw new BeanIsAbstractException(beanName);    }    if (args != null && !mbd.isPrototype()) {        throw new BeanDefinitionStoreException(                "Can only specify arguments for the getBean method when referring to a prototype bean definition");    }}/** * Remove the merged bean definition for the specified bean, recreating it on next * access. *  * @param beanName the bean name to clear the merged definition for */protected void clearMergedBeanDefinition(String beanName) {    this.mergedBeanDefinitions.remove(beanName);}// 解析类型，处理异常protected Class resolveBeanClass(final RootBeanDefinition mbd, String beanName,        final Class... typesToMatch) throws CannotLoadBeanClassException {    try {        if (mbd.hasBeanClass()) {            return mbd.getBeanClass();        }        if (System.getSecurityManager() != null) {            return AccessController.doPrivileged(                    new PrivilegedExceptionAction>() {                        public Class run() throws Exception {                            return doResolveBeanClass(mbd, typesToMatch);                        }                    }, getAccessControlContext());        }        else {            return doResolveBeanClass(mbd, typesToMatch);        }    }    catch (PrivilegedActionException pae) {        ClassNotFoundException ex = (ClassNotFoundException) pae.getException();        throw new CannotLoadBeanClassException(mbd.getResourceDescription(), beanName,                mbd.getBeanClassName(), ex);    }    catch (ClassNotFoundException ex) {        throw new CannotLoadBeanClassException(mbd.getResourceDescription(), beanName,                mbd.getBeanClassName(), ex);    }    catch (LinkageError err) {        throw new CannotLoadBeanClassException(mbd.getResourceDescription(), beanName,                mbd.getBeanClassName(), err);    }}// 真正的解析类型private Class doResolveBeanClass(RootBeanDefinition mbd, Class... typesToMatch)        throws ClassNotFoundException {    if (!ObjectUtils.isEmpty(typesToMatch)) {        ClassLoader tempClassLoader = getTempClassLoader();// 找到临时的类加载器        if (tempClassLoader != null) {            if (tempClassLoader instanceof DecoratingClassLoader) {// 若为装饰类加载器                DecoratingClassLoader dcl = (DecoratingClassLoader) tempClassLoader;                for (Class typeToMatch : typesToMatch) {                    dcl.excludeClass(typeToMatch.getName());                }            }            String className = mbd.getBeanClassName();            return (className != null ? ClassUtils.forName(className, tempClassLoader)                    : null);        }    }    return mbd.resolveBeanClass(getBeanClassLoader());}/** * Evaluate the given String as contained in a bean definition, potentially resolving * it as an expression. *  * @param value the value to check * @param beanDefinition the bean definition that the value comes from * @return the resolved value * @see #setBeanExpressionResolver */protected Object evaluateBeanDefinitionString(String value,        BeanDefinition beanDefinition) {    if (this.beanExpressionResolver == null) {        return value;    }    Scope scope = (beanDefinition != null            ? getRegisteredScope(beanDefinition.getScope()) : null);    return this.beanExpressionResolver.evaluate(value,            new BeanExpressionContext(this, scope));}// 预测类型protected Class predictBeanType(String beanName, RootBeanDefinition mbd,        Class... typesToMatch) {    // 若根Bena定义的工厂方法名存在，说明它是工厂Bean创建的，无法预测类型？    if (mbd.getFactoryMethodName() != null) {        return null;    }    // 否则，解析Bean的Class    return resolveBeanClass(mbd, beanName, typesToMatch);}/** * Check whether the given bean is defined as a {@link FactoryBean}. *  * @param beanName the name of the bean * @param mbd the corresponding bean definition */protected boolean isFactoryBean(String beanName, RootBeanDefinition mbd) {    Class beanType = predictBeanType(beanName, mbd, FactoryBean.class);    return (beanType != null && FactoryBean.class.isAssignableFrom(beanType));}// 返回工厂Bean的类型protected Class getTypeForFactoryBean(String beanName, RootBeanDefinition mbd) {    if (!mbd.isSingleton()) {        return null;    }    try {        FactoryBean factoryBean = doGetBean(FACTORY_BEAN_PREFIX + beanName,                FactoryBean.class, null, true);        return getTypeForFactoryBean(factoryBean);    }    catch (BeanCreationException ex) {        // Can only happen when getting a FactoryBean.        if (logger.isDebugEnabled()) {            logger.debug(                    "Ignoring bean creation exception on FactoryBean type check: "                            + ex);        }        onSuppressedException(ex);        return null;    }}// 标记这个Bean已经被创建protected void markBeanAsCreated(String beanName) {    this.alreadyCreated.put(beanName, Boolean.TRUE);}/** * Determine whether the specified bean is eligible for having its bean definition * metadata cached. *  * @param beanName the name of the bean * @return {@code true} if the bean's metadata may be cached at this point already */// 若本根Bean定义包含Bean元定义作为缓存，这个方法应被之类覆盖，这里仅判断Bean是否已经被创建protected boolean isBeanEligibleForMetadataCaching(String beanName) {    return this.alreadyCreated.containsKey(beanName);}/** * Remove the singleton instance (if any) for the given bean name, but only if it * hasn't been used for other purposes than type checking. *  * @param beanName the name of the bean * @return {@code true} if actually removed, {@code false} otherwise */protected boolean removeSingletonIfCreatedForTypeCheckOnly(String beanName) {    if (!this.alreadyCreated.containsKey(beanName)) {        removeSingleton(beanName);        return true;    }    else {        return false;    }}// 返回它自己或工厂Bean创建的实例protected Object getObjectForBeanInstance(Object beanInstance, String name,        String beanName, RootBeanDefinition mbd) {    // 如果这个Bean是工厂Bean创建的 且 这个Bean实例并不是FactoryBean实例，抛异常    if (BeanFactoryUtils.isFactoryDereference(name)            && !(beanInstance instanceof FactoryBean)) {        throw new BeanIsNotAFactoryException(transformedBeanName(name),                beanInstance.getClass());    }    // 如果这个Bean实例并不是FactoryBean实例 或 这个Bean是工厂Bean创建的，直接返回    if (!(beanInstance instanceof FactoryBean)            || BeanFactoryUtils.isFactoryDereference(name)) {        return beanInstance;    }    // ——————————以下都是 这个Bean实例是FactoryBean实例的情况    Object object = null;    if (mbd == null) {// 若根Bean定义为空，取这个BeanFactory所生产的实例        object = getCachedObjectForFactoryBean(beanName);    }    if (object == null) {// 若取不到，那么手动取        FactoryBean factory = (FactoryBean) beanInstance;// 把这个实例转化成一个FactoryBean        // Caches object obtained from FactoryBean if it is a singleton.        if (mbd == null && containsBeanDefinition(beanName)) {// 若根Bean定义为空，但是容器内有Bean定义            mbd = getMergedLocalBeanDefinition(beanName);// 返回合并后的Bean定义        }        boolean synthetic = (mbd != null && mbd.isSynthetic());// 标记这个Bean定义是合并的        object = getObjectFromFactoryBean(factory, beanName, !synthetic);// 从工厂Bean中取    }    return object;}// 判断给定的Bean是否被使用过public boolean isBeanNameInUse(String beanName) {    // 若是别名 或 并非工厂bean生产出来的 或 被其他某个bean所依赖，那么判断其被使用过    return isAlias(beanName) || containsLocalBean(beanName)            || hasDependentBean(beanName);}/** * Determine whether the given bean requires destruction on shutdown. * 
 * The default implementation checks the DisposableBean interface as well as a * specified destroy method and registered DestructionAwareBeanPostProcessors. *  * @param bean the bean instance to check * @param mbd the corresponding bean definition * @see org.springframework.beans.factory.DisposableBean * @see AbstractBeanDefinition#getDestroyMethodName() * @see org.springframework.beans.factory.config.DestructionAwareBeanPostProcessor */protected boolean requiresDestruction(Object bean, RootBeanDefinition mbd) {    return (bean != null && (DisposableBeanAdapter.hasDestroyMethod(bean, mbd)            || hasDestructionAwareBeanPostProcessors()));}/** * Add the given bean to the list of disposable beans in this factory, registering its * DisposableBean interface and/or the given destroy method to be called on factory * shutdown (if applicable). Only applies to singletons. *  * @param beanName the name of the bean * @param bean the bean instance * @param mbd the bean definition for the bean * @see RootBeanDefinition#isSingleton * @see RootBeanDefinition#getDependsOn * @see #registerDisposableBean * @see #registerDependentBean */protected void registerDisposableBeanIfNecessary(String beanName, Object bean,        RootBeanDefinition mbd) {    AccessControlContext acc = (System.getSecurityManager() != null            ? getAccessControlContext() : null);    if (!mbd.isPrototype() && requiresDestruction(bean, mbd)) {        if (mbd.isSingleton()) {            // Register a DisposableBean implementation that performs all destruction            // work for the given bean: DestructionAwareBeanPostProcessors,            // DisposableBean interface, custom destroy method.            registerDisposableBean(beanName, new DisposableBeanAdapter(bean, beanName,                    mbd, getBeanPostProcessors(), acc));        }        else {            // A bean with a custom scope...            Scope scope = this.scopes.get(mbd.getScope());            if (scope == null) {                throw new IllegalStateException(                        "No Scope registered for scope '" + mbd.getScope() + "'");            }            scope.registerDestructionCallback(beanName, new DisposableBeanAdapter(                    bean, beanName, mbd, getBeanPostProcessors(), acc));        }    }}// ---------------------------------------------------------------------// Abstract methods to be implemented by subclasses// ---------------------------------------------------------------------// 标记是否包含Bean定义的方法protected abstract boolean containsBeanDefinition(String beanName);// 根据Bean名返回其BeanDefinitionprotected abstract BeanDefinition getBeanDefinition(String beanName)        throws BeansException;// 根据指定的bean定义和bean名、参数，创建对象protected abstract Object createBean(String beanName, RootBeanDefinition mbd,        Object[] args) throws BeanCreationException;} 
  
由于文章篇幅有限，IOC 面试和 AOP 相关问题将留待下一篇仔细讲解。
 
  
 
  
本文首发于GitChat，未经授权不得转载，转载需与GitChat联系。
 
  
阅读全文: http://gitbook.cn/gitchat/activity/5a03ab9fb993597ed32f8ef1
 
  
您还可以下载 CSDN 旗下精品原创内容社区 GitChat App ，阅读更多 GitChat 专享技术内容哦。
 
  
FtooAtPSkEJwnW-9xkCLqSTRpBKX
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(深入浅出解读 Spring 源码：IOC/AOP 篇)

        

            

                
    
                    
  • 男士护肤品哪个牌子好？十大男士护肤品排行榜
                        高省APP珊珊

                        
    很多男生意识到护肤的必要性，开始着手护肤，但不知道该选哪个男士护肤品品牌使用好。目前市面上很多男士护肤品品牌，可谓琳琅满目，让人眼花缭乱。男士挑选护肤品时，根据自己皮肤需求去正规渠道挑选合适的知名护肤品比较放心靠谱。高省APP，是2021年推出的平台，0投资，0风险、高省APP佣金更高，模式更好，终端用户不流失。【高省】是一个自用省钱佣金高，分享推广赚钱多的平台，百度有几百万篇报道，也期待你的加入
    
                    
    • 
                    
  • 程翔授《评价一篇记叙文》
                        行吟斯基

                        
    桂林十一中高一2中学生自读程老师学生文章板书课题师巡看。看完举手。问：它是记叙文。不商量。独立打分。学生评价打分。师：高低都正常，不受干扰。师巡，略评。打完举手。调查：分层次举手——高分先举手。最低分。最高95分。最低45分。女：差距太大！师：同一篇，相差55分。若是你的文章，愿落谁手？男：身临其境感觉。师：你有此经历？没也没关系。女：不优美……，结尾无升华……无感悟……师：辞藻不美？(师追问)男
    
                    
    • 
                    
  • 自律打卡第四天：比昨天进步一点点
                        花儿的念想

                        
    今天新闻我们县城又确诊了一例，截止目前已经确诊的三例了，打开，看了一篇简友写的武汉的真实情况，有病住不了院，还没等到床位已经去世的消息，心里更加的难受，武汉尚且这样，如果是我们这没有高速没有火车的十八线的小县城发生这种情况，那情况将是更加的不堪设想，不敢想，唯有祈求灾难早点快去，平安才是最大的福气。突然觉得我的自律打卡，比昨天进步一点点。更希望疫情战争每一天都要比昨天好一点，希望一觉醒来听到的是好
    
                    
    • 
                    
  • 25-1-2019
                        树藤与海岛呢

                        
    hello八月来报道了今天看到了一篇文章就只想记下那两句话：良田千顷不过一日三餐广夏万间只睡卧榻三尺大概的意思就是要珍惜当下不要等来不及的时候才珍惜分享今天的两餐最近没有时间运动呢下个月补回好了说完了哈哈goodnight图片发自App图片发自App
    
                    
    • 
                    
  • SpringMVC执行流程（原理），通俗易懂
                        国服冰
SpringMVCspringmvc
                        
    SpringMVC执行流程（原理），通俗易懂一、图解SpringMVC流程二、进一步理解Springmvc的执行流程1、导入依赖2、建立展示的视图3、web.xml4、spring配置文件springmvc-servlet5、Controller6、tomcat配置7、访问的url8、视图页面一、图解SpringMVC流程图为SpringMVC的一个较完整的流程图，实线表示SpringMVC框架提
    
                    
    • 
                    
  • 别再讲道理啦，对方听不进去的
                        方所

                        
    我之前写过一篇叫做《你总妄想改变他人》，然后就有朋友跟我说，有一些方法可以改变他人之类的。嗯，是这样，但是任何具体的问题，都要限定好语境，描述清楚前提条件，然后再表达观点，我的这位朋友的说法就犯了一刀切的错误，这样并不能让讨论正常展开（这篇我得先给她看看，不然可能会挨揍）。好了，hhhh，谁让她不能写文章呢，我就来再说一说吧。我前面说过，我们在学到一个道理、学会一种方法之后，总是迫不及待地想要去与
    
                    
    • 
                    
  • Spring进阶 - SpringMVC实现原理之DispatcherServlet处理请求的过程
                        倾听铃的声
后端springjavamvc开发语言分布式
                        
    前文我们有了IOC的源码基础以及SpringMVC的基础，我们便可以进一步深入理解SpringMVC主要实现原理，包含DispatcherServlet的初始化过程和DispatcherServlet处理请求的过程的源码解析。本文是第二篇：DispatcherServlet处理请求的过程的源码解析。@pdaiSpring进阶-SpringMVC实现原理之DispatcherServlet处理请求的
    
                    
    • 
                    
  • Flowable 高级扩展：自定义元素与性能优化实战
                        练习时长两年半的程序员小胡
Flowable流程引擎实战指南流程图flowableBPMN流程引擎java
                        
    在前五篇文章中，我们从基础概念、流程设计、API实战、SpringBoot集成，到外部系统协同，逐步构建了Flowable的应用体系。但企业级复杂场景中，原生功能往往难以满足定制化需求——比如需要特殊的审批规则网关、与决策引擎联动实现动态路由，或是在高并发场景下优化流程引擎性能。本文将聚焦Flowable的高级扩展能力，详解如何自定义流程元素、集成规则引擎，并掌握大型系统中的性能调优策略。一、自定
    
                    
    • 
                    
  • SpringMVC的执行流程
                        

                        
    1、什么是MVCMVC是一种设计模式。MVC的原理图如下所示M-Model模型（完成业务逻辑：有javaBean构成，service+dao+entity）V-View视图（做界面的展示jsp，html……）C-Controller控制器（接收请求—>调用模型—>根据结果派发页面2、SpringMVC是什么SpringMVC是一个MVC的开源框架，SpringMVC=Struts2+Spring，
    
                    
    • 
                    
  • 2018-09-27 aop相关
                        蒋超_58dc

                        
    1.静态织入，需要使用aspectj专用的compilermaven工程可以采用：https://www.mojohaus.org/aspectj-maven-plugin/2.动态织入，配合spring，创建代理来执行3.
    
                    
    • 
                    
  • Aop +反射 实现方法版本动态切换
                        

                        
    需求分析在做技术选型的时候一直存在着两个声音，mongo作为数据库比较mysql好，mysql做为该数据比mongo好。当然不同数据库都有有着自己的优势，我们在做技术选型的时候无非就是做到对数据库的扬长避短。mysql最大的优势就是支持事务，事务的五大特性保证的业务可靠性，随之而来的就是事务会产生的问题：脏读、幻读、不可重复度，当然我们也会使用不同的隔离级别来解决。（最典型的业务问题：银行存取钱）
    
                    
    • 
                    
  • 免费排版助手：智能修正段落 + 删除干扰符，杂乱文本一键变规范
                        

                        
    各位文字工作者们！你们有没有被排版折磨到崩溃的时候？我跟你们说，我之前排版一篇文章，那简直就像在走迷宫，头晕眼花的！不过后来我发现了一款软件——排版助手！软件下载地址安装包这玩意儿是个文章智能排版工具，专门给新闻编辑、文摘网站这些文字工作者用的。它功能老多了，能修正段落，把那些乱七八糟的段落变得规规矩矩；还能删除干扰符，就像给文章做了个大扫除，把没用的东西都清理掉；简繁转换也不在话下，不管是简体还
    
                    
    • 
                    
  • 小白买保险科普篇-意外险
                        手牵手走

                        
    意外险顾名思义，就是️对因意外导致的损失进行经济补偿的保险产品。我们看保险产品一定要看包含的责任。意外险通常包含：意外身故理赔金，额度10万-几百万不等。意外残疾理赔金，额度10万-几百万不等。意外医疗理赔金，额度通常在1-5万之间。这里的意外到底包含哪些意外事件，不能一概而论。综合意外险，我们重点看免责条款里的除外责任。比如：酒驾、违法不属于赔偿范围。这类产品小朋友和老人家往往有专属产品。年轻人
    
                    
    • 
                    
  • 人物系列首篇｜总会有人陪你走一段路
                        诗小蛮5786400

                        
    主题纲要：1.总会有人陪你走一段路2.不打扰也是一种幸福3.留在身边的，哪怕瞎逼逼一番也是珍贵一、总会有人陪你走一段路在综艺《向往的生活》，任嘉伦曾问过这样一个问题：“你们有没有过那样一种朋友：你们小时候关系很好，但因为你事业越来越好；他觉得你们之间的距离越来越远，然后他就自己疏远你的那种。”何炅说：我们要接受这是常态，我们每个人都有在乎的、喜欢的人，但我从来没有奢望，要把谁留在身边一辈子，因为这
    
                    
    • 
                    
  • Java并发核心：线程池使用技巧与最佳实践！ | 多线程篇(五)
                        bug菌¹
Java实战(进阶版)javaJava零基础入门Java并发线程池多线程篇
                        
    本文收录于「Java进阶实战」专栏，专业攻坚指数级提升，希望能够助你一臂之力，帮你早日登顶实现财富自由；同时，欢迎大家关注&&收藏&&订阅！持续更新中，up！up！up！！环境说明：Windows10+IntelliJIDEA2021.3.2+Jdk1.8本文目录前言摘要正文何为线程池？为什么需要线程池？线程池的好处线程池使用场景如何创建线程池？线程池的常见配置源码解析案例分享案例代码演示案例运行
    
                    
    • 
                    
  • 我最喜欢的公众号
                        素颜创始人小云

                        
    一年多前，也是因为工作的原因。认识了她，她是我七个人物法其一，她在我心里也是很敬佩的一个女孩子。她会讲一些护肤知识，哪些产品好用哪些不好用而他讲解的产品都是我跃跃欲试的。图片发自App她做的每一篇文章都很精美，可以吸引到我从头看到尾，看每一个字都会很珍惜很期待，做事也特别的认真仔细。去年出了一本《活得漂亮》我也看了她的创业故事，很厉害！她的认真及敬业精神我觉得是很难学得来的，现在怀孕3个月了，依然
    
                    
    • 
                    
  • 提升在直返APP中的等级：解锁更多特权与收益的秘诀
                        古楼

                        
    在直返APP的世界里，每个用户都渴望提升自己的等级，以解锁更多特权与收益。那么，如何提升在直返APP中的等级呢？接下来，我们将为您揭示这一秘密。【高省】APP（高佣金领导者）是一个自用省钱佣金高，分享推广赚钱多的平台，百度有几百万篇报道，运行三年，稳定可靠。高省APP，是2021年推出的平台，0投资，0风险、高省APP佣金更高，模式更好，终端用户不流失。高省是公认的返利最高的软件。古楼导师高省邀请
    
                    
    • 
                    
  • 人不能两次踏进同一条河流
                        就是源

                        
    这是古希腊学家赫拉克利特的名言，在我原先看来就是万事万物都在不断的变化，强调事物的运动性。可后来了解到他还有个徒弟更深的进行了解读，人哪怕一次也不能踏进同一条河流，因为当你踏进的时候，已经不是你最初想的那天河流了。这确实也说明了事物无时无刻不在运动，可感觉毫无意义，如果一切都这样去算，那么每一秒甚至每一个更加微小的时间上都会有一个不同的结论，这根本无法指明生活的方向和解决困顿，只会让人更加困顿。这
    
                    
    • 
                    
  • 全面解读设备状态监测
                        xiatianxy
设备状态监测设备状态监测
                        
    长期以来，基于巡检和定期维护维修保养的方式，对电机\泵类\风机等旋转类设备的故障维修，大多都是在设备问题出现之后的事后维护或者定期的预防性维护，前者无法减少或避免设备故障的发生，后者则存在维修不足或维修过剩等问题。另外，日常维护工作严重依赖于人的责任心和经验，一旦出现人员更替，设备的运营管理压力加大，并且现场丰富的维护保养经验也很难传承到新人手中。维护利器——设备状态监测设备状态监测，即对运行中的
    
                    
    • 
                    
  • uniapp微信小程序 - 详解微信小程序平台用户授权登录全流程，uniapp v3版本中小程序端开发下用户点击登录后获取手机号/昵称/性别/头像等信息完成登录（提供完整示例代码，一键复制开箱即用）
                        十一猫咪爱养鱼
前端组件与功能(开箱即用)uniapp常见问题解决uniappvue3uniapp3小程序授权登录微信小程序登录获取用户信息教程获取用户昵称手机号头像信息登录vue3版本小程序平台授权登录uniap小程序端用户登录流程uni完整的小程序平台登录源码
                        
    效果图在uniapp微信小程序端开发中，超详细实现用户授权登录完整功能源码，用户授权后获取手机号/昵称/头像/性别等，提供完整思路流程及逻辑讲解。uniappVue3和Vue2都能用，你也可以直接复制粘贴，然后改下参数放到你的项目中去就行。整体思路做功能之前，先来看一下整体流程是
    
                    
    • 
                    
  • 《倾“庙”之恋》里的诗意
                        道之可道

                        
    这是毕飞宇老师《小说课》的最后一课。同前些课一样，他的每节课带给我的全新的解读视角都令我目眩神迷。汪曾祺老师的《受戒》正是我前段时间读过的，读后只觉得很有意思，两个单纯的可爱的少男少女之间的感情非常令人心动，而那个小和尚的身份又让这个故事有些传奇色彩，然而清新又是主调，还有一种淡淡的悲悯，为着他们未来未知的可能是悲剧的命运。毕老师的解读简直让我瞠目结舌，原来这个小说里藏着那么多唯美的诗意，那么多生
    
                    
    • 
                    
  • 《家庭教育促进法》解读（14）落到实处方是真
                        愿我们顺利平安

                        
    点击上方蓝字，关注我们吧！坚持写作第七十七天今天继续为大家解读和普及我国首部家庭类法律——《家庭教育促进法》的第四章“社会协同”。这一章是上一章“国家支持”的落脚点。第三十八条居民委员会、村民委员会可以依托城乡社区公共服务设施，设立社区家长学校等家庭教育指导服务站点，配合家庭教育指导机构组织面向居民、村民的家庭教育知识宣传，为未成年人的父母或者其他监护人提供家庭教育指导服务。个人认为这一点非常必要
    
                    
    • 
                    
  • 坚持53天断更 重新开始
                        静安梨子

                        
    因为种种原因，原本计划好不管怎样每天坚持更新一篇的，但计划赶不上变化，在更完53天后终于还是断更了。但是也不算后悔，之前的状态确实不好，每天的输出大多数都感觉自己在凑字数，内容连自己都感觉看不下去了。调整好状态以后重新开始，给自己一个鼓励，虽然断更了，但能重新开始也很好，至少没有选择永远放弃。加油！
    
                    
    • 
                    
  • [spring6: Mvc-网关]-源码解析
                        

                        
    推荐阅读：[spring6:Mvc-函数式编程]-源码解析GatewayServerMvcAutoConfiguration@AutoConfiguration(after={HttpClientAutoConfiguration.class,RestTemplateAutoConfiguration.class,RestClientAutoConfiguration.class,FilterAu
    
                    
    • 
                    
  • 面试必考题：Android Binder 机制详解
                        大模型大数据攻城狮
androidbinder面试reactnativekotlindalvikretrofit
                        
    目录第一章：Binder的基本概念什么是Binder？多角度解读Binder第二章：Binder的工作机制Binder的整体流程服务注册：从零到有的第一步服务查询：找到目标的“地图”服务调用：请求与响应的旅程Binder驱动的幕后功劳为什么Binder这么快？第三章：Binder在系统架构中的角色Activity：界面背后的通信枢纽Binder的角色实例分析Service：后台任务的跨进程支柱Bi
    
                    
    • 
                    
  • 百度地图 雷达/地理编码 功能使用
                        安卓开发者

                        
    目录(?)[-]地图雷达基本使用首先你需要在你的API控制台注册你的雷达初始化并注入你的信息开始上传单次上传定时重复上传取回信息打完收工元古巨坑地理编码最近一直在优化软件的bug..然后后面可能又要大改..所以趁这两天有时间赶紧码两篇博文..=.=地图功能可以说是现在APP中最常用的功能…呃..之一..不管是电商,社交,o2o,b2c,p2p,锟斤拷,烫烫烫都需要用地图来辅助..博客里基本的地图实
    
                    
    • 
                    
  • 大数据技术笔记—spring入门
                        卿卿老祖

                        
    篇一spring介绍spring.io官网快速开始Aop面向切面编程，可以任何位置，并且可以细致到方法上连接框架与框架Spring就是IOCAOP思想有效的组织中间层对象一般都是切入service层spring组成前后端分离已学方式，前后台未分离：Spring的远程通信：明日更新创建第一个spring项目来源：科多大数据
    
                    
    • 
                    
  • GDP经济社会人文民生栅格数据下载网站汇总
                        疯狂学习GIS

                        
      本文为“GIS数据获取整理”专栏（https://blog.csdn.net/zhebushibiaoshifu/category_10857546.html）中第八篇独立博客，因此本文全部标题均由“8”开头。本文对目前主要的GDP、社会与经济数据获取网站加以整理与介绍，若需其它GIS领域数据（如遥感影像数据、气象数据、土地土壤数据、农业数据等），大家可以点击上方专栏查看，也可以看这一篇汇总文
    
                    
    • 
                    
  • GitLab 18.2 发布几十项与 DevSecOps 有关的功能，可升级体验【二】
                        极小狐
gitlab极狐gitlabdevsecopsdevopsci/cd
                        
    沿袭我们的月度发布传统，极狐GitLab发布了18.2版本，该版本带来了议题和任务的自定义工作流状态、新的合并请求主页、新的群组概览合规仪表盘、下载安全报告的PDF导出文件、中心化的安全策略管理（Beta）等几十个重点功能的改进。下面是对部分重点功能的详细解读。关于极狐GitLab的安装升级，可以查看官方指导文档。18.2.0容器镜像registry.gitlab.cn/omnibus/gitla
    
                    
    • 
                    
  • 二级域名分发系统商业版全开源v3版
                        CloseAi论坛
程序源码二级域名分发系统商业版开源
                        
    介绍：名分发-快乐二级域名分发源码主要是二级域名分发网站源码，域名接口配置自己研究吧网盘下载地址：https://zijiewangpan.com/NbX6950sYLn图片：
    
                    
    • 
                                
  • Algorithm
                                    香水浓
javaAlgorithm
                                    
    冒泡排序 
 

	public static void sort(Integer[] param) {
		for (int i = param.length - 1; i > 0; i--) {
			for (int j = 0; j < i; j++) {
				int current = param[j];
				int next = param[j + 1];
    
                                
    • 
                                
  • mongoDB 复杂查询表达式
                                    开窍的石头
mongodb
                                    
    1:count 
   Pg: db.user.find().count(); 
   统计多少条数据 
2:不等于$ne 
   Pg: db.user.find({_id:{$ne:3}},{name:1,sex:1,_id:0}); 
   查询id不等于3的数据。 
3：大于$gt $gte(大于等于) 
&n
    
                                
    • 
                                
  • Jboss Java heap space异常解决方法, jboss OutOfMemoryError : PermGen space
                                    0624chenhong
jvmjboss
                                    
    转自 
http://blog.csdn.net/zou274/article/details/5552630 
 
解决办法： 
 
window->preferences->java->installed jres->edit jre 
把default vm arguments 的参数设为-Xms64m -Xmx512m 
 
 
 
----------------
    
                                
    • 
                                
  • 文件上传 下载 解析 相对路径
                                    不懂事的小屁孩
文件上传
                                    
    有点坑吧，弄这么一个简单的东西弄了一天多，身边还有大神指导着，网上各种百度着。 
下面总结一下遇到的问题： 
 
文件上传，在页面上传的时候，不要想着去操作绝对路径，浏览器会对客户端的信息进行保护，避免用户信息收到攻击。 
在上传图片，或者文件时，使用form表单来操作。 
前台通过form表单传输一个流到后台，而不是ajax传递参数到后台，代码如下: 
 

<form action=&
    
                                
    • 
                                
  • 怎么实现qq空间批量点赞
                                    换个号韩国红果果
qq
                                    
    纯粹为了好玩！！ 
逻辑很简单 
1 打开浏览器console；输入以下代码。 
先上添加赞的代码 
 

var tools={};
		//添加所有赞
		function  init(){
			document.body.scrollTop=10000;
				setTimeout(function(){document.body.scrollTop=0;},2000);//加
    
                                
    • 
                                
  • 判断是否为中文
                                    灵静志远
中文
                                    
    方法一： 
public class Zhidao { 
 public static void main(String args[]) { 
 String s = "sdf灭礌 kjl d{';\fdsjlk是"; 
 int n=0; 
 for(int i=0; i<s.length(); i++) { 
 n = (int)s.charAt(i); 
 if((
    
                                
    • 
                                
  • 一个电话面试后总结
                                    a-john
面试
                                    
    今天，接了一个电话面试，对于还是初学者的我来说，紧张了半天。 
面试的问题分了层次，对于一类问题，由简到难。自己觉得回答不好的地方作了一下总结： 
  
在谈到集合类的时候，举几个常用的集合类，想都没想，直接说了list,map。 
  
然后对list和map分别举几个类型： 
  
list方面：ArrayList,LinkedList。在谈到他们的区别时，愣住了
    
                                
    • 
                                
  • MSSQL中Escape转义的使用
                                    aijuans
MSSQL
                                    
    IF OBJECT_ID('tempdb..#ABC') is not null
drop table tempdb..#ABC


create table #ABC
(
PATHNAME NVARCHAR(50)
)


insert into #ABC
SELECT N'/ABCDEFGHI' 
UNION ALL SELECT N'/ABCDGAFGASASSDFA' 
UNION ALL
    
                                
    • 
                                
  • 一个简单的存储过程
                                    asialee
mysql存储过程构造数据批量插入
                                    
               今天要批量的生成一批测试数据，其中中间有部分数据是变化的，本来想写个程序来生成的，后来想到存储过程就可以搞定，所以随手写了一个，记录在此： 
  
         
DELIMITER $$  
DROP PROCEDURE IF EXISTS inse
    
                                
    • 
                                
  • annot convert from HomeFragment_1 to Fragment
                                    百合不是茶
android导包错误
                                    
    创建了几个类继承Fragment, 需要将创建的类存储在ArrayList<Fragment>中; 出现不能将new 出来的对象放到队列中,原因很简单; 
    创建类时引入包是:import android.app.Fragment; 
  
   创建队列和对象时使用的包是:import android.support.v4.ap
    
                                
    • 
                                
  • Weblogic10两种修改端口的方法
                                    bijian1013
weblogic端口号配置管理config.xml
                                    
    一.进入控制台进行修改    1.进入控制台:  http://127.0.0.1:7001/console     2.展开左边树菜单         域结构->环境->服务器-->点击AdminServer(管理) &
    
                                
    • 
                                
  • mysql 操作指令
                                    征客丶
mysql
                                    
    一、连接mysql 
进入 mysql 的安装目录； 
$ bin/mysql -p [host IP 如果是登录本地的mysql 可以不写 -p 直接 -u] -u [userName] -p 
输入密码，回车，接连； 
 
二、权限操作［如果你很了解mysql数据库后，你可以直接去修改系统表，然后用 mysql> flush privileges; 指令让权限生效］ 
1、赋权 
mys
    
                                
    • 
                                
  • 【Hive一】Hive入门
                                    bit1129
hive
                                    
    Hive安装与配置 
Hive的运行需要依赖于Hadoop，因此需要首先安装Hadoop2.5.2，并且Hive的启动前需要首先启动Hadoop。 
  Hive安装和配置的步骤 
  
1. 从如下地址下载Hive0.14.0 
  
http://mirror.bit.edu.cn/apache/hive/ 
  
 2.解压hive，在系统变
    
                                
    • 
                                
  • ajax 三种提交请求的方法
                                    BlueSkator
Ajaxjqery
                                    
    1、ajax 提交请求 
$.ajax({
			type:"post",
			url : "${ctx}/front/Hotel/getAllHotelByAjax.do",
			dataType : "json",
			success : function(result) {
				try {
					for(v
    
                                
    • 
                                
  • mongodb开发环境下的搭建入门
                                    braveCS
运维
                                    
      
linux下安装mongodb 
1）官网下载mongodb-linux-x86_64-rhel62-3.0.4.gz 
2）linux 解压   
gzip -d mongodb-linux-x86_64-rhel62-3.0.4.gz; 
mv mongodb-linux-x86_64-rhel62-3.0.4 mongodb-linux-x86_64-rhel62-
    
                                
    • 
                                
  • 编程之美-最短摘要的生成
                                    bylijinnan
java数据结构算法编程之美
                                    
    

import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;

public class ShortestAbstract {

	/**
	 * 编程之美 最短摘要的生成
	 * 扫描过程始终保持一个[pBegin,pEnd]的range,初始化确保[pBegin,pEnd]的ran
    
                                
    • 
                                
  • json数据解析及typeof
                                    chengxuyuancsdn
jstypeofjson解析
                                    
       
       // json格式
	var people='{"authors": [{"firstName": "AAA","lastName": "BBB"},'
		                    +' {"firstName": "CCC&
    
                                
    • 
                                
  • 流程系统设计的层次和目标
                                    comsci
设计模式数据结构sql框架脚本
                                    
     
                              流程系统设计的层次和目标 
 
 
 
    
                                
    • 
                                
  • RMAN List和report 命令
                                    daizj
oraclelistreportrman
                                    
    LIST 命令 
使用RMAN LIST 命令显示有关资料档案库中记录的备份集、代理副本和映像副本的 
信息。使用此命令可列出： 
• RMAN 资料档案库中状态不是AVAILABLE 的备份和副本 
• 可用的且可以用于还原操作的数据文件备份和副本 
• 备份集和副本，其中包含指定数据文件列表或指定表空间的备份 
• 包含指定名称或范围的所有归档日志备份的备份集和副本 
• 由标记、完成时间、可
    
                                
    • 
                                
  • 二叉树:红黑树
                                    dieslrae
二叉树
                                    
        红黑树是一种自平衡的二叉树,它的查找,插入,删除操作时间复杂度皆为O(logN),不会出现普通二叉搜索树在最差情况时时间复杂度会变为O(N)的问题. 
    红黑树必须遵循红黑规则,规则如下 
    
1、每个节点不是红就是黑。     2、根总是黑的  &
    
                                
    • 
                                
  • C语言homework3，7个小题目的代码
                                    dcj3sjt126com
c
                                    
    1、打印100以内的所有奇数。 
# include <stdio.h>

int main(void)
{
	int i;

	for (i=1; i<=100; i++)
	{
		if (i%2 != 0)
			printf("%d ", i);
	}

	return 0;
}
 
 2、从键盘上输入10个整数，
    
                                
    • 
                                
  • 自定义按钮, 图片在上, 文字在下, 居中显示
                                    dcj3sjt126com
自定义
                                    
    #import <UIKit/UIKit.h>

@interface MyButton : UIButton

-(void)setFrame:(CGRect)frame ImageName:(NSString*)imageName Target:(id)target Action:(SEL)action Title:(NSString*)title Font:(CGFloa
    
                                
    • 
                                
  • MySQL查询语句练习题，测试足够用了
                                    flyvszhb
sqlmysql
                                    
    http://blog.sina.com.cn/s/blog_767d65530101861c.html 
1.创建student和score表 
CREATE  TABLE  student ( 
id  INT(10)  NOT NULL  UNIQUE  PRIMARY KEY  , 
name  VARCHAR
    
                                
    • 
                                
  • 转：MyBatis Generator 详解
                                    happyqing
mybatis
                                    
      
MyBatis Generator 详解 
http://blog.csdn.net/isea533/article/details/42102297 
  
MyBatis Generator详解 
http://git.oschina.net/free/Mybatis_Utils/blob/master/MybatisGeneator/MybatisGeneator.
    
                                
    • 
                                
  • 让程序员少走弯路的14个忠告
                                    jingjing0907
工作计划学习
                                    
      
无论是谁，在刚进入某个领域之时，有再大的雄心壮志也敌不过眼前的迷茫：不知道应该怎么做，不知道应该做什么。下面是一名软件开发人员所学到的经验，希望能对大家有所帮助 
  
1.不要害怕在工作中学习。  
只要有电脑，就可以通过电子阅读器阅读报纸和大多数书籍。如果你只是做好自己的本职工作以及分配的任务，那是学不到很多东西的。如果你盲目地要求更多的工作，也是不可能提升自己的。放
    
                                
    • 
                                
  • nginx和NetScaler区别
                                    流浪鱼
nginx
                                    
    NetScaler是一个完整的包含操作系统和应用交付功能的产品，Nginx并不包含操作系统，在处理连接方面，需要依赖于操作系统，所以在并发连接数方面和防DoS攻击方面，Nginx不具备优势。 
2.易用性方面差别也比较大。Nginx对管理员的水平要求比较高，参数比较多，不确定性给运营带来隐患。在NetScaler常见的配置如健康检查，HA等，在Nginx上的配置的实现相对复杂。 
3.策略灵活度方
    
                                
    • 
                                
  • 第11章 动画效果（下）
                                    onestopweb
动画
                                    
    index.html 
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/
    
                                
    • 
                                
  • FAQ - SAP BW BO roadmap
                                    blueoxygen
BOBW
                                    
    http://www.sdn.sap.com/irj/boc/business-objects-for-sap-faq 
  
Besides, I care that how to integrate tightly. 
  
By the way, for BW consultants, please just focus on Query Designer which i
    
                                
    • 
                                
  • 关于java堆内存溢出的几种情况
                                    tomcat_oracle
javajvmjdkthread
                                    
    【情况一】：   　　 
java.lang.OutOfMemoryError: Java heap space：这种是java堆内存不够，一个原因是真不够，另一个原因是程序中有死循环；   　　如果是java堆内存不够的话，可以通过调整JVM下面的配置来解决：   　　<jvm-arg>-Xms3062m</jvm-arg>   　　<jvm-arg>-Xmx
    
                                
    • 
                                
  • Manifest.permission_group权限组
                                    阿尔萨斯
Permission
                                    
    结构 
继承关系 
public static final class Manifest.permission_group extends Object 
java.lang.Object 
android. Manifest.permission_group 常量 
ACCOUNTS 直接通过统计管理器访问管理的统计 
COST_MONEY可以用来让用户花钱但不需要通过与他们直接牵涉的权限 
D
    
                                
    •