Spring IOC源码解析（05）BeanDefinition

BeanDefinitionRegistry

在阐释BeanDefinitionRegistry之前，我们有必要简单提一下BeanDefinition。BeanDefinition是spring容器中bean的定义，这些定义可以是xml配置，可以是注解配置，还可以是别的。

BeanDefinitionRegistry是一个接口，中文名为BeanDefinition注册器，继承了AliasRegistry接口，同时增加了对BeanDefinition的管理。

因此，我们可以说，这个接口包含以下几方面的功能：

1. BeanDefinition管理的功能
2. 包含对别名管理的功能

public interface BeanDefinitionRegistry extends AliasRegistry {

    /**
     * 注册BeanDefinition
     * Register a new bean definition with this registry.
     * Must support RootBeanDefinition and ChildBeanDefinition.
     * @param beanName the name of the bean instance to register
     * @param beanDefinition definition of the bean instance to register
     * @throws BeanDefinitionStoreException if the BeanDefinition is invalid
     * @throws BeanDefinitionOverrideException if there is already a BeanDefinition
     * for the specified bean name and we are not allowed to override it
     * @see GenericBeanDefinition
     * @see RootBeanDefinition
     * @see ChildBeanDefinition
     */
    void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
            throws BeanDefinitionStoreException;

    /**
     * 移除BeanDefinition
     * Remove the BeanDefinition for the given name.
     * @param beanName the name of the bean instance to register
     * @throws NoSuchBeanDefinitionException if there is no such bean definition
     */
    void removeBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;

    /**
     * 根据bean名称获取BeanDefinition
     * Return the BeanDefinition for the given bean name.
     * @param beanName name of the bean to find a definition for
     * @return the BeanDefinition for the given name (never {@code null})
     * @throws NoSuchBeanDefinitionException if there is no such bean definition
     */
    BeanDefinition getBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;

    /**
     * 判断是否包含bean名称
     * Check if this registry contains a bean definition with the given name.
     * @param beanName the name of the bean to look for
     * @return if this registry contains a bean definition with the given name
     */
    boolean containsBeanDefinition(String beanName);

    /**
     * 获取BeanDefinition的所有名称数组
     * Return the names of all beans defined in this registry.
     * @return the names of all beans defined in this registry,
     * or an empty array if none defined
     */
    String[] getBeanDefinitionNames();

    /**
     * 获取BeanDefinition的数量
     * Return the number of beans defined in the registry.
     * @return the number of beans defined in the registry
     */
    int getBeanDefinitionCount();

    /**
     * 判断beanName对应的BeanDefinition是否被使用了
     * Determine whether the given bean name is already in use within this registry,
     * i.e. whether there is a local bean or alias registered under this name.
     * @param beanName the name to check
     * @return whether the given bean name is already in use
     */
    boolean isBeanNameInUse(String beanName);
}

DefaultListableBeanFactory中的实现

DefaultListableBeanFactory是BeanFactory的具体实现，内容繁多且负责，这儿仅仅分析实现BeanDefinitionRegistry接口的那些方法。

涉及到的字段信息

// BeanDefinition容器
/** Map of bean definition objects, keyed by bean name. */
private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256);

// BeanDefinition名称列表
/** List of bean definition names, in registration order. */
private volatile List<String> beanDefinitionNames = new ArrayList<>(256);

// 手动单例名称列表
/** List of names of manually registered singletons, in registration order. */
private volatile Set<String> manualSingletonNames = new LinkedHashSet<>(16);

// 冻结名称列表
/** Cached array of bean definition names in case of frozen configuration. */
@Nullable
private volatile String[] frozenBeanDefinitionNames;

// 冻结开关，默认关闭
/** Whether bean definition metadata may be cached for all beans. */
private volatile boolean configurationFrozen = false;

registerBeanDefinition

public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
        throws BeanDefinitionStoreException {

    // beanName不允许为空，beanDefinition不允许为null
    Assert.hasText(beanName, "Bean name must not be empty");
    Assert.notNull(beanDefinition, "BeanDefinition must not be null");

    // 如果是AbstractBeanDefinition类型，则需要调用`validate()`校验一下正确性
    if (beanDefinition instanceof AbstractBeanDefinition) {
        try {
            ((AbstractBeanDefinition) beanDefinition).validate();
        }
        catch (BeanDefinitionValidationException ex) {
            throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
                    "Validation of bean definition failed", ex);
        }
    }

    // 尝试从BeanDefinition容器中查找
    BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName);
    
    // BeanDefinition容器中存在，则做了以下事情：
    // 1. 如果不允许重复注册，则抛出异常
    // 2. 条件满足的情况下，记录一帕拉日志
    // 3. 注册到BeanDefinition容器
    if (existingDefinition != null) {
        if (!isAllowBeanDefinitionOverriding()) {
            throw new BeanDefinitionOverrideException(beanName, beanDefinition, existingDefinition);
        }
        else if (existingDefinition.getRole() < beanDefinition.getRole()) {
            // e.g. was ROLE_APPLICATION, now overriding with ROLE_SUPPORT or ROLE_INFRASTRUCTURE
            if (logger.isInfoEnabled()) {
                logger.info("Overriding user-defined bean definition for bean '" + beanName +
                        "' with a framework-generated bean definition: replacing [" +
                        existingDefinition + "] with [" + beanDefinition + "]");
            }
        }
        else if (!beanDefinition.equals(existingDefinition)) {
            if (logger.isDebugEnabled()) {
                logger.debug("Overriding bean definition for bean '" + beanName +
                        "' with a different definition: replacing [" + existingDefinition +
                        "] with [" + beanDefinition + "]");
            }
        }
        else {
            if (logger.isTraceEnabled()) {
                logger.trace("Overriding bean definition for bean '" + beanName +
                        "' with an equivalent definition: replacing [" + existingDefinition +
                        "] with [" + beanDefinition + "]");
            }
        }
        this.beanDefinitionMap.put(beanName, beanDefinition);
    }
    
    // BeanDefinition容器中不存在
    // 1. 如果bean创建已经开始，则需要在锁环境下完成注册操作
    // 2. 如果bean创建还未开始，则不需要在所环境下操作，因为这个时候所有的操作都是在一个线程内完成
    // 3. 清空冻结名称列表，目的是为了后续查找方便
    else {
        if (hasBeanCreationStarted()) {
            // Cannot modify startup-time collection elements anymore (for stable iteration)
            synchronized (this.beanDefinitionMap) {
                this.beanDefinitionMap.put(beanName, beanDefinition);
                List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1);
                updatedDefinitions.addAll(this.beanDefinitionNames);
                updatedDefinitions.add(beanName);
                this.beanDefinitionNames = updatedDefinitions;
                removeManualSingletonName(beanName);
            }
        }
        else {
            // Still in startup registration phase
            this.beanDefinitionMap.put(beanName, beanDefinition);
            this.beanDefinitionNames.add(beanName);
            removeManualSingletonName(beanName);
        }
        this.frozenBeanDefinitionNames = null;
    }

    // 如果BeanDefinition容器中存在，或者当前BeanDefinition是一个单例定义，则需要重置BeanDefinition
    if (existingDefinition != null || containsSingleton(beanName)) {
        resetBeanDefinition(beanName);
    }
}

resetBeanDefinition

/**
 * 重置BeanDefinition，包括beanName被移除或替换的场景。
 * Reset all bean definition caches for the given bean,
 * including the caches of beans that are derived from it.
 * <p>Called after an existing bean definition has been replaced or removed,
 * triggering {@link #clearMergedBeanDefinition}, {@link #destroySingleton}
 * and {@link MergedBeanDefinitionPostProcessor#resetBeanDefinition} on the
 * given bean and on all bean definitions that have the given bean as parent.
 * @param beanName the name of the bean to reset
 * @see #registerBeanDefinition
 * @see #removeBeanDefinition
 */
protected void resetBeanDefinition(String beanName) {
    // Remove the merged bean definition for the given bean, if already created.
    // 清除合并的BeanDefinition
    clearMergedBeanDefinition(beanName);

    // Remove corresponding bean from singleton cache, if any. Shouldn't usually
    // be necessary, rather just meant for overriding a context's default beans
    // (e.g. the default StaticMessageSource in a StaticApplicationContext).
    // 销毁单例
    destroySingleton(beanName);

    // Notify all post-processors that the specified bean definition has been reset.
    // 调用MergedBeanDefinitionPostProcessor进行回调处理
    for (BeanPostProcessor processor : getBeanPostProcessors()) {
        if (processor instanceof MergedBeanDefinitionPostProcessor) {
            ((MergedBeanDefinitionPostProcessor) processor).resetBeanDefinition(beanName);
        }
    }

    // Reset all bean definitions that have the given bean as parent (recursively).
    for (String bdName : this.beanDefinitionNames) {
        if (!beanName.equals(bdName)) {
            BeanDefinition bd = this.beanDefinitionMap.get(bdName);
            // Ensure bd is non-null due to potential concurrent modification
            // of the beanDefinitionMap.
            // 父名称和当前名称相同的情况下，需要递归调用此方法
            if (bd != null && beanName.equals(bd.getParentName())) {
                resetBeanDefinition(bdName);
            }
        }
    }
}

removeBeanDefinition

public void removeBeanDefinition(String beanName) throws NoSuchBeanDefinitionException {
    Assert.hasText(beanName, "'beanName' must not be empty");

    // 移除不存在的BeanDefinition，会抛出异常
    BeanDefinition bd = this.beanDefinitionMap.remove(beanName);
    if (bd == null) {
        if (logger.isTraceEnabled()) {
            logger.trace("No bean named '" + beanName + "' found in " + this);
        }
        throw new NoSuchBeanDefinitionException(beanName);
    }

    // 和注册逻辑一样，Bean创建开始了，则需要在锁环境下进行移除操作，同时额外执行以下操作：
    // 1. 清空冻结名称列表
    // 2. 重置BeanDefinition
    if (hasBeanCreationStarted()) {
        // Cannot modify startup-time collection elements anymore (for stable iteration)
        synchronized (this.beanDefinitionMap) {
            List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames);
            updatedDefinitions.remove(beanName);
            this.beanDefinitionNames = updatedDefinitions;
        }
    }
    else {
        // Still in startup registration phase
        this.beanDefinitionNames.remove(beanName);
    }
    this.frozenBeanDefinitionNames = null;

    resetBeanDefinition(beanName);
}

getBeanDefinition && containsBeanDefinition && getBeanDefinitionCount

很简单！

public BeanDefinition getBeanDefinition(String beanName) throws NoSuchBeanDefinitionException {
    BeanDefinition bd = this.beanDefinitionMap.get(beanName);
    if (bd == null) {
        if (logger.isTraceEnabled()) {
            logger.trace("No bean named '" + beanName + "' found in " + this);
        }
        throw new NoSuchBeanDefinitionException(beanName);
    }
    return bd;
}

public boolean containsBeanDefinition(String beanName) {
    Assert.notNull(beanName, "Bean name must not be null");
    return this.beanDefinitionMap.containsKey(beanName);
}

public int getBeanDefinitionCount() {
    return this.beanDefinitionMap.size();
}

getBeanDefinitionNames

首先从frozenBeanDefinitionNames获取，如果为null，再从beanDefinitionNames获取。

【注意】：为了线程安全，这儿使用了数组的clone()操作。

public String[] getBeanDefinitionNames() {
    String[] frozenNames = this.frozenBeanDefinitionNames;
    if (frozenNames != null) {
        return frozenNames.clone();
    }
    else {
        return StringUtils.toStringArray(this.beanDefinitionNames);
    }
}

isBeanNameInUse

这个方法在AbstractBeanFactory类里面。beanName是否在使用，有3种情况：

1. 是一个别名
2. 是一个本地Bean的名称
3. 通过这个名字创建了一个内部bean（也叫依赖bean）

public boolean isBeanNameInUse(String beanName) {
    return isAlias(beanName) || containsLocalBean(beanName) || hasDependentBean(beanName);
}

总结

至此，我们粗略地对BeanDefinitionRegistry及其实现DefaultListableBeanFactory进行了分析。相对来说，比较简单，主要是对ConcurrentHashMap这种集合对象进行增删改查操作。