## Spring Boot 优势 * 自动装配 * 内嵌容器 * 应用监控 * Starter 包简化集成难度。 自动装配：Spring Boot 会根据某些规则对所有配置的 Bean 进行初始化。可以减少了很多重复性的工作。比如使用 mybatis时，只需要在 pom.xml 中加入 mybatis的 Starter 包，然后配置 mybatis的连接信息，就可以直接使用 @mapper自动装配来操作数据库了。 内嵌容器：Spring Boot 应用程序可以不用部署到外部容器中，比如 Tomcat。Spring Boot 应用程序可以直接通过 Maven 命令编译成可执行的 jar 包，通过 java -jar 命令启动即可，非常方便。 应用监控：Spring Boot 中自带监控功能 Actuator，可以实现对程序内部运行情况进行监控，比如 Bean 加载情况、环境变量、日志信息、线程信息等。当然也可以自定义跟业务相关的监控，通过Actuator 的端点信息进行暴露。 Starter 包简化框架集成难度：将 Bean 的自动装配逻辑封装在 Starter 包内部，同时也简化了 Maven Jar 包的依赖，对框架的集成只需要加入一个 Starter 包的配置，降低了烦琐配置的出错几率。 ## Spring Boot 框架图  ## Spring Boot 启动源码分析 我们知道 Spring Boot 程序的入口是 SpringApplication.run(Application.class, args) 方法，那么就从 run() 方法开始分析吧，它的源码如下： ``` public ConfigurableApplicationContext run(String... args) { // 1.创建并启动计时监控类 StopWatch stopWatch = new StopWatch(); stopWatch.start(); // 2.声明应用上下文对象和异常报告集合 ConfigurableApplicationContext context = null; Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList(); // 3.设置系统属性 headless 的值 this.configureHeadlessProperty(); // 4.创建所有 Spring 运行监听器并发布应用启动事件 SpringApplicationRunListeners listeners = this.getRunListeners(args); listeners.starting(); Collection exceptionReporters; try { // 5.处理 args 参数 ApplicationArguments applicationArguments = new DefaultApplicationArguments(args); // 6.准备环境 ConfigurableEnvironment environment = this.prepareEnvironment(listeners, applicationArguments); this.configureIgnoreBeanInfo(environment); // 7.创建 Banner 的打印类 Banner printedBanner = this.printBanner(environment); // 8.创建应用上下文 context = this.createApplicationContext(); // 9.实例化异常报告器 exceptionReporters = this.getSpringFactoriesInstances(SpringBootExceptionReporter.class, new Class[]{ConfigurableApplicationContext.class}, context); // 10.准备应用上下文 this.prepareContext(context, environment, listeners, applicationArguments, printedBanner); // 11.刷新应用上下文 this.refreshContext(context); // 12.应用上下文刷新之后的事件的处理 this.afterRefresh(context, applicationArguments); // 13.停止计时监控类 stopWatch.stop(); // 14.输出日志记录执行主类名、时间信息 if (this.logStartupInfo) { (new StartupInfoLogger(this.mainApplicationClass)).logStarted(this.getApplicationLog(), stopWatch); } // 15.发布应用上下文启动完成事件 listeners.started(context); // 16.执行所有 Runner 运行器 this.callRunners(context, applicationArguments); } catch (Throwable var10) { this.handleRunFailure(context, var10, exceptionReporters, listeners); throw new IllegalStateException(var10); } try { // 17.发布应用上下文就绪事件 listeners.running(context); // 18.返回应用上下文对象 return context; } catch (Throwable var9) { this.handleRunFailure(context, var9, exceptionReporters, (SpringApplicationRunListeners)null); throw new IllegalStateException(var9); } } ``` ## Spring Boot 的启动流程 * 1.创建并启动计时监控类 此计时器是为了监控并记录 Spring Boot 应用启动的时间的，它会记录当前任务的名称，然后开启计时器。 * 2.声明应用上下文对象和异常报告集合 此过程声明了应用上下文对象和一个异常报告的 ArrayList 集合。 * 3.设置系统属性 headless 的值 设置 Java.awt.headless = true，其中 awt（Abstract Window Toolkit）的含义是抽象窗口工具集。设置为 true 表示运行一个 headless 服务器，可以用它来作一些简单的图像处理。 * 4.创建所有 Spring 运行监听器并发布应用启动事件 此过程用于获取配置的监听器名称并实例化所有的类。 * 5.初始化默认应用的参数类 也就是说声明并创建一个应用参数对象。 * 6.准备环境 创建配置并且绑定环境（通过 property sources 和 profiles 等配置文件）。 * 7.创建 Banner 的打印类 Spring Boot 启动时会打印 Banner 图片 * 8.创建应用上下文 根据不同的应用类型来创建不同的 ApplicationContext 上下文对象。 * 9.实例化异常报告器 它调用的是 getSpringFactoriesInstances() 方法来获取配置异常类的名称，并实例化所有的异常处理类。 * 10.准备应用上下文 此方法的主要作用是把上面已经创建好的对象，传递给 prepareContext 来准备上下文，例如将环境变量 environment 对象绑定到上下文中、配置 bean 生成器以及资源加载器、记录启动日志等操作。 * 11.刷新应用上下文 此方法用于解析配置文件，加载 bean 对象，并且启动内置的 web 容器等操作。bean定位，载入和注册。 * 12.应用上下文刷新之后的事件处理 这个方法的源码是空的，可以做一些自定义的后置处理操作。 * 13.停止计时监控类 停止此过程第一步中的程序计时器，并统计任务的执行信息。 * 14.输出日志信息 把相关的记录信息，如类名、时间等信息进行控制台输出。 * 15.发布应用上下文启动完成事件 触发所有 SpringApplicationRunListener 监听器的 started 事件方法。 * 16.执行所有 Runner 运行器 执行所有的 ApplicationRunner 和 CommandLineRunner 运行器。 * 17.发布应用上下文就绪事件 触发所有的 SpringApplicationRunListener 监听器的 running 事件。 * 18.返回应用上下文对象 到此为止 Spring Boot 的启动程序就结束了，我们就可以正常来使用 Spring Boot 框架了，下面我们具体到代码分析启动流程。 ## springboot内置代码分析 > 运行流程： * 1：判断是否是web环境 ``` public SpringApplication(Object... sources) { initialize(sources); } @SuppressWarnings({ "unchecked", "rawtypes" }) private void initialize(Object[] sources) { if (sources != null && sources.length > 0) { this.sources.addAll(Arrays.asList(sources)); } this.webEnvironment = deduceWebEnvironment(); setInitializers((Collection) getSpringFactoriesInstances( ApplicationContextInitializer.class)); setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class)); this.mainApplicationClass = deduceMainApplicationClass(); } private boolean deduceWebEnvironment() { for (String className : WEB_ENVIRONMENT_CLASSES) { if (!ClassUtils.isPresent(className, null)) { return false; } } return true; } ``` * 2：加载所有classpath下面的META-INF/spring.factories ApplicationContextInitializer ``` @SuppressWarnings({ "unchecked", "rawtypes" }) private void initialize(Object[] sources) { if (sources != null && sources.length > 0) { this.sources.addAll(Arrays.asList(sources)); } this.webEnvironment = deduceWebEnvironment(); setInitializers((Collection) getSpringFactoriesInstances( ApplicationContextInitializer.class)); setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class)); this.mainApplicationClass = deduceMainApplicationClass(); } ``` * 3：推断main方法所在的类 ``` private Class<?> deduceMainApplicationClass() { try { StackTraceElement[] stackTrace = new RuntimeException().getStackTrace(); for (StackTraceElement stackTraceElement : stackTrace) { if ("main".equals(stackTraceElement.getMethodName())) { return Class.forName(stackTraceElement.getClassName()); } } } catch (ClassNotFoundException ex) { // Swallow and continue } return null; } ``` * 4：加载所有classpath下面的META-INF/spring.factories SpringApplicationRunListener ``` SpringApplicationRunListeners listeners = getRunListeners(args); listeners.starting(); ``` * 5：执行所有SpringApplicationRunListener的started方法 * 6：实例化ApplicationArguments对象 * 7：创建environment * 8：配置environment，主要是把run方法的参数配置到environment * 9：执行所有SpringApplicationRunListener的environmentPrepared方法 * 10：如果不是web环境，但是是web的environment，则把这个web的environment转换成标准的environment * 11：打印Banner ，banner 信息是在 SpringBootBanner 类中定义的，我们可以通过实现 Banner 接口来自定义 banner 信息，然后通过代码 setBanner() 方法设置 Spring Boot 项目使用自己自定义 Banner 信息，或者是在 resources 下添加一个 banner.txt，把 banner 信息添加到此文件中，就可以实现自定义 banner 的功能了。 * 12：初始化applicationContext, 如果是web环境，则实例化AnnotationConfigEmbeddedWebApplicationContext对象，否则实例化AnnotationConfigApplicationContext对象 * 13：如果beanNameGenerator不为空，就把beanNameGenerator对象注入到context里面去 * 14：回调所有的ApplicationContextInitializer方法 * 15：执行所有SpringApplicationRunListener的contextPrepared方法 * 16：依次往spring容器中注入：ApplicationArguments，Banner * 17：加载所有的源到context里面去 * 18：执行所有SpringApplicationRunListener的contextLoaded方法 * 19：执行context的refresh方法，并且调用context的registerShutdownHook方法（这一步执行完成之后，spring容器就完全初始化好了） ``` @Override public void refresh() throws BeansException, IllegalStateException { synchronized (this.startupShutdownMonitor) { //一些准备工作，列如配置属性源，记录启动时间，环境变量准备，部分map的清理工作 prepareRefresh(); //能对xml读取，转换为bean，AbstractApplicationContext因为引用了一个beanFactory //所有她拥有了beanFactory的所有功能。还在此基础上进一步扩展。做了哪些扩展？ //真正的初始化bean Factory ,设置一些参数，并读取xml文件，转换为bean Definition ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory(); // 准备bean 工厂，对beanFactory进行各种功能填充 // Prepare the bean factory for use in this context. // 此时，spring已经完成对配置文件的解析，也就是beanFactory对bean的解析已经开始 prepareBeanFactory(beanFactory); try { // Allows post-processing of the bean factory in context subclasses. //保留方法 允许在上下文子类中对bean工厂进行后处理。 postProcessBeanFactory(beanFactory); // 激活各种beanFactory 处理器，按顺序执行了 invokeBeanFactoryPostProcessors(beanFactory); // 执行完invokeBeanFactoryPostProcessors后，beanDefinition 基本都已经找出来了 ，并且新初始了如下 8个 bean 至此已经初始化16个bean // 注册拦截bean 创建的 bean 后置处理器 ，执行是在getBean时候 // Register bean processors that intercept bean creation. // 注册 BeanPostProcessor 处理 bean的 registerBeanPostProcessors(beanFactory); // 执行完 registerBeanPostProcessors()方法后，新增了9个后置处理器 至此已经初始化25个bean // 为此上下文初始化消息源，即不同语言的消息体。国际化处理 // Initialize message source for this context. initMessageSource(); //执行完新增1个bean 至此已经初始化26个bean //messageSource -> {DelegatingMessageSource@5542} //初始化应用消息（事件）广播器，并放入 ApplicationEventMulticaster bean 中 // Initialize event multicaster for this context. // 广播器，会保存相关的监听器，在有事件发生的时候，会调用相关的监听器的方法， // 让监听器去执行内部的监听逻辑 initApplicationEventMulticaster(); //执行完新增一个bean 至此已经初始化27个bean //applicationEventMulticaster -> {SimpleApplicationEventMulticaster@5595} //留给子类来初始化其他bean // Initialize other special beans in specific context subclasses. onRefresh(); //执行完 onRefresh（）新增 29个 bean 至此已经初始化65 个bean // 将所有监听器bean，注册到前面刚刚注册的消息广播器。 // 并将没有发出的事件一并发出去。 // Check for listener beans and register them. registerListeners(); // 初始化剩下的，非延迟加载的 bean的初始化工作。（也就是非延迟加载的bean,会在这一步实现初始化，其他bean不会）） // ConversionService 设置（这个是干啥的？） // 配置冻结 、非延迟加载的 bean的初始化工作 // Instantiate all remaining (non-lazy-init) singletons. //这也是context&bean Factory的区别所在 finishBeanFactoryInitialization(beanFactory); // 发布相关事件 Last step: publish corresponding event // 完成刷新过程，通知生命周期处理器，LifecycleProcesser 刷新过程， // 并同时发出ContextRefreshEvent 通知别人（通知被人干啥. finishRefresh(); } } ``` * 20：回调，获取容器中所有的ApplicationRunner、CommandLineRunner接口，然后排序，依次调用 * 21：执行所有SpringApplicationRunListener的finished方法 ## 工作原理总结 * 引导机制 Spring Boot 使用注解代替 xml 配置文件配置应用上下文，称之为 auto-configuration。在提供自己的组件时，Spring Boot 不会自己来扫描所有的包，而是通过读取 classpath 下 META-INF/spring.factories 文件中配置的类来开始加载流程。这可以视为 Spring Boot 的引导机制。 在 spring.factories 中，可以配置： org.springframework.boot.autoconfigure.EnableAutoConfiguration 自动配置类 org.springframework.context.ApplicationContextInitializer 实现该接口可以自定义窗口启动早期的初始化行为 org.springframework.context.ApplicationListener 实现该接口可以监听容器事件 配置键是接口或注解的全名，配置值是实现类或目标类的全名。在spring.factories中配置的类，都会被 spring 容器加载并实例化为 spring beans。 * Bean装配 1. 处理注解 @ComponentScan 2. 处理 @Import 注解 3. 处理@ImportResource注解 4. 处理 带@Bean注解的 方法 抓主线BeanDefinition的定位，载入，注册过程 * 条件配置 Spring Boot 支持在 @Configuration 和 @Bean 上使用条件注解（Condition annotations），在程序实际运行时动态判定初始化行为。比如根据某配置项、某个类是否存在判断是否加载某个 bean。 @ConditionalOnClass/@ConditionalOnMissingClass 根据类的存在性判定 @ConditionalOnBean/@ConditionalOnMissingBean 根据bean的存在性判定 @ConditionalOnProperty 根据配置项的存在性判定 @ConditionalOnResource 根据文件的存在性判定 @ConditionalOnWebApplication/@ConditionalOnNotWebApplication 根据是否为Web应用判定 @ConditionalOnExpression 根据 Spring EL 判定 基于“约定优于配置”的思想，条件注解可以用来根据实际情况灵活地配置自己的组件。比如使用@ConditionalOnClass，探测到程序中存在 com.mysql.jdbc.Driver 类，就可以视为应用使用 MySQL 作为数据源，可以自动配置 MySQL 相关的功能；比如使用@ConditionalOnProperty可以根据程序实际的配置项来决定初始化行为。 总结下 Starter 的工作原理 Spring Boot 在启动时扫描项目所依赖的 JAR 包，寻找包含spring.factories文件的 JAR 包 根据spring.factories 配置加载AutoConfigure类 根据@Conditional注解的条件，进行自动配置并将 Bean 注入 Spring Context。 ## spring bean生命周期  ## eureka-server 启动加载了哪些类