Spring Boot简介

Spring boot的资料获取

https://spring.io/projects/spring-boot 官方网站
https://github.com/spring-projects/spring-boot github源码地址
https://stackoverflow.com/questions/tagged/spring-boot stackoverflow问题汇总

SpringBoot版本选择

image.png

以2.3.5 CURRENT AG这个当前版本为例：
2. 主版本，主版本一般情况下是不变的，除非有大机制或者是架构的调整，才会去调整主版本。且主版本之间一般是不相兼容的。
3. 次版本，此版本主要是在主版本架构不管的情况下，增加一些新特性。可以理解为发布的新特性。同一个主版本下的次要版本之间通常是要保证兼容的。
5. 增量版本，bug修复。
最后一个“单词/缩略形式”版本大概有如下，这些定义由开发团队商量来定义，用来描述一个版本的发布状态（发布计划）：
GA：General Available：通用可使用，官方推荐使用此版本
PRE：预览版，内测版
SNAPSHOT
RC：Release
稳定性（由小到大）：
PRE<SNAPSHOT<RC<GA

一般使用的话选择GA版本

一些有关Spring Boot的问题.

Spring Boot 是如何基于Spring Framework逐步走向自动化装配的
SpringApplication 是怎样掌控Spring应用的生命周期的
Spring Boot 外部化配置与Spring Environment 抽象之间是什么关系?
Spring Web MVC 向Spring Reactive WebFlux过渡的真实价值和意义?

课程收获

Spring 全栈技术和实现原理
Spring Boot 核心技术
BAT 大规模微服务基础设施开发与生产实施经验

为什么说Spring Boot 易学难精

组件自动装配: 规约大于配置，专注核心业务
(难精)模式注解,@Eable模块，条件装配,加载机制
外部化配置:一次构建,按需调配,到处运行
(难精)Enviroment抽象,生命周期，破坏性变更
嵌入式容器: 内置容器,无需部署,独立运行
(难精)Servlet web容器,Reactive Web容器
Spring Boot Stater: 简化依赖,按需装配,自我包含
(难精)依赖管理,装配条件,装配顺序.
Production-Ready:一站式运维,生态无缝整合
(难精)健康检查,数据指标,@Endpoint管控

Spring Boot 与Java EE规范
Web: Servlet (JSR-315,JSR-340)
SQL:JDBC(JSR-221)
数据校验:Bean Validation(JSR-303,JSR-349)
缓存:Java Caching API(JSR-107)
WebSockets: Java API for WebSocket

理解SpringApplication

SpringApplication的准备阶段
定义:Spring应用引导类,提供便利的自定义行为方法
配置:Spring Bean来源
推断:Web 应用类型和主引导类(Main Class)
加载:应用上下文初始器 和应用事件监听器
场景:嵌入式Web应用和非Web应用

SpringApplication的运行阶段

基础技术
Spring Framework
1.Spring模式注解
2.Spring应用上下文
3.Spring工厂加载机制
4.Spring应用上下文初始器
5.Spring Environment抽象
6.Spring 应用事件/监听器

衍生技术
SpringApplication
SpringApplication Builder API
SpringApplicaiton 运行监听器
SpringApplication 参数
SpringApplication 故障分析
Spring Boot应用事件/监听

主要类的源码分析

SpringApplication准备阶段

  1. /**
  2.  * Class that can be used to bootstrap and launch a Spring application from a Java main
  3.  * method. By default class will perform the following steps to bootstrap your
  4.  * application:
  5.  *
  6.  * 这里是说这个是引导和加载Spring Applicaiton的Java 主方法,也就是Spring Boot应用的入口.
  7.  * 你可以通过默认的类和下面的步骤来引导你的应用。
  8.  *
  9.  * <ul>
  10.  * <li>Create an appropriate {@link ApplicationContext} instance (depending on your
  11.  * classpath)</li>
  12.  * <li>Register a {@link CommandLinePropertySource} to expose command line arguments as
  13.  * Spring properties</li>
  14.  * <li>Refresh the application context, loading all singleton beans</li>
  15.  * <li>Trigger any {@link CommandLineRunner} beans</li>
  16.  * </ul>
  17.  *
  18.  * In most circumstances the static {@link #run(Class, String[])} method can be called
  19.  * directly from your {@literal main} method to bootstrap your application:
  20.  *
  21.  * <pre class="code">
  22.  * &#064;Configuration
  23.  * &#064;EnableAutoConfiguration
  24.  * public class MyApplication  {
  25.  *
  26.  *   // ... Bean definitions
  27.  *
  28.  *   public static void main(String[] args) {
  29.  *     SpringApplication.run(MyApplication.class, args);
  30.  *   }
  31.  * }
  32.  * </pre>
  33.  *
  34.  * <p>
  35.  * For more advanced configuration a {@link SpringApplication} instance can be created and
  36.  * customized before being run:
  37.  *
  38.  * <pre class="code">
  39.  * public static void main(String[] args) {
  40.  *   SpringApplication application = new SpringApplication(MyApplication.class);
  41.  *   // ... customize application settings here
  42.  *   application.run(args)
  43.  * }
  44.  * </pre>
  45.  *
  46.  * {@link SpringApplication}s can read beans from a variety of different sources. It is
  47.  * generally recommended that a single {@code @Configuration} class is used to bootstrap
  48.  * your application, however, you may also set {@link #getSources() sources} from:
  49.  * <ul>
  50.  * <li>The fully qualified class name to be loaded by
  51.  * {@link AnnotatedBeanDefinitionReader}</li>
  52.  * <li>The location of an XML resource to be loaded by {@link XmlBeanDefinitionReader}, or
  53.  * a groovy script to be loaded by {@link GroovyBeanDefinitionReader}</li>
  54.  * <li>The name of a package to be scanned by {@link ClassPathBeanDefinitionScanner}</li>
  55.  * </ul>
  56.  *
  57.  * Configuration properties are also bound to the {@link SpringApplication}. This makes it
  58.  * possible to set {@link SpringApplication} properties dynamically, like additional
  59.  * sources ("spring.main.sources" - a CSV list) the flag to indicate a web environment
  60.  * ("spring.main.web-application-type=none") or the flag to switch off the banner
  61.  * ("spring.main.banner-mode=off").
  62.  *
  63.  * @since 1.0.0
  64.  * @see #run(Class, String[])
  65.  * @see #run(Class[], String[])
  66.  * @see #SpringApplication(Class...)
  67.  */
  68. public class SpringApplication {
  70.     /**
  71.      * The class name of application context that will be used by default for non-web
  72.      * environments.
  73.      */
  74.     public static final String DEFAULT_CONTEXT_CLASS = "org.springframework.context."
  75.             + "annotation.AnnotationConfigApplicationContext";
  77.  ......

首先我们来看它的构造方法

  1. /**
  2.      * Create a new {@link SpringApplication} instance. The application context will load
  3.      * beans from the specified primary sources (see {@link SpringApplication class-level}
  4.      * documentation for details. The instance can be customized before calling
  5.      * {@link #run(String...)}.
  6.      * @param primarySources the primary bean sources
  7.      * @see #run(Class, String[])
  8.      * @see #SpringApplication(ResourceLoader, Class...)
  9.      * @see #setSources(Set)
  10.      */
  11.     public SpringApplication(Class<?>... primarySources) {
  12.         this(null, primarySources);
  13.     }
  15.     /**
  16.      * Create a new {@link SpringApplication} instance. The application context will load
  17.      * beans from the specified primary sources (see {@link SpringApplication class-level}
  18.      * documentation for details. The instance can be customized before calling
  19.      * {@link #run(String...)}.
  20.      * @param resourceLoader the resource loader to use
  21.      * @param primarySources the primary bean sources
  22.      * @see #run(Class, String[])
  23.      * @see #setSources(Set)
  24.      */
  25.     @SuppressWarnings({ "unchecked", "rawtypes" })
  26.     public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
  27.         //资源加载器
  28.         this.resourceLoader = resourceLoader;
  29.         //判断配置源是否为空
  30.         Assert.notNull(primarySources, "PrimarySources must not be null");
  31.         //多个配置源放入链表中
  32.         this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
  33.         //判断启动容器的类型--查看WebApplicationType类的deduceFromClasspath();一共三种类型
  34.         //1.WebApplicationType.NONE; 2.WebApplicationType.SERVLET 3.WebApplicationType.REACTIVE;
  35.         this.webApplicationType = WebApplicationType.deduceFromClasspath();
  36.         //初始化Bean和监听器
  37.         setInitializers((Collection)     getSpringFactoriesInstances(ApplicationContextInitializer.class));
  38.         setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
  39.         //决定Application的MainClass
  40.         this.mainApplicationClass = deduceMainApplicationClass();
  41.     }
  43.     private Class<?> deduceMainApplicationClass() {
  44.         try {
  45.             StackTraceElement[] stackTrace = new RuntimeException().getStackTrace();
  46.             for (StackTraceElement stackTraceElement : stackTrace) {
  47.                 if ("main".equals(stackTraceElement.getMethodName())) {
  48.                     return Class.forName(stackTraceElement.getClassName());
  49.                 }
  50.             }
  51.         }
  52.         catch (ClassNotFoundException ex) {
  53.             // Swallow and continue
  54.         }
  55.         return null;
  56.     }

为什么我们传入了Main Class还需要再判断Main Class呢?——推断引导类

  1.     private Class<?> deduceMainApplicationClass() {
  2.         try {
  3.             StackTraceElement[] stackTrace = new RuntimeException().getStackTrace();
  4.             //遍历堆栈信息,找到名字含有main的方法栈
  5.             for (StackTraceElement stackTraceElement : stackTrace) {
  6.                 if ("main".equals(stackTraceElement.getMethodName())) {
  7.                     return Class.forName(stackTraceElement.getClassName());
  8.                 }
  9.             }
  10.         }
  11.         catch (ClassNotFoundException ex) {
  12.             // Swallow and continue
  13.         }
  14.         return null;
  15.     }

加载应用上下文初始器
就是这一段

  1. setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));

继续往下

  1. private <T> Collection<T> getSpringFactoriesInstances(Class<T> type, Class<?>[] parameterTypes, Object... args) {
  2.         ClassLoader classLoader = getClassLoader();
  3.         // Use names and ensure unique to protect against duplicates
  4.         Set<String> names = new LinkedHashSet<>(SpringFactoriesLoader.loadFactoryNames(type, classLoader));
  5.         List<T> instances = createSpringFactoriesInstances(type, parameterTypes, classLoader, args, names);
  6.         AnnotationAwareOrderComparator.sort(instances);
  7.         return instances;
  8.     }

实现类:SpringFactoriesLoader
配置资源:META-INF/spring.factories （可能在jar包里）


SpringApplication运行阶段

加载:SpringApplication 运行监听器
运行:SpringApplication 运行监听器
监听:SpringBoot事件,Spring 事件
创建:应用上下文,Environment,其他(不重要)
失败:故障报告
回调:CommandLineRunner,ApplicaitonRunner

看一下SpringApplication类的run方法

  1. /**
  2.      * Run the Spring application, creating and refreshing a new
  3.      * {@link ApplicationContext}.
  4.      启动Spring Application，创建并且刷新一个新的Application上下文
  5.      * @param args the application arguments (usually passed from a Java main method)
  6.      * @return a running {@link ApplicationContext}
  7.      */
  8.     public ConfigurableApplicationContext run(String... args) {
  9.         StopWatch stopWatch = new StopWatch();
  10.         stopWatch.start();
  11.         ConfigurableApplicationContext context = null;
  12.         Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList<>();
  13.         configureHeadlessProperty();
  14.         //加载运行监听器
  15.         SpringApplicationRunListeners listeners = getRunListeners(args);
  16.         listeners.starting();
  17.         try {
  18.             ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
  19.             ConfigurableEnvironment environment = prepareEnvironment(listeners, applicationArguments);
  20.             configureIgnoreBeanInfo(environment);
  21.             Banner printedBanner = printBanner(environment);
  22.             context = createApplicationContext();
  23.             exceptionReporters = getSpringFactoriesInstances(SpringBootExceptionReporter.class,
  24.                     new Class[] { ConfigurableApplicationContext.class }, context);
  25.             prepareContext(context, environment, listeners, applicationArguments, printedBanner);
  26.             refreshContext(context);
  27.             afterRefresh(context, applicationArguments);
  28.             stopWatch.stop();
  29.             if (this.logStartupInfo) {
  30.                 new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), stopWatch);
  31.             }
  32.             listeners.started(context);
  33.             callRunners(context, applicationArguments);
  34.         }
  35.         catch (Throwable ex) {
  36.             handleRunFailure(context, ex, exceptionReporters, listeners);
  37.             throw new IllegalStateException(ex);
  38.         }
  40.         try {
  41.             listeners.running(context);
  42.         }
  43.         catch (Throwable ex) {
  44.             handleRunFailure(context, ex, exceptionReporters, null);
  45.             throw new IllegalStateException(ex);
  46.         }
  47.         return context;
  48.     }