Spring源码阅读:BeanDefinitionRegistry接口

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);
}
}
0%