每日一课 | Spring Boot 启动原理-01

我会带着你远行 2022-10-10 06:12 163阅读 0赞

![e70256c37ff0db5c114b6244faac7595.png][]

**04****.**

Spring Boot启动原理-01

大家好，我我是营长，上期给大家分享——[**Spring Boot 搭建复杂的系统框架-02**][Spring Boot _-02]

本期分享内容：**Spring Boot 启动原理-01**

本期邀请的是李熠老师（某大型互联网公司系统架构师）为我们分享《Spring Cloud快速入门》专栏。

**Spring  Cloud**

**Spring Boot启动原理**

Spring Boot 大大简化了我们的开发配置，节省了大量的时间，确实比较方便。但是对于新手来说，如果不了解个中原理，难免会遇到坑。

本文作者将带领大家走近神秘的 Spring Boot，一步步破开它的神秘面纱，探索 Spring Boot 的启动原理。

开发任何基于 Spring Boot 的项目，我们都会使用以下的启动类：

import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    
    @SpringBootApplication
    public class Application {
    
        public static void main(String[] args) {
            SpringApplication.run(Application.class, args);
        }
    }

可以看到，Application 类中定义了注解 @SpringBootApplication，main 方法里通过 SpringApplication.run 来启动整个应用程序。因此要研究 Spring Boot 的启动原理，我们就需要从这两个地方入手。

### **强大的 SpringBootApplication** ###

首先，我们先来看看 SpringBootApplication 源码是怎么定义这个注解的：

/**
     * Indicates a {@link Configuration configuration} class that declares one or more
     * {@link Bean @Bean} methods and also triggers {@link EnableAutoConfiguration
     * auto-configuration} and {@link ComponentScan component scanning}. This is a convenience
     * annotation that is equivalent to declaring {@code @Configuration},
     * {@code @EnableAutoConfiguration} and {@code @ComponentScan}.
     *
     * @author Phillip Webb
     * @author Stephane Nicoll
     * @since 1.2.0
     */
    @Target(ElementType.TYPE)
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    @Inherited
    @SpringBootConfiguration
    @EnableAutoConfiguration
    @ComponentScan(excludeFilters = {
        @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
        @Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
    public @interface SpringBootApplication {
    
      /**
       * Exclude specific auto-configuration classes such that they will never be applied.
       * @return the classes to exclude
       */
      @AliasFor(annotation = EnableAutoConfiguration.class, attribute = "exclude")
      Class<?>[] exclude() default {};
    
      /**
       * Exclude specific auto-configuration class names such that they will never be
       * applied.
       * @return the class names to exclude
       * @since 1.3.0
       */
      @AliasFor(annotation = EnableAutoConfiguration.class, attribute = "excludeName")
      String[] excludeName() default {};
    
      /**
       * Base packages to scan for annotated components. Use {@link #scanBasePackageClasses}
       * for a type-safe alternative to String-based package names.
       * @return base packages to scan
       * @since 1.3.0
       */
      @AliasFor(annotation = ComponentScan.class, attribute = "basePackages")
      String[] scanBasePackages() default {};
    
      /**
       * Type-safe alternative to {@link #scanBasePackages} for specifying the packages to
       * scan for annotated components. The package of each class specified will be scanned.
       * <p>
       * Consider creating a special no-op marker class or interface in each package that
       * serves no purpose other than being referenced by this attribute.
       * @return base packages to scan
       * @since 1.3.0
       */
      @AliasFor(annotation = ComponentScan.class, attribute = "basePackageClasses")
      Class<?>[] scanBasePackageClasses() default {};
    
    }

可以看到，除了最基础的注解外，还增加了三个 @SpringBootConfiguration、@EnableAutoConfiguration、@ComponentScan。因此，正如上一篇所讲的一样，我们将 SpringBootApplication 替换成这三个注解也是相同的效果：

import org.springframework.boot.SpringApplication;
    import org.springframework.boot.SpringBootConfiguration;
    import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
    import org.springframework.context.annotation.ComponentScan;
    
    @SpringBootConfiguration
    @EnableAutoConfiguration
    @ComponentScan
    public class Application {
    
        public static void main(String[] args) {
            SpringApplication.run(Application.class, args);
        }
    }

每次我们都写这三个注解比较麻烦，因此我们只写 @SpringBootApplication 就行了。

下面，我们分别来介绍这三个注解。

#### **SpringBootConfiguration** ####

我们先来看看它的源码：

import java.lang.annotation.Documented;
    import java.lang.annotation.ElementType;
    import java.lang.annotation.Retention;
    import java.lang.annotation.RetentionPolicy;
    import java.lang.annotation.Target;
    import org.springframework.context.annotation.Configuration;
    
    @Target({ElementType.TYPE})
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    @Configuration
    public @interface SpringBootConfiguration {
    }

它其实就是一个 Configuration，但是 Spring Boot 推荐用 SpringBootConfiguration 来代替 Configuration。

Spring Boot 社区推荐使用 JavaConfig 配置，所以要用到 @Configuration。

我们先来看看 SpringMVC 基于 XML 是如何配置的：

<?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd"
           default-lazy-init="true">
        
    </beans>

而 JavaConfig 的配置是这样的：

import org.springframework.boot.SpringBootConfiguration;
    
    @SpringBootConfiguration
    public class WebConfig {
        //bean定义
    }

任何标注了 SpringBootConfiguration 或 Configuration 的类都是一个 JavaConfig。

我们再来看看基于 XML 的 Bean 是如何定义的：

而 JavaConfig 的配置是这样的：

import org.springframework.boot.SpringBootConfiguration;
    
    @SpringBootConfiguration
    public class WebConfig {
        //bean定义
        @Bean
        public Service service(){
        return new ServiceImpl();
      }
    }

任何标注了 Bean 的方法都被定义为一个 Bean，我们可以在任何 Spring 的 IoC 容器中注入进去。

#### **EnableAutoConfiguration** ####

这个注解尤为重要，它的作用是自动将 JavaConfig 中的 Bean 装载到 IoC 容器中。

通过分析其源码，我们就能分析出其原理，它的源码如下：

@Target(ElementType.TYPE)
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    @Inherited
    @AutoConfigurationPackage
    @Import(AutoConfigurationImportSelector.class)
    public @interface EnableAutoConfiguration {
    
      String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";
    
      /**
       * Exclude specific auto-configuration classes such that they will never be applied.
       * @return the classes to exclude
       */
      Class<?>[] exclude() default {};
    
      /**
       * Exclude specific auto-configuration class names such that they will never be
       * applied.
       * @return the class names to exclude
       * @since 1.3.0
       */
      String[] excludeName() default {};
    
    }

我们注意到该注解引入了 @AutoConfigurationPackage 注解，通过其字面意思，就知道它的作用是自动配置 Package，即它会默认配置启动类所在包及其子包下的所有标注了 Configuration 注解的类。

而以上注解使用 @Import 注解，该注解的作用是自动执行该注解指定的类。在上述注解中，其导入了 AutoConfigurationImportSelector 类，通过其类名就知道该类的作用是自动配置选择器，因此，我们使用了 @EnableAutoConfiguration 注解后，它就会自动执行 AutoConfigurationImportSelector 类，最终会调用哪个方法呢？请看它的源码：

@Override
    public Class<? extends Group> getImportGroup() {
      return AutoConfigurationGroup.class;
    }

程序启动后，只要标注了 @EnableAutoConfiguration 注解，那么最后会调用 getImportGroup 方法，它返回的是一个 Group 对象。而上述代码中 AutoConfigurationGroup 继承的是 Group 接口，通过查看 Group 源码得知，Group 接口被定义在 DeferredImportSelector 接口中，继续查看 AutoConfigurationGroup 类的代码，我们发现以下源码：

@Override
        public void process(AnnotationMetadata annotationMetadata,
            DeferredImportSelector deferredImportSelector) {
          Assert.state(
              deferredImportSelector instanceof AutoConfigurationImportSelector,
              () -> String.format("Only %s implementations are supported, got %s",
                  AutoConfigurationImportSelector.class.getSimpleName(),
                  deferredImportSelector.getClass().getName()));
          AutoConfigurationEntry autoConfigurationEntry = ((AutoConfigurationImportSelector) deferredImportSelector)
              .getAutoConfigurationEntry(getAutoConfigurationMetadata(),
                  annotationMetadata);
          this.autoConfigurationEntries.add(autoConfigurationEntry);
          for (String importClassName : autoConfigurationEntry.getConfigurations()) {
            this.entries.putIfAbsent(importClassName, annotationMetadata);
          }
        }
    
    @Override
        public Iterable<Entry> selectImports() {
          if (this.autoConfigurationEntries.isEmpty()) {
            return Collections.emptyList();
          }
          Set<String> allExclusions = this.autoConfigurationEntries.stream()
              .map(AutoConfigurationEntry::getExclusions)
              .flatMap(Collection::stream).collect(Collectors.toSet());
          Set<String> processedConfigurations = this.autoConfigurationEntries.stream()
              .map(AutoConfigurationEntry::getConfigurations)
              .flatMap(Collection::stream)
              .collect(Collectors.toCollection(LinkedHashSet::new));
          processedConfigurations.removeAll(allExclusions);
    
          return sortAutoConfigurations(processedConfigurations,
              getAutoConfigurationMetadata())
                  .stream()
                  .map((importClassName) -> new Entry(
                      this.entries.get(importClassName), importClassName))
                  .collect(Collectors.toList());
        }

也就是说最终会自动执行 process 和 selectImports 方法。

可以注意到 autoConfigurationEntry.getConfigurations()，它就是获取所有标注了 @Configuration 注解的类，并加入到 Map 中。

需要注意的是，AutoConfigurationImportSelector 类实现的是 DeferredImportSelector 接口，而 process 是 DeferredImportSelector.Group 接口定义的方法。

#### **ComponentScan** ####

这个注解的作用是自动扫描并加载符合条件的组件（如：Component、Bean 等），我们可以通过 basePakcages 来指定其扫描的范围，如果不指定，则默认从标注了 @ComponentScan 注解的类所在包开始扫描。如下代码：

@ComponentScan(basePackages = "com.lynn")

因此，Spring Boot 的启动类最好放在 root package 下面，因为默认不指定 basePackages，这样能保证扫描到所有包。

以上只是从表面来研究 Spring Boot 的启动原理，那么，为什么通过 SpringBootApplication 和 SpringApplication.run() 就能启动一个应用程序，它的底层到底是怎么实现的呢？别急，我们马上来一探究竟。

### **源码解析** ###

我们知道，启动类先调用了 SpringApplication 的静态方法 run，跟踪进去后发现，它会先实例化 SpringApplication，然后调用 run 方法。

/**
       * Static helper that can be used to run a {@link SpringApplication} from the
       * specified sources using default settings and user supplied arguments.
       * @param primarySources the primary sources to load
       * @param args the application arguments (usually passed from a Java main method)
       * @return the running {@link ApplicationContext}
       */
      public static ConfigurableApplicationContext run(Class<?>[] primarySources,
          String[] args) {
        return new SpringApplication(primarySources).run(args);
      }

所以，要分析它的启动源码，首先要分析 SpringApplicaiton 的构造过程。

今日内容有get吗，欢迎各位留言讨论！

**下期预告：Spring Boot 启动原理-02**

以上专栏均来自CSDN GitChat专栏**《Spring Cloud快速入门》，**作者**李熠**，专栏详情可识别下方二维码查看哦！

**了解更多详情**

**可识别下方二维码**

![e147a0237c4f9d54dc730c29cf3ce50d.png][]

[e70256c37ff0db5c114b6244faac7595.png]: /images/20221005/71d0a3168c74480286273df190c89a50.png
[Spring Boot _-02]: http://mp.weixin.qq.com/s?__biz=MzU3Njc1MDAxNg%3D%3D&chksm=fd0dac4dca7a255b1baa90207b97944d562a78f1e872a43a5a55641012f4adaa7e698246b828&idx=2&mid=2247501026&scene=21&sn=0c47f40fd4df72bc5de9b6ce8183eff9#wechat_redirect
[e147a0237c4f9d54dc730c29cf3ce50d.png]: /images/20221005/dbfca4e0aa3446ab8842d023d6499bf6.png