Spring Boot 2.0深度实践之系列总览

一.Spring Boot2.0易学难精

1.Spring Boot易学

　　组件自动装配：规约大于配置，专注核心业务

　　外部化配置：一次构建、按需调配，到处运行

　　嵌入式容器：内置容器、无需部署、独立运行

　　Spring Boot Starter：简化依赖、按需装配、自我包含

　　Production-Ready：一站式运维、生态无缝整合

2.Spring Boot难精

　　组件自动装配：模式注解、@Enable模块、条件装配、加载机制

　　外部化配置：Environment抽象、生命周期、破坏性变更[Spring Boot1.0和Spring Boot2.0之间有一点不太兼容的，在迁移和学习时，应予以高度关注]

　　嵌入式容器：Servlet Web容器、Reactive Web容器[Netty来做的]

　　Spring Boot Starter：依赖管理、装配条件、装配顺序

　　Production-Ready：健康检查、数据指标、@Endpoint管控

3.Spring Boot与Java EE规范

　　Web：Servlet（JSR-315、JSR-340）JSR-315表示Servlet3.0、JSR-340表示Servlet3.1规范。Servlet3.0包括了异步化，Servlet3.1包括了非阻塞，因此Web Flux也可以兼容在Servlet3.1容器里。

　　SQL：JDBC（JSR-221）,JSR-221其实就是JDBC4.0

　　数据校验：Bean Validation（JSR-303、JSR-349）,JSR-303是Bean Validation1.0，JSR-349是Bean Validation1.2

　　缓存：Java Caching API（JSR-107）

　　WebSockets：Java API for WebSocket（JSR-356），Spring并不提供任何的实现，它是实现是落在Tomcat这种容器上，因此Tomcat容器它是实现了WebSockets的规范，这是Spring和Java EE的困境

　　Web Services：JAX-WS（JSR-224）

　　Java管理：JMX（JSR 3），Java管理的扩展JMX，Spring Boot的核心概念Production-Ready（为生产级别而准备的一些特性），包括@Endpoint端点的东西，端点提供了两种方式，一种是Web方式来进行访问，另一种就是JMX，Spring Boot是和JMX整合的比较好的

　　消息：JMS（JSR-914），主要是指JMS的规范，主要是指JMS1.1，其中有代表性的实现就是Active MQ

　　其实，上面举的例子只是很小的一部分，其实Spring Framework和Spring Boot在实现Java EE规范方面是花了非常多的心思的，Java EE规范是一个大而全的技术体系栈。Spring Boot在此基础上提升了它的开发效率，并且简化了那些部分复杂的API，因此我们需要搞清楚Spring Boot和Java EE规范之间的联系。

4.Spring Boot深度实践-系列总览

　　核心特性、Web应用（引入了Reactive Web的开发，就是我们常说的Web Flux，这是对Spring MVC或Servlet应用是一种补充，因为Spring MVC是构建在Servlet基础上的实现）、数据相关（JDBC、JPA相关的操作）、功能扩展（Web化配置、自动装配、嵌入式容器都需要对Spring Boot API非常熟悉，尤其像Spring Boot嵌入式容器这块，2.0和1.0的实现方式也发生了变化）、运维管理（为生产而准备的特性，以运维为主、日志监控、性能监控以及核心的业务指标监控，Spring Boot提供了一套完整的解决方案）

二.核心特性介绍

Spring Boot三大特性

　　组件自动装配：Web MVC、Web Flux、JDBC等

　　嵌入性Web容器：Tomcat、Jetty以及Undertow

　　生产准备特性：指标（CPU、内存、磁盘的利用率）、健康检查（应用是否健康、数据库、磁盘、文件系统是否健康）、外部化配置（不用写代码可以调整应用的行为）等非功能特性的

三.核心特性组件自动装配介绍

1.组件自动装配

　　a.激活：@EnableAutoConfigureation，言外之意Spring Boot默认是没有激活自动装配功能的

　　b.配置：/META-INF/spring.factories，这是一个规约文件，既可以是它内部的实现，也可以是用户自定义的实现。/META-INF是元信息的目录，.factories是工厂机制，类似key-value形式

　　c.实现：XXXAutoConfiguration，XXX代表一种特性，比如WebMVCAutoConfiguration、JDBCAutoConfiguration。

　　然后点击“Generate Project”将工程下载到本地解压，导入到Idea中，我们可以看到DiveInSpringBootApplication.java中有@SpringBootApplication注解。

　　点击＠SpringBootApplication，可以看到它是有包括@EnableAutoConfiguration注解的

　　在IDEA中按Ctrl+Shift+N，输入spring.factories，选择spring-boot-autoconfigure-2.1.2.RELEASE.jar下的spring.factories

　　在这里，我们清楚地看到org.springframework.boot.autoconfigure.EnableAutoConfiguration做为一个键，它的value是各种各样的校验装配。spring.factories可以依赖在各个jar包，但真正去加载是因为在这里的配置，如WebMvcConfiguration

　　因为WebMvcConfiguration依赖Servlet、DispatcherServlet等，而这些东西我们工程里没有，所以它是不会被装配起来的，它的功能将加以阻止。

　　其实自动化装配复杂在有很多前提条件，如WebMvcConfiguration有很多前提条件和相应的顺序。

2.嵌入式Web容器

　　Web Servlet：Tomcat、Jetty和Undertow

　　Web Reactive：Netty Web Server

　　Web Flux是基于Netty Web Server来做的，当然它也可以基于Servlet3.1 API来实现，两种不同的容器在Spring应用里没有太大的区别，在编程方面呢，两者其实是兼容的

3.生产准备特性

　　Production-Ready不是为了功能性特性（功能性特性如web flux、web mvc以及jdbc这些东西都是为开发做准备的），而为生产做准备的主要是监控和管理应用相关的特性。

　　a.指标：/actuator/metrics，可以是CPU、内存、磁盘利用率信息的铺路

　　b.健康检查：/actuator/health，包括磁盘、DB等其它的分健康检查

　　c.外部化配置：/actuator/configprops，可以endpoint进行暴露的，也就是说它可以通过调整配置的方式修改应用的行为，这在Spirng Boot工程里用的非常广泛的，然而它的本质是来自于Spring Framework，只是在Spring Framework它不叫外部化配置，Spirng Boot把这个概念加以提升了。

四.Web应用介绍

1.传统Servlet应用

　　a.Servlet组件：Servlet、Filter、Listener

　　b.Servlet注册：Servlet注解、Spring Bean、RegistrationBean

　　　　Servlet注解其实是Servlet3.0本身提供的特性

　　　　Spring的注册方式，在Spring Boot里面，我们允许把Servlet部署成一个Spring的Bean加以加载和映射

　　　　Spring Boot提供新的API，就是RegistrationBean这种方式，RegistrationBean有几种不同的变种

　　c.异步非阻塞：异步Servlet、非阻塞Servlet

　　　　这块主是是Servlet3.0以上的API来进行实现的，异步Servlet主要是Servlet3.0提供的一种实现，非阻塞Servlet是Servlet3.1的实现，因此，在Web Flux里面，它有一个地方提到了：Web Flux可以运行在Servlet3.1以上的API，也说是说Serlvet3.1里面其实有包含异步和非阻塞两个特性

2.传统Web应用实例

　　Spring Boot的自动装配其实是采用spring-boot-starter方式，spring-boot-starter分很多功能模块，如spring-boot-starter-test、spring-boot-starter-web模块，这些模块的groupId都是org.springframework.boot，而artifactId都是以spring-boot-starter开头的。

　　从这里可以看到间隔依赖，包括这里的tomcat依赖。

　　依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

　　启动Spring Boot应用，我们可以看到启动的容器是Tomcat，端口是8080，和上面的包依赖tomcat遥相呼应了，当输入localhost:8080后，显示如下信息：

　　目前没有增加映射的任何处理，会出现一个白页，这个白页是错误信息的警告，也就是说当前页面没有映射到任何一个我们处理的实现，因此会报404的错误。

　　实例：

　　DiveInSpringBootApplication.java

package com.bijian.diveinspringboot;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.WebApplicationType;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.servlet.ServletComponentScan;

@SpringBootApplication
@ServletComponentScan(basePackages = "com.bijian.diveinspringboot.web.servlet")
public class DiveInSpringBootApplication {

    public static void main(String[] args) {

        SpringApplication.run(DiveInSpringBootApplication.class, args);
    }
}

　　MyServlet.java

package com.bijian.diveinspringboot.web.servlet;

import javax.jws.WebService;
import javax.servlet.AsyncContext;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@WebServlet(urlPatterns = "/my/servlet")
public class MyServlet extends HttpServlet {

    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

        resp.getWriter().println("Hello,World");
    }
}

　　启动应用后，在浏览器输入http://localhost:8080/my/servlet后，能正常获得“Hello,World”信息。

　　从这我们可以看出，传统的SpringMVC应用也是要以放到Spring Boot里面来的。

　　a.Servlet组件（Servlet是一种组件，Filter、Listener依次类推）

　　　　实现

　　　　　　@WebServlet

　　　　　　继承HttpServlet

　　　　URL映射

　　　　　　@WebServlet(urlPatterns = "/my/servlet", asyncSupported = true)

　　　　　　@ServletComponentScan(basePackages = "com.bijian.diveinspringboot.web.servlet")

　　b.Servlet注册

　　方式一：Servlet注解

　　　　@ServletComponentScan

　　　　@WebServlet

　　　　@WebFilter

　　　　@WebListener

　　方式二：Spring Bean

　　　　@Bean(Servlet、Filter、Listener)

　　方式三：RegistrationBean

　　　　ServletRegistrationBean

　　上面所说的Servlet的注册方式是Spring的自定义的注册方式，它结合了Servlet规范来操作的，另外还有Spring Beant和RegistrationBean两种方式，Spring Bean和RegistrationBean方式有点类似。

五.异步非阻塞Servlet

　　异步非阻塞分两个方面，一个是异步Servlet，一个是非阻塞Servlet，其实异步、非阻塞分别是在3.0和3.1展开的。

1.异步Servlet

　　javax.servlet.ServletRequest#startAsync()

　　javax.servlet.AsyncContext

2.非阻塞Servlet

　　javax.servlet.ServletInputStream#setReadListener

　　　　javax.servlet.ReadListener

　　javax.servlet.ServletOutputStream#setWriteListener

　　　　javax.servlet.WriteListener

3.实例

　　MyServlet.java

package com.bijian.diveinspringboot.web.servlet;

import javax.jws.WebService;
import javax.servlet.AsyncContext;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@WebServlet(urlPatterns = "/my/servlet", asyncSupported = true)
public class MyServlet extends HttpServlet {

    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

        //resp.getWriter().println("Hello,World");
        AsyncContext asyncContext = req.startAsync();
        asyncContext.start(()->{
            try {
                resp.getWriter().println("Hello,World");
                //触发完成
                asyncContext.complete();
            }catch (IOException e) {
                e.printStackTrace();
            }
        });
    }
}

　　要配置asyncSupported = true，并且把asyncContext.complete();放到start方法里面去。

六.Spring Web MVC应用介绍

1.Web MVC视图：模板引擎、内容协商、异常处理等

　　Web MVC视图：ViewResolver、View

　　　　ViewResolver视图上的处理器，处理器有一个方法：View resolveViewName(String viewName, Locale locale) throws Exception;通过名称和Locale来查询或者处理视图，视图返回之后只关心一件事情，那就是它的渲染，渲染就需要它的上下文，就是render方法中的第一个参数。

void render(@Nullable Map<String, ?> model, HttpServletRequest request, HttpServletResponse response) throws Exception;

　　response就会输出内容，具体由render所在接口View的实现来操作。也就是说，对于我们的模板引擎来说，Thymeleaf、Freemark、JSP每一种模板引擎都会对应一个ViewResolver实现，同时会结合相应的策略来操作。当你的应用里有多种模板引擎，这个时候就是内容协商的优势了，内容协商能帮你选择最佳匹配的模板引擎来渲染，其中包括ContentNegotiatingViewResolver来处理，这个ContentNegotiatingViewResolver会包含所有的ViewResolver逐一进行处理。

　　模板引擎：Thymeleaf、Freemark、JSP

　　内容协商

　　　　ContentNegotiationConfigure

　　　　ContentNegotiationStrategy

　　　　ContentNegotiatingViewResolver

　　异常处理

　　　　@ExceptionHandler

　　　　HandlerExceptionResolver

　　　　　　ExceptionHandlerExceptionResolver

　　　　BasicErrorController（Spring Boot）

　　　　异常处理在SpringMVC是通过打个标签@ExceptionHandler方式来处理，另外，SpringMVC、Spring Boot会自动帮我们创建HandlerExceptionResolver，比如ExceptionHandler的处理方式是由HandlerExceptionResolver的子类ExceptionHandlerExceptionResolver产生的。在Spring Boot里面，我们前面看到的错误白页（400页面），这个白页是由BasicErrorController生成的。BasicErrorController中的/error和白页中的/error是遥相呼应的，BasicErrorController有两种方式的显示，一种是html方式，一种是json方式，两种不同的方式分别表达不同的方式和方法。

2.Web MVC REST：资源服务、资源跨域、服务发现等

　　a.资源服务，@RequestMapping、@ResponseBody、@RequestBody这三个在SpringMVC中用的很多，其实在Spring4.3以后，做了一些调整，第一个调整就是@GetMapping，GetMapping其实是一种RequestMapping的同义词，它关注Get方法，对应查询，且它还有PostMapping、PutMapping、DeleteMapping等，其中PostMapping关注PUT方法，对应添加，PutMapping对应更新、DeleteMapping对应删除。

　　@RequestMapping和@AliasFor是一种委派的方式。

　　　　@RequestMapping

　　　　　　@GetMapping

　　　　@ResponseBody

　　　　@RequestBody

　　b.资源跨域

　　　　传统资源跨域有两种解决办法，一种是iframe，另一种是JSONP，这两种方案各有优劣，但在新型浏览器里面不推荐这两种方式了，而用CrossOrigin来进行操作，CrossOrigin会告诉浏览器，我有哪些东西是可以跨域的，它默认就是说让你对origins进行配置。

　　另外一种就是WebMvcConfigurer方案，CrossOrigin和WebMvcConfigurer其实都是SpringMVC里面的，只是由于Spring Boot的流行，才把这些东西重新拾起来。

　　addCorsMappings(CorsRegistry registry)就是我们要配CorsRegistry，和CrossOrigin语义是一样的，只是CrossOrigin是注解驱动，WebMvcConfigurer是接口编程，它们两个都是Spring Framework4.2里面的。

　　　　CrossOrigin

　　　　WebMvcConfigurer#addCorsMapping

　　c.服务发现

　　　　HATEOS，其实在SpringMVC里面也会有服务发现，只不过它在控制台（Mapped URL path），控制台没办法暴露给服务，无法让程序识别，也就是说如果一个应用访问过来的时候，会告诉你哪些东西来访问。

3.Web MVC核心：核心架构、处理流程、核心组件

　　a.核心架构

　　b.处理流程

　　c.核心组件

　　核心组件的入口是DispatcherServlet，它其实也是一个Servlet，和普通的Servlet没有什么区别，唯一的区别是它会把请求转发到不同的Controller里去，映射到Controller里的路径，映射路径和HandlerMapping进行交互，Handler可以理解为就是Controller的处理方法，处理方法和Handler做映射，所以有HandlerMapping，HandlerMapping是内部的一个转换，帮助我们把方法转换成它内部的一个实现，处理完之后会返回一个ModelAndView的东西，ModelAndView中的这个Model会继续给我们这里的ViewResolver来进行处理，最后生成视图。当然，如果是Rest应用，处理流程发生了一些变化。

七.Spring Web Flux应用

　　Spring Web Flux是Spring5开始支持的一种新的Web特性，是对Servlet进行的一个补充，也就是说，从我们的Web应用中，从传统的同步阻塞的编程变成异步非阻塞的编程，这对我们的编程模型也是一大挑战和升级。

1.Reactor基础：Java Lambda、Mono、Flux

　　Java Lambda是Reactive的一个基础，Reactor是Reactive Stream的一种实现方式，Java Reactive Stream其实有好几种实现方式，包括Java9里Flow API，包括IX JAVA，它们的技术都是Java Lambda。同时它有两个核心接口—Mono和Flux

2.Web Flux核心：Web MVC注解、函数式声明、异步非阻塞

　　Web Flux可以和Spring MVC兼容的，其实在官方文档上也有说明，如@Controller、@RequestMapping、@ResponseBody、@RequestBody

　　函数式声明主要是RouterFunction，RouterFunction名字就可以知道，Router是路由器的意思，Function是函数，可以通过路由的方式来表达函数，它可以通过我们编程的方式更丰富的去做方法内联。就是关于我们用函数的方式来进行声明我们的一些Endpoint的暴露，包括路径通过表达表来暴露。

　　函数式编程的好处：有更好的弹性，可以通过很多条件来做，尽管这个东西可以在Condition条件上面做一个判断，但程序方面的灵活性就远远大过其它的方法，这种方式相对就比较直观一些，同时它可以绑定相应的实现方法，我可以在一个声明表达式里面部署多个Endpoint以及它们映射方法的处理机制，不需要到处进行相应的绑定。

　　非阻塞和异步结合起来相对来讲有性能上的提升的，因为可以提高吞吐量。异步非阻塞包括两个方面：Servlet3.1和Netty Reactor。

3.使用场景：Web Flux优势和限制

　　它的使用场景分成几个方面，和SpringMVC没有太大区别，一个是页面渲染，一个是REST应用，这两个应用是比较核心的。

　　性能测试：https://blog.ippon.tech/spring-5-webflux-performance-tests/，这是一个性能方面的测试，结论是在Web Flux里面性能没有提升太多，在某些方面Web Flux性能反而会有所下降。

　　那为什么要用Reactive呢？提升系统的吞吐量，吞吐量不代表快。

八.Web Server应用

1.切换Web Server

　　如果你不喜欢用Tomcat，或者你不得不用Jetty，这时你就需要做切换，同时你也许不太想用Servlet容器，想尝试新的Netty Web Server，也是可以的

　　a.Tomat->jetty

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

　　改成

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <exclusions>
        <!-- Exclude the Tomcat dependency -->
        <exclusion>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
        </exclusion>
    </exclusions>
</dependency>

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jetty</artifactId>
</dependency>

　　tomcat优先级高于Jetty，如果仅仅把jetty加上，不把tomcat排除，同样还是Tomcat。

　　b.替换Servlet容器为WebFlux

　　将如下配置加到pom.xml中，注意把web配置注释掉，加上spring-boot-starter-webflux依赖

<!--
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <exclusions>
        <exclusion>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
        </exclusion>
    </exclusions>
</dependency>

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jetty</artifactId>
</dependency>
-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-webflux</artifactId>
</dependency>

　　传统的web模块和webflux模块不能共存，如两者都存在时，使用的是webflux。

2.自定义Servlet Web Server

　　通常不需要定义，有些特殊场景是无法自定义的，前面讲过Web化配置，它能调整Web容器的一些配置，但不是每个点都是Web化配置都覆盖到了，因此有时候你需要定制化服务器的行为。

　　WebServerFactoryCustomizer：Spring Boot2.0新加的接口，这个接口是我们如何自定义的关键，这是一个总接口，可以看到有很多的实现。

　　ServletWebServerFactoryCustomizer是接口的通用实现，它还有一些自定义的接口实现，如TomcatServletWebServerFactoryCustomizer，它的实现是比较复杂的，我们可以通过一些简单的方式来进行操作，如通过配置项来进行操作。

3.自定义Reactive Web Server

　　ReactiveWebServerFactoryCustomizer类，它的实现很简单，就是端口、地址、SSL等的实现。

　　我们在这里可以扩展它的实现，如可以覆盖它的默认行为，提供一些具有高级特性的行为。一般来说，Spring Boot里的默认实现只是提供一些通用实现，或者说是最简单的实现、最常用的实现，这种实现方式也许满足你大部分需求，当你不需要时，可以进行自定义的调整。

九.数据相关

关系型数据（数据操作还有缓存(NOSQL、REDIS)、JMS消息服务）

1.JDBC：数据源、JdbcTemplate、自动装配

　　a.依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>

　　Spring Boot2.0开始，JDBC连接池依赖一个新型的连接池，这个连接池是一个非常好性能的连接池，可以去看看相应的设置，同时依赖spring5.0对JDBC的实现。

　　b.数据源接口：javax.sql.DataSource，它是JAVA1.4就有了的一个接口，数据库连接池就是把DataSource进行包装

　　c.JdbcTemplate：它是spring-jdbc的一部分

　　我们可以打开spring-boot-autoconfigure中的spring.factories，可以看到都在org.springframework.boot.autoconfigure.EnableAutoConfiguration中配置。

　　我们可以看到，Spring Boot配置了非常多的自动装配，这些东西都它默认内部实现的，帮助简化我们的配置和开发。

2.JPA：实体映射关系、实体操作、自动装配

　　自动装配其实是非常复杂的操作，那么你需要了解自动装配很底层的细节，才能够实现一些很高级的特性，比如JDBC的多数据源，Spring Boot默认是没有支持的，你需要进行相应的操作，假设你需要调整JPA的行为，也需要做一些相应的调整。

　　a.依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>

　　jpa和JDBC并不冲突，jpa需要JDBC的DataSource，DataSource会在DataSourceAutoConfiguration中自动装配，会产生一个数据库连接池，然后数据库会把这个DataSource进行保存。

　　b.实体映射关系

　　@javax.persistence.OneToOne

　　@javax.persistence.OneToMany

　　@javax.persistence.ManyToOne

　　@javax.persistence.ManyToMany

　　...

　　c.实体操作

　　javax.persistence.EntityManager，增、删、改、查操作，如persist是存的方法，merge更新，remove删除，find查找。

　　d.自动装配

　　HibernateJpaAutoConfiguration：它主要的操作在HibernateJpaConfiguration中

3.事务：Spring事务抽象、JDBC事务处理、自动装配

　　Spring事务在Spring里面是非常非常重要的一块，包括几个方面，有一个事务的抽象，其中包括JDBC事务的处理以及它的自动装配。

　　a.依赖

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-tx</artifactId>
</dependency>

　　b.Spring事务抽象

　　PlatformTransactionManager：它是根接口，是一个关键的接口，关键的地方是有一个具体的抽象，事务管理不止是数据库事务，也有可能有其它的事务，这里有两种事务，一种是JTA（分布式事务），一种是JDBC的DataSource事务。

　　c.JDBC事务处理

　　DataSourceTransactionManager

　　d.自动装配

　　TransactionAutoConfiguration

　　spring-boot-autoconfigure中的spring.factories，确实也有org.springframework.boot.autoconfigure.transaction.TransactionAutoConfiguration配置，也是依赖于EnableAutoConfiguration进行操作的。

十.功能扩展

Spring Boot应用

1.SpringApplication：失败分析、应用特性、事件监听等

　　失败分析：FailureAnalysisReporter类来表达的

　　应用特性：Fluent API

　　事件监听

2.Spring Boot配置：外部化配置、Profile、配置属性

　　外部化配置：ConfigurationProperty

　　Spring Boot2.0.0开始引入的，它提供了一个新的属性Origin，提供了一个新的功能，我要跟踪我的配置从哪里来，这样自然就有一个配置，如我的配置有多个方面的来源，可通过来源来做一些跟踪。是为了解决在Spring Boot2.0里有一个问题，我的配置源有很多个，多的时候会你非常麻烦，不知来源是在什么地方，如下是官方文档17种配置来源。

　　Profile：侧面，有条件的配置

　　Profile在很多软件里都会有，它主要是一个注解的方式，Profile相当于是一种条件的方式，在Spring4之前，没有@Conditional条件，通过Profile来进行控制，当有出现明显特征的时候，如线上和线下环境，线上加载什么服务，线下加载什么服务，这个时候可以通过这个条件来进行区分，但是Profile的能力非常弱，后续会调整为@Conditional，@Conditional和前面的自支装配非常相似。

　　配置属性：PropertySources，它是Spring的一个接口。

　　PropertySources是一个复数的形式，并且实现了Iterable接口，也就是说PropertySources类可以迭代PropertySource，PropertySource有17种不同的依赖的原则，因此它会有很多很多的来源。

3.Spring Boot Starter：Starter开发、最佳实践

　　这部分相对难些，它不但要了解Spring自动装配的主要的特性，同时还包括外部化配置以及运维管理。

十一.运维管理

　　Spring Boot Actuator：Spring Boot的自动装置，有两个含义，一个是我可以控制spring Boot的一些行为，同时我可以记录它的一些行为。它的管理的方式是通过端点的方式。

　　依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

　　重新启动后发现输出了两个端点信息。

1.端点：各类Web和JMX Endpoints

　　a.Web Endpoints

　　它有两种方式来表达，一种是Web Endpoints，一种是JMX Endpoints，这两种Endpoints是不同的介质（或者手段）来进行管理，当你没有开Web端口时，可通过JMX来进行操作，而JMX可支持远程操作，基于数据敏感性，也许会把JMX关掉、开放Web方式来进行操作。

　　status是UP说明应有启动起来了。

　　没有任何信息，说明没有暴露任何信息。但不管怎样，至少有一点，我们看到actuator给我们获得了一些信息，同时我们注意一下http://localhost:8080/actuator，会返回一些信息，这里就是前面讲到的所谓发现，因为我并不知道我里面提供了哪些东西，所以需要这样一个东西来给我们进行描述。

　　b.JMX Endpoints

　　在运行处，输入jconsole打开jconsole界面，选择我们这里的进程，点击“连接”。

　　同样选择health，可以看到如下信息，比Web Endpoints方式获得的信息多些（因为Web Endpoints可能会暴露到公网去，为减少风险，信息尽量少）

　　如果我们要开放所有Web Endpoints，则可以在工程的application.properties中进行如下配置。

#开放所有的Web Endpoints
management.endpoints.web.exposure.include=*

　　重启应用，刷新http://localhost:8080/actuator，可以看到更多的服务发现。

　　/actuator/beans：可以看到当前应用当前上下文的所有bean

　　/actuator/mappings：可以看到所有访问页面的情况

　　/actuator/metrics：可以看到通过查看对应的信息，如http://localhost:8080/actuator/metrics/jvm.memory.max查看最大内存

　　这里的内存是以KB为单位的。

2.健康检查：Health、HealthIndicator

　　Health、HealthIndicator这两个接口也是端点方式来进行描述的，是给用户（运维人员）和应用之间的交互方式

3.指标：内建Metrics、自定义Metrics

　　Metrics既可以暴露应用的Metrics，也可以暴露业务的Metrics，如访问多少次、交易的数量。可以结合Web和JMX Endpoints把运维平台搭建起来。

十二.总结

1.Spring Boot核心特性

2.Spring Boot功能应用

3.Spring Boot运维管理

学习地址：https://www.imooc.com/video/18042

posted on 2019-02-09 19:06 bijian1013 阅读(601) 评论(0) 收藏举报

刷新页面返回顶部

bijian1013

Spring Boot 2.0深度实践之系列总览

导航

公告