Spring5源码解析1从启动容器开始

共计 6171 个字符，预计需要花费 16 分钟才能阅读完成。

最简单的启动 spring 的代码如下：

@Configuration
@ComponentScan
public class AppConfig {
}

public class Main {public static void main(String[] args) {
        AnnotationConfigApplicationContext context =
                new AnnotationConfigApplicationContext(AppConfig.class);
        context.close();}
}

先来看一下 AnnotationConfigApplicationContext 类的 UML 图，留个印象。

点开 AnnotationConfigApplicationContext(AppConfig.class); 方法查看源码：

public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
    // 调用默认无参构造器, 里面有一大堆初始化逻辑
    this();

    // 把传入的 Class 进行注册,Class 既可以有 @Configuration 注解, 也可以没有 @Configuration 注解
    // 怎么注册? 委托给了 org.springframework.context.annotation.AnnotatedBeanDefinitionReader.register 方法进行注册
    // 传入 Class 生成  BeanDefinition , 然后通过 注册到 BeanDefinitionRegistry
    register(annotatedClasses);

    // 刷新容器上下文
    refresh();}

该构造器允许我们传入一个或者多个 class 对象。class 对象可以是被 @Configuration 标注的，也可以是一个普通的 Java 类。

有参构造器调用了无参构造器，点开源码：

public AnnotationConfigApplicationContext() {
    // 隐式调用父类构造器, 初始化 beanFactory, 具体实现类为 DefaultListableBeanFactory
    super(); // 这个代码是笔者添加的，方便定位到 super 方法

    // 创建 AnnotatedBeanDefinitionReader,
    // 创建时会向传入的 BeanDefinitionRegistry 中 注册 注解配置相关的 processors 的 BeanDefinition
    this.reader = new AnnotatedBeanDefinitionReader(this);

    this.scanner = new ClassPathBeanDefinitionScanner(this);
}

初始化子类时会先初始化父类，会默认调用父类无参构造器。AnnotationConfigApplicationContext继承了 GenericApplicationContext，在GenericApplicationContext 的无参构造器中，创建了 BeanFactory 的具体实现类 DefaultListableBeanFactory。spring 中的BeanFactory 就是在这里被实例化的，并且使用 DefaultListableBeanFactory 做的 BeanFactory 的默认实现。

public GenericApplicationContext() {this.beanFactory = new DefaultListableBeanFactory();
}

AnnotationConfigApplicationContext的构造器中还创建了两个对象：AnnotatedBeanDefinitionReader 和 ClassPathBeanDefinitionScanner。

先说 scanner 的作用，通过查看源码可以发现，这个 scanner 只有在手动调用 AnnotationConfigApplicationContext 的一些方法的时候才会被使用（通过后面的源码探究也可以发现，spring 并不是使用这个 scanner 来扫描包获取 Bean 的）。

创建 AnnotatedBeanDefinitionReader 对象。spring 在创建 reader 的时候把 this 当做了参数传给了构造器。也就是说，reader对象里面包含了一个 this 对象，也就是 AnnotationConfigApplicationContext 对象。AnnotationConfigApplicationContext 实现了 BeanDefinitionRegistry 接口。点开 this.reader = new AnnotatedBeanDefinitionReader(this); 源码：

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

从传入的 BeanDefinitionRegistry 对象，也就是 AnnotationConfigApplicationContext 对象中获取Environment（共用同一个Environment），然后又接着调用另一个构造器。点开源码：

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);
    // 在 BeanDefinitionRegistry 中注册 注解配置相关的 processors
    AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
}

在这个构造器中，执行了一个非常重要的方法AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);，顾名思义，spring 通过这个方法注册了解析注解配置相关的处理器。点开源码：

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)) {
        //org.springframework.context.annotation.internalConfigurationAnnotationProcessor - ConfigurationClassPostProcessor.class
        // 这个类非常的重要, 它是一个 BeanDefinitionRegistryPostProcessor
        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)) {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)) {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)) {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)) {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)) {RootBeanDefinition def = new RootBeanDefinition(DefaultEventListenerFactory.class);
        def.setSource(source);
        beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_FACTORY_BEAN_NAME));
    }

    return beanDefs;
}

该方法从传入的 BeanDefinitionRegistry 对象，也就是 AnnotationConfigApplicationContext 对象中获取到 DefaultListableBeanFactory 对象。
为获取的 DefaultListableBeanFactory 对象设置属性
往 DefaultListableBeanFactory 对象中注册 BeanDefinition，注册的是一些 spring 内置的 PostProcessor 的BeanDefinition（关于BeanDefinition 的介绍下期在讲）。注意，此时只是注册 BeanDefinition，并没有实例化 bean。默认情况下，执行完该方法后，spring 容器中所注册的BeanDefinition 为：

源码学习笔记：https://github.com/shenjianen…

欢迎关注公众号：

从启动容器开始

Just My Socks（注册教程 内含优惠码）

Just My Socks（注册教程内含优惠码）