SpringBoot源码解析:SpringBoot怎么创建Spring应用上下文/容器

本文是基于springboot2.1.6 RELEASE源码解析

本文主要介绍了一下SpringBoot怎么创建spring应用上下文，没有详细介绍流程，主要是为了让读者便于理解后续博文做一个简单介绍（后续需要再做完整源码解析补充）。

1. 构造SpringApplication

1. 简单看一下构造方法

   public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
       this.resourceLoader = resourceLoader;
       Assert.notNull(primarySources, "PrimarySources must not be null");
       this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
       //我们可以webApplicationType怎么初始化的，此处就不深入了，可以看到返回的是WebApplicationType.SERVLET
       this.webApplicationType = WebApplicationType.deduceFromClasspath();
       setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
       setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
       this.mainApplicationClass = deduceMainApplicationClass();
   }
   

2. 创建应用上下文ApplicationContext，注册解析Bean的BeanPostProcessor

1. ConfigurationClassPostProcessor，AutowiredAnnotationBeanPostProcessor是springboot启动是创建应用上下文ApplicationContext时注册的。我们可以看看：

   SpringApplication.run

   public ConfigurableApplicationContext run(String... args) {
   
       //就是此处跟进去
       context = createApplicationContext();
   
       //刷新应用上下文
       refreshContext(context);
       return context;
   }
   
   public static final String DEFAULT_SERVLET_WEB_CONTEXT_CLASS = "org.springframework.boot."
       + "web.servlet.context.AnnotationConfigServletWebServerApplicationContext";
   
   protected ConfigurableApplicationContext createApplicationContext() {
       Class<?> contextClass = this.applicationContextClass;
       if (contextClass == null) {
           try {
               switch (this.webApplicationType) {
                   case SERVLET:
                       
                       contextClass = Class.forName(DEFAULT_SERVLET_WEB_CONTEXT_CLASS);
                       break;
                   case REACTIVE:
                       contextClass = Class.forName(DEFAULT_REACTIVE_WEB_CONTEXT_CLASS);
                       break;
                   default:
                       contextClass = Class.forName(DEFAULT_CONTEXT_CLASS);
               }
           }
           catch (ClassNotFoundException ex) {
   
           }
       }
       
       //上面webApplicationType=SERVLET，创建的是AnnotationConfigServletWebServerApplicationContext，通过反射装载
       return (ConfigurableApplicationContext) BeanUtils.instantiateClass(contextClass);
   }
   

2. 从上面我们知道要创建AnnotationConfigServletWebServerApplicationContext。我们就看看AnnotationConfigServletWebServerApplicationContext的构造方法

   public AnnotationConfigServletWebServerApplicationContext() {
       //创建AnnotatedBeanDefinitionReader，跟进去看看
       this.reader = new AnnotatedBeanDefinitionReader(this);
       this.scanner = new ClassPathBeanDefinitionScanner(this);
   }
   

3. AnnotatedBeanDefinitionReader

   public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry) {
       this(registry, getOrCreateEnvironment(registry));
   }
   
   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);
       //在此处，我们会看到会注册一些BeanPostProcessor，进去看看
       AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
   }
   

4. AnnotationConfigUtils。就是在创建应用上下文时创建一系列BeanPostProcessor

   public static void registerAnnotationConfigProcessors(BeanDefinitionRegistry registry) {
       registerAnnotationConfigProcessors(registry, null);
   }
   
   public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
       BeanDefinitionRegistry registry, @Nullable Object source) {
   
       DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);
       //设置@AutoWired，@Value解析器ContextAnnotationAutowireCandidateResolver
       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);
   
       //创建ConfigurationClassPostProcessor，用于解析Configuration类
       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));
       }
   
       //创建AutowiredAnnotationBeanPostProcessor，用于Autowired注入，Value注入
       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));
       }
   
       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));
       }
   
       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;
   }
   

3. 刷新应用上下文

1. SpringApplication.refreshContext

   private void refreshContext(ConfigurableApplicationContext context) {
       refresh(context);
       if (this.registerShutdownHook) {
           try {
               context.registerShutdownHook();
           }
           catch (AccessControlException ex) {
               // Not allowed in some environments.
           }
       }
   }
   
   protected void refresh(ApplicationContext applicationContext) {
       Assert.isInstanceOf(AbstractApplicationContext.class, applicationContext);
       //进去此处，我们应该会很熟悉，就是spring的刷新应用上下文，实例化相应的bean，在此不再介绍。AbstractApplicationContext是spring ioc/aop的关键类，每个读过spring源码的人都很清晰。
       ((AbstractApplicationContext) applicationContext).refresh();
   }