Spring源码阅读：BeanDefinitionRegistry接口

发表于 分类于 Waline： 阅读次数：

BeanDefinitionRegistry 是一个接口，从名字上就可以看出来，它是一个管理 BeanDefinition 的注册中心。通常情况下，BeanFactory 的具体实现类也会实现该接口，用于管理 AbstractBeanDefinition 继承结构下的 BeanDefinition 实例，例如 RootBeanDefinition 和 ChildBeanDefinition 实例。

BeanDefinitionRegistry 的结构

BeanDefinitionRegistry 是一个接口，它实现了 AliasRegistry 接口。其继承结构如下：

image-20200114003530283

AliasRegistry

AliasRegistry 是一个用于管理别名的通用接口，也是 BeanDefinitionRegistry 的父接口。它的定义如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public interface AliasRegistry {
    /**
     * 给定一个名字，为其注册别名
     */
    void registerAlias(String name, String alias);

    /**
     * 从已注册的别名中移除指定的别名
     */
    void removeAlias(String alias);

    /**
     * 判断给定的别名是否已注册过
     */
    boolean isAlias(String name);

    /**
     * 根据给定的名字，获取所有的别名
     */
    String[] getAliases(String name);
}

包含的功能有：注册别名、移除别名、判断别名是否已注册过、获取指定名字的所有别名

SimpleAliasRegistry 是该接口的一个简单实现，它内部持有了一个 HashMap，用于保存别名映射关系

1
2
// key: 别名 value: 原始名
private final Map<String, String> aliasMap = new ConcurrentHashMap<>(16);

BeanDefinitionRegistry 的方法

BeanDefinitionRegistry 的方法定义了如何对 BeanDefinition 进行管理。SimpleBeanDefinitionRegistry 是 BeanDefinitionRegistry 的一个简单实现，可通过它来了解下具体实现。

SimpleBeanDefinitionRegistry 内部持有了一个 HashMap，用于保存注册的 BeanDefinition，它的所有方法都是基于该 HashMap 进行操作。

1
2
// key: beanName value: 对应的 beanDefinition
private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(64);

registerBeanDefinition

用于注册一个 BeanDefinition

1
2
void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
            throws BeanDefinitionStoreException;

SimpleBeanDefinitionRegistry 中的实现：将 beanName 到 beanDefinition 的映射关系保存到 beanDefinitionMap 中

1
2
3
4
5
6
7
public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
        throws BeanDefinitionStoreException {

    Assert.hasText(beanName, "'beanName' must not be empty");
    Assert.notNull(beanDefinition, "BeanDefinition must not be null");
    this.beanDefinitionMap.put(beanName, beanDefinition);
}

removeBeanDefinition

用于移除一个 BeanDefinition

SimpleBeanDefinitionRegistry 中的实现：从 beanDefinitionMap 将指定的 beanName 移除

1
2
3
4
5
public void removeBeanDefinition(String beanName) throws NoSuchBeanDefinitionException {
    if (this.beanDefinitionMap.remove(beanName) == null) {
        throw new NoSuchBeanDefinitionException(beanName);
    }
}

getBeanDefinition

用于获取一个 BeanDefinition

containsBeanDefinition

判断一个 beanDefinition 是否已注册过

getBeanDefinitionNames

获取已注册的所有 beanDefinition 的名字

getBeanDefinitionCount

获取已注册的 BeanDefinition 数量

isBeanNameInUse

判断一个 beanName 是否已使用

SimpleBeanDefinitionRegistry 中的实现：判断是否为别名，或者已经注册到 BeanDefinitionRegistry 中

1
2
3
public boolean isBeanNameInUse(String beanName) {
    return isAlias(beanName) || containsBeanDefinition(beanName);
}

DefaultListableBeanFactory 中的实现

DefaultListableBeanFactory 是一个基本功能的 BeanFactory，它实现了 BeanDefinitionRegistry 接口。它的继承结构如下：

image-20200114012534310

DefaultListableBeanFactory 也是通过一个 HashMap 来管理 BeanDefinition 的，它比 SimpleBeanDefinitionRegistry 多了一些其他的数据存储，使用上也更复杂

1
2
3
4
5
6
7
8
9
// 用于保存 BeanDefinition
// key: beanName value: BeanDefinition
private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256);

// 已注册的 beanName，按注册的顺序有序
private volatile List<String> beanDefinitionNames = new ArrayList<>(256);

// 手动注册的 singleton bean 的名字，按注册的顺序有序
private volatile Set<String> manualSingletonNames = new LinkedHashSet<>(16);

registerBeanDefinition

往 BeanFactory 中注册 BeanDefinition

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
        throws BeanDefinitionStoreException {
    // 验证 beanDefinition
    if (beanDefinition instanceof AbstractBeanDefinition) {
        try {
            ((AbstractBeanDefinition) beanDefinition).validate();
        }
        catch (BeanDefinitionValidationException ex) {
            throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
                    "Validation of bean definition failed", ex);
        }
    }

    BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName);
    // 已经注册过了
    if (existingDefinition != null) {
        // 不允许覆盖，直接抛异常
        if (!isAllowBeanDefinitionOverriding()) {
            throw new BeanDefinitionOverrideException(beanName, beanDefinition, existingDefinition);
        }

        // 覆盖已注册的beanDefinition
        this.beanDefinitionMap.put(beanName, beanDefinition);
    }
    // 还没有注册过
    else {
        // bean正在创建中
        if (hasBeanCreationStarted()) {
            // Cannot modify startup-time collection elements anymore (for stable iteration)
            synchronized (this.beanDefinitionMap) {
                // 注册beanDefinition
                this.beanDefinitionMap.put(beanName, beanDefinition);

                // 更新已注册的beanName
                List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1);
                updatedDefinitions.addAll(this.beanDefinitionNames);
                updatedDefinitions.add(beanName);
                this.beanDefinitionNames = updatedDefinitions;

                // 从手动注册的 singleton bean map 中移除
                if (this.manualSingletonNames.contains(beanName)) {
                    Set<String> updatedSingletons = new LinkedHashSet<>(this.manualSingletonNames);
                    updatedSingletons.remove(beanName);
                    this.manualSingletonNames = updatedSingletons;
                }
            }
        }
        // 还没开始创建
        else {
            // Still in startup registration phase
            this.beanDefinitionMap.put(beanName, beanDefinition);
            this.beanDefinitionNames.add(beanName);
            this.manualSingletonNames.remove(beanName);
        }
        this.frozenBeanDefinitionNames = null;
    }

    if (existingDefinition != null || containsSingleton(beanName)) {
        resetBeanDefinition(beanName);
    }
}

removeBeanDefinition

从 BeanFactory 中移除 BeanDefinition

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
public void removeBeanDefinition(String beanName) throws NoSuchBeanDefinitionException {
    // 从 beanDefinitionMap 中移除
    BeanDefinition bd = this.beanDefinitionMap.remove(beanName);
    if (bd == null) {
        // 不存在这个 BeanDefinition，抛异常出来
        throw new NoSuchBeanDefinitionException(beanName);
    }

    // 已经有 bean 正在创建中
    if (hasBeanCreationStarted()) {
        // Cannot modify startup-time collection elements anymore (for stable iteration)
        synchronized (this.beanDefinitionMap) {
            // 不能修改原来的 list，防止迭代器遍历失败
            // 复制一份，修改完之后再更新
            List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames);
            updatedDefinitions.remove(beanName);
            this.beanDefinitionNames = updatedDefinitions;
        }
    }
    else {
        // Still in startup registration phase
        // factory 还在启动注册阶段，可以直接移除 beanName
        this.beanDefinitionNames.remove(beanName);
    }
    this.frozenBeanDefinitionNames = null;

    // 重置 beanDefinition 缓存
    resetBeanDefinition(beanName);
}

containsBeanDefinition

1
2
3
4
public boolean containsBeanDefinition(String beanName) {
    // 判断是否在 beanDefinitionMap 中
    return this.beanDefinitionMap.containsKey(beanName);
}

getBeanDefinitionCount

1
2
3
4
public int getBeanDefinitionCount() {
    // 获取 beanDefinitionMap 的大小
    return this.beanDefinitionMap.size();
}

getBeanDefinitionNames

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public String[] getBeanDefinitionNames() {
    // 冻结所有的 BeanDefinition 后，已注册的 BeanDefinition 不能再修改
    // 也不能进行 post-processed 处理
    // 已冻结的 BeanDefinition 名字保存在 frozenBeanDefinitionNames 中
    String[] frozenNames = this.frozenBeanDefinitionNames;
    if (frozenNames != null) {
        // 返回的是副本
        return frozenNames.clone();
    }
    else {
        // 返回 beanDefinitionNames
        return StringUtils.toStringArray(this.beanDefinitionNames);
    }
}
相关文章