上一章总结到,AnnotationConfigApplicationContext提供两种方式注册bean,一是注册指定的bean,二是扫描指定的包。本章主要描述前者的过程。

注册指定的bean

    AnnotatedBeanDefinitionReader.register()向容器注册指定bean。该方法完成整个过程的调用,其总结步骤如下

  1. 解析元数据信息,如作用域
  2. 对bean定义的通用注解处理
  3. 对qualifiers数据处理
  4. 根据作用域创建代理对象
  5. 注册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
public void register(Class<?>... annotatedClasses) {
for (Class<?> annotatedClass : annotatedClasses) {
registerBean(annotatedClass);
}
}
public void registerBean(Class<?> annotatedClass) {
doRegisterBean(annotatedClass, null, null, null);
}

<T> void doRegisterBean(Class<T> annotatedClass, @Nullable Supplier<T> instanceSupplier, @Nullable String name,
@Nullable Class<? extends Annotation>[] qualifiers, BeanDefinitionCustomizer... definitionCustomizers) {
// 创建BeanDefinition的实现对象,用于封装配置信息
AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(annotatedClass);
if (this.conditionEvaluator.shouldSkip(abd.getMetadata())) {
return;
}

abd.setInstanceSupplier(instanceSupplier);
// 解析作用域,例如@Scoper("singleton")
ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd);
// 保存到BeanDefinition对象中
abd.setScope(scopeMetadata.getScopeName());
// 为bean生成名字
String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry));

// 处理通用bean定义注解,如@Lazy、@Primary
AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);
// 对@Qualifier处理,如果自动装配配置了该注解,则使用该注解名字进行装配
if (qualifiers != null) {
for (Class<? extends Annotation> qualifier : qualifiers) {
// 如果配置了@Primary,则使用该bean进行注入
if (Primary.class == qualifier) {
abd.setPrimary(true);
}
// 如果配置了@Lazy,则设置延迟加载
else if (Lazy.class == qualifier) {
abd.setLazyInit(true);
}
// 如果不是@Primary、@Lazy注解,则为bean添加自动装配时的限定符,既:根据名字进行装配
else {
abd.addQualifier(new AutowireCandidateQualifier(qualifier));
}
}
}
for (BeanDefinitionCustomizer customizer : definitionCustomizers) {
customizer.customize(abd);
}
// 将BeanDefinition封装成Holder对象,用于方便注册。
BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);
//根据bean的作用域(singleton、prototype) 创建代理对象
definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
// 像IOC注册BeanDefinition
BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);
}

解析元数据信息

    该过程由AnnotationScopeMetadataResolver.resolveScopeMetadata()实现,主要用于解析bean是原生类型(prototype)还是单例类型(singleton)。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public ScopeMetadata resolveScopeMetadata(BeanDefinition definition) {
ScopeMetadata metadata = new ScopeMetadata();
if (definition instanceof AnnotatedBeanDefinition) {
AnnotatedBeanDefinition annDef = (AnnotatedBeanDefinition) definition;
// annDef.getMetadata()在AnnotatedBeanDefinition构造中初始化的,用数组存储着bean所标注的注解,管理着所有注解和注解的值.
// 从所有的注解中获取scope的值,即@Scope注解的值
AnnotationAttributes attributes = AnnotationConfigUtils.attributesFor(
annDef.getMetadata(), this.scopeAnnotationType);
if (attributes != null) {
// 将Scope中的值保存到返回值中
metadata.setScopeName(attributes.getString("value"));
ScopedProxyMode proxyMode = attributes.getEnum("proxyMode");
if (proxyMode == ScopedProxyMode.DEFAULT) {
proxyMode = this.defaultProxyMode;
}
metadata.setScopedProxyMode(proxyMode);
}
}
return metadata;
}

处理通用注解

    这里为啥叫通用注解,我其实觉得不太合适,我就是英文直译过来的。因为在我看来通用注解不应该只包含@Lazy、@Primary、@DependsOn。或者从某个角度来说,所有注解都应该通用。不过好像除了通用能简单描述一下,好像也没有其他更合适的词了。

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
public static void processCommonDefinitionAnnotations(AnnotatedBeanDefinition abd) {
processCommonDefinitionAnnotations(abd, abd.getMetadata());
}

static void processCommonDefinitionAnnotations(AnnotatedBeanDefinition abd, AnnotatedTypeMetadata metadata) {
// 处理@Lazy注解
AnnotationAttributes lazy = attributesFor(metadata, Lazy.class);
if (lazy != null) {
abd.setLazyInit(lazy.getBoolean("value"));
} else if (abd.getMetadata() != metadata) {
// 这里我选择的这个流程,通过重载方法进来的,二者一定相等。
lazy = attributesFor(abd.getMetadata(), Lazy.class);
if (lazy != null) {
abd.setLazyInit(lazy.getBoolean("value"));
}
}

// 处理@Primary注解,标记自动装配时首选该bean
if (metadata.isAnnotated(Primary.class.getName())) {
abd.setPrimary(true);
}
// @DependsOn注解,用于标注该bean所依赖的其他bean
// 在实例化该bean之前,spring会先实例化它所依赖的bean
AnnotationAttributes dependsOn = attributesFor(metadata, DependsOn.class);
if (dependsOn != null) {
abd.setDependsOn(dependsOn.getStringArray("value"));
}

if (abd instanceof AbstractBeanDefinition) {
AbstractBeanDefinition absBd = (AbstractBeanDefinition) abd;
AnnotationAttributes role = attributesFor(metadata, Role.class);
if (role != null) {
absBd.setRole(role.getNumber("value").intValue());
}
AnnotationAttributes description = attributesFor(metadata, Description.class);
if (description != null) {
absBd.setDescription(description.getString("value"));
}
}
}

根据作用域创建代理对象

    这个方法存在的意义是为了区分使用jdk代理还是cglib代理,这里主要为引入AOP埋下伏笔,主要还是在AOP中使用。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
static BeanDefinitionHolder applyScopedProxyMode(
ScopeMetadata metadata, BeanDefinitionHolder definition, BeanDefinitionRegistry registry) {

// 刚刚所获取的元数据信息
ScopedProxyMode scopedProxyMode = metadata.getScopedProxyMode();
// 如果proxy-mode的值为NO,表示不需要代理
if (scopedProxyMode.equals(ScopedProxyMode.NO)) {
return definition;
}
// 判断设置的值是TARGET_CLASS,还是INTERFACES
boolean proxyTargetClass = scopedProxyMode.equals(ScopedProxyMode.TARGET_CLASS);
// 根据是为INTERFACES,判断使用JDK动态代理还是CGLIB来生成代理对象
return ScopedProxyCreator.createScopedProxy(definition, registry, proxyTargetClass);
}

注册BeanDefinition

    向IOC中注册BeanDefinition跟XML一样,都调用的是BeanDefinitionReaderUtils.registerBeanDefinition()。spring源码之IOC - xml - 注册BeanDefinition

总结

    整体来说,注解配置bean比XML要简单,在spring内部实现也要简单。没有复杂的xml解析过程,对应的Class属性值、id、name,都能直接获取的到,然后将其保存在BeanDefinition中,并注册IOC就完成了容器启动。