【Java】【系列篇】【Spring源码解析】【三】【体系】【Registry体系】

整体结构图

这个体系主要有以下几种分支:
	1. 别名注册，主要有AliasRegistry-->SimpleAliasRegistry
	2. BeanDefinition注册,主要有BeanDefinitionRegistry-->SimpleBeanDefinitionRegistry
	3. Bean注册（包括对FactoryBean的支持），SingletonBeanRegistry-->DefaultSingletonBeanRegistry-->FactoryBeanRegistrySupport

别名注册

接口-AliasRegistry

作用

别名注册表，主要是对springBean的别名进行管理的顶级接口，主要是对别名的增删功能

注释

public interface AliasRegistry {
	/*
	为这个 name 注册一个 alias
	*/
	void registerAlias(String name, String alias);
    /*
    从注册表中移除这个alias对应的关系
    */
	void removeAlias(String alias);
    /*
    给定的这个 name是否是一个 别名
    */
	boolean isAlias(String name);
    /*
    根据这个 bean name 获取所有他的别名
    */
	String[] getAliases(String name);
}

类-SimpleAliasRegistry

作用

AliasRegistry接口的实现类，没啥好说的

解析

属性

// 内部使用一个ConcurrentHashMap来存储，保证线程安全
private final Map<String, String> aliasMap = new ConcurrentHashMap<>(16);
用来存储别名和本名的映射关系
    注册一个别名，存储方式为：
	别名->本名 ，一个本名可以对应多个别名，如成龙有别名元楼、陈元龙，那么存储就是
	元楼->成龙
	陈元龙->成龙

方法解释

补充：多个别名是如何产生的？别名循环 和别名递归注册又是怎样产生的

@Override
public void registerAlias(String name, String alias) {
    Assert.hasText(name, "'name' must not be empty");
    Assert.hasText(alias, "'alias' must not be empty");
    synchronized (this.aliasMap) {
        //如果本名和别名一样就删除别名
        if (alias.equals(name)) {
            this.aliasMap.remove(alias);
            if (logger.isDebugEnabled()) {
                logger.debug("Alias definition '" + alias + "' ignored since it points to same name");
            }
        }
        else {
            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 define alias '" + alias + "' for name '" +
                            name + "': It is already registered for name '" + registeredName + "'.");
                }
                if (logger.isDebugEnabled()) {
                    logger.debug("Overriding alias '" + alias + "' definition for registered name '" +
                            registeredName + "' with new target name '" + name + "'");
                }
            }
             //检查是否有别名的循环如A->B B->C C->A就是一个循环
            checkForAliasCircle(name, alias);
            this.aliasMap.put(alias, name);
            if (logger.isTraceEnabled()) {
                logger.trace("Alias definition '" + alias + "' registered for name '" + name + "'");
            }
        }
    }
}

/*
是否允许将别名挂到别的本名上，默认允许
 */
protected boolean allowAliasOverriding() {
    return true;
}

/*
检查一个本名是否有指定别名，别名是可以递归注册的，如A->B B->C 那么C也是A的别名
 */
public boolean hasAlias(String name, String alias) {
    String registeredName = this.aliasMap.get(alias);
    return ObjectUtils.nullSafeEquals(registeredName, name) || (registeredName != null
            && hasAlias(name, registeredName));
}

@Override
public void removeAlias(String alias) {
    synchronized (this.aliasMap) {
        String name = this.aliasMap.remove(alias);
        if (name == null) {
            throw new IllegalStateException("No alias '" + alias + "' registered");
        }
    }
}

/*
递归的查找出一个本名的所有别名
 */
private void retrieveAliases(String name, List<String> result) {
    this.aliasMap.forEach((alias, registeredName) -> {
        if (registeredName.equals(name)) {
            result.add(alias);
            retrieveAliases(alias, result);
        }
    });
}

/*
使用字符串解析器如占位符解析器解析所有别名
 */
public void resolveAliases(StringValueResolver valueResolver) {
    Assert.notNull(valueResolver, "StringValueResolver must not be null");
    // ConcurrentHashMap只能保证单个put、remove方法的原子性。而不能保证多个操作同时的原子性。比如我一边添加、一边删除  
    // 显然这是不被允许的,加synchronized的目的是防止注册别名时产生并发
    synchronized (this.aliasMap) {
        Map<String, String> aliasCopy = new HashMap<>(this.aliasMap);
        aliasCopy.forEach((alias, registeredName) -> {
            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);
                        return;
                    }
                    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);
            }
        });
    }
}

/*
检查是否存在别名的环
 */
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");
    }
}

/*
根据一个别名获取到本名
 */
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;
}

BeanDefinition注册

BeanDefinitionRegistry

作用

定义BeanDefinition的注册相关方法的接口

接口解析

这个接口主要是BeanDefinition的注册中心，可以对BeanDefinition增加删除查询等操作，总共有两个核心的类继承了他，分别是DefaultListablebeanFactory和GenericApplicationContext,当然还有一些类间接继承。

值得一说的是，虽然GenericApplicationContext实现了BeanDefinitionRegistry，但本质上还是使用的DefaultListablebeanFactory的方法，如图（只有这三个方法）：

GenericApplicationContext和DefaultListablebeanFactory的关系是组合关系，GenericApplicationContext虽然实现了BeanDefinitionRegistry，但还是用的

DefaultListablebeanFactory的方法。最终保存在beanDefinitionMap里面：

**注：**其他方法在GenericApplicationContext上一层抽象类里面，虽然实现的是ListableBeanFactory接口的方法，但是他们和BeanDefinitionRegistry的方法名称参数都一致，所以他的子类可以不实现这几个方法：

方法解释

// 在注册中心注册一个bean定义，必须支持RootBeanDefinition和ChildBeanDefinition
void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)throws BeanDefinitionStoreException;
// 移除对应bean名称的bean定义
void removeBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;
// 返回给定bean名称对应的bean定义
BeanDefinition getBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;
// 检查注册中心是否包含指定名称的bean定义
boolean containsBeanDefinition(String beanName);
// 返回注册中心中所有的bean定义的名称的数组
String[] getBeanDefinitionNames();
// 返回注册中心中bean定义的个数
int getBeanDefinitionCount();
// 返回beanName是否被占用，即已经在注册中心中注册了bean定义
boolean isBeanNameInUse(String beanName);

SimpleBeanDefinitionRegistry

作用

BeanDefinitionRegistry接口的双实现。仅提供注册表功能，不内置工厂功能。例如，可以用于测试bean定义阅读器。
目前没有有用到的，可以用来测试啥的

方法解析

/** Map of bean definition objects, keyed by bean name. */
private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(64);
内置了一个Map容器，还有BeanDefinitionRegistry接口的所有实现

Bean注册

SingletonBeanRegistry

作用

Spring容器对单例bean实例的登记管理主要通过接口SingletonBeanRegistry建模抽象，我们可以称之为"单例bean实例注册表"。

解析

如图：

我们可以看到SingletonBeanRegistry的分支链是有两条的，但最终都指向了DefaultListableBeanFactory,而有意思的是，虽然右边经历了这样的继承路线：SingletonBeanRegistry–>ConfigurableBeanFactory–>ConfigurableListableBeanFactory–>DefaultListableBeanFactory，但是最终只有DefaultListableBeanFactory实现了registerSingleton这个方法：

而其他的方法，都是交由DefaltSingletonBeanRegistry实现的，这也是DefaltSingletonBeanRegistry被称之为"单例bean实例注册表"的原因。

方法注释

void registerSingleton(String beanName, Object singletonObject);
给定的Object必须是被完全初始化了的(比如new出来的)（动态的向容器里直接放置一个Bean）
此方法有两个实现类：一个是DefaultSingletonBeanRegistry，一个是DefaultListableBeanFactory

DefaultSingletonBeanRegistry

作用

1. 存储单例Bean
2. 存储Bean之间的依赖关系
3. 存储Bean的包含关系（外部类包含内部类）
4. Bean所处的状态（正在创建、创建完毕等）
5. 负责单例Bean的销毁（在其中会看到销毁方法的回调）

解析

DefaultSingletonBeanRegistry是SingletonBeanRegistry的实现类，是真正的单例bean注册中心，基本上Spring框架里的单例都由他注册管理。

循环依赖

通过三级缓存，来解决循环依赖的问题，当然，构造器循环依赖是解决不了的，因为本质上解决循环依赖的其中最重要的一个步骤就需要创建一个不完全的实例化对象，当存在构造器循环依赖时，构造器互相依赖，则无法创建实例，导致死循环。下面这三个就是三级缓存：

首先先从一级缓存里面找，找不到就从二级缓存里面找，还找不到，就通过三级缓存里面的单例工厂获取单例，并存入二级缓存。当然，存入二级缓存的bean还不是完整的bean,只是实例化的对象，但是可以注入了。具体循环依赖的流程不多赘述，会开一篇文章详细解释。

除了处理循环依赖的问题，他还存储了Bean的包含关系（外部类包含内部类）

以及Bean之间的依赖关系（@DependOn）

当然还有Bean所处的状态（正在创建、创建完毕等）

最后还有一次性bean的存储集合

方法注释

spring使用双重判断加锁创建单例
spring删除bean运用了图的深度优先算法，bean之间的依赖关系本来就可以看成是图

Bean注册

/*
添加一个单例对象
 */
@Override
public void registerSingleton(String beanName, Object singletonObject) throws IllegalStateException {
    Assert.notNull(beanName, "Bean name must not be null");
    Assert.notNull(singletonObject, "Singleton object 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);
    }
}
/*
添加进去一个实例，实际上它做了好几步操作呢
 singletonObjects和singletonFactories是对立关系  不会同时存在
 */
protected void addSingleton(String beanName, Object singletonObject) {
    // 注意此处继续上锁
    synchronized (this.singletonObjects) {
        // 添加进map缓存起来
        this.singletonObjects.put(beanName, singletonObject);
        // 因为已经添加进去了，所以Factories就可以移除了~~~
        this.singletonFactories.remove(beanName);
        // 已经存在单例（循环依赖）也可以移除了~~~
        this.earlySingletonObjects.remove(beanName);
        // beanName放进单例注册表中
        this.registeredSingletons.add(beanName);
    }
}

Bean获取

@Override
@Nullable
public Object getSingleton(String beanName) {
    return getSingleton(beanName, true);
}
/*
allowEarlyReference：是否要创建早期引用
 */
@Nullable
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
    // 先根据这个beanName去查找，找到value值
    Object singletonObject = this.singletonObjects.get(beanName);
    // 此处：如果此单例不存在，也不要立马就返回null了  还有工作需要处理呢
    // 这里的条件是：如果单例不存在，并且并且这个bean正在创建中~~~(在这个singletonsCurrentlyInCreation集合了，表示它正在创建中)
    // 什么时候放进这个集合表示创建中呢？调用beforeSingletonCreation()方法，因为他是protected方法，所以只允许本类和子类调用~
    if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
        singletonObject = this.earlySingletonObjects.get(beanName);
        if (singletonObject == null && allowEarlyReference) {
            synchronized (this.singletonObjects) {
                // 这里再去earlySingletonObjects去看一下，看是否有呢   如果有直接返回即可
                singletonObject = this.singletonObjects.get(beanName);
                // 如果还未null，并且 并且allowEarlyReference是允许的  也就是说是允许创建一个早期引用的
                //（简单的说就是先可以把引用提供出去，但是并还没有完成真正的初始化~~~~）
                // 这里ObjectFactory就发挥很大的作用了~~~
                if (singletonObject == null) {
                    singletonObject = this.earlySingletonObjects.get(beanName);
                    if (singletonObject == null) {
                        ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
                        // 若有对应的ObjectFactory 那就可以继续处理
                        // 备注：singletonFactories这个Map只有调用`addSingletonFactory()`方法的时候才往里添加
                        // 它是一个protected方法，目前Spring还只有在`AbstractAutowireCapableBeanFactory#doCreateBean`里有过调用
                        if (singletonFactory != null) {//如果单例工程有，调用getObject方法返回
                            singletonObject = singletonFactory.getObject();
                            // 注意此处：把生产出来的放进earlySingletonObjects里面去，表示生产出来了一个引用
                            this.earlySingletonObjects.put(beanName, singletonObject);
                            // 然后把nFactories可以移除了，因为引用已经产生了~~~
                            this.singletonFactories.remove(beanName);
                        }
                    }
                }
            }
        }
    }
    return singletonObject;
}
/*
这个方法蛮重要的。首先它不是接口方法，而是一个单纯的public方法~~~
它的调用处只有一个地方：AbstractBeanFactory#doGetBean  在真正 `if (mbd.isSingleton()) { sharedInstance = getSingleton(...) }`
它第二个参数传的是ObjectFactory~~~~~~~实现有创建Bean实例的逻辑~~~
 */
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
    Assert.notNull(beanName, "Bean name must not be null");
    // 在锁内工作~~~~
    synchronized (this.singletonObjects) {
        Object singletonObject = this.singletonObjects.get(beanName);
        // 很显然如果都不为null了，那还做什么呢  直接返回吧
        if (singletonObject == null) {
            // 如果目前在销毁singellton 那就抛异常呗~~~~
            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 + "'");
            }
            // 标记这个bean正在被创建~~~~
            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;
                }
                // 释放这个状态  说明这个bean已经创建完成了
                afterSingletonCreation(beanName);
            }
            // 如果是新创建了  这里执行一下添加  缓存起来~~~~
            // 如果是旧的  是不用添加的~~~~
            if (newSingleton) {
                addSingleton(beanName, singletonObject);
            }
        }
        return singletonObject;
    }
}

销毁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);
    }
}
/*
销毁单例
 */
public void destroySingletons() {
    if (logger.isTraceEnabled()) {
        logger.trace("Destroying singletons in " + this);
    }
    // 设置当前正在销毁
    synchronized (this.singletonObjects) {
        this.singletonsCurrentlyInDestruction = true;
    }
    String[] disposableBeanNames;
    synchronized (this.disposableBeans) {
        disposableBeanNames = StringUtils.toStringArray(this.disposableBeans.keySet());
    }
    // 销毁disposableBeans中的所有bean
    for (int i = disposableBeanNames.length - 1; i >= 0; i--) {
        destroySingleton(disposableBeanNames[i]);
    }
    // 清空containedBeanMap、dependentBeanMap、dependenciesForBeanMap
    this.containedBeanMap.clear();
    this.dependentBeanMap.clear();
    this.dependenciesForBeanMap.clear();
    // 清除单例缓存
    clearSingletonCache();
}

/*
清除单例缓存
 */
protected void clearSingletonCache() {
    synchronized (this.singletonObjects) {
        this.singletonObjects.clear();
        this.singletonFactories.clear();
        this.earlySingletonObjects.clear();
        this.registeredSingletons.clear();
        // 清除完后，标志恢复为false
        this.singletonsCurrentlyInDestruction = false;
    }
}

/*
销毁单例bean
 */
public void destroySingleton(String beanName) {
    // 从缓存中移除
    removeSingleton(beanName);

    // Destroy the corresponding DisposableBean instance.
    DisposableBean disposableBean;
    synchronized (this.disposableBeans) {
        // 从disposableBeans移除，如果有beanName对应的对象，返回这个对象
        disposableBean = (DisposableBean) this.disposableBeans.remove(beanName);
    }
    // 销毁bean
    destroyBean(beanName, disposableBean);
}

/*
消耗bean
 */
protected void destroyBean(String beanName, @Nullable DisposableBean bean) {
    // Trigger destruction of dependent beans first...
    Set<String> dependencies;
    // 移除依赖当前beanName的bean
    synchronized (this.dependentBeanMap) {
        // 获取依赖当前beanName的bean
        dependencies = this.dependentBeanMap.remove(beanName);
    }
    if (dependencies != null) {
        if (logger.isTraceEnabled()) {
            logger.trace("Retrieved dependent beans for bean '" + beanName + "': " + dependencies);
        }
        // 移除依赖当前beanName的bean
        for (String dependentBeanName : dependencies) {
            destroySingleton(dependentBeanName);
        }
    }
    // Actually destroy the bean now...
    if (bean != null) {
        try {
            // 销毁bean
            bean.destroy();
        }
        catch (Throwable ex) {
            if (logger.isWarnEnabled()) {
                logger.warn("Destruction of bean with name '" + beanName + "' threw an exception", ex);
            }
        }
    }
    // 异常beanName的对应关系的bean
    Set<String> containedBeans;
    synchronized (this.containedBeanMap) {
        // Within full synchronization in order to guarantee a disconnected Set
        containedBeans = this.containedBeanMap.remove(beanName);
    }
    if (containedBeans != null) {
        for (String containedBeanName : containedBeans) {
            destroySingleton(containedBeanName);
        }
    }
    // 这个对象被其他bean依赖，也要移除依赖关系
    synchronized (this.dependentBeanMap) {
        for (Iterator<Map.Entry<String, Set<String>>> it = this.dependentBeanMap.entrySet().iterator(); it.hasNext();) {
            Map.Entry<String, Set<String>> entry = it.next();
            Set<String> dependenciesToClean = entry.getValue();
            dependenciesToClean.remove(beanName);
            //如果除了当前的beanName，没有其他依赖了，直接删除
            if (dependenciesToClean.isEmpty()) {
                it.remove();
            }
        }
    }
    // 移除当前bean与依赖其他bean的关系
    this.dependenciesForBeanMap.remove(beanName);
}

其他Bean操作

/*
 直接检查 singleton object 存储器了，其他的存储器不做检查
 */
@Override
public boolean containsSingleton(String beanName) {
    return this.singletonObjects.containsKey(beanName);
}
/*
获取已经注册过的bean名称
 */
@Override
public String[] getSingletonNames() {
    synchronized (this.singletonObjects) {
        return StringUtils.toStringArray(this.registeredSingletons);
    }
}
/*
获取单例的个数
 */
@Override
public int getSingletonCount() {
    synchronized (this.singletonObjects) {
        return this.registeredSingletons.size();
    }
}
/*
这个方法  只是简单的把这个Map返回出去了~~~~~
 */
@Override
public final Object getSingletonMutex() {
    return this.singletonObjects;
}

添加工厂

/*
注意：它是一个protected方法，并不是接口方法。子类会向这里添加工厂的~~~
 */
protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
    Assert.notNull(singletonFactory, "Singleton factory must not be null");
    synchronized (this.singletonObjects) {
        //首先判断一下：这个bean没有被产生才需要添加工厂，否则啥都不做~~~
        //判断singletonObjects内名字为beanName是否被占用，若没有，进行注册操作
        if (!this.singletonObjects.containsKey(beanName)) {
            this.singletonFactories.put(beanName, singletonFactory);
            //已经存在单例（循环依赖）也可以移除了~~~
            this.earlySingletonObjects.remove(beanName);
            // 注意注意注意：此处beanName也缓存了哦~~~一定要注意
            this.registeredSingletons.add(beanName);
        }
    }
}

依赖关系

/*
注册两个bean之间的一个包含关系
 */
public void registerContainedBean(String containedBeanName, String containingBeanName) {
    synchronized (this.containedBeanMap) {
        // 如果没有key为containingBeanName的value，说明内部bean集合为空，则初始化一个
        Set<String> containedBeans =
                this.containedBeanMap.computeIfAbsent(containingBeanName, k -> new LinkedHashSet<>(8));
        // 如果已经存在了对应关系，则直接返回，不存在，就添加对应关系
        if (!containedBeans.add(containedBeanName)) {
            return;
        }
    }
    registerDependentBean(containedBeanName, containingBeanName);
}

/*
注册给定bean的一个依赖bean，给定的bean销毁之前被销毁
 */
public void registerDependentBean(String beanName, String dependentBeanName) {
    String canonicalName = canonicalName(beanName);
    synchronized (this.dependentBeanMap) {
        Set<String> dependentBeans =
                this.dependentBeanMap.computeIfAbsent(canonicalName, k -> new LinkedHashSet<>(8));
        // 如果已经存在了对应关系，则直接返回,不存在，就添加对应关系
        if (!dependentBeans.add(dependentBeanName)) {
            return;
        }
    }
    synchronized (this.dependenciesForBeanMap) {
        Set<String> dependenciesForBean =
                this.dependenciesForBeanMap.computeIfAbsent(dependentBeanName, k -> new LinkedHashSet<>(8));
        // 添加对应关系
        dependenciesForBean.add(canonicalName);
    }
}
/*
dependentBeanName是否依赖beanName
 */
protected boolean isDependent(String beanName, String dependentBeanName) {
    synchronized (this.dependentBeanMap) {
        return isDependent(beanName, dependentBeanName, null);
    }
}
/*
判断beanName是否依赖dependentBeanName
*/
private boolean isDependent(String beanName, String dependentBeanName, @Nullable Set<String> alreadySeen) {
    if (alreadySeen != null && alreadySeen.contains(beanName)) {
        return false;
    }
    String canonicalName = canonicalName(beanName);
    Set<String> dependentBeans = this.dependentBeanMap.get(canonicalName);
    // 为空，说明没有bean依赖beanName，直接返回false
    if (dependentBeans == null) {
        return false;
    }
    // 有其他bean依赖beanName，且包含了dependentBeanName，返回true
    if (dependentBeans.contains(dependentBeanName)) {
        return true;
    }
    // 有其他bean依赖beanName，但是不包含dependentBeanName
    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);
}
/*
返回依赖指定bean的数组
 */
public String[] getDependentBeans(String beanName) {
    Set<String> dependentBeans = this.dependentBeanMap.get(beanName);
    if (dependentBeans == null) {
        return new String[0];
    }
    synchronized (this.dependentBeanMap) {
        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];
    }
    synchronized (this.dependenciesForBeanMap) {
        return StringUtils.toStringArray(dependenciesForBean);
    }
}

一次性bean

/*
注册一次性bean实例
 */
public void registerDisposableBean(String beanName, DisposableBean bean) {
    synchronized (this.disposableBeans) {
        this.disposableBeans.put(beanName, bean);
    }
}

Bean状态

/*
设置不检查的beanName
 */
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);
}

/*
是否当前创建的bean
 */
public boolean isSingletonCurrentlyInCreation(String beanName) {
    return this.singletonsCurrentlyInCreation.contains(beanName);
}

/*
这两个方法 一个在Bean创建开始之前还行。一个在创建完成后执行 finally里执行
表示；beforeSingletonCreation()方法用于记录加载的状态  表示该Bean当前正在初始化中~~~
调用this.singletonsCurrentlyInCreation.add(beanName)将当前正要创建的bean记录在缓存中，这样便可以对循环依赖进行检测啦
afterSingletonCreation显然就是
 */
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");
    }
}

FactoryBeanRegistrySupport

作用

在DefaultSingletonBeanRegistry的基础上，补充了对FactoryBean实例的处理能力

方法注释

获取FactoryBean类型

/*
根据工厂bean的名字，从缓存中获取对应工厂bean创建的对象；缓存中没有则返回null
1.通过给定的factoryBean来确定真实的FactoryBean类型
2.AccessController类用于访问控制操作和决策,其中doPrivileged为本地方法
 */
@Nullable
protected Class<?> getTypeForFactoryBean(FactoryBean<?> factoryBean) {
    try {
        if (System.getSecurityManager() != null) {
            //本地方法
            return AccessController.doPrivileged(
                    (PrivilegedAction<Class<?>>) factoryBean::getObjectType, getAccessControlContext());
        }
        else {
            //调用FactoryBean的getObjectType方法获取factoryBean的真实类型
            return factoryBean.getObjectType();
        }
    }
    catch (Throwable ex) {
        // Thrown from the FactoryBean's getObjectType implementation.
        logger.info("FactoryBean threw exception from getObjectType, despite the contract saying " +
                "that it should return null if the type of its object cannot be determined yet", ex);
        return null;
    }
}

获取FactoryBean

/*
从缓存中获取
 */
@Nullable
protected Object getCachedObjectForFactoryBean(String beanName) {
    return this.factoryBeanObjectCache.get(beanName);
}
/*
返回FactoryBean
 */
protected FactoryBean<?> getFactoryBean(String beanName, Object beanInstance) throws BeansException {
    if (!(beanInstance instanceof FactoryBean)) {
        throw new BeanCreationException(beanName,
                "Bean instance of type [" + beanInstance.getClass() + "] is not a FactoryBean");
    }
    return (FactoryBean<?>) beanInstance;
}

获取FactoryBean里的Bean

/**
 * 从给定的factory中获取暴露的object
 * @param factory FactoryBean的具体实例
 * @param beanName bean的name
 * @param shouldPostProcess 是否需要后置处理
 */
protected Object getObjectFromFactoryBean(FactoryBean<?> factory, String beanName, boolean shouldPostProcess) {
    //先就是简单的判断,是否是单例和包含该单例bean
    if (factory.isSingleton() && containsSingleton(beanName)) {
        synchronized (getSingletonMutex()) {
            //先从缓存中去拿
            Object object = this.factoryBeanObjectCache.get(beanName);
            //这里表示没有拿到
            if (object == null) {
                //实质还是去调用getObject()去拿,这里分装了一层
                object = doGetObjectFromFactoryBean(factory, beanName);
                //处理了仅有doGetObjectFromFactoryBean调用getObject()期间保存时需要进行后置处理,如循环引用的问题
                Object alreadyThere = this.factoryBeanObjectCache.get(beanName);
                if (alreadyThere != null) {
                    object = alreadyThere;
                }
                else {
                    //后置处理
                    if (shouldPostProcess) {
                        //通过传入的beanName来判断当前bean是否正在创建中
                        if (isSingletonCurrentlyInCreation(beanName)) {
                            //这里返回的是临时的非后置处理的object,并不保存它
                            return object;
                        }
                        //当前单例bean创建之前的回调该方法处理
                        beforeSingletonCreation(beanName);
                        try {
                            //对object进行后置处理,如果在FactoryBean找不到该object抛如下异常
                            object = postProcessObjectFromFactoryBean(object, beanName);
                        }
                        catch (Throwable ex) {
                            throw new BeanCreationException(beanName,
                                    "Post-processing of FactoryBean's singleton object failed", ex);
                        }
                        finally {
                            //当所有的条件具备完成,最后调用该方法对单例bean创建之后的一些处理,如:不能重复创建
                            afterSingletonCreation(beanName);
                        }
                    }
                    if (containsSingleton(beanName)) {
                        this.factoryBeanObjectCache.put(beanName, object);
                    }
                }
            }
            //返回从FactoryBean拿到的bean
            return object;
        }
    }
    //这里说明是factory不是单例且beanName在缓存中找不到
    else {
        //1.从factoryBean中去拿
        Object object = doGetObjectFromFactoryBean(factory, beanName);
        //需要后置处理
        if (shouldPostProcess) {
            try {
                //从factoryBean拿到object后对其后置处理逻辑
                object = postProcessObjectFromFactoryBean(object, beanName);
            }
            catch (Throwable ex) {
                throw new BeanCreationException(beanName, "Post-processing of FactoryBean's object failed", ex);
            }
        }
        //最后返回该object
        return object;
    }
}

/*
从factory(该factory实质是FactoryBean的实例)获取暴露的object对象
 */
private Object doGetObjectFromFactoryBean(FactoryBean<?> factory, String beanName) throws BeanCreationException {
    Object object;
    try {
        if (System.getSecurityManager() != null) {
            AccessControlContext acc = getAccessControlContext();
            try {
                object = AccessController.doPrivileged((PrivilegedExceptionAction<Object>) factory::getObject, acc);
            }
            catch (PrivilegedActionException pae) {
                throw pae.getException();
            }
        }
        else {
            //这里是真正的获取object的方法入口
            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);
    }

    //这里表明从FactoryBean没拿到,调用isSingletonCurrentlyInCreation判断该bean是否在创建中:
    //1.1.如果返回true,抛以下异常,当前bean在创建中
    if (object == null) {
        if (isSingletonCurrentlyInCreation(beanName)) {
            throw new BeanCurrentlyInCreationException(
                    beanName, "FactoryBean which is currently in creation returned null from getObject");
        }
        //1.1.2.返回false话,创建一个空bean返回
        object = new NullBean();
    }
    return object;
}

其他

/*
1.通过给定的object(object是从FactoryBean获取到的)去从FactoryBean获取然后进行后置处理
1.1.通过拿到的object将暴露给bean的引用
1.1.2.如果仅仅是实现只会返回原来的object对象
子类重写，预留钩子
 */
protected Object postProcessObjectFromFactoryBean(Object object, String beanName) throws BeansException {
    return object;
}
/*
除了移除DefaultSingletonBeanRegistry的对应beanName几个缓存，还要移除factoryBeanObjectCache的缓存
 */
@Override
protected void removeSingleton(String beanName) {
    synchronized (getSingletonMutex()) {
        super.removeSingleton(beanName);
        this.factoryBeanObjectCache.remove(beanName);
    }
}

/*
除了移除DefaultSingletonBeanRegistry的几个缓存，还要移除factoryBeanObjectCache的缓存
 */
@Override
protected void clearSingletonCache() {
    synchronized (getSingletonMutex()) {
        super.clearSingletonCache();
        this.factoryBeanObjectCache.clear();
    }
}

/*
获取安全作用域
 */
protected AccessControlContext getAccessControlContext() {
    return AccessController.getContext();
}

附录

循环依赖几种方式

1. 构造器循环依赖

2. setter循环依赖

3. 构造器和setter交叉循环依赖

除了第一种无法解决，其他的都可以解决，另外只支持单例模式，原型模式不支持。