抱歉，您的浏览器无法访问本站
本页面需要浏览器支持（启用）JavaScript
了解详情 >

SpringIOC-20-AnnotationConfigApplicationContext流程

源码springIOCAnnotationConfigApplicationContext

发布于：2020年1月13日

次浏览

SpringIOC-AnnotationConfigApplicationContext流程

前言

​ 上面已经讲解了整个基于XML的IOC流程，下面介绍一下基于AnnotationConfigApplicationContext纯注解方式的使用Spring框架

使用方式

入口

1
AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(SpringApplicationContextInitializer.class);

配置类

SpringApplicationContextInitializer

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
@Configuration
@ComponentScan("com.test")
public class SpringApplicationContextInitializer implements
        ApplicationContextInitializer<ConfigurableApplicationContext> {
    @Override
    public void initialize(ConfigurableApplicationContext applicationContext) {
        // 自己的逻辑实现

        // 例子1：通过硬编码的方式添加监听器
        MyRefreshedListener earlyListener = new MyRefreshedListener();
        applicationContext.addApplicationListener(earlyListener);

        // 例子2：通过硬编码的方式添加BeanFactoryPostProcessor
        MyBeanFactoryPostProcessor myBeanFactoryPostProcessor = new MyBeanFactoryPostProcessor();
        applicationContext.addBeanFactoryPostProcessor(myBeanFactoryPostProcessor);
    }
}

源码分析

构造方法

通过new AnnotationConfigApplicationContext()进入构造方法

1
2
3
4
5
6
7
public AnnotationConfigApplicationContext(Class<?>... componentClasses) {
    //进行初始化需要看
    this();
    //注册配置类
    register(componentClasses);
    refresh();
}
this()方法

调用父类的构造方法

1
2
3
4
5
6
public AnnotationConfigApplicationContext() {
    //创建注解解析器 里面有一个重点 注册注解的ConfigProcessors
    this.reader = new AnnotatedBeanDefinitionReader(this);
    //创建扫描器
    this.scanner = new ClassPathBeanDefinitionScanner(this);
}
创建注解解析器
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
public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry) {
    //创建AnnotatedBeanDefinitionReader，并注册注解的ConfigProcessors
    this(registry, getOrCreateEnvironment(registry));
}

/**
 * 创建AnnotatedBeanDefinitionReader
 *
 */
public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry, Environment environment) {
    Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
    Assert.notNull(environment, "Environment must not be null");
    this.registry = registry;
    this.conditionEvaluator = new ConditionEvaluator(registry, environment, null);
    //注册注解的ConfigProcessors
    AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
}

/**
 * Register all relevant annotation post processors in the given registry.
 * 注册配置类的解析器
 */
public static void registerAnnotationConfigProcessors(BeanDefinitionRegistry registry) {
    //注册注解的解析器
    registerAnnotationConfigProcessors(registry, null);
}
registerAnnotationConfigProcessors

注册配置类的解析器

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
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
/**
 * Register all relevant annotation post processors in the given registry.
 * 注册配置类的解析器
 */
public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
    BeanDefinitionRegistry registry, @Nullable Object source) {

    DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);
    if (beanFactory != null) {
        if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) {
            // 1.设置dependencyComparator属性
            beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
        }
        if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) {
            // 2.设置autowireCandidateResolver属性（设置自动注入候选对象的解析器，用于判断BeanDefinition是否为候选对象）
            beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());
        }
    }

    Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<>(8);

    // 3.注册内部管理的用于处理@Configuration注解的后置处理器的bean
    //注册@Configuration 解析类
    if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) {
        //将ConfigurationClassPostProcessor转换为BeanDefinition
        //该类非常重要，解决了@Configuration,@Component，@ComponentScan，@Import，@ImportResource，@Bean注解的扫描以及注册BeanDefinition
        RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
        def.setSource(source);
        // 3.1 registerPostProcessor: 注册BeanDefinition到注册表中
        //注册BeanDefinition并返回创建的BeanDefinitionHolder
        beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME));
    }

    // 4.注册内部管理的用于处理@Autowired、@Value、@Inject以及@Lookup注解的后置处理器的bean
    //注册@Autowired 解析类
    if (!registry.containsBeanDefinition(AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) {
        //将AutowiredAnnotationBeanPostProcessor转换为BeanDefinition
        RootBeanDefinition def = new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class);
        def.setSource(source);
        //注册BeanDefinition并返回创建的BeanDefinitionHolder
        beanDefs.add(registerPostProcessor(registry, def, AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME));
    }


    /**
		 * 注册公共注解的解析类
		 * Common注解包括
		 *    @Resource
		 *    @PostConstruct
		 *    @PreDestroy
		 */

    // 6.注册内部管理的用于处理JSR-250注解（例如@Resource, @PostConstruct, @PreDestroy）的后置处理器的bean
    // Check for JSR-250 support, and if present add the CommonAnnotationBeanPostProcessor.
    if (jsr250Present && !registry.containsBeanDefinition(COMMON_ANNOTATION_PROCESSOR_BEAN_NAME)) {
        RootBeanDefinition def = new RootBeanDefinition(CommonAnnotationBeanPostProcessor.class);
        def.setSource(source);
        beanDefs.add(registerPostProcessor(registry, def, COMMON_ANNOTATION_PROCESSOR_BEAN_NAME));
    }

    // 7.注册内部管理的用于处理JPA注解的后置处理器的bean
    // Check for JPA support, and if present add the PersistenceAnnotationBeanPostProcessor.
    if (jpaPresent && !registry.containsBeanDefinition(PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME)) {
        RootBeanDefinition def = new RootBeanDefinition();
        try {
            def.setBeanClass(ClassUtils.forName(PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME,
                                                AnnotationConfigUtils.class.getClassLoader()));
        } catch (ClassNotFoundException ex) {
            throw new IllegalStateException(
                "Cannot load optional framework class: " + PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME, ex);
        }
        def.setSource(source);
        beanDefs.add(registerPostProcessor(registry, def, PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME));
    }

    // 8.注册内部管理的用于处理@EventListener注解的后置处理器的bean
    if (!registry.containsBeanDefinition(EVENT_LISTENER_PROCESSOR_BEAN_NAME)) {
        RootBeanDefinition def = new RootBeanDefinition(EventListenerMethodProcessor.class);
        def.setSource(source);
        beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_PROCESSOR_BEAN_NAME));
    }

    // 9.注册内部管理用于生产ApplicationListener对象的EventListenerFactory对象
    if (!registry.containsBeanDefinition(EVENT_LISTENER_FACTORY_BEAN_NAME)) {
        RootBeanDefinition def = new RootBeanDefinition(DefaultEventListenerFactory.class);
        def.setSource(source);
        beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_FACTORY_BEAN_NAME));
    }

    return beanDefs;
}

在这一步有一个重要的代码完成了对ConfigurationClassPostProcessor类向BeanDefinition的注册,BeanName是internalConfigurationAnnotationProcessor。

注册配置类

register
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
/**
 * 进行配置类的注册
 */
@Override
public void register(Class<?>... componentClasses) {
    Assert.notEmpty(componentClasses, "At least one component class must be specified");
    //用注解解析器来注册componentClasses
    this.reader.register(componentClasses);
}

public void register(Class<?>... componentClasses) {
    for (Class<?> componentClass : componentClasses) {
        //注册配置类
        registerBean(componentClass);
    }
}

public void registerBean(Class<?> beanClass) {
    doRegisterBean(beanClass, null, null, null, null);
}
doRegisterBean

注册配置类

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
private <T> void doRegisterBean(Class<T> beanClass, @Nullable String name,
                                @Nullable Class<? extends Annotation>[] qualifiers, @Nullable Supplier<T> supplier,
                                @Nullable BeanDefinitionCustomizer[] customizers) {
    //1. 将配置类转换为BeanDefinition
    AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(beanClass);
    if (this.conditionEvaluator.shouldSkip(abd.getMetadata())) {
        return;
    }

    abd.setInstanceSupplier(supplier);
    ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd);
    abd.setScope(scopeMetadata.getScopeName());
    //获取或生成BeanName
    String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry));
    //2. 解析BeanDefinition
    AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);
    //3. 对相关注解的支撑
    if (qualifiers != null) {
        for (Class<? extends Annotation> qualifier : qualifiers) {
            if (Primary.class == qualifier) {
                abd.setPrimary(true);
            } else if (Lazy.class == qualifier) {
                abd.setLazyInit(true);
            } else {
                abd.addQualifier(new AutowireCandidateQualifier(qualifier));
            }
        }
    }
    if (customizers != null) {
        for (BeanDefinitionCustomizer customizer : customizers) {
            customizer.customize(abd);
        }
    }
    //4. 创建BeanDefinitionHolder
    BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);
    definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
    //5. 将definitionHolder进行注册
    BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);
}

到这一步完成了对配置类的注册

刷新流程

刷新流程（refresh方法）和xml的流程是一样的，只是在注册阶段，xml方式将配置的都注册到了BeanDefinition中了，但是注解方式启动时只注册了ConfigurationClassPostProcessor以及自定义的配置类SpringApplicationContextInitializer。

invokeBeanFactoryPostProcessors

这个方法主要完成使用ConfigurationClassPostProcessor类对自定义注解的解析

下一篇博客我们来介绍下这个类

博客内容遵循 署名-非商业性使用-相同方式共享 4.0 国际 (CC BY-NC-SA 4.0) 协议

本文永久链接是：http://www.baiyp.ren/SpringIOC-20-AnnotationConfigApplicationContext%E6%B5%81%E7%A8%8B.html

更新于：2020年3月17日

源码

spring

IOC

AnnotationConfigApplicationContext

评论