Spring源码阅读 - AnnotatedBeanDefinitionReader 的创建

1. 概述

  1. 作为AnnotationConfigApplicationContext的字段
public class AnnotationConfigApplicationContext extends GenericApplicationContext implements AnnotationConfigRegistry {

    /**
     * 注解 Class 读取器/处理器，在构造函数中创建
     * AnnotatedBeanDefinitionReader 被实例化时已经向容器注入了部分 BeanDefinition
     * 区分 BeanPostProcessor 和 BeanFactoryPostProcessor
     *
     * 从其提供的 API 来看，大致就是将一个 Class 解析为 BeanDefinition 放入 BeanFactory
     */
    private final AnnotatedBeanDefinitionReader reader;
}
  1. 当AnnotationConfigApplicationContext构造函数传入配置类/启动类时，也是通过它进行转换为BeanDefinition并注入容器
this.reader.register(componentClasses);
  1. 功能
    其类头注释为
Convenient adapter for programmatic registration of bean classes.
This is an alternative to ClassPathBeanDefinitionScanner, applying the same resolution of annotations but for explicitly registered classes only.

便于将一个Class注册到容器，类似一个 Helper 工具类，将一些功能抽出来专门作为一个类处理，单一职责。
类似于ClassPathBeanDefinitionScanner，不过这个类仅处理显式注册的类，而前者会自动在类路径下查找并注册。

2. 构造函数

BeanDefinitionRegistry 实例作为属性：registry 可看出是一个注册器，能够将 BD 注入容器，因此这个类肯定有注册类的能力
Environmet：作为属性，这个也挺重要的，但是这里也暂略

public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry) {
    this(registry, getOrCreateEnvironment(registry));
}

private static Environment getOrCreateEnvironment(BeanDefinitionRegistry registry) {
    Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
    if (registry instanceof EnvironmentCapable) {
        return ((EnvironmentCapable) registry).getEnvironment();
    }
    return new StandardEnvironment();
}

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);
    // 注册一些和处理配置类相关的 BeanDefinition
    // BeanPostProcessor 插手 Bean 的初始化过程
    // BeanFactoryPostProcessor 插手 BeanDefinition 的处理过程
    AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
}

3. EnvironmentCapable

ApplicationContext继承了这个接口，因此所有的ApplicationContext子类都有这个功能。
单一职责。

public interface EnvironmentCapable {

    /**
     * Return the {@link Environment} associated with this component.
     */
    Environment getEnvironment();

}

4. registerAnnotationConfigProcessors

AnnotatedBeanDefinitionReader 调用它向 BeanDefinitionRegistry 注入了很多配置类处理器 ConfigProcessor
org.springframework.context.annotation.AnnotationConfigUtils#registerAnnotationConfigProcessors

public static void registerAnnotationConfigProcessors(BeanDefinitionRegistry registry) {
    registerAnnotationConfigProcessors(registry, null);
}
public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
        BeanDefinitionRegistry registry, @Nullable Object source) {

    DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);
    if (beanFactory != null) {
        if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) {
            beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
        }
        if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) {
            beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());
        }
    }

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

    if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) {
        // RootBeanDefinition 表明是 Spring 自己注入的
        // 是一个 BeanFactoryPostProcessor（BeanDefinitionRegistryPostProcessor），能够插手 BeanDefinition 的处理过程
        RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
        def.setSource(source);
        beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME));
    }

    if (!registry.containsBeanDefinition(AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) {
        // 是一个 BeanPostProcessor，能够插手 Bean 的实例化过程
        RootBeanDefinition def = new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class);
        def.setSource(source);
        beanDefs.add(registerPostProcessor(registry, def, AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME));
    }

    // Check for JSR-250 support, and if present add the CommonAnnotationBeanPostProcessor.
    if (jsr250Present && !registry.containsBeanDefinition(COMMON_ANNOTATION_PROCESSOR_BEAN_NAME)) {
        // 是一个 BeanPostProcessor，能够插手 Bean 的实例化过程
        RootBeanDefinition def = new RootBeanDefinition(CommonAnnotationBeanPostProcessor.class);
        def.setSource(source);
        beanDefs.add(registerPostProcessor(registry, def, COMMON_ANNOTATION_PROCESSOR_BEAN_NAME));
    }

    // Check for JPA support, and if present add the PersistenceAnnotationBeanPostProcessor.
    if (jpaPresent && !registry.containsBeanDefinition(PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME)) {
        // 是一个 BeanPostProcessor，能够插手 Bean 的实例化过程
        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));
    }

    if (!registry.containsBeanDefinition(EVENT_LISTENER_PROCESSOR_BEAN_NAME)) {
        // 是一个 BeanFactoryPostProcessor，能够插手 BeanDefinition 的处理过程
        RootBeanDefinition def = new RootBeanDefinition(EventListenerMethodProcessor.class);
        def.setSource(source);
        beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_PROCESSOR_BEAN_NAME));
    }

    if (!registry.containsBeanDefinition(EVENT_LISTENER_FACTORY_BEAN_NAME)) {
        // 较为普通的 Bean
        RootBeanDefinition def = new RootBeanDefinition(DefaultEventListenerFactory.class);
        def.setSource(source);
        beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_FACTORY_BEAN_NAME));
    }

    return beanDefs;
}

private static BeanDefinitionHolder registerPostProcessor(
        BeanDefinitionRegistry registry, RootBeanDefinition definition, String beanName) {
    // 暂时不知道作用
    definition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
    registry.registerBeanDefinition(beanName, definition);
    return new BeanDefinitionHolder(definition, beanName);
}

注意，它上面虽然调用 unwrapDefaultListableBeanFactory 返回 DefaultListableBeanFactory，但并未强制要求，仅是一个可选项，而且仅是设置属性，而非注入 BD

5. 注入的 BD

单独 spring-context 使用 AnnotationConfigApplicationContext 时注入了那些东西呢（当使用WEB、SpringBoot时，可能还不一样）
除了JPA的那个，其他都注入了
image

  1. ConfigurationClassPostProcessor
    继承 BeanDefinitionRegistryPostProcessor 可用于注册 BD。
    处理配置类的，能够处理@ComponentScan、@Import等等注解。
    BeanFactoryPostProcessor 可用于处理 BD。
    继承 PriorityOrdered 但是 LOWEST_PRECEDENCE，也即排序优先级最高，但是在继承 PriorityOrdered 的类中优先级又最低。
    这是一个及其核心和重要的类，由 Readre 默认注册了。

  2. AutowiredAnnotationBeanPostProcessor
    继承 BeanPostProcessor，参与类的实例化过程。
    处理的注解：@Autowire、@Value、@Inject、@Lookup，前两个是最常用的和主要的。

  3. CommonAnnotationBeanPostProcessor
    继承 BeanPostProcessor，参与类的实例化过程。
    处理生命周期注解 @PostConstructor、@PreDestroy。
    处理Java本身提供的注解而非Spring提供的：@Resource。等等

  4. EventListenerMethodProcessor
    是一个 BeanFactoryPostProcessor，参与 BD 的生成，可处理/修改已注册进入容器的BD。
    处理 @EventListener 注解的方法。

  5. DefaultEventListenerFactory
    生成 ApplicationListener 的工厂。
    暂时不知道作用。

posted @ 2022-04-08 21:38  YangDanMua  阅读(155)  评论(0)  编辑  收藏  举报