Spring5源码分析(024)——IoC篇之bean加载：parentBeanFactory和依赖处理

注：《Spring5源码分析》汇总可参考：Spring5源码分析(002)——博客汇总

---

　　前面已经分析了从单例缓存中获取到有 bean 实例时的处理流程，那从缓存单例中没有获取到 bean 缓存时，Spring 是如何处理的呢？这也是 Spring 统一加载的，而且肯定都是需要去实例化，可以想到的应该有以下两种场景：

• 1、从父工厂 parentBeanFactory 中进行加载 ：如果当前 BeanFactory 的 beanDefinitionMap 中没有相关的 BeanDefinition 定义且存在父工厂时，则通过父工厂 parentBeanFactory 来获取 bean 实例，此时是递归调用 #getBean 的各个重载方法来处理
• 2、在当前 BeanFactory 中，根据各种 scope 进行 bean 实例化，此时还需要处理的就是相关的依赖 bean ，他们都需要提前实例化。也即是先实例化依赖，然后再根据不同的 scope 来进行实际的实例化。

 

　　鉴于根据各种 scope 进行 bean 实例化的过程相对复杂且篇幅较多，接下来的介绍会拆分为两大部分：

• 第一部分，主要是一些前置检测、通过 parentBeanFactory 获取 bean 实例、依赖 bean 处理，前文中提到的 2.4 - 2.8
• 第二部分，则是根据各种 scope 进行 bean 的实例化

　　本篇主要对第一部分进行分析，也即是在《Spring5源码分析(021)——IoC篇之bean加载》中提到的 2.4 - 2.8 这几个小节所提到的处理，代码如下：

/// org.springframework.beans.factory.support.AbstractBeanFactory
/// protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType, @Nullable final Object[] args, boolean typeCheckOnly)

// 其他处理代码。。。

// Fail if we're already creating this bean instance:
// We're assumably within a circular reference.
// 4、原型模式的依赖检查
// 只有在单例情况下才会尝试解决循环依赖，原型模式情况下，如果存在 A 中有 B 的属性， B 中有 A 的属性，
// 那么当依赖注入的时候，就会产生A还未创建完的时候因为对于B的创建再次返回创建A，造成循环依赖，也就是下面的情况。
// 原型模式下如果存在循环依赖则会抛出异常
if (isPrototypeCurrentlyInCreation(beanName)) {
    throw new BeanCurrentlyInCreationException(beanName);
}

// 5、检查 parentBeanFactory 是否存在对应的 bean
// Check if bean definition exists in this factory.
BeanFactory parentBeanFactory = getParentBeanFactory();
// 当前容器中没有找到，则从父类容器中加载
// 如果 beanDefinitionMap 中也就是在所有已经加载的类中不包括 beanName 指定的 bean，
// 则尝试从 parentBeanFactory 中检测
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
    // Not found -> check parent.
    String nameToLookup = originalBeanName(name);
    // 递归到 BeanFactory 中寻找
    if (parentBeanFactory instanceof AbstractBeanFactory) {
        return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
                nameToLookup, requiredType, args, typeCheckOnly);
    }
    else if (args != null) {
        // Delegation to parent with explicit args.
        return (T) parentBeanFactory.getBean(nameToLookup, args);
    }
    else if (requiredType != null) {
        // No args -> delegate to standard getBean method.
        return parentBeanFactory.getBean(nameToLookup, requiredType);
    }
    else {
        return (T) parentBeanFactory.getBean(nameToLookup);
    }
}

// 6、如果不是仅仅做类型检查则是创建 bean ，这里需要进行记录
if (!typeCheckOnly) {
    markBeanAsCreated(beanName);
}

try {
    // 7、将存储 XML 配置的 GenericBeanDefinition 转换成 RootBeanDefinition ，
    // 如果指定的 beanName 是子 bean 的话同时会合并父类的相关属性
    final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
    checkMergedBeanDefinition(mbd, beanName, args);

    // 8、处理依赖的 bean
    // Guarantee initialization of beans that the current bean depends on.
    // 若存在依赖则需要递归实例化依赖的 bean
    String[] dependsOn = mbd.getDependsOn();
    if (dependsOn != null) {
        for (String dep : dependsOn) {
            // 循环依赖的情况，depends-on 是强制依赖
            if (isDependent(beanName, dep)) {
                throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                        "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
            }
            // 缓存依赖调用
            registerDependentBean(dep, beanName);
            try {
                // 递归调用获取依赖的 bean
                getBean(dep);
            }
            catch (NoSuchBeanDefinitionException ex) {
                throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                        "'" + beanName + "' depends on missing bean '" + dep + "'", ex);
            }
        }
    }
/// 其他处理代码。。。

　　结合注释可以看出，这段代码主要处理以下这几个部分：

• 4、原型模式的依赖检测，原型模式下如果检测到循环依赖，即当前 bean 正在创建中，则抛出 BeanCurrentlyInCreationException 异常，具体分析参考【1、原型模式的依赖检测】
• 5、检查 parentBeanFactory 是否存在对应的 bean ，如果当前 BeanFactory 的 beanDefinitionMap 中没有相关的 BeanDefinition 定义且存在父工厂时，则通过父工厂 parentBeanFactory 来获取 bean 实例，具体分析参考【2、检查 parentBeanFactory 是否存在对应的 bean】
• 6、类型检查，将指定的 bean 标记为已创建或即将创建，具体分析参考【3、类型检查】
• 7、将存储 XML 配置的 GenericBeanDefinition 转换成 RootBeanDefinition，具体分析参考【4、将存储 XML 配置的 GenericBeanDefinition 转换成 RootBeanDefinition】
• 8、依赖处理，具体分析参考【5、依赖处理】

 

本文目录如下：

• 1、原型模式的依赖检测
• 2、检查 parentBeanFactory 是否存在对应的 bean
• 3、类型检查
• 4、将存储 XML 配置的 GenericBeanDefinition 转换成 RootBeanDefinition
• 5、依赖处理
• 5.1、isDependent
• 5.2、registerDependentBean
• 5.3、getBean
• 6、参考

1、原型模式的依赖检测

　　众所周知， Spring 只解决单例模式下的循环依赖，而原型模式下检测到循环依赖则会抛出异常（要不然会陷入无限创建的循环中），这就是 #isPrototypeCurrentlyInCreation(String beanName) 所做的处理，具体代码如下：

/// org.springframework.beans.factory.support.AbstractBeanFactory

// Fail if we're already creating this bean instance:
// We're assumably within a circular reference.
// 4、原型模式的依赖检查
// 只有在单例情况下才会尝试解决循环依赖，原型模式情况下，如果存在 A 中有 B 的属性， B 中有 A 的属性，
// 那么当依赖注入的时候，就会产生A还未创建完的时候因为对于B的创建再次返回创建A，造成循环依赖，也就是下面的情况。
// 原型模式下如果存在循环依赖则会抛出异常
if (isPrototypeCurrentlyInCreation(beanName)) {
    throw new BeanCurrentlyInCreationException(beanName);
}

///
/**
 * Return whether the specified prototype bean is currently in creation
 * (within the current thread).
 * @param beanName the name of the bean
 */
protected boolean isPrototypeCurrentlyInCreation(String beanName) {
    Object curVal = this.prototypesCurrentlyInCreation.get();
    return (curVal != null &&
            (curVal.equals(beanName) || (curVal instanceof Set && ((Set<?>) curVal).contains(beanName))));
}

/** Names of beans that are currently in creation. */
private final ThreadLocal<Object> prototypesCurrentlyInCreation =
        new NamedThreadLocal<>("Prototype beans currently in creation");

　　可以看到循环依赖的检测判断有些似曾相识，都是通过正在创建中的集合来判断的，也就是创建时记录和检查，这里是通过 prototypesCurrentlyInCreation 这个 ThreadLocal 来进行记录相关的创建中原型集合的，而这个记录则是在 beforePrototypeCreation(String beanName) 和 afterPrototypeCreation(String beanName) ，这个可以在稍后面的原型实例化创建时看到有相关调用，这里的默认实现就是直接将 beanName 丢到 prototypesCurrentlyInCreation 中。

2、检查 parentBeanFactory 是否存在对应的 bean

　　如果当前 BeanFactory 的 beanDefinitionMap 中没有相关的 BeanDefinition 定义，也就是说通过 # containsBeanDefinition(String beanName) 方法获不到对应的bean定义，且存在父工厂时，则通过父工厂 parentBeanFactory 来获取 bean 实例，代码如下：

/// org.springframework.beans.factory.support.AbstractBeanFactory

// 5、检查 parentBeanFactory 是否存在对应的 bean
// Check if bean definition exists in this factory.
BeanFactory parentBeanFactory = getParentBeanFactory();
// 当前容器中没有找到，则从父类容器中加载
// 如果 beanDefinitionMap 中也就是在所有已经加载的类中不包括 beanName 指定的 bean，
// 则尝试从 parentBeanFactory 中检测
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
    // Not found -> check parent.
    String nameToLookup = originalBeanName(name);
    // 递归到 BeanFactory 中寻找
    if (parentBeanFactory instanceof AbstractBeanFactory) {
        return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
                nameToLookup, requiredType, args, typeCheckOnly);
    }
    else if (args != null) {
        // Delegation to parent with explicit args.
        return (T) parentBeanFactory.getBean(nameToLookup, args);
    }
    else if (requiredType != null) {
        // No args -> delegate to standard getBean method.
        return parentBeanFactory.getBean(nameToLookup, requiredType);
    }
    else {
        return (T) parentBeanFactory.getBean(nameToLookup);
    }
}

　　这过程其实也好理解，就是递归调用 #getBean 方法来获取实例。需要注意的是，这里的 beanName 是需要做转换的，调用 #originalBeanName(String name) 来处理，代码如下：

/**
 * Determine the original bean name, resolving locally defined aliases to canonical names.
 * @param name the user-specified name
 * @return the original bean name
 */
protected String originalBeanName(String name) {
    String beanName = transformedBeanName(name);
    if (name.startsWith(FACTORY_BEAN_PREFIX)) {
        beanName = FACTORY_BEAN_PREFIX + beanName;
    }
    return beanName;
}

　　这里先调用 transformedBeanName(name)（前面文章已经提到过） 来获取真正的 beanName ，然后（如果有的话）再补上 FactoryBean 引用前缀 & 。

 

3、类型检查

　　如果不是仅仅做类型检查则是创建 bean ，则需要调用 #markBeanAsCreated(String beanName) 方法，将该 bean 标记为已创建或即将创建。代码如下：

/// org.springframework.beans.factory.support.AbstractBeanFactory

/**
 * Mark the specified bean as already created (or about to be created).
 * <p>This allows the bean factory to optimize its caching for repeated
 * creation of the specified bean.
 * <p>将指定的 bean 标记为已创建或即将创建。
 * <p>这允许 beanFactory 优化其缓存，以重复创建指定的Bean。
 * @param beanName the name of the bean
 */
protected void markBeanAsCreated(String beanName) {
    // 还没有创建
    if (!this.alreadyCreated.contains(beanName)) {
        // 加锁
        synchronized (this.mergedBeanDefinitions) {
            // DCL 双重检查
            if (!this.alreadyCreated.contains(beanName)) {
                // Let the bean definition get re-merged now that we're actually creating
                // the bean... just in case some of its metadata changed in the meantime.
                clearMergedBeanDefinition(beanName);
                // 添加到已创建 bean 集合中
                this.alreadyCreated.add(beanName);
            }
        }
    }
}

/**
 * Remove the merged bean definition for the specified bean,
 * recreating it on next access.
 * <p>从 mergedBeanDefinitions 中删除指定的 bean ，并在下次访问时重新创建它。
 * @param beanName the bean name to clear the merged definition for
 */
protected void clearMergedBeanDefinition(String beanName) {
    RootBeanDefinition bd = this.mergedBeanDefinitions.get(beanName);
    if (bd != null) {
        bd.stale = true;
    }
}

 

4、将存储 XML 配置的 GenericBeanDefinition 转换成 RootBeanDefinition

　　代码如下：

/// org.springframework.beans.factory.support.AbstractBeanFactory

// 7、将存储 XML 配置的 GenericBeanDefinition 转换成 RootBeanDefinition ，
// 如果指定的 beanName 是子 bean 的话同时会合并父类的相关属性
final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
checkMergedBeanDefinition(mbd, beanName, args);

• 1、这里首先调用 #getMergedLocalBeanDefinition(String beanName) 方法，获取 BeanDefinition 对象，代码如下：

/// org.springframework.beans.factory.support.AbstractBeanFactory

/**
 * Return a merged RootBeanDefinition, traversing the parent bean definition
 * if the specified bean corresponds to a child bean definition.
 * <p>将存储 XML 配置的 GenericBeanDefinition 转换成 RootBeanDefinition ，
 *    如果指定的 beanName 是子bean的话同时会合并父类的相关属性
 * @param beanName the name of the bean to retrieve the merged definition for
 * @return a (potentially merged) RootBeanDefinition for the given bean
 * @throws NoSuchBeanDefinitionException if there is no bean with the given name
 * @throws BeanDefinitionStoreException in case of an invalid bean definition
 */
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 && !mbd.stale) {
        return mbd;
    }
    return getMergedBeanDefinition(beanName, getBeanDefinition(beanName));
}

/**
 * Return a RootBeanDefinition for the given top-level bean, by merging with
 * the parent if the given bean's definition is a child bean definition.
 * <p>返回给定顶层 bean 的 RootBeanDefinition ，如果给定的 bean 定义是
 * 子 bean 定义，则会同时合并父bean定义
 * @param beanName the name of the bean definition
 * @param bd the original bean definition (Root/ChildBeanDefinition)
 * @return a (potentially merged) RootBeanDefinition for the given bean
 * @throws BeanDefinitionStoreException in case of an invalid bean definition
 */
protected RootBeanDefinition getMergedBeanDefinition(String beanName, BeanDefinition bd)
        throws BeanDefinitionStoreException {

    return getMergedBeanDefinition(beanName, bd, null);
}

/**
 * Return a RootBeanDefinition for the given bean, by merging with the
 * parent if the given bean's definition is a child bean definition.
 * @param beanName the name of the bean definition
 * @param bd the original bean definition (Root/ChildBeanDefinition)
 * @param containingBd the containing bean definition in case of inner bean,
 * or {@code null} in case of a top-level bean
 * @return a (potentially merged) RootBeanDefinition for the given bean
 * @throws BeanDefinitionStoreException in case of an invalid bean definition
 */
protected RootBeanDefinition getMergedBeanDefinition(
        String beanName, BeanDefinition bd, @Nullable BeanDefinition containingBd)
        throws BeanDefinitionStoreException {

    // 同步锁
    synchronized (this.mergedBeanDefinitions) {
        RootBeanDefinition mbd = null;
        RootBeanDefinition previous = null;

        // Check with full lock now in order to enforce the same merged instance.
        // 同步锁下重新获取，确保是同一个合并实例对象
        if (containingBd == null) {
            mbd = this.mergedBeanDefinitions.get(beanName);
        }
        // 需要合并/重新合并
        if (mbd == null || mbd.stale) {
            previous = mbd;
            // 没有父bean
            if (bd.getParentName() == null) {
                // Use copy of given root bean definition.
                if (bd instanceof RootBeanDefinition) {
                    mbd = ((RootBeanDefinition) bd).cloneBeanDefinition();
                }
                else {
                    mbd = new RootBeanDefinition(bd);
                }
            }
            else {
                // 需要合并父bean定义
                // Child bean definition: needs to be merged with parent.
                BeanDefinition pbd;
                try {
                    String parentBeanName = transformedBeanName(bd.getParentName());
                    if (!beanName.equals(parentBeanName)) {
                        pbd = getMergedBeanDefinition(parentBeanName);
                    }
                    else {
                        BeanFactory parent = getParentBeanFactory();
                        if (parent instanceof ConfigurableBeanFactory) {
                            pbd = ((ConfigurableBeanFactory) parent).getMergedBeanDefinition(parentBeanName);
                        }
                        else {
                            throw new NoSuchBeanDefinitionException(parentBeanName,
                                    "Parent name '" + parentBeanName + "' 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);
                }
                // Deep copy with overridden values.
                mbd = new RootBeanDefinition(pbd);
                mbd.overrideFrom(bd);
            }

            // Set default singleton scope, if not configured before.
            // 设置默认 scope
            if (!StringUtils.hasLength(mbd.getScope())) {
                mbd.setScope(SCOPE_SINGLETON);
            }

            // A bean contained in a non-singleton bean cannot be a singleton itself.
            // Let's correct this on the fly here, since this might be the result of
            // parent-child merging for the outer bean, in which case the original inner bean
            // definition will not have inherited the merged outer bean's singleton status.
            if (containingBd != null && !containingBd.isSingleton() && mbd.isSingleton()) {
                mbd.setScope(containingBd.getScope());
            }

            // Cache the merged bean definition for the time being
            // (it might still get re-merged later on in order to pick up metadata changes)
            if (containingBd == null && isCacheBeanMetadata()) {
                this.mergedBeanDefinitions.put(beanName, mbd);
            }
        }
        if (previous != null) {
            copyRelevantMergedBeanDefinitionCaches(previous, mbd);
        }
        return mbd;
    }
}

• • 先从缓存 mergedBeanDefinitions 中获取 RootBeanDefinition 对象，如果存在且不需要重新合并，则直接返回；
  • 否则调用 #getMergedBeanDefinition(String beanName, BeanDefinition bd, @Nullable BeanDefinition containingBd) 获取。前面从 bean 的解析过程中我们可以知道，从 xml 配置文件中读取到的 bean 信息是存储在 GenericBeanDefinition 中的，而 Spring 中所有的 bean 后续的处理都是针对 RootBeanDefinition 的，因此这里需要进行一个转换，转换的同时如果父类 bean 不为空的话，则会一并合并父类的属性，感兴趣的可以进一步深入研究。

• 2、调用 #checkMergedBeanDefinition(RootBeanDefinition mbd, String beanName, @Nullable Object[] args) 方法，对 RootBeanDefinition 进行校验，这里只是检查是否是抽象类。

/**
 * Check the given merged bean definition,
 * potentially throwing validation exceptions.
 * @param mbd the merged bean definition to check
 * @param beanName the name of the bean
 * @param args the arguments for bean creation, if any
 * @throws BeanDefinitionStoreException in case of validation failure
 */
protected void checkMergedBeanDefinition(RootBeanDefinition mbd, String beanName, @Nullable Object[] args)
        throws BeanDefinitionStoreException {

    if (mbd.isAbstract()) {
        throw new BeanIsAbstractException(beanName);
    }
}

5、依赖处理

　　如果需要获取的 bean 有依赖，则需要确保相关依赖先初始化，代码如下：

// 8、处理依赖的 bean
// Guarantee initialization of beans that the current bean depends on.
// 若存在依赖则需要递归实例化依赖的 bean
String[] dependsOn = mbd.getDependsOn();
if (dependsOn != null) {
    for (String dep : dependsOn) {
        // 循环依赖的情况，depends-on 是强制依赖
        if (isDependent(beanName, dep)) {
            throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                    "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
        }
        // 缓存依赖调用
        registerDependentBean(dep, beanName);
        try {
            // 递归调用获取依赖的 bean
            getBean(dep);
        }
        catch (NoSuchBeanDefinitionException ex) {
            throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                    "'" + beanName + "' depends on missing bean '" + dep + "'", ex);
        }
    }
}

　　主要逻辑还是循环依赖检测、缓存注册，然后递归调用 #getBean 方法进行 bean 依赖的实例化。

5.1、isDependent

　　该方法用于确定指定的依赖Bean是否已注册为依赖于给定Bean或依赖于其任何传递依赖项，递归检测，其实就是循环依赖检测，因为 depends-on 是强制依赖，不能有循环依赖。

/// org.springframework.beans.factory.support.DefaultSingletonBeanRegistry

/** Map between dependent bean names: bean name to Set of dependent bean names.
 * <p>存放映射关系(依赖谁集合)： beanName --> 依赖的 beanNames 集合，即 [canonicalName --> dependentBeanName set] */
private final Map<String, Set<String>> dependentBeanMap = new ConcurrentHashMap<>(64);

/**
 * Determine whether the specified dependent bean has been registered as
 * dependent on the given bean or on any of its transitive dependencies.
 * <p>确定指定的依赖Bean是否已注册为依赖于给定Bean或依赖于其任何传递依赖项。
 * @param beanName the name of the bean to check
 * @param dependentBeanName the name of the dependent bean
 * @since 4.0
 */
protected boolean isDependent(String beanName, String dependentBeanName) {
    synchronized (this.dependentBeanMap) {
        return isDependent(beanName, dependentBeanName, null);
    }
}

private boolean isDependent(String beanName, String dependentBeanName, @Nullable Set<String> alreadySeen) {
    if (alreadySeen != null && alreadySeen.contains(beanName)) {
        return false;
    }
    // 获取真正的 beanName
    String canonicalName = canonicalName(beanName);
    // 当前 beanName 依赖的bean集合
    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 中
        alreadySeen.add(beanName);
        // 递归调用检测
        if (isDependent(transitiveDependency, dependentBeanName, alreadySeen)) {
            return true;
        }
    }
    return false;
}

5.2、registerDependentBean

　　为给定的 bean 注册一个依赖 bean，在销毁指定的 bean 之前销毁该 bean，其实就是记录“谁依赖哪些谁”、“谁被哪些谁依赖”之间的映射。需要说明的是， depends-on 是一种强制依赖初始化，不能有循环依赖，因此这里进行了注册判断。代码如下：

/**
 * Register a dependent bean for the given bean,
 * to be destroyed before the given bean is destroyed.
 * <p>为给定的 bean 注册一个依赖 bean，在销毁指定的 bean 之前销毁该 bean
 * @param beanName the name of the bean
 * @param dependentBeanName the name of the dependent bean
 */
public void registerDependentBean(String beanName, String dependentBeanName) {
    // 获取真正的 beanName
    String canonicalName = canonicalName(beanName);

    // 添加 [canonicalName --> dependentBeanName set] 到 dependentBeanMap 中
    synchronized (this.dependentBeanMap) {
        Set<String> dependentBeans =
                this.dependentBeanMap.computeIfAbsent(canonicalName, k -> new LinkedHashSet<>(8));
        if (!dependentBeans.add(dependentBeanName)) {
            return;
        }
    }

    // 添加 [dependentBeanName --> canonicalName set] 到 dependenciesForBeanMap 中
    synchronized (this.dependenciesForBeanMap) {
        Set<String> dependenciesForBean =
                this.dependenciesForBeanMap.computeIfAbsent(dependentBeanName, k -> new LinkedHashSet<>(8));
        dependenciesForBean.add(canonicalName);
    }
}

 

5.3、getBean

　　这里就是通过递归调用 #getBean 方法实例化依赖的 bean 。 

6、参考

• [1]spring 官方文档 5.2.3.RELEASE：https://docs.spring.io/spring-framework/docs/5.2.3.RELEASE/spring-framework-reference/core.html
• [2]Spring源码深度解析（第2版）
• [3]相关注释和案例可参考笔者 github 链接：https://github.com/wpbxin/spring-framework