## 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 框架图 ![](https://img.kancloud.cn/6b/ba/6bba83f90e6def3167ffa767520d0589_1510x608.png) ## 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生命周期 ![](https://img.kancloud.cn/a5/6d/a56d92ea0980751d0387cac41335ed33_725x260.png) ## eureka-server 启动加载了哪些类 ![](https://img.kancloud.cn/fa/1d/fa1d8f5b77645781d21d7fa81bb14d3a_1260x617.png) ![](https://img.kancloud.cn/68/45/684526d881f27e94e95cbc526189690a_1268x423.png)