SpringBoot启动流程分析4--run方法之createApplicationContext()方法

fanderboy

已于 2024-01-04 20:13:49 修改

阅读量1k

点赞数 24

CC 4.0 BY-SA版权

分类专栏： # SpringBoot启动流程分析文章标签： spring boot java 后端

于 2024-01-04 19:53:30 首次发布

本文链接：https://blog.youkuaiyun.com/fanderboy/article/details/135392013

SpringBoot启动流程分析专栏收录该内容

11 篇文章

订阅专栏

SpringBoot启动流程分析4–run方法之createApplicationContext()方法

一、概述

源码基于SpringBoot 2.7.xx版本

1.1 简介

根据web的类型使用ApplicationContextFactory进行创建应用上下文–ConfigurableApplicationContext。

对于后面的所有操作都是以该应用上下文为准，包括@Bean、@Component、@ComponentScan等等。
该方法创建了AnnotationConfigServletWebServerApplicationContext类，也就是所说的应用上下文ApplicationContext，
同时也触发了GenericApplicationContext类的构造函数，从而IoC容器–DefaultListableBeanFactory也创建了。

ApplicationContext 就是我们熟悉的应用上下文(也有人称之为容器，都可以，看个人爱好和理解)
DefaultListableBeanFactory 就是我们所说的IoC容器的真实面孔了。

细细感受下上下文和容器的联系和区别，对于我们理解源码有很大的帮助。在系列文章中，我们也是将应用上下文和IoC容器严格区分开来的。

1.2 名词解释

应用上下文–ApplicationContext
可以理解成IoC容器的高级表现形式，应用上下文确实是在IoC容器的基础上丰富了一些高级功能。
IoC容器–DefaultListableBeanFactory
应用上下文有一个属性beanFactory，就是IoC容器–DefaultListableBeanFactory，他们之间是持有和扩展的关系。

二、详解

2.1 根据应用类型创建应用上下文

public class SpringApplication {

    protected ConfigurableApplicationContext createApplicationContext() {
        // 根据web的类型使用进行创建ApplicationContext
        return this.applicationContextFactory.create(this.webApplicationType);
    }
}

和创建应用上下文环境类似，创建应用上下文根据webApplicationType进行创建

class DefaultApplicationContextFactory implements ApplicationContextFactory {

    @Override
    public ConfigurableApplicationContext create(WebApplicationType webApplicationType) {
        try {
            return getFromSpringFactories(webApplicationType, ApplicationContextFactory::create,
                    AnnotationConfigApplicationContext::new);
        } catch (Exception ex) {
            throw new IllegalStateException("Unable create a default ApplicationContext instance, "
                    + "you may need a custom ApplicationContextFactory", ex);
        }
    }

    private <T> T getFromSpringFactories(WebApplicationType webApplicationType,
                                         BiFunction<ApplicationContextFactory, WebApplicationType, T> action, Supplier<T> defaultResult) {
        // ApplicationContextFactory默认加载的实现类为
        // AnnotationConfigReactiveWebServerApplicationContext.Factory
        // AnnotationConfigServletWebServerApplicationContext.Factory
        // 根据webApplicationType创建为AnnotationConfigServletWebServerApplicationContext
        org.springframework.boot.web.servlet.context.AnnotationConfigServletWebServerApplicationContext.Factory
        for (ApplicationContextFactory candidate : SpringFactoriesLoader.loadFactories(ApplicationContextFactory.class,
                getClass().getClassLoader())) {
            T result = action.apply(candidate, webApplicationType);
            if (result != null) {
                return result;
            }
        }
        return (defaultResult != null) ? defaultResult.get() : null;
    }
}

spring.factories的配置：

# Application Context Factories
org.springframework.boot.ApplicationContextFactory=\
org.springframework.boot.web.reactive.context.AnnotationConfigReactiveWebServerApplicationContext.Factory,\
org.springframework.boot.web.servlet.context.AnnotationConfigServletWebServerApplicationContext.Factory

2.2 创建应用上下文详解

创建应用上下文–AnnotationConfigServletWebServerApplicationContext

public class AnnotationConfigServletWebServerApplicationContext extends ServletWebServerApplicationContext
        implements AnnotationConfigRegistry {

    private final AnnotatedBeanDefinitionReader reader;

    private final ClassPathBeanDefinitionScanner scanner;

    // 创建ApplicationContext，会调用父类构造器GenericApplicationContext()创建IoC容器--DefaultListableBeanFactory
    public AnnotationConfigServletWebServerApplicationContext() {
        // 创建AnnotatedBeanDefinitionReader时会将一些BeanFactoryPostProcessor、BeanPostProcessor、ListenerFactory注册
        // 进beanFactory中的beanDefinitionMap中,例如比较重要的ConfigurationClassPostProcessor、DefaultEventListenerFactory
        this.reader = new AnnotatedBeanDefinitionReader(this);
        this.scanner = new ClassPathBeanDefinitionScanner(this);
    }
}

创建IoC容器–DefaultListableBeanFactory

AnnotationConfigServletWebServerApplicationContext --> ServletWebServerApplicationContext -->
GenericWebApplicationContext

public class GenericApplicationContext extends AbstractApplicationContext implements BeanDefinitionRegistry {

    private final DefaultListableBeanFactory beanFactory;

    // 创建IoC容器--DefaultListableBeanFactory
    public GenericApplicationContext() {
        this.beanFactory = new DefaultListableBeanFactory();
    }
}

创建AnnotatedBeanDefinitionReader

AnnotationConfigServletWebServerApplicationContext --> AnnotatedBeanDefinitionReader

public class 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);
        // 注入注解相关的后置处理器
        AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
    }
}

注入注解相关的后置处理器–ConfigurationClassPostProcessor、AutowiredAnnotationBeanPostProcessor、CommonAnnotationBeanPostProcessor、
EventListenerMethodProcessor

注入DefaultEventListenerFactory

AnnotationConfigServletWebServerApplicationContext --> AnnotatedBeanDefinitionReader --> AnnotationConfigUtils

public abstract class AnnotationConfigUtils {

    /**
     * The bean name of the internally managed Configuration annotation processor.
     */
    public static final String CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME =
            "org.springframework.context.annotation.internalConfigurationAnnotationProcessor";

    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);

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

        // 注册内部管理的用于处理@Autowired，@Value,@Inject以及@Lookup注解的后置处理器beanDefinition
        // AutowiredAnnotationBeanPostProcessor
        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.
        // 注册内部管理的用于处理JSR-250注解，例如@Resource,@PostConstruct,@PreDestroy的后置处理器beanDefinition
        // 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.
        // 注册内部管理的用于处理JPA注解的后置处理器beanDefinition
        // 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));
        }
        // 注册内部管理的用于处理@EventListener注解的后置处理器的beanDefinition
        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));
        }

        // 注册内部管理用于生产ApplicationListener对象的EventListenerFactory的beanDefinition
        // DefaultEventListenerFactory
        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;
    }
}

AnnotationConfigUtils.registerAnnotationConfigProcessors导入了四个后置处理器及一个ListenerFactory：

ConfigurationClassPostProcessor：beanName为internalConfigurationAnnotationProcessor用于处理@configuration注解的后置处理器的bean
AutowiredAnnotationBeanPostProcessor：beanName为internalAutowiredAnnotationProcessor用于处理@Autowired，@Value,@Inject以及
@Lookup注解的后置处理器bean
CommonAnnotationBeanPostProcessor：beanName为internalCommonAnnotationProcessor用于处理JSR-250注解，例如@Resource,
@PostConstruct,@PreDestroy的后置处理器bean
EventListenerMethodProcessor：beanName为internalEventListenerProcessor用于处理@EventListener注解的后置处理器的bean
DefaultEventListenerFactory：beanName为internalEventListenerFactory管理用于生产ApplicationListener对象的EventListenerFactory对象