spring源码（12）加载指定bean前，先加载依赖的bean

接着看bean的加载过程，本节来看看如何递归实例化依赖的bean。

一、bean标签的depends-on属性

Spring Framework Reference Documentation 6.4.3. Using depends-on

该节详细介绍了 bean的depends-on，下面简单复习一下：

If a bean is a dependency of another that usually means that one bean is set as a property of another. 
Typically you accomplish this with the <ref/> element in XML-based configuration metadata.
 However, sometimes dependencies between beans are less direct; 
The depends-on attribute can explicitly force one or more beans to 
be initialized before the bean using this element is initialized. 
The following example uses the depends-on 
attribute to express a dependency on a single bean:

如果一个A bean是B bean的依赖，那么一般意味着A bean是B bean的一个属性。在XML配置文件中可以通过ref属性，将B bean设为A bean的属性。但是，这只是一般情况，还有一些情况虽然A bean是B bean的依赖，仅仅意味着在加载B bean时，要先加载A bean。看下面的例子：

<bean id="beanOne" class="ExampleBean" depends-on="manager"/>
<bean id="manager" class="ManagerBean" />

To express a dependency on multiple beans, supply a list of bean names 
as the value of the depends-on attribute, with commas, whitespace and semicolons, used as valid delimiters:

如果想要表达依赖多个bean，可以使用逗号，空格和分号作为多个beand分隔符，看下面的例子：

<bean id="beanOne" class="ExampleBean" depends-on="manager,accountDao">
    <property name="manager" ref="manager" />
</bean>

<bean id="manager" class="ManagerBean" />
<bean id="accountDao" class="x.y.jdbc.JdbcAccountDao" />

---

特别注意：

在单例情况下，可以指定相互依赖bean之间的销毁顺序。
如果A bean是B bean的依赖，则在销毁B bean时，A bean先被销毁。

---

二、代码分析

String[] dependsOn = mbd.getDependsOn();
if (dependsOn != null) {
    for (String dep : dependsOn) {
        if (isDependent(beanName, dep)) {
                            throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");}
        registerDependentBean(dep, beanName);
        getBean(dep);
    }
}

首先获取所依赖的所有bean。
在DefaultSingletonBeanRegistry中有两个属性，分别是：

/** Map between dependent bean names: bean name --> Set of dependent bean names */
    private final Map<String, Set<String>> dependentBeanMap = new ConcurrentHashMap<>(64);

    /** Map between depending bean names: bean name --> Set of bean names for the bean's dependencies */
    private final Map<String, Set<String>> dependenciesForBeanMap = new ConcurrentHashMap<>(64);

dependentBeanMap ：key-被依赖的bean value-依赖者

dependenciesForBeanMap ：key-依赖者 value-被依赖的bean

---

通过断点来试验一下：

<bean id="A" class="com.demo.app.Cat" depends-on="B;C"></bean>

    <bean id="B" class="com.demo.app.Cat"></bean>

    <bean id="C" class="com.demo.app.Cat" depends-on="B;D"></bean>

    <bean id="D" class="com.demo.app.Cat"></bean>

public static void main(String[] args) {

        BeanFactory bf = new XmlBeanFactory(new ClassPathResource("springContext.xml"));
        Cat cat = (Cat) bf.getBean("A");
    }

没啥问题！

---

接下来会判断是否循环依赖，如果是则抛出异常。

protected boolean isDependent(String beanName, String dependentBeanName) {
        return isDependent(beanName, dependentBeanName, null);
    }

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

在上面的代码中通过递归的方式来判断是否存在循环依赖。
假如 A 依赖 B，查看B是否也依赖A，如果是则返回false。

当然没有这简单。
假如：
A 依赖 B
C、D依赖 A ，
spring还会去判断 B与C，B与D是否循环依赖。

我也不知道应该用什么图来表达递归，很烦！

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

        // No entry yet -> fully synchronized manipulation of the dependentBeans Set
        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<String> dependenciesForBean = this.dependenciesForBeanMap.get(dependentBeanName);
            if (dependenciesForBean == null) {
                dependenciesForBean = new LinkedHashSet<>(8);
                this.dependenciesForBeanMap.put(dependentBeanName, dependenciesForBean);
            }
            dependenciesForBean.add(canonicalName);
        }
    }

这段代码就是讲依赖关系存入dependentBeanMap和dependenciesForBeanMap，很简单。

---

记录bean之间的依赖关系有两方面的作用：

1.避免循环依赖

2.在单例情况下，可以指定相互依赖bean之间的销毁顺序