Spring源码分析——BeanFactory体系之抽象类、类分析（一）

public class SimpleAliasRegistry implements AliasRegistry {

    /*
     *用一个支持高并发的ConcurrentHashMap来放置所有的别名
     */
    private final Map<String, String> aliasMap = new ConcurrentHashMap<String, String>(
            16);

    // AliasRegistry的接口方法，注册别名。不允许重复注册。
    public void registerAlias(String name, String alias) {
        Assert.hasText(name, "‘name‘ must not be empty");
        Assert.hasText(alias, "‘alias‘ must not be empty");
        if (alias.equals(name)) {
            this.aliasMap.remove(alias);
        } else {
            if (!allowAliasOverriding()) {
                String registeredName = this.aliasMap.get(alias);
                if (registeredName != null && !registeredName.equals(name)) {
                    throw new IllegalStateException("Cannot register alias ‘"
                            + alias + "‘ for name ‘" + name
                            + "‘: It is already registered for name ‘"
                            + registeredName + "‘.");
                }
            }
            checkForAliasCircle(name, alias);//alias不能等于name在map中最后的对应（详见checkForAliasCircle方法）
            this.aliasMap.put(alias, name);//alias是key,name是value
        }
    }

    /**
     * 返回是否允许Alias重写，默认为允许
     */
    protected boolean allowAliasOverriding() {
        return true;
    }

    // AliasRegistry的接口方法，移除别名，如果别名未注册，则抛出异常
    public void removeAlias(String alias) {
        String name = this.aliasMap.remove(alias);
        if (name == null) {
            throw new IllegalStateException("No alias ‘" + alias
                    + "‘ registered");
        }
    }

    // AliasRegistry的接口方法，给定名称判断是否为别名
    public boolean isAlias(String name) {
        return this.aliasMap.containsKey(name);
    }

    // AliasRegistry的接口方法
    public String[] getAliases(String name) {
        List<String> result = new ArrayList<String>();
        synchronized (this.aliasMap) {
            retrieveAliases(name, result);
        }
        return StringUtils.toStringArray(result);
    }

    /*
     * 找出名字说对应的所有别名。
     */
    private void retrieveAliases(String name, List<String> result) {
        for (Map.Entry<String, String> entry : this.aliasMap.entrySet()) {//遍历aliasMap
            String registeredName = entry.getValue();//取aliasMap的每个value
            if (registeredName.equals(name)) {//如果value等于指定的这个name
                String alias = entry.getKey();//取value对应的key
                result.add(alias);//将alias加入
                retrieveAliases(alias, result);//继续查看以alias为value的key
            }
        }
    }

    /*
     * 处理所有的别名，如果处理正确，把原来的用解析后的替换
     */
    public void resolveAliases(StringValueResolver valueResolver) {
        Assert.notNull(valueResolver, "StringValueResolver must not be null");
        synchronized (this.aliasMap) {
            Map<String, String> aliasCopy = new HashMap<String, String>(
                    this.aliasMap);
            for (String alias : aliasCopy.keySet()) {
                String registeredName = aliasCopy.get(alias);//取出key对应的value
                String resolvedAlias = valueResolver.resolveStringValue(alias);//解析后的key
                String resolvedName = valueResolver
                        .resolveStringValue(registeredName);//解析后的value
                if (resolvedAlias.equals(resolvedName)) {//若解析后的key、name相等，就把它们从aliasMap中移除
                    this.aliasMap.remove(alias);
                } else if (!resolvedAlias.equals(alias)) {//若解析后的key不等于原来的Key
                    String existingName = this.aliasMap.get(resolvedAlias);//取出解析后的key对应的value
                    if (existingName != null//如果不为空且不等于解析后的value，就抛出异常
                            && !existingName.equals(resolvedName)) {
                        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);
                }
            }
        }
    }

    /*
     * 根据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);//aliasMap中规范名对应的值赋值给已解析名
            if (resolvedName != null) {//如果已解析名存在（即规范名在aliasMap中有对应的值）
                canonicalName = resolvedName;   // 这个已解析名赋值给标准名
            }
        } while (resolvedName != null);//不断循环，直到已解析名不存在
        return canonicalName;
    }

    /*
     * 如果别名alias等于canonicalName(name)就抛出异常
     */
    protected void checkForAliasCircle(String name, String alias) {
        if (alias.equals(canonicalName(name))) {
            throw new IllegalStateException("Cannot register alias ‘" + alias
                    + "‘ for name ‘" + name + "‘: Circular reference - ‘"
                    + name + "‘ is a direct or indirect alias for ‘" + alias
                    + "‘ already");
        }
    }

}

public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {

    protected static final Object NULL_OBJECT = new Object();//空object


    /** Logger available to subclasses */
    protected final Log logger = LogFactory.getLog(getClass());

    /** 单例缓存: bean name --> bean instance */
    private final Map<String, Object> singletonObjects = new ConcurrentHashMap<String, Object>(64);

    /** 单例工厂缓存: bean name --> ObjectFactory */
    private final Map<String, ObjectFactory> singletonFactories = new HashMap<String, ObjectFactory>(16);

    /** 早期单例对象缓存: bean name --> bean instance */
    private final Map<String, Object> earlySingletonObjects = new HashMap<String, Object>(16);

    /** 注册过的单例类（单例工厂） */
    private final Set<String> registeredSingletons = new LinkedHashSet<String>(64);

    /** 即将创建的单例类 (using a ConcurrentHashMap as a Set) */
    private final Map<String, Boolean> singletonsCurrentlyInCreation = new ConcurrentHashMap<String, Boolean>(16);

    /** 正在创建的单例类 (using a ConcurrentHashMap as a Set) */
    private final Map<String, Boolean> inCreationCheckExclusions = new ConcurrentHashMap<String, Boolean>(16);

    /** 被压制的异常集合 */
    private Set<Exception> suppressedExceptions;

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

    /** Disposable接口的实例: bean name --> disposable instance */
    private final Map<String, Object>   = new LinkedHashMap<String, Object>();

    /** bean名称和bean所有包含的Bean的名称的map: bean name --> Set of bean names that the bean contains */
    private final Map<String, Set<String>> containedBeanMap = new ConcurrentHashMap<String, Set<String>>(16);

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

    /** bean名称和bean所依赖的所有名称的map --> Set of bean names for the bean‘s dependencies */
    private final Map<String, Set<String>> dependenciesForBeanMap = new ConcurrentHashMap<String, Set<String>>(64);

    //SingletonBeanRegistry接口的实现类————注册单例Bean，不能重复注册
    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);
        }
    }

    //注册一个单例类，注册之后，从singletonFactories、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);
            }
        }
    }

    //SingletonBeanRegistry接口的实现类
    public Object getSingleton(String beanName) {
        return getSingleton(beanName, true);
    }

    //根据beanName返回单例类
    protected Object getSingleton(String beanName, boolean allowEarlyReference) {
        Object singletonObject = this.singletonObjects.get(beanName);
        if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {    //    如果取不到，且该bean正在创建
            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，如果取不到就调用指定的singletonFactory的getObject来返回
    public Object getSingleton(String beanName, ObjectFactory singletonFactory) {
        Assert.notNull(beanName, "‘beanName‘ must not be null");
        synchronized (this.singletonObjects) {
            Object singletonObject = this.singletonObjects.get(beanName);//从单例缓存中获取
            if (singletonObject == null) {
                if (this.singletonsCurrentlyInDestruction) {//如果单例类正在被销毁，就抛出异常
                    throw new BeanCreationNotAllowedException(beanName,
                            "Singleton bean creation not allowed while the singletons of this factory are in destruction " +
                            "(Do not request a bean from a BeanFactory in a destroy method implementation!)");
                }
                if (logger.isDebugEnabled()) {
                    logger.debug("Creating shared instance of singleton bean ‘" + beanName + "‘");
                }
                //如果不在inCreationCheckExclusions中，且可以向singletonsCurrentlyInCreation中添加，就抛出异常
                beforeSingletonCreation(beanName);
                //是否有记录被压制的异常
                boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
                if (recordSuppressedExceptions) {//如果没有记录，即没有被压制的异常，就创建被压制的异常容器
                    this.suppressedExceptions = new LinkedHashSet<Exception>();
                }
                try {
                    singletonObject = singletonFactory.getObject();//以上都没有异常产生，那么就从指定的facgtory中取
                }
                catch (BeanCreationException ex) {
                    if (recordSuppressedExceptions) {
                        for (Exception suppressedException : this.suppressedExceptions) {
                            ex.addRelatedCause(suppressedException);
                        }
                    }
                    throw ex;
                }
                finally {
                    if (recordSuppressedExceptions) {
                        this.suppressedExceptions = null;
                    }
                    afterSingletonCreation(beanName);
                }
                addSingleton(beanName, singletonObject);//取成功就放进singletonObjects中
            }
            return (singletonObject != NULL_OBJECT ? singletonObject : null);
        }
    }

    //添加一个被压制的异常
    protected void onSuppressedException(Exception ex) {
        synchronized (this.singletonObjects) {
            if (this.suppressedExceptions != null) {
                this.suppressedExceptions.add(ex);
            }
        }
    }

    //根据名称移除本容器中缓存的对应的单例Bean，把对应的单例从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);
        }
    }
    //SingletonBeanRegistry接口的实现类
    public boolean containsSingleton(String beanName) {
        return (this.singletonObjects.containsKey(beanName));
    }

    //SingletonBeanRegistry接口的实现类
    public String[] getSingletonNames() {
        synchronized (this.singletonObjects) {
            return StringUtils.toStringArray(this.registeredSingletons);
        }
    }
    //SingletonBeanRegistry接口的实现类
    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.put(beanName, Boolean.TRUE);
        }
        else {
            this.inCreationCheckExclusions.remove(beanName);
        }
    }

    //判断某个Bean是否正在被创建
    public boolean isCurrentlyInCreation(String beanName) {
        Assert.notNull(beanName, "Bean name must not be null");
        return (!this.inCreationCheckExclusions.containsKey(beanName) && isActuallyInCreation(beanName));
    }

    protected boolean isActuallyInCreation(String beanName) {
        return isSingletonCurrentlyInCreation(beanName);
    }

    //是否即将被创建
    public boolean isSingletonCurrentlyInCreation(String beanName) {
        return this.singletonsCurrentlyInCreation.containsKey(beanName);
    }

    //单例类创建开始之前调用
    //如果不在正在创建的单例类集合中，且可以向即将创建的单例类中添加，就抛出异常
    protected void beforeSingletonCreation(String beanName) {
        if (!this.inCreationCheckExclusions.containsKey(beanName) &&
                this.singletonsCurrentlyInCreation.put(beanName, Boolean.TRUE) != null) {
            throw new BeanCurrentlyInCreationException(beanName);
        }
    }

    //单例类创建之后调用
    //如果不在正在创建的单例类中，也不在即将创建的单例类中移除失败，就抛出异常
    protected void afterSingletonCreation(String beanName) {
        if (!this.inCreationCheckExclusions.containsKey(beanName) &&
                !this.singletonsCurrentlyInCreation.remove(beanName)) {
            throw new IllegalStateException("Singleton ‘" + beanName + "‘ isn‘t currently in creation");
        }
    }

    //往Disposable实例集合注册Disposable实例
    public void registerDisposableBean(String beanName, DisposableBean bean) {
        synchronized (this.disposableBeans) {
            this.disposableBeans.put(beanName, bean);
        }
    }

    //注册一个被包含的Bean和一个包含它的Bean（子->父）
    public void registerContainedBean(String containedBeanName, String containingBeanName) {
        synchronized (this.containedBeanMap) {
            Set<String> containedBeans = this.containedBeanMap.get(containingBeanName);
            if (containedBeans == null) {
                containedBeans = new LinkedHashSet<String>(8);//containedBeans的初始容量为8
                this.containedBeanMap.put(containingBeanName, containedBeans);//注意！containedBeanMap的Key是父bean，value是其所包含的所有子Bean（父->子）
            }
            containedBeans.add(containedBeanName);
        }
        registerDependentBean(containedBeanName, containingBeanName);//因为包含也是依赖的一种，所以此时也要注册在dependentBeanMap中
    }

    //给指定的Bean注册一个其依赖的Bean
    public void registerDependentBean(String beanName, String dependentBeanName) {
        String canonicalName = canonicalName(beanName);//在aliasMap中取规范名
        synchronized (this.dependentBeanMap) {    //    这里是注册依赖BeanMap，key是bean的名称，value是依赖这个bean的所有bean的名称
            Set<String> dependentBeans = this.dependentBeanMap.get(canonicalName);
            if (dependentBeans == null) {
                dependentBeans = new LinkedHashSet<String>(8);//dependentBeans的初始容量也为8
                this.dependentBeanMap.put(canonicalName, dependentBeans);//dependentBeanMap中Key为beanName的规范名，value是依赖它的所有Bean的名称
            }
            dependentBeans.add(dependentBeanName);
        }
        synchronized (this.dependenciesForBeanMap) {    //    这里相反，注册的是某个Bean和其所依赖的Bean的集合，key是这个beanName，value是这个Bean的依赖的所有Bean的Name
            Set<String> dependenciesForBean = this.dependenciesForBeanMap.get(dependentBeanName);
            if (dependenciesForBean == null) {
                dependenciesForBean = new LinkedHashSet<String>(8);
                this.dependenciesForBeanMap.put(dependentBeanName, dependenciesForBean);
            }
            dependenciesForBean.add(canonicalName);
        }
    }

    //判断某个Bean是否被其他Bean所依赖
    protected boolean hasDependentBean(String beanName) {
        return this.dependentBeanMap.containsKey(beanName);
    }

    //返回依赖于给定Bean的Bean名称的集合
    public String[] getDependentBeans(String beanName) {
        Set<String> dependentBeans = this.dependentBeanMap.get(beanName);
        if (dependentBeans == null) {
            return new String[0];
        }
        return StringUtils.toStringArray(dependentBeans);
    }

    //返回某个Bean所依赖的所有Bean的名称
    public String[] getDependenciesForBean(String beanName) {
        Set<String> dependenciesForBean = this.dependenciesForBeanMap.get(beanName);
        if (dependenciesForBean == null) {
            return new String[0];
        }
        return dependenciesForBean.toArray(new String[dependenciesForBean.size()]);
    }

    //这个方法居然连注释都没有？太奇怪了！
    public void destroySingletons() {
        if (logger.isInfoEnabled()) {
            logger.info("Destroying singletons in " + this);
        }
        synchronized (this.singletonObjects) {//首先标记，所有的单例Bean正在被销毁，那么getSingleton就无法获得单例Bean了
            this.singletonsCurrentlyInDestruction = true;
        }

        String[] disposableBeanNames;
        synchronized (this.disposableBeans) {//然后把所有的disposableBean都放进数组，一个个按名称销毁
            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;
        }
    }

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

        DisposableBean disposableBean;//它相应的DisposableBean实例
        synchronized (this.disposableBeans) {
            disposableBean = (DisposableBean) this.disposableBeans.remove(beanName);//从disposableBeans移除这个实例
        }
        destroyBean(beanName, disposableBean);
    }

    // 销毁指定名称的Bean，且销毁依赖于它的所有Bean
    protected void destroyBean(String beanName, DisposableBean bean) {
        // 首先销毁依赖它的所有Bean
        Set<String> dependencies = this.dependentBeanMap.remove(beanName);//取依赖于指定Bean的所有Bean
        if (dependencies != null) {
            if (logger.isDebugEnabled()) {
                logger.debug("Retrieved dependent beans for bean ‘" + beanName + "‘: " + dependencies);
            }
            for (String dependentBeanName : dependencies) {
                destroySingleton(dependentBeanName);//一个个销毁
            }
        }

        // 然后销毁它
        if (bean != null) {
            try {
                bean.destroy();
            }
            catch (Throwable ex) {
                logger.error("Destroy method on bean with name ‘" + beanName + "‘ threw an exception", ex);
            }
        }

        // 然后销毁它所包含的Bean
        Set<String> containedBeans = this.containedBeanMap.remove(beanName);
        if (containedBeans != null) {
            for (String containedBeanName : containedBeans) {
                destroySingleton(containedBeanName);
            }
        }

        // 然后把所有它依赖的Bean的依赖关系删除，首先删除dependentBeanMap中的依赖关系
        synchronized (this.dependentBeanMap) {
            //这样的for循环用法实在是经典
            for (Iterator<Map.Entry<String, Set<String>>> it = this.dependentBeanMap.entrySet().iterator(); it.hasNext();) {
                Map.Entry<String, Set<String>> entry = it.next();
                Set<String> dependenciesToClean = entry.getValue();
                dependenciesToClean.remove(beanName);
                if (dependenciesToClean.isEmpty()) {
                    it.remove();
                }
            }
        }

        // 然后删除dependenciesForBeanMap中的依赖关系
        this.dependenciesForBeanMap.remove(beanName);
    }

    /**
     * Expose the singleton mutex to subclasses.
     * <p>Subclasses should synchronize on the given Object if they perform
     * any sort of extended singleton creation phase. In particular, subclasses
     * should <i>not</i> have their own mutexes involved in singleton creation,
     * to avoid the potential for deadlocks in lazy-init situations.
     */
    //返回子类单例类的互斥体？这个暂且放着。
    protected final Object getSingletonMutex() {
        return this.singletonObjects;
    }

}