关于后端:spring系列Spring-Boot从初识到实战

Spring Boot 从初识到实战

一、Hello Spring Boot

1、Spring Boot 简介

• 简化 Spring 利用开发的一个框架；
• 整个 Spring 技术栈的一个大整合；
• J2EE 开发的一站式解决方案；

2、微服务

• 微服务：架构格调（服务微化）
• 一个利用应该是一组小型服务；能够通过 HTTP 的形式进行互通；
• 单体利用：ALL IN ONE
• 微服务：每一个性能元素最终都是一个可独立替换和独立降级的软件单元；具体参照微服务文档

3、环境筹备

• jdk1.8：Spring Boot 举荐 jdk1.7 及以上；java version “1.8.0_112”
• maven3.x：maven 3.3 以上版本；Apache Maven 3.3.9
• IntelliJIDEA、STS
• SpringBoot 2.2.2.RELEASE；对立环境；

3.1、MAVEN 设置；

给 maven 的 settings.xml 配置文件的 profiles 标签增加

<profile>
    <id>jdk‐1.8</id>
    <activation>
    <activeByDefault>true</activeByDefault>
    <jdk>1.8</jdk>
    </activation>
    <properties>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <maven.compiler.compilerVersion>1.8</maven.compiler.compilerVersion>
    </properties>
</profile>

3.2、IDEA 设置

整合 maven 进来

3.3、Spring Boot HelloWorld

实现一个小性能：浏览器发送 hello 申请，服务器承受申请并解决，响应 Hello World 字符串；

1、创立一个 maven 工程；（jar）

2、导入 spring boot 相干的依赖

<parent>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring‐boot‐starter‐parent</artifactId>
  <version>2.2.2.RELEASE</version>
</parent>
<dependencies>
  <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring‐boot‐starter‐web</artifactId>
  </dependency>
</dependencies>

3、编写一个主程序；启动 Spring Boot 利用

/**
* @SpringBootApplication 来标注一个主程序类，阐明这是一个 Spring Boot 利用
*/
@SpringBootApplication
    public class HelloWorldMainApplication {public static void main(String[] args) {
    // Spring 利用启动起来
     SpringApplication.run(HelloWorldMainApplication.class,args);
  }
}

4、编写相干的Controller、Service

@Controller
    public class HelloController {
        @ResponseBody
        @RequestMapping("/hello")
        public String hello(){return "Hello World!";}
    }

5、运行主程序 main 办法，测试

6、简化部署

<!‐‐ 这个插件，能够将利用打包成一个可执行的 jar 包；‐‐>
  <build>
      <plugins>
          <plugin>
              <groupId>org.springframework.boot</groupId>
              <artifactId>spring‐boot‐maven‐plugin</artifactId>
          </plugin>
      </plugins>
  </build>

将这个利用打成 jar 包，间接应用 java -jar 的命令进行执行java -jar HelloWorldMainApplication.jar

3.4、Hello World 探索

3.4.1、POM 文件

1. 父我的项目

   <parent>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring‐boot‐starter‐parent</artifactId>
       <version>2.2.2.RELEASE</version>
   </parent>

   进入父我的项目，能够看到父我的项目的父我的项目（爷我的项目）

   <!-- 爷爷我的项目(他的父我的项目）是 -->
   <parent>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring‐boot‐dependencies</artifactId>
       <version>2.2.2.RELEASE</version>
       <relativePath>../../spring‐boot‐dependencies</relativePath>
   </parent>

   他来真正治理 Spring Boot 利用外面的所有依赖版本；是Spring Boot 的版本仲裁核心；

   当前咱们导入依赖默认是不须要写版本的；（没有在 dependencies 外面治理的依赖天然须要申明版本号）

2. 启动器

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

​ spring-boot-starter-web：

​ spring-boot-starter：spring-boot 场景启动器；帮咱们导入了 web 模块失常运行所依赖的组件；

​ Spring Boot 将所有的性能场景都抽取进去，做成一个个的 starters（启动器），只须要在我的项目外面引入这些 starter

​ 相干场景的所有依赖都会导入进来。要用什么性能就导入什么场景的启动器

3.4.2、主程序类，主入口类（跟着伪装点进去，看看源码，成为一个看过源码的初学者）

/**
 * @SpringBootApplication 来标注一个主程序类，阐明这是一个 Spring Boot 利用
 */
@SpringBootApplication
public class HelloWorldMainApplication {public static void main(String[] args) {
        // Spring 利用启动起来
        SpringApplication.run(HelloWorldMainApplication.class, args);
    }
}

@SpringBootApplication: Spring Boot 利用标注在某个类上阐明这个类是 SpringBoot 的主配置类，SpringBoot

就应该运行这个类的 main 办法来启动 SpringBoot 利用；

@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 {

@SpringBootConfiguration:Spring Boot 的配置类；标注在某个类上，示意这是一个 Spring Boot 的配置类；

@Configuration: 用来标注这是个配置类；

@EnableAutoConfiguration：开启主动配置性能；

以前咱们须要配置的货色，Spring Boot 帮咱们主动配置；@EnableAutoConfiguration通知 SpringBoot 开启主动配置性能；这样主动配置能力失效；

@AutoConfigurationPackage
@Import({AutoConfigurationImportSelector.class})
public @interface EnableAutoConfiguration {

@AutoConfigurationPackage：主动配置包

Spring 的底层注解@Import，给容器中导入一个组件；导入的组件由 AutoConfigurationImportSelector.class

将主配置类（@SpringBootApplication 标注的类）的所在包及上面所有子包外面的所有组件扫描到 Spring 容器；

@Import(EnableAutoConfigurationImportSelector.class)；给容器中导入组件？

AutoConfigurationImportSelector：导入哪些组件的选择器；

将所有须要导入的组件以全类名的形式返回；这些组件就会被增加到容器中；

会给容器中导入十分多的主动配置类（xxxAutoConfiguration）；就是给容器中导入这个场景须要的所有组件，并配置好这些组件；

有了主动配置类，免去了咱们手动编写配置注入性能组件等的工作；

SpringFactoriesLoader.loadFactoryNames(this.getSpringFactoriesLoaderFactoryClass(), this.getBeanClassLoader());

Spring Boot 在启动的时候从类门路下的 META-INF/spring.factories 中获取 EnableAutoConfiguration 指定的值，将这些值作为主动配置类导入到容器中，主动配置类就失效，帮咱们进行主动配置工作；以前咱们须要本人配置的货色，主动配置类都帮咱们配置好了；

J2EE 的整体整合解决方案和主动配置都在 spring-boot-autoconfigure-2.2.2.RELEASE.jar；

3.5、应用 Spring Initializer 疾速创立 Spring Boot 我的项目

1. IDEA：能够应用 Spring Initializer疾速创立我的项目

IDE 都反对应用 Spring 的我的项目创立向导疾速创立一个 Spring Boot 我的项目；抉择咱们须要的模块；向导会联网创立 Spring Boot 我的项目；

默认生成的 Spring Boot 我的项目；

• 主程序曾经生成好了，咱们只须要咱们本人的逻辑
• resources 文件夹中目录构造
• static：保留所有的动态资源；js css images；
• templates：保留所有的模板页面；（Spring Boot 默认 jar 包应用嵌入式的 Tomcat，默认不反对 JSP 页面）；能够应用模板引擎（freemarker、thymeleaf）；
• application.properties：Spring Boot 利用的配置文件；能够批改一些默认设置；

2. STS应用 Spring Starter Project疾速创立我的项目

二、配置文件

1、配置文件

SpringBoot 应用一个全局的配置文件，配置文件名是固定的(有两种模式)；

• application.properties
• application.yml

配置文件的作用：批改 SpringBoot 主动配置的默认值；(SpringBoot 在底层都给咱们主动配置好了)

YAML（YAML Ain’t Markup Language）YAML A Markup Language：是一个 标记语言

YAML：以数据为核心，比 json、xml 等更适宜做配置文件；

以前的配置文件；大多都应用的是 xxxx.xml文件；eg:

YAML：配置例子

server:
  port: 8080

XML 例子：

<server>
  <port>8080</port>
</server>

2、YAML 语法：

1、根本语法

k:(空格)v：示意一对键值对（空格必须有）；

以空格的缩进来管制层级关系；只有是左对齐的一列数据，都是同一个层级的

server:
    port: 8080
    path: /hello

<mark> 属性和值是大小写敏感的 </mark>；

2、值的写法

字面量：一般的值（数字，字符串，布尔）

k: v：字面间接来写；

字符串默认不必加上单引号或者双引号；

""：双引号；不会本义字符串外面的特殊字符；特殊字符会作为自身想示意的意思 name: “zhangsan \n lisi”：输入；zhangsan 换行 lisi

''：单引号；会本义特殊字符，特殊字符最终只是一个一般的字符串数据

name:‘zhangsan \n lisi’：输入；zhangsan \n lisi

对象、Map（属性和值）（键值对）：

k: v

：在下一行来写对象的属性和值的关系；留神缩进

对象还是 k: v 的形式

friends:
    lastName: zhangsan
    age: 20    

行内写法：

friends: {lastName: zhangsan,age: 20}

数组（List、Set）：

用 - 值示意数组中的一个元素

pets:
  ‐ cat
  ‐ dog
  ‐ pig

行内写法

pets: [cat,dog,pig]

3、配置文件值注入

3.1、配置文件:

person:
    lastName: hello
    age: 18
    boss: false
    birth: 2017/12/12
    maps: {k1: v1,k2: 12}
    lists:
        ‐ lisi
        ‐ zhaoliu
    dog:
        name: 小狗
        age: 12

3.2、javaBean：

/**
* 将配置文件中配置的每一个属性的值，映射到这个组件中
* @ConfigurationProperties：通知 SpringBoot 将本类中的所有属性和配置文件中相干的配置进行绑定；* prefix = "person"：配置文件中哪个上面的所有属性进行一一映射
*
* 只有这个组件是容器中的组件，能力应用容器提供的 @ConfigurationProperties 性能；*
*/
@Component
@ConfigurationProperties(prefix = "person")
public class Person {
  private String lastName;
  private Integer age;
  private Boolean boss;
  private Date birth;
  private Map<String,Object> maps;
  private List<Object> lists;
  private Dog dog;
}

咱们能够导入配置文件处理器，当前编写配置就有提醒了

<!‐‐导入配置文件处理器，配置文件进行绑定就会有提醒‐‐>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring‐boot‐configuration‐processor</artifactId>
    <optional>true</optional>
</dependency>

3.3、@Value 获取值和 @ConfigurationProperties 获取值的区别

• 配置文件 yml 还是 properties 他们都能获取到值；
• 如果说，咱们只是在某个业务逻辑中须要获取一下配置文件中的某项值，应用 @Value；
• 如果说，咱们专门编写了一个 javaBean 来和配置文件进行映射，咱们就间接应用 @ConfigurationProperties；

3.4、配置文件注入值数据校验

 @Component
 @ConfigurationProperties(prefix = "person")
 @Validated
 public class Person {
    /**
      * <bean class="Person">
      * <property name="lastName" value=" 字面量 /${key}从环境变量、配置文件中获取值 /#
          {SpEL}"></property>
      * <bean/>
      */
    //lastName 必须是邮箱格局
    @Email
    //@Value("${person.last‐name}")
    private String lastName;
    //@Value("#{11*2}")
    private Integer age;
    //@Value("true")
    private Boolean boss;
    private Date birth;
    private Map<String,Object> maps;
    private List<Object> lists;
    private Dog dog;
 }

3.5、@PropertySource&@ImportResource&@Bean

@PropertySource：加载指定的配置文件；

/**
* 将配置文件中配置的每一个属性的值，映射到这个组件中
* @ConfigurationProperties：通知 SpringBoot 将本类中的所有属性和配置文件中相干的配置进行绑定；* prefix = "person"：配置文件中哪个上面的所有属性进行一一映射
*
* 只有这个组件是容器中的组件，能力容器提供的 @ConfigurationProperties 性能；* @ConfigurationProperties(prefix = "person")默认从全局配置文件中获取值；*
*/
@PropertySource(value = {"classpath:person.properties"})
@Component
@ConfigurationProperties(prefix = "person")
//@Validated
public class Person {
    /**
    * <bean class="Person">
    * <property name="lastName" value=" 字面量 /${key}从环境变量、配置文件中获取值 /#
    {SpEL}"></property>
    * <bean/>
    */
    //lastName 必须是邮箱格局
    // @Email
    //@Value("${person.last‐name}")
    private String lastName;
    //@Value("#{11*2}")
    private Integer age;
    //@Value("true")
    private Boolean boss;}

@ImportResource：导入 Spring 的配置文件，让配置文件外面的内容失效；

Spring Boot 外面没有 Spring 的配置文件，咱们本人编写的配置文件，也不能自动识别；想让 Spring

的配置文件失效，加载进来；须要将 @ImportResource 标注在一个配置类上，导入 Spring 的配置文件让其失效

@ImportResource(locations = {"classpath:beans.xml"})

自定义的 Spring 配置文件

<?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.xsd">
<bean id="helloService" class="com.atguigu.springboot.service.HelloService"></bean>
</beans>

SpringBoot 举荐给容器中增加组件的形式；举荐应用全注解的形式

1. 配置类@Configuration——>Spring 配置文件

2. 应用 @Bean 给容器中增加组件

   /**
   * @Configuration：指明以后类是一个配置类；就是来代替之前的 Spring 配置文件
   * 在配置文件中用 <bean><bean/> 标签增加组件
   */
   @Configuration
       public class MyAppConfig {
       // 将办法的返回值增加到容器中；容器中这个组件默认的 id 就是办法名
       @Bean
       public HelloService helloService02(){System.out.println("配置类 @Bean 给容器中增加组件了...");
       return new HelloService();}
   }

3.6、配置文件占位符

1、随机数

${random.value}、${random.int}、${random.long}
${random.int(10)}、${random.int[1024,65536]}

2、占位符获取之前配置的值，如果没有能够是用 : 指定默认值

person.last‐name= 张三 ${random.uuid}
person.age=${random.int}
person.birth=2017/12/15
person.boss=false
person.maps.k1=v1
person.maps.k2=14
person.lists=a,b,c
person.dog.name=${person.hello:hello}_dog
person.dog.age=15

3.7、Profile

3.7.1、多 Profile 文件

咱们在主配置文件编写的时候，文件名能够是 application-{profile}.properties/yml

默认应用 application.properties 的配置；

3.7.2、yml 反对多文档块形式

server:
    port: 8081
spring:
    profiles:
    active: prod
‐‐‐
server:
    port: 8083
spring:
    profiles: dev
‐‐‐
server:
    port: 8084
    spring:
profiles: prod #指定属于哪个环境

3.7.3、激活指定 profile

1、在配置文件中指定 spring.profiles.active=dev

2、命令行：

java -jar spring-boot-02-config-0.0.1-SNAPSHOT.jar --spring.profiles.active=dev；能够间接在测试的时候，配置传入命令行参数

3、虚拟机参数；

-Dspring.profiles.active=dev

3.8、配置文件加载地位

springboot 启动会扫描以下地位的 application.properties 或者 application.yml 文件作为 Spring boot 的默认配置文件

• file:./config/
• file:./
• classpath:/config/
• classpath:/

<mark> 优先级由高到底，高优先级的配置会笼罩低优先级的配置；</mark>

SpringBoot 会从这四个地位全副加载主配置文件；互补配置；

咱们还能够通过 spring.config.location 来扭转默认的配置文件地位

我的项目打包好当前，咱们能够应用命令行参数的模式，启动我的项目的时候来指定配置文件的新地位；指定配置文件和默 认加载的这些配置文件独特起作用造成互补配置；

java -jar spring-boot-02-config-02-0.0.1-SNAPSHOT.jar --spring.config.location=G:/application.properties

3.9、内部配置加载程序

SpringBoot也能够从以下地位加载配置；优先级从高到低；高优先级的配置笼罩低优先级的配置，所有的配置会造成互补配置

1. 命令行参数

   所有的配置都能够在命令行上进行指定

   java -jar spring-boot-02-config-02-0.0.1-SNAPSHOT.jar --server.port=8087 --server.context-path=/abc

   多个配置用空格离开；– 配置项 = 值

2. 来 自 java:comp/env 的 JNDI 属 性
3. Java 零碎属性（System.getProperties()）
4. 操作系统环境变量
5. RandomValuePropertySource 配置的 random.* 属性值

由 jar 包内向 jar 包内进行寻找；优先加载带profile

6. jar包内部的 application-{profile}.properties 或application.yml(带 spring.profile) 配置文件
7. jar包外部的 application-{profile}.properties 或application.yml(带 spring.profile) 配置文件

再来加载不带profile

8. jar 包内部的 application.properties 或 application.yml(不带 spring.profile)配置文件

9. jar包外部的 application.properties 或application.yml(不带 spring.profile) 配置文件

   10.@Configuration 注解类上的 @PropertySource

   11. 通过 SpringApplication.setDefaultProperties 指定的默认属性所有反对的配置加载起源；

参考官网文档

3.10、主动配置原理

配置文件到底能写什么？怎么写？主动配置原理；配置文件能配置的属性参照

3.10.1、主动配置原理：

1）、SpringBoot 启动的时候加载主配置类，开启了主动配置性能 @EnableAutoConfiguration

2）、@EnableAutoConfiguration 作用：

• 利用 AutoConfigurationImportSelector 给容器中导入一些组件
• 能够查看 selectImports()办法的内容；
• List configurations = getCandidateConfigurations(annotationMetadata, attributes); 获取候选的配置

SpringFactoriesLoader.loadFactoryNames()

扫描所有 jar 包类门路下 META‐INF/spring.factories，把扫描到的这些文件的内容包装成 properties 对象
从 properties 中获取到 EnableAutoConfiguration.class类（类名）对应的值，而后把他们增加在容器
中

将类门路下 META-INF/spring.factories 外面配置的所有 EnableAutoConfiguration 的值退出到了容器中；

# Auto Configure
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.springframework.boot.autoconfigure.admin.SpringApplicationAdminJmxAutoConfiguration,\
org.springframework.boot.autoconfigure.aop.AopAutoConfiguration,\
org.springframework.boot.autoconfigure.amqp.RabbitAutoConfiguration,\
org.springframework.boot.autoconfigure.batch.BatchAutoConfiguration,\
org.springframework.boot.autoconfigure.cache.CacheAutoConfiguration,\
org.springframework.boot.autoconfigure.cassandra.CassandraAutoConfiguration,\
org.springframework.boot.autoconfigure.cloud.CloudAutoConfiguration,\
org.springframework.boot.autoconfigure.context.ConfigurationPropertiesAutoConfiguration,\
org.springframework.boot.autoconfigure.context.MessageSourceAutoConfiguration,\
org.springframework.boot.autoconfigure.context.PropertyPlaceholderAutoConfiguration,\
org.springframework.boot.autoconfigure.couchbase.CouchbaseAutoConfiguration,\
org.springframework.boot.autoconfigure.dao.PersistenceExceptionTranslationAutoConfiguration,
\
org.springframework.boot.autoconfigure.data.cassandra.CassandraDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.cassandra.CassandraRepositoriesAutoConfiguration
,\
org.springframework.boot.autoconfigure.data.couchbase.CouchbaseDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.couchbase.CouchbaseRepositoriesAutoConfiguration
,\
org.springframework.boot.autoconfigure.data.elasticsearch.ElasticsearchAutoConfiguration,\
org.springframework.boot.autoconfigure.data.elasticsearch.ElasticsearchDataAutoConfiguration

每一个这样的 xxxAutoConfiguration 类都是容器中的一个组件，都退出到容器中；用他们来做主动配置；

3）、每一个主动配置类进行主动配置性能；

4）、以 HttpEncodingAutoConfiguration（Http 编码主动配置）为例解释主动配置原理；

    @Configuration  // 示意这是一个配置类，以前编写的配置文件一样，也能够给容器中增加组件
    @EnableConfigurationProperties(HttpEncodingProperties.class) // 启动指定类的
    //ConfigurationProperties 性能；将配置文件中对应的值和 HttpEncodingProperties 绑定起来；并把
     //       HttpEncodingProperties 退出到 ioc 容器中
    @ConditionalOnWebApplication //Spring 底层 @Conditional 注解（Spring 注解版），依据不同的条件，如     // 果满足指定的条件，整个配置类外面的配置就会失效；判断以后利用是否是 web 利用，如果是，以后配置类失效
    @ConditionalOnClass(CharacterEncodingFilter.class) // 判断以后我的项目有没有这个类
      // CharacterEncodingFilter；SpringMVC 中进行乱码解决的过滤器；@ConditionalOnProperty(prefix = "spring.http.encoding", value = "enabled", matchIfMissing = true) // 判断配置文件中是否存在某个配置 spring.http.encoding.enabled；如果不存在，判断也是成立的即便咱们配置文件中不配置 pring.http.encoding.enabled=true，也是默认失效的；public class HttpEncodingAutoConfiguration {
        // 他曾经和 SpringBoot 的配置文件映射了
        private final HttpEncodingProperties properties;
        // 只有一个有参结构器的状况下，参数的值就会从容器中拿
        public HttpEncodingAutoConfiguration(HttpEncodingProperties properties) {this.properties = properties;}
        @Bean // 给容器中增加一个组件，这个组件的某些值须要从 properties 中获取
        @ConditionalOnMissingBean(CharacterEncodingFilter.class) // 判断容器没有这个组件？public CharacterEncodingFilter characterEncodingFilter() {CharacterEncodingFilter filter = new OrderedCharacterEncodingFilter();
            filter.setEncoding(this.properties.getCharset().name());
            filter.setForceRequestEncoding(this.properties.shouldForce(Type.REQUEST));
            filter.setForceResponseEncoding(this.properties.shouldForce(Type.RESPONSE));
            return filter;
        }

依据以后不同的条件判断，决定这个配置类是否失效

一但这个配置类失效；这个配置类就会给容器中增加各种组件；这些组件的属性是从对应的 properties 类中获取 的，这些类外面的每一个属性又是和配置文件绑定的；

5）、所有在配置文件中能配置的属性都是在 xxxxProperties 类中封装者‘；配置文件能配置什么就能够参照某个功 能对应的这个属性类

@ConfigurationProperties(prefix = "spring.http.encoding") // 从配置文件中获取指定的值和 bean 的属
性进行绑定
public class HttpEncodingProperties {public static final Charset DEFAULT_CHARSET = Charset.forName("UTF‐8");

精华：

1）、SpringBoot启动会加载大量的主动配置类

2）、咱们看咱们须要的性能有没有 SpringBoot 默认写好的主动配置类；

3）、咱们再来看这个主动配置类中到底配置了哪些组件；（只有咱们要用的组件有，咱们就不须要再来配置了）

4）、给容器中主动配置类增加组件的时候，会从 properties 类中获取某些属性。咱们就能够在配置文件中指定这 些属性的值；

xxxxAutoConfigurartion：主动配置类；给容器中增加组件

xxxxProperties: 封装配置文件中相干属性；

3.10.2、细节

1、@Conditional派生注解（Spring注解版原生的 @Conditional 作用）

作用：必须是 @Conditional 指定的条件成立，才给容器中增加组件，配置外面的所有内容才失效；

主动配置类必须在肯定的条件下能力失效；咱们怎么晓得哪些主动配置类失效；

咱们能够通过启用 debug=true属性；来让控制台打印主动配置报告，这样咱们就能够很不便的晓得哪些主动配置类失效；

=========================
AUTO‐CONFIGURATION REPORT
=========================
Positive matches:（主动配置类启用的）‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
DispatcherServletAutoConfiguration matched:
‐ @ConditionalOnClass found required class
'org.springframework.web.servlet.DispatcherServlet'; @ConditionalOnMissingClass did not find
unwanted class (OnClassCondition)
‐ @ConditionalOnWebApplication (required) found StandardServletEnvironment
(OnWebApplicationCondition)
Negative matches:（没有启动，没有匹配胜利的主动配置类）‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
ActiveMQAutoConfiguration:
Did not match:
‐ @ConditionalOnClass did not find required classes 'javax.jms.ConnectionFactory',
'org.apache.activemq.ActiveMQConnectionFactory' (OnClassCondition)
AopAutoConfiguration:
Did not match:
‐ @ConditionalOnClass did not find required classes
'org.aspectj.lang.annotation.Aspect', 'org.aspectj.lang.reflect.Advice' (OnClassCondition)

三、日志

日志的具体介绍和 logback 的应用点击——> 缕清各种 Java Logging

1、日志框架

Java 大猿帅在很久很久以前，要开发一个大型零碎的心路和倒退历程；

1、System.out.println(“”)；将要害数据打印在控制台；去掉？写在一个文件？

2、框架来记录零碎的一些运行时信息；日志框架；biglogging.jar；

3、高大上的几个性能？异步模式？主动归档？xxxx？biglogging-good.jar？

4、将以前框架卸下来？换上新的框架，从新批改之前相干的 API；biglogging-prefect.jar；

5、JDBC— 数据库驱动；

6、写了一个对立的接口层；日志门面（日志的一个形象层）；logging-abstract.jar；给我的项目中导入具体的日志实现就行了；咱们之前的日志框架都是实现的形象层；

市面上的日志框架；

JUL、JCL、Jboss-logging、logback、log4j、log4j2、slf4j….

右边选一个门面（形象层）、左边来选一个实现；我蒙着眼轻易选两个，日志门面选：SLF4J，日志实现选：Logback（居然和 SpringBoot 的设计者选的一样，英雄所见略同呀）；

SpringBoot：底层是 Spring 框架，Spring 框架默认是用 JCL；SpringBoot选用 SLF4j和logback；

2、SLF4j 应用

1、如何在零碎中应用 SLF4j

当前开发的时候，日志记录办法的调用，不应该来间接调用日志的实现类，而是调用日志形象层外面的办法；给零碎外面导入 slf4j 的 jar 和 logback 的实现 jar

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class HelloWorld {public static void main(String[] args) {Logger logger = LoggerFactory.getLogger(HelloWorld.class);
  logger.info("Hello World");    
  }
}    

每一个日志的实现框架都有本人的配置文件。应用 slf4j 当前，配置文件还是做成日志实现框架本人自身的配置文 件；

2、遗留问题

SpringBoot（slf4j+logback）: Spring（commons-logging）、Hibernate（jboss-logging）、MyBatis、xxxx

对立日志记录，即便是别的框架和我一起对立应用 slf4j 进行输入？

如何让零碎中所有的日志都对立到slf4j；

1、将零碎中其余日志框架先排除进来；

2、用两头包来替换原有的日志框架；

3、咱们导入 slf4j 其余的实现

3、SpringBoot 日志关系

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

SpringBoot 应用它来做日志性能；

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring‐boot‐starter‐logging</artifactId>
</dependency>

总结：

1. SpringBoot 底层也是应用 slf4j+logback 的形式进行日志记录
2. SpringBoot 也把其余的日志都替换成了 slf4j；

3. 两头替换包

   @SuppressWarnings("rawtypes")
   public abstract class LogFactory {
   static String UNSUPPORTED_OPERATION_IN_JCL_OVER_SLF4J =
   "http://www.slf4j.org/codes.html#unsupported_operation_in_jcl_over_slf4j";
   static LogFactory logFactory = new SLF4JLogFactory();

4. 如果咱们要引入其余框架？肯定要把这个框架的默认日志依赖移除掉

   Spring 框架用的是 commons-logging；

   <dependency>
       <groupId>org.springframework</groupId>
       <artifactId>spring‐core</artifactId>
       <exclusions>
           <exclusion>
               <groupId>commons‐logging</groupId>
               <artifactId>commons‐logging</artifactId>
           </exclusion>
       </exclusions>
   </dependency>

SpringBoot能主动适配所有的日志，而且底层应用 slf4j+logback 的形式记录日志，引入其余框架的时候，只须要把这个框架依赖的日志框架排除掉即可；

4、日志应用

4.1、默认配置

SpringBoot 默认帮咱们配置好了日志；

// 记录器
Logger logger = LoggerFactory.getLogger(getClass());
@Test
public void contextLoads() {//System.out.println();
    // 日志的级别；// 由低到高 trace<debug<info<warn<error
    // 能够调整输入的日志级别；日志就只会在这个级别以当前的高级别失效
    logger.trace("这是 trace 日志...");
    logger.debug("这是 debug 日志...");
    //SpringBoot 默认给咱们应用的是 info 级别的，没有指定级别的就用 SpringBoot 默认规定的级别；root
    级别
    logger.info("这是 info 日志...");
    logger.warn("这是 warn 日志...");
    logger.error("这是 error 日志...");
}

日志输入格局：%d 示意日期工夫，%thread 示意线程名，%‐5level：级别从左显示 5 个字符宽度
%logger{50} 示意 logger 名字最长 50 个字符，否则依照句点宰割。%msg：日志音讯，%n 是换行符
‐‐>
%d{yyyy‐MM‐dd HH:mm:ss.SSS} [%thread] %‐5level %logger{50} ‐ %msg%n

SpringBoot 批改日志的默认配置

logging.level.cn.starfish=trace
#logging.path=
# 不指定门路在以后我的项目下生成 springboot.log 日志
# 能够指定残缺的门路；#logging.file=G:/springboot.log
# 在以后磁盘的根门路下创立 spring 文件夹和外面的 log 文件夹；应用 spring.log 作为默认文件
logging.path=/spring/log
# 在控制台输入的日志的格局
logging.pattern.console=%d{yyyy‐MM‐dd} [%thread] %‐5level %logger{50} ‐ %msg%n
# 指定文件中日志输入的格局
logging.pattern.file=%d{yyyy‐MM‐dd} === [%thread] === %‐5level === %logger{50} ==== %msg%n

4.2、指定配置

给类门路下放上每个日志框架本人的配置文件即可；SpringBoot 就不应用他默认配置的了

logback.xml：间接就被日志框架辨认了；

logback-spring.xml：日志框架就不间接加载日志的配置项，由 SpringBoot 解析日志配置，能够应用 SpringBoot

的高级 Profile 性能

<springProfile name="staging">
<!‐‐ configuration to be enabled when the "staging" profile is active ‐‐>
能够指定某段配置只在某个环境下失效
</springProfile>

如：

<appender name="stdout" class="ch.qos.logback.core.ConsoleAppender">
<!‐‐
   日志输入格局：%d 示意日期工夫，%thread 示意线程名，%‐5level：级别从左显示 5 个字符宽度
   %logger{50} 示意 logger 名字最长 50 个字符，否则依照句点宰割。%msg：日志音讯，%n 是换行符
‐‐>
<layout class="ch.qos.logback.classic.PatternLayout">
<springProfile name="dev">
<pattern>%d{yyyy‐MM‐dd HH:mm:ss.SSS} ‐‐‐‐> [%thread] ‐‐‐> %‐5level
%logger{50} ‐ %msg%n</pattern>
</springProfile>
<springProfile name="!dev">
<pattern>%d{yyyy‐MM‐dd HH:mm:ss.SSS} ==== [%thread] ==== %‐5level
%logger{50} ‐ %msg%n</pattern>
</springProfile>
</layout>
</appender>

如果应用 logback.xml 作为日志配置文件，还要应用 profile 性能，会有以下谬误

no applicable action for [springProfile]

5、切换日志框架

能够依照 slf4j 的日志适配图，进行相干的切换；

slf4j+log4j 的形式；

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring‐boot‐starter‐web</artifactId>
    <exclusions>
        <exclusion>
        <artifactId>logback‐classic</artifactId>
        <groupId>ch.qos.logback</groupId>
        </exclusion>
    <exclusion>
        <artifactId>log4j‐over‐slf4j</artifactId>
        <groupId>org.slf4j</groupId>
        </exclusion>
    </exclusions>
</dependency>
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j‐log4j12</artifactId>
</dependency>

切换为 log4j2

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring‐boot‐starter‐web</artifactId>
  <exclusions>
      <exclusion>
          <artifactId>spring‐boot‐starter‐logging</artifactId>
          <groupId>org.springframework.boot</groupId>
      </exclusion>
  </exclusions>
</dependency>
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring‐boot‐starter‐log4j2</artifactId>
</dependency>

四、Web 开发

1、应用 SpringBoot

1）、创立 SpringBoot 利用，选中咱们须要的模块；

2）、SpringBoot曾经默认将这些场景配置好了，只须要在配置文件中指定大量配置就能够运行起来

3）、本人编写业务代码；

2、SpringBoot 对动态资源的映射规定；

一层一层的剥开 SpringBoot 到 ResourceProperties，能够看到加载 resource 的门路程序，以及属性的一些操作链（SpringBoot1.xx 的版本是继承了 ResourceLoaderAware，2.xx 和 1.xx 的变动还挺大饿）。

• 所有 /webjars/**，都去 classpath:/META-INF/resources/webjars/ 找资源；

  webjars：以 jar 包的形式引入动态资源；

  localhost:8080/webjars/jquery/3.3.1/jquery.js

<!‐‐引入 jquery‐webjar‐‐> 在拜访的时候只须要写 webjars 上面资源的名称即可
<dependency>
    <groupId>org.webjars</groupId>
    <artifactId>jquery</artifactId>
    <version>3.3.1</version>
</dependency>

• “/**” 拜访以后我的项目的任何资源，都去（动态资源的文件夹）找映射

  "classpath:/META‐INF/resources/",
  "classpath:/resources/",
  "classpath:/static/",
  "classpath:/public/"
  "/"：以后我的项目的根门路

localhost:8080/abc === 去动态资源文件夹外面找 abc

• 欢送页；动态资源文件夹下的所有 index.html 页面；被 ”/**” 映射；

  localhost:8080/ 找 index 页面

• 所有的 **/favicon.ico 都是在动态资源文件下找；

3、模板引擎

常见的模板引擎：JSP、Velocity、Freemarker、Thymeleaf

SpringBoot 举荐的 Thymeleaf；语法更简略，性能更弱小；

3.1、引入 thymeleaf；

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring‐boot‐starter‐thymeleaf</artifactId>
</dependency>
<!-- 切换 thymeleaf 版本 -->
<properties>
<thymeleaf.version>3.0.9.RELEASE</thymeleaf.version>
<!‐‐布局性能的反对程序 thymeleaf3 主程序 layout2 以上版本‐‐>
<!‐‐ thymeleaf2 layout1‐‐>
<thymeleaf‐layout‐dialect.version>2.2.2</thymeleaf‐layout‐dialect.version>
</properties>

3.2、Thymeleaf 应用

@ConfigurationProperties(prefix = "spring.thymeleaf")
public class ThymeleafProperties {private static final Charset DEFAULT_ENCODING = Charset.forName("UTF‐8");
private static final MimeType DEFAULT_CONTENT_TYPE = MimeType.valueOf("text/html");
public static final String DEFAULT_PREFIX = "classpath:/templates/";
public static final String DEFAULT_SUFFIX = ".html";

只有咱们把 HTML 页面放在 classpath:/templates/，thymeleaf 就能主动渲染；

1. 导入 thymeleaf 的名称空间

   <html lang="en" xmlns:th="http://www.thymeleaf.org">

2. 应用 thymeleaf 语法；

   <!DOCTYPE html>
   <html lang="en" xmlns:th="http://www.thymeleaf.org">
   <head>
   <meta charset="UTF‐8">
   <title>Title</title>
   </head>
   <body>
   <h1> 胜利！</h1>
   <!‐‐th:text 将 div 外面的文本内容设置为 ‐‐>
   <div th:text="${hello}"> 这是显示欢送信息 </div>
   </body>
   </html>

3.3、语法规定

1）、th:text；扭转以后元素外面的文本内容；

​ th：任意 html 属性；来替换原生属性的值

2）、表达式

Simple expressions:（表达式语法）Variable Expressions: ${...}：获取变量值；OGNL；1）、获取对象的属性、调用办法
2）、应用内置的根本对象：#ctx : the context object.
#vars: the context variables.
#locale : the context locale.
#request : (only in Web Contexts) the HttpServletRequest object.
#response : (only in Web Contexts) the HttpServletResponse object.
#session : (only in Web Contexts) the HttpSession object.
#servletContext : (only in Web Contexts) the ServletContext object.
${session.foo}
3）、内置的一些工具对象：#execInfo : information about the template being processed.
#messages : methods for obtaining externalized messages inside variables expressions, in the
same way as they would be obtained using #{…} syntax.
#uris : methods for escaping parts of URLs/URIs
#conversions : methods for executing the configured conversion service (if any).
#dates : methods for java.util.Date objects: formatting, component extraction, etc.
#calendars : analogous to #dates , but for java.util.Calendar objects.
#numbers : methods for formatting numeric objects.
#strings : methods for String objects: contains, startsWith, prepending/appending, etc.
#objects : methods for objects in general.
#bools : methods for boolean evaluation.
#arrays : methods for arrays.
#lists : methods for lists.
#sets : methods for sets.
#maps : methods for maps.
#aggregates : methods for creating aggregates on arrays or collections.
#ids : methods for dealing with id attributes that might be repeated (for example, as a
result of an iteration).
Selection Variable Expressions: *{...}：抉择表达式：和 ${}在性能上是一样；补充：配合 th:object="${session.user}：<div th:object="${session.user}">
<p>Name: <span th:text="*{firstName}">Sebastian</span>.</p>
<p>Surname: <span th:text="*{lastName}">Pepper</span>.</p>
<p>Nationality: <span th:text="*{nationality}">Saturn</span>.</p>
</div>
Message Expressions: #{...}：获取国际化内容
Link URL Expressions: @{...}：定义 URL；@{/order/process(execId=${execId},execType='FAST')}
Fragment Expressions: ~{...}：片段援用表达式
<div th:insert="~{commons :: main}">...</div>
Literals（字面量）Text literals: 'one text' , 'Another one!' ,…
Number literals: 0 , 34 , 3.0 , 12.3 ,…
Boolean literals: true , false
Null literal: null
Literal tokens: one , sometext , main ,…
Text operations:（文本操作）String concatenation: +
Literal substitutions: |The name is ${name}|
Arithmetic operations:（数学运算）Binary operators: + , ‐ , * , / , %

4、SpringMVC 主动配置

4.1、Spring MVC auto-configuration

Spring Boot 主动配置好了 SpringMVC

以下是 SpringBoot 对 SpringMVC 的默认配置:（WebMvcAutoConfiguration）

• Inclusion of ContentNegotiatingViewResolver and BeanNameViewResolver beans.

  • 主动配置了 ViewResolver（视图解析器：依据办法的返回值失去视图对象（View），视图对象决定如何 渲染（转发？重定向？））
  • ContentNegotiatingViewResolver：组合所有的视图解析器的；
  • 如何定制：咱们能够本人给容器中增加一个视图解析器；主动的将其组合进来；
• Support for serving static resources, including support for WebJars (see below). 动态资源文件夹路 径,webjars
• Static index.html support. 动态首页拜访
• Custom Favicon support (see below). favicon.ico
• 主动注册了 of Converter , GenericConverter , Formatter beans. Converter：转换器；public String hello(User user)：类型转换应用 Converter Formatter 格式化器；2017.12.17===Date；

@Bean
@ConditionalOnProperty(prefix = "spring.mvc", name = "date‐format")// 在文件中配置日期格
式化的规定
public Formatter<Date> dateFormatter() {return new DateFormatter(this.mvcProperties.getDateFormat());// 日期格式化组件
}

本人增加的格式化器转换器，咱们只须要放在容器中即可

• Support for HttpMessageConverters (see below).

  • HttpMessageConverter：SpringMVC 用来转换 Http 申请和响应的；User—Json
  • HttpMessageConverters 是从容器中确定；获取所有的 HttpMessageConverter；本人给容器中增加 HttpMessageConverter，只须要将本人的组件注册容器中（@Bean,@Component）
• Automatic registration of MessageCodesResolver (see below). 定义谬误代码生成规定
• Automatic use of a ConfigurableWebBindingInitializer bean (see below). 咱们能够配置一个 ConfigurableWebBindingInitializer 来替换默认的；（增加到容器）

4.2、扩大 SpringMVC

<mvc:view‐controller path="/hello" view‐name="success"/>
<mvc:interceptors>
    <mvc:interceptor>
        <mvc:mapping path="/hello"/>
        <bean></bean>
    </mvc:interceptor>
</mvc:interceptors>

编写一个配置类（@Configuration），是 WebMvcConfigurerAdapter 类型；不能标注 @EnableWebMvc;

既保留了所有的主动配置，也能用咱们扩大的配置；

// 应用 WebMvcConfigurerAdapter 能够来扩大 SpringMVC 的性能
@Configuration
    public class MyMvcConfig extends WebMvcConfigurerAdapter {
    @Override
    public void addViewControllers(ViewControllerRegistry registry) {// super.addViewControllers(registry);
    // 浏览器发送 /atguigu 申请来到 success
    registry.addViewController("/atguigu").setViewName("success");
    }
}

原理：

1）、WebMvcAutoConfiguration 是 SpringMVC 的主动配置类

2）、在做其余主动配置时会导入；@Import(EnableWebMvcConfiguration.class)

@Configuration
public static class EnableWebMvcConfiguration extends DelegatingWebMvcConfiguration {private final WebMvcConfigurerComposite configurers = new WebMvcConfigurerComposite();
    // 从容器中获取所有的 WebMvcConfigurer
    @Autowired(required = false)
    public void setConfigurers(List<WebMvcConfigurer> configurers) {if (!CollectionUtils.isEmpty(configurers)) {this.configurers.addWebMvcConfigurers(configurers);
    // 一个参考实现；将所有的 WebMvcConfigurer 相干配置都来一起调用；@Override
    // public void addViewControllers(ViewControllerRegistry registry) {// for (WebMvcConfigurer delegate : this.delegates) {// delegate.addViewControllers(registry);
    // }
        }
    }
}

3）、容器中所有的 WebMvcConfigurer 都会一起起作用；

4）、咱们的配置类也会被调用；

成果：SpringMVC 的主动配置和咱们的扩大配置都会起作用；

4.3、全面接管 SpringMVC；

SpringBoot 对 SpringMVC 的主动配置不须要了，所有都是咱们本人配置；所有的 SpringMVC 的主动配置都生效了 咱们须要在配置类中增加 @EnableWebMvc 即可；

// 应用 WebMvcConfigurerAdapter 能够来扩大 SpringMVC 的性能
@EnableWebMvc
@Configuration
public class MyMvcConfig extends WebMvcConfigurerAdapter {
@Override
public void addViewControllers(ViewControllerRegistry registry) {// super.addViewControllers(registry);
    // 浏览器发送 /atguigu 申请来到 success
    registry.addViewController("/atguigu").setViewName("success");
    }
}

原理：

为什么 @EnableWebMvc 主动配置就生效了；

1）@EnableWebMvc 的外围

@Import(DelegatingWebMvcConfiguration.class)
public @interface EnableWebMvc {

2）、

@Configuration
public class DelegatingWebMvcConfiguration extends WebMvcConfigurationSupport {

3）、

@Configuration
@ConditionalOnWebApplication
@ConditionalOnClass({ Servlet.class, DispatcherServlet.class,
WebMvcConfigurerAdapter.class })
// 容器中没有这个组件的时候，这个主动配置类才失效
@ConditionalOnMissingBean(WebMvcConfigurationSupport.class)
@AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE + 10)
@AutoConfigureAfter({ DispatcherServletAutoConfiguration.class,
ValidationAutoConfiguration.class })
public class WebMvcAutoConfiguration {

4）、@EnableWebMvc 将 WebMvcConfigurationSupport 组件导入进来；

5）、导入的 WebMvcConfigurationSupport 只是 SpringMVC 最根本的性能；

5、如何批改 SpringBoot 的默认配置

模式：

1）、SpringBoot 在主动配置很多组件的时候，先看容器中有没有用户本人配置的（@Bean、@Component）如 果有就用用户配置的，如果没有，才主动配置；如果有些组件能够有多个（ViewResolver）将用户配置的和本人默 认的组合起来；

2）、在 SpringBoot 中会有十分多的 xxxConfigurer 帮忙咱们进行扩大配置

3）、在 SpringBoot 中会有很多的 xxxCustomizer 帮忙咱们进行定制配置

6、RestfulCRUD

1）、默认拜访首页

// 应用 WebMvcConfigurerAdapter 能够来扩大 SpringMVC 的性能
//@EnableWebMvc 不要接管 SpringMVC
@Configuration
public class MyMvcConfig extends WebMvcConfigurerAdapter {
    @Override
    public void addViewControllers(ViewControllerRegistry registry) {// super.addViewControllers(registry);
        // 浏览器发送 /atguigu 申请来到 success
        registry.addViewController("/atguigu").setViewName("success");
    }
    // 所有的 WebMvcConfigurerAdapter 组件都会一起起作用
    @Bean // 将组件注册在容器
    public WebMvcConfigurerAdapter webMvcConfigurerAdapter(){WebMvcConfigurerAdapter adapter = new WebMvcConfigurerAdapter() {
            @Override
            public void addViewControllers(ViewControllerRegistry registry) {registry.addViewController("/").setViewName("login");
                registry.addViewController("/index.html").setViewName("login");
            }
        };
        return adapter;
    }
}

2）、国际化

• 编写国际化配置文件；
• 应用 ResourceBundleMessageSource 治理国际化资源文件
• 在页面应用 fmt:message 取出国际化内容

步骤：

a、编写国际化配置文件，抽取页面须要显示的国际化音讯

b、SpringBoot 主动配置好了治理国际化资源文件的组件；

@ConfigurationProperties(prefix = "spring.messages")
public class MessageSourceAutoConfiguration {
    /**
     * Comma‐separated list of basenames (essentially a fully‐qualified classpath
     * location), each following the ResourceBundle convention with relaxed support for
     * slash based locations. If it doesn't contain a package qualifier (such as
     * "org.mypackage"), it will be resolved from the classpath root.
     */
    private String basename = "messages";
    // 咱们的配置文件能够间接放在类门路下叫 messages.properties；@Bean
    public MessageSource messageSource() {ResourceBundleMessageSource messageSource = new ResourceBundleMessageSource();
        if (StringUtils.hasText(this.basename)) {
// 设置国际化资源文件的根底名（去掉语言国家代码的）messageSource.setBasenames(StringUtils.commaDelimitedListToStringArray(StringUtils.trimAllWhitespace(this.basename)));
        }
        if (this.encoding != null) {messageSource.setDefaultEncoding(this.encoding.name());
        }
        messageSource.setFallbackToSystemLocale(this.fallbackToSystemLocale);
        messageSource.setCacheSeconds(this.cacheSeconds);
        messageSource.setAlwaysUseMessageFormat(this.alwaysUseMessageFormat);
        return messageSource;
    }

 @ConfigurationProperties(prefix  =  "spring.messages")  
public  class  MessageSourceAutoConfiguration  { 3

           private  String  basename  =  "messages";
           // 咱们的配置文件能够间接放在类门路下叫 messages.properties；12

           @Bean
           public  MessageSource  messageSource()  {ResourceBundleMessageSource  messageSource  =  new  ResourceBundleMessageSource();
                   if  (StringUtils.hasText(this.basename))  {
                            // 设置国际化资源文件的根底名（去掉语言国家代码的）messageSource.setBasenames(StringUtils.commaDelimitedListToStringArray(StringUtils.trimAllWhitespace(this.basename))); 20     }

                   if (this.encoding != null) {messageSource.setDefaultEncoding(this.encoding.name()); 23    }

                   messageSource.setFallbackToSystemLocale(this.fallbackToSystemLocale);

                   messageSource.setCacheSeconds(this.cacheSeconds);

                   messageSource.setAlwaysUseMessageFormat(this.alwaysUseMessageFormat);

           return  messageSource; 28        }

c、去页面获取国际化的值；

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
<meta http‐equiv="Content‐Type" content="text/html; charset=UTF‐8">
<meta name="viewport" content="width=device‐width, initial‐scale=1, shrink‐to‐
fit=no">
<meta name="description" content="">
<meta name="author" content="">
<title>Signin Template for Bootstrap</title>
<!‐‐ Bootstrap core CSS ‐‐>
<link href="asserts/css/bootstrap.min.css"
th:href="@{/webjars/bootstrap/4.0.0/css/bootstrap.css}" rel="stylesheet">
<!‐‐ Custom styles for this template ‐‐>
<link href="asserts/css/signin.css" th:href="@{/asserts/css/signin.css}"
rel="stylesheet">
</head>
<body class="text‐center">
<form class="form‐signin" action="dashboard.html">
<img class="mb‐4" th:src="@{/asserts/img/bootstrap‐solid.svg}"
src="asserts/img/bootstrap‐solid.svg" alt=""width="72"height="72">
<h1 class="h3 mb‐3 font‐weight‐normal" th:text="#{login.tip}">Please sign
in</h1>
<label class="sr‐only" th:text="#{login.username}">Username</label>
<input type="text" class="form‐control" placeholder="Username" th:placeholder="#
{login.username}"required="" autofocus="">
<label class="sr‐only" th:text="#{login.password}">Password</label>
<input type="password" class="form‐control" placeholder="Password"
th:placeholder="#{login.password}" required="">
<div class="checkbox mb‐3">
<label>
<input type="checkbox" value="remember‐me"/> [[#{login.remember}]]
</label>
</div>
<button class="btn btn‐lg btn‐primary btn‐block" type="submit" th:text="#
{login.btn}">Sign in</button>
<p class="mt‐5 mb‐3 text‐muted">© 2017‐2018</p>
<a class="btn btn‐sm"> 中文 </a>
<a class="btn btn‐sm">English</a>
</form>
</body>
</html>

成果：依据浏览器语言设置的信息切换了国际化；

原理：

国际化 Locale（区域信息对象）；LocaleResolver（获取区域信息对象）；默认的就是依据申请头带来的区域信息获取 Locale 进行国际化

@Bean
@ConditionalOnMissingBean
@ConditionalOnProperty(prefix = "spring.mvc", name = "locale")
public LocaleResolver localeResolver() {
    if (this.mvcProperties
    .getLocaleResolver() == WebMvcProperties.LocaleResolver.FIXED) {return new FixedLocaleResolver(this.mvcProperties.getLocale());
    }
    AcceptHeaderLocaleResolver localeResolver = new AcceptHeaderLocaleResolver();
    localeResolver.setDefaultLocale(this.mvcProperties.getLocale());
    return localeResolver;
}

d、点击链接切换国际化

/**
 * 能够在连贯上携带区域信息
 */
public class MyLocaleResolver implements LocaleResolver {
    @Override
    public Locale resolveLocale(HttpServletRequest request) {String l = request.getParameter("l");
        Locale locale = Locale.getDefault();
        if(!StringUtils.isEmpty(l)){String[] split = l.split("_");
            locale = new Locale(split[0],split[1]);
        }
        return locale;
    }
    @Override
    public void setLocale(HttpServletRequest request, HttpServletResponse response, Locale
            locale) {}}
    @Bean
    public LocaleResolver localeResolver(){return new MyLocaleResolver();
    }
}

3）、登陆

开发期间模板引擎页面批改当前，要实时失效

​ a、禁用模板引擎的缓存

# 禁用缓存
spring.thymeleaf.cache=false

​ b、页面批改实现当前 ctrl+f9：从新编译；登陆谬误音讯的显示

<p style="color: red" th:text="${msg}" th:if="${not #strings.isEmpty(msg)}"></p>

4）、拦截器进行登陆查看

拦截器

/**
 * 登陆查看，*/
public class LoginHandlerInterceptor implements HandlerInterceptor {
    // 指标办法执行之前
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response,
                             Object handler) throws Exception {Object user = request.getSession().getAttribute("loginUser");
        if(user == null){
// 未登陆，返回登陆页面
            request.setAttribute("msg","没有权限请先登陆");
            request.getRequestDispatcher("/index.html").forward(request,response);
            return false;
        }else{
// 已登陆，放行申请
            return true;
        }
    }
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object
            handler, ModelAndView modelAndView) throws Exception { }
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response,
                                Object handler, Exception ex) throws Exception { }

注册拦截器

 // 所有的 WebMvcConfigurerAdapter 组件都会一起起作用
   @Bean // 将组件注册在容器
   public WebMvcConfigurerAdapter webMvcConfigurerAdapter(){WebMvcConfigurerAdapter adapter = new WebMvcConfigurerAdapter() {
           @Override
           public void addViewControllers(ViewControllerRegistry registry) {registry.addViewController("/").setViewName("login");
               registry.addViewController("/index.html").setViewName("login");
               registry.addViewController("/main.html").setViewName("dashboard");
           }
           // 注册拦截器
           @Override
           public void addInterceptors(InterceptorRegistry registry) {//super.addInterceptors(registry);
// 动态资源；*.css , *.js
//SpringBoot 曾经做好了动态资源映射
               registry.addInterceptor(new
                       LoginHandlerInterceptor()).addPathPatterns("/**")
                       .excludePathPatterns("/index.html","/","/user/login");
           }
       };
       return adapter;
   }

5）、CRUD- 员工列表

试验要求：

a、RestfulCRUD：CRUD 满足 Rest 格调；

URI：/ 资源名称 / 资源标识 HTTP 申请形式辨别对资源 CRUD 操作

b、试验的申请架构;

c、员工列表：

thymeleaf公共页面元素抽取

1、抽取公共片段
<div th:fragment="copy">
&copy; 2011 The Good Thymes Virtual Grocery
</div>
2、引入公共片段
<div th:insert="~{footer :: copy}"></div>
~{templatename::selector}：模板名:: 选择器
~{templatename::fragmentname}: 模板名:: 片段名
3、默认成果：insert 的公共片段在 div 标签中
如果应用 th:insert 等属性进行引入，能够不必写~{}：行内写法能够加上：[[~{}]];[(~{})]；

三种引入公共片段的 th 属性：

th:insert：将公共片段整个插入到申明引入的元素中

th:replace：将申明引入的元素替换为公共片段

th:include：将被引入的片段的内容蕴含进这个标签中

<footer th:fragment="copy">
&copy; 2011 The Good Thymes Virtual Grocery
</footer>
引入形式
<div th:insert="footer :: copy"></div>
引入片段的时候传入参数：6）、CRUD- 员工增加
增加页面
<div th:replace="footer :: copy"></div>
<div th:include="footer :: copy"></div>
成果
<div>
<footer>
&copy; 2011 The Good Thymes Virtual Grocery
</footer>
</div>
<footer>
&copy; 2011 The Good Thymes Virtual Grocery
</footer>
<div>
&copy; 2011 The Good Thymes Virtual Grocery
</div>

7、错误处理机制

1）、SpringBoot 默认的错误处理机制

默认成果：

a、浏览器，返回一个默认的谬误页面

b、如果是其余客户端，默认响应一个 json 数据

原理：

能够参照 ErrorMvcAutoConfiguration；错误处理的主动配置；给容器中增加了以下组件

1. DefaultErrorAttributes：帮咱们在页面共享信息；

   @Override
   public Map<String, Object> getErrorAttributes(RequestAttributes requestAttributes,
                                                 boolean includeStackTrace) {Map<String, Object> errorAttributes = new LinkedHashMap<String, Object>();
       errorAttributes.put("timestamp", new Date());
       addStatus(errorAttributes, requestAttributes);
       addErrorDetails(errorAttributes, requestAttributes, includeStackTrace);
       addPath(errorAttributes, requestAttributes);
       return errorAttributes;
   }

2. BasicErrorController：解决默认 /error 申请

   @Controller
   @RequestMapping("${server.error.path:${error.path:/error}}")
   public class BasicErrorController extends AbstractErrorController {@RequestMapping(produces = "text/html")// 产生 html 类型的数据；浏览器发送的申请来到这个办法解决
       public ModelAndView errorHtml(HttpServletRequest request,
                                     HttpServletResponse response) {HttpStatus status = getStatus(request);
           Map<String, Object> model = Collections.unmodifiableMap(getErrorAttributes(request, isIncludeStackTrace(request, MediaType.TEXT_HTML)));
           response.setStatus(status.value());
   // 去哪个页面作为谬误页面；蕴含页面地址和页面内容
           ModelAndView modelAndView = resolveErrorView(request, response, status, model);
           return (modelAndView == null ? new ModelAndView("error", model) : modelAndView);
       }
       @RequestMapping
       @ResponseBody // 产生 json 数据，其余客户端来到这个办法解决；public ResponseEntity<Map<String, Object>> error(HttpServletRequest request) {
           Map<String, Object> body = getErrorAttributes(request,
                   isIncludeStackTrace(request, MediaType.ALL));
           HttpStatus status = getStatus(request);
           return new ResponseEntity<Map<String, Object>>(body, status);
       }

3. ErrorPageCustomizer：

   @Value("${error.path:/error}")
   // 零碎呈现谬误当前来到 error 申请进行解决；（web.xml 注册的谬误页面规定）private String path = "/error"; 

4. DefaultErrorViewResolver：

       @Override
       public ModelAndView resolveErrorView(HttpServletRequest request, HttpStatus status,
                                            Map<String, Object> model) {ModelAndView modelAndView = resolve(String.valueOf(status), model);
           if (modelAndView == null && SERIES_VIEWS.containsKey(status.series())) {modelAndView = resolve(SERIES_VIEWS.get(status.series()), model);
           }
           return modelAndView;
       }
       private ModelAndView resolve(String viewName, Map<String, Object> model) {
           // 默认 SpringBoot 能够去找到一个页面？error/404
           String errorViewName = "error/" + viewName;
           // 模板引擎能够解析这个页面地址就用模板引擎解析
           TemplateAvailabilityProvider provider = this.templateAvailabilityProviders
                   .getProvider(errorViewName, this.applicationContext);
           if (provider != null) {
               // 模板引擎可用的状况下返回到 errorViewName 指定的视图地址
               return new ModelAndView(errorViewName, model);
           }
           // 模板引擎不可用，就在动态资源文件夹下找 errorViewName 对应的页面 error/404.html
           return resolveResource(errorViewName, model);
       } 

步骤：

一但零碎呈现 4xx 或者 5xx 之类的谬误；ErrorPageCustomizer 就会失效（定制谬误的响应规定）；就会来到 /error 申请；就会被 BasicErrorController 解决；

1. 响应页面；去哪个页面是由 DefaultErrorViewResolver 解析失去的；

   protected ModelAndView resolveErrorView(HttpServletRequest request,
                                           HttpServletResponse response, HttpStatus status, Map<String, Object> model) {
       // 所有的 ErrorViewResolver 失去 ModelAndView
       for (ErrorViewResolver resolver : this.errorViewResolvers) {ModelAndView modelAndView = resolver.resolveErrorView(request, status, model);
           if (modelAndView != null) {return modelAndView;}
       }
       return null;
   }

2)、如何定制谬误响应：

a. 如何定制谬误的页面；

• 有模板引擎的状况下；error/状态码;【将谬误页面命名为 谬误状态码.html 放在模板引擎文件夹外面 error 文件夹下】，产生此状态码的谬误就会来到对应的页面；

  咱们能够应用 4xx 和 5xx 作为谬误页面的文件名来匹配这种类型的所有谬误，准确优先（优先寻找准确的状态 码.html）；

  页面能获取的信息:timestamp：

  • 工夫戳
  • status：状态码
  • error：谬误提醒 exception：异样对象
  • message：异样音讯
  • errors：JSR303 数据校验的谬误都在这里
• 没有模板引擎（模板引擎找不到这个谬误页面），动态资源文件夹下找；
• 以上都没有谬误页面，就是默认来到 SpringBoot 默认的谬误提醒页面；

b. 如何定制谬误的 json 数据；

• 自定义异样解决 & 返回定制 json 数据；

  @ControllerAdvice
  public class MyExceptionHandler {
      @ResponseBody
      @ExceptionHandler(UserNotExistException.class)
      public Map<String,Object> handleException(Exception e){Map<String,Object> map = new HashMap<>();
          map.put("code","user.notexist");
          map.put("message",e.getMessage());
          return map;
      }
  }
  // 没有自适应成果...

• 转发到 /error 进行自适应响应成果解决

  @ExceptionHandler(UserNotExistException.class)
  public String handleException(Exception e, HttpServletRequest request){Map<String,Object> map = new HashMap<>();
      // 传入咱们本人的谬误状态码 4xx 5xx，否则就不会进入定制谬误页面的解析流程
      /**
      * Integer statusCode = (Integer) request
      .getAttribute("javax.servlet.error.status_code");
      */
      request.setAttribute("javax.servlet.error.status_code",500);
      map.put("code","user.notexist");
      map.put("message",e.getMessage());
      // 转发到 /error
      return "forward:/error";
  }

3）、将咱们的定制数据携带进来；

呈现谬误当前，会来到 /error 申请，会被 BasicErrorController 解决，响应进来能够获取的数据是由

getErrorAttributes 失去的（是 AbstractErrorController（ErrorController）规定的办法）；

1. 齐全来编写一个 ErrorController 的实现类【或者是编写 AbstractErrorController 的子类】，放在容器中；

2. 页面上能用的数据，或者是 json 返回能用的数据都是通过 errorAttributes.getErrorAttributes 失去；容器中 DefaultErrorAttributes.getErrorAttributes()；默认进行数据处理的；

   自定义 ErrorAttributes

   // 给容器中退出咱们本人定义的 ErrorAttributes
   @Component
   public class MyErrorAttributes extends DefaultErrorAttributes {
       @Override
       public Map<String, Object> getErrorAttributes(RequestAttributes requestAttributes,
                                                     boolean includeStackTrace) {
           Map<String, Object> map = super.getErrorAttributes(requestAttributes,
                   includeStackTrace);
           map.put("company","atguigu");
           return map;
       }

   最终的成果：响应是自适应的，能够通过定制 ErrorAttributes 扭转须要返回的内容，

8、配置嵌入式 Servlet 容器

SpringBoot 默认应用 Tomcat 作为嵌入式的 Servlet 容器；

1）、如何定制和批改 Servlet 容器的相干配置；

1. 批改和 server 无关的配置（ServerProperties【也是 EmbeddedServletContainerCustomizer】）；

   server.port=8081
   server.context‐path=/crud
   server.tomcat.uri‐encoding=UTF‐8
   // 通用的 Servlet 容器设置
   server.xxx
   //Tomcat 的设置
   server.tomcat.xxx

2. 编写一个EmbeddedServletContainerCustomizer：嵌入式的 Servlet 容器的定制器；来批改 Servlet 容器的配置

   @Bean // 肯定要将这个定制器退出到容器中
   public EmbeddedServletContainerCustomizer embeddedServletContainerCustomizer(){return new EmbeddedServletContainerCustomizer() {
           // 定制嵌入式的 Servlet 容器相干的规定
           @Override
           public void customize(ConfigurableEmbeddedServletContainer container) {container.setPort(8083);
           }
       };
   }

2）、注册 Servlet 三大组件【Servlet、Filter、Listener】

因为 SpringBoot 默认是以 jar 包的形式启动嵌入式的 Servlet 容器来启动 SpringBoot 的 web 利用，没有 web.xml 文 件。

注册三大组件用以下形式

ServletRegistrationBean

// 注册三大组件
@Bean
public ServletRegistrationBean myServlet(){
    ServletRegistrationBean registrationBean = new ServletRegistrationBean(new
MyServlet(),"/myServlet");
    return registrationBean;
}

FilterRegistrationBean

@Bean
public FilterRegistrationBean myFilter(){FilterRegistrationBean registrationBean = new FilterRegistrationBean();
    registrationBean.setFilter(new MyFilter());
    registrationBean.setUrlPatterns(Arrays.asList("/hello","/myServlet"));
    return registrationBean;
}

ServletListenerRegistrationBean

@Bean
public ServletListenerRegistrationBean myListener(){
    ServletListenerRegistrationBean<MyListener> registrationBean = new
    ServletListenerRegistrationBean<>(new MyListener());
    return registrationBean;
}

SpringBoot 帮咱们主动配置 SpringMVC 的时候，主动的注册 SpringMVC 的前端控制器；DIspatcherServlet；

DispatcherServletAutoConfiguration中：

@Bean(name = DEFAULT_DISPATCHER_SERVLET_REGISTRATION_BEAN_NAME)
@ConditionalOnBean(value = DispatcherServlet.class, name =
                   DEFAULT_DISPATCHER_SERVLET_BEAN_NAME)
public ServletRegistrationBean dispatcherServletRegistration(DispatcherServlet dispatcherServlet) {
    ServletRegistrationBean registration = new ServletRegistrationBean(dispatcherServlet, this.serverProperties.getServletMapping());
    // 默认拦挡：/ 所有申请；包动态资源，然而不拦挡 jsp 申请；/* 会拦挡 jsp
    // 能够通过 server.servletPath 来批改 SpringMVC 前端控制器默认拦挡的申请门路
    registration.setName(DEFAULT_DISPATCHER_SERVLET_BEAN_NAME);
    registration.setLoadOnStartup(this.webMvcProperties.getServlet().getLoadOnStartup());
    if (this.multipartConfig != null) {registration.setMultipartConfig(this.multipartConfig);
    }
    return registration;
}

3）、替换为其余嵌入式 Servlet 容器

默认反对：

Tomcat（默认应用）

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring‐boot‐starter‐web</artifactId>
    引入 web 模块默认就是应用嵌入式的 Tomcat 作为 Servlet 容器；</dependency>

Jetty

<!‐‐ 引入 web 模块 ‐‐>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring‐boot‐starter‐web</artifactId>
    <exclusions>
        <exclusion>
            <artifactId>spring‐boot‐starter‐tomcat</artifactId>
            <groupId>org.springframework.boot</groupId>
        </exclusion>
    </exclusions>
</dependency>
<!‐‐引入其余的 Servlet 容器‐‐>
<dependency>
    <artifactId>spring‐boot‐starter‐jetty</artifactId>
    <groupId>org.springframework.boot</groupId>
</dependency>

Undertow

<!‐‐ 引入 web 模块 ‐‐>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring‐boot‐starter‐web</artifactId>
    <exclusions>
    <exclusion>
        <artifactId>spring‐boot‐starter‐tomcat</artifactId>
        <groupId>org.springframework.boot</groupId>
    </exclusion>
    </exclusions>
</dependency>
<!‐‐引入其余的 Servlet 容器‐‐>
<dependency>
    <artifactId>spring‐boot‐starter‐undertow</artifactId>
    <groupId>org.springframework.boot</groupId>
</dependency>

4）、嵌入式 Servlet 容器主动配置原理；

EmbeddedServletContainerAutoConfiguration：嵌入式的 Servlet 容器主动配置？

@AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE)
@Configuration
@ConditionalOnWebApplication
@Import(BeanPostProcessorsRegistrar.class)
// 导入 BeanPostProcessorsRegistrar：Spring 注解版；给容器中导入一些组件
// 导入了 EmbeddedServletContainerCustomizerBeanPostProcessor：// 后置处理器：bean 初始化前后（创立完对象，还没赋值赋值）执行初始化工作
public class EmbeddedServletContainerAutoConfiguration {
   @Configuration
   @ConditionalOnClass({Servlet.class, Tomcat.class})// 判断以后是否引入了 Tomcat 依赖；@ConditionalOnMissingBean(value = EmbeddedServletContainerFactory.class, search =
           SearchStrategy.CURRENT)// 判断以后容器没有用户本人定义 EmbeddedServletContainerFactory：嵌入式的
   Servlet 容器工厂；作用：创立嵌入式的 Servlet 容器
   public static class EmbeddedTomcat {
       @Bean
       public TomcatEmbeddedServletContainerFactory tomcatEmbeddedServletContainerFactory()
       {return new TomcatEmbeddedServletContainerFactory();
       }
   }
   /**
    * Nested configuration if Jetty is being used.
    */
   @Configuration
   @ConditionalOnClass({ Servlet.class, Server.class, Loader.class,
           WebAppContext.class })
   @ConditionalOnMissingBean(value = EmbeddedServletContainerFactory.class, search =
           SearchStrategy.CURRENT)
   public static class EmbeddedJetty {
       @Bean
       public JettyEmbeddedServletContainerFactory jettyEmbeddedServletContainerFactory() {return new JettyEmbeddedServletContainerFactory();
       }
   }
   /**
    * Nested configuration if Undertow is being used.
    */
   @Configuration
   @ConditionalOnClass({Servlet.class, Undertow.class, SslClientAuthMode.class})
   @ConditionalOnMissingBean(value = EmbeddedServletContainerFactory.class, search =
           SearchStrategy.CURRENT)
   public static class EmbeddedUndertow {
       @Bean
       public UndertowEmbeddedServletContainerFactory
       undertowEmbeddedServletContainerFactory() {return new UndertowEmbeddedServletContainerFactory();
       }
   }

1. EmbeddedServletContainerFactory（嵌入式 Servlet 容器工厂）

   public interface EmbeddedServletContainerFactory {
       // 获取嵌入式的 Servlet 容器
       EmbeddedServletContainer getEmbeddedServletContainer(ServletContextInitializer... initializers);
   }

2. EmbeddedServletContainer：（嵌入式的 Servlet 容器）

3. 以 TomcatEmbeddedServletContainerFactory 为例

    @Override
       public EmbeddedServletContainer getEmbeddedServletContainer(ServletContextInitializer... initializers) {
   // 创立一个 Tomcat
           Tomcat tomcat = new Tomcat();
   // 配置 Tomcat 的根本环节
           File baseDir = (this.baseDirectory != null ? this.baseDirectory
                   : createTempDir("tomcat"));
           tomcat.setBaseDir(baseDir.getAbsolutePath());
           Connector connector = new Connector(this.protocol);
           tomcat.getService().addConnector(connector);
           customizeConnector(connector);
           tomcat.setConnector(connector);
           tomcat.getHost().setAutoDeploy(false);
           configureEngine(tomcat.getEngine());
           for (Connector additionalConnector : this.additionalTomcatConnectors) {tomcat.getService().addConnector(additionalConnector);
           }
           prepareContext(tomcat.getHost(), initializers);
   // 将配置好的 Tomcat 传入进去，返回一个 EmbeddedServletContainer；并且启动 Tomcat 服务器
           return getTomcatEmbeddedServletContainer(tomcat);

   咱们对嵌入式容器的配置批改是怎么失效？

   ServerProperties、EmbeddedServletContainerCustomizer

   EmbeddedServletContainerCustomizer：定制器帮咱们批改了 Servlet 容器的配置？怎么批改的原理？

   容器中导入了 EmbeddedServletContainerCustomizerBeanPostProcessor

    // 初始化之前
       @Override
       public Object postProcessBeforeInitialization(Object bean, String beanName)
               throws BeansException {
   // 如果以后初始化的是一个 ConfigurableEmbeddedServletContainer 类型的组件
           if (bean instanceof ConfigurableEmbeddedServletContainer) {
   //
               postProcessBeforeInitialization((ConfigurableEmbeddedServletContainer) bean);
           }
           return bean;
       }
       private void postProcessBeforeInitialization(ConfigurableEmbeddedServletContainer bean) {
   // 获取所有的定制器，调用每一个定制器的 customize 办法来给 Servlet 容器进行属性赋值；for (EmbeddedServletContainerCustomizer customizer : getCustomizers()) {customizer.customize(bean);
           }
       }
       private Collection<EmbeddedServletContainerCustomizer> getCustomizers() {if (this.customizers == null) {
   // Look up does not include the parent context
               this.customizers = new ArrayList<EmbeddedServletContainerCustomizer>(
                       this.beanFactory
   // 从容器中获取所有这葛类型的组件：EmbeddedServletContainerCustomizer
   // 定制 Servlet 容器，给容器中能够增加一个 EmbeddedServletContainerCustomizer 类型的组件
                               .getBeansOfType(EmbeddedServletContainerCustomizer.class,
                                       false, false)
                               .values());
               Collections.sort(this.customizers, AnnotationAwareOrderComparator.INSTANCE);
               this.customizers = Collections.unmodifiableList(this.customizers);
           }
           return this.customizers;
       }
   ServerProperties 也是定制器

   步骤：

   a、SpringBoot 依据导入的依赖状况，给容器中增加相应的

   ​ EmbeddedServletContainerFactory【TomcatEmbeddedServletContainerFactory】

   b、容器中某个组件要创建对象就会轰动后置处理器；EmbeddedServletContainerCustomizerBeanPostProcessor；

   只有是嵌入式的 Servlet 容器工厂，后置处理器就工作；

   c、后置处理器，从容器中获取所有的EmbeddedServletContainerCustomizer，调用定制器的定制办法

5）、嵌入式 Servlet 容器启动原理；

什么时候创立嵌入式的 Servlet 容器工厂？

什么时候获取嵌入式的 Servlet 容器并启动 Tomcat；获取嵌入式的 Servlet 容器工厂：

1. SpringBoot 利用启动运行 run 办法
2. refreshContext(context);SpringBoot 刷新 IOC 容器【创立 IOC 容器对象，并初始化容器，创立容器中的每一个 组 件】；如 果 是 web 应 用 创 建 AnnotationConfigEmbeddedWebApplicationContext，否 则：AnnotationConfigApplicationContext

3. refresh(context); 刷新方才创立好的 ioc 容器；

   public void refresh() throws BeansException, IllegalStateException {synchronized (this.startupShutdownMonitor) {
   // Prepare this context for refreshing.
   prepareRefresh();
   // Tell the subclass to refresh the internal bean factory.
   ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
   // Prepare the bean factory for use in this context.
   prepareBeanFactory(beanFactory);
   try {
   // Allows post‐processing of the bean factory in context subclasses.
   

4. onRefresh(); web 的 ioc 容器重写了 onRefresh 办法
5. webioc 容器会创立嵌入式的 Servlet 容器；createEmbeddedServletContainer();

6. 获取嵌入式的 Servlet 容器工厂：

   EmbeddedServletContainerFactory containerFactory = getEmbeddedServletContainerFactory();

   从 ioc 容器中获取 EmbeddedServletContainerFactory 组件；TomcatEmbeddedServletContainerFactory创建对象，后置处理器一看是这个对象，就获取所有的定制器来先定制 Servlet 容器的相干配置；

7. 应用容器工厂获取嵌入式的 Servlet 容器：

   this.embeddedServletContainer = containerFactory
   .getEmbeddedServletContainer(getSelfInitializer());

8. 嵌入式的 Servlet 容器创建对象并启动 Servlet 容器；

   先启动嵌入式的 Servlet 容器，再将 ioc 容器中剩下没有创立出的对象获取进去；

   IOC容器启动创立嵌入式的 Servlet 容器

9、应用外置的 Servlet 容器

9.1. 嵌入式 Servlet 容器：

利用打成可执行的 jar

长处：简略、便携；

毛病：默认不反对 JSP、优化定制比较复杂（应用定制器【ServerProperties、自定义

EmbeddedServletContainerCustomizer】，本人编写嵌入式 Servlet 容器的创立工厂

【EmbeddedServletContainerFactory】）；

9.2. 外置的 Servlet 容器

里面装置 Tomcat— 利用 war 包的形式打包；

步骤

1. 必须创立一个 war 我的项目；（利用 idea 创立好目录构造）

2. 将嵌入式的 Tomcat 指定为 provided；

   <dependency>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring‐boot‐starter‐tomcat</artifactId>
       <scope>provided</scope>
   </dependency>
    

3. 必须编写一个 SpringBootServletInitializer 的子类，并调用 configure 办法

   public class ServletInitializer extends SpringBootServletInitializer {
       @Override
       protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
   // 传入 SpringBoot 利用的主程序
           return application.sources(SpringBoot04WebJspApplication.class);
       }
   }

4. 启动服务器就能够应用；

9.3. 原理

• jar 包：执行 SpringBoot 主类的 main 办法——> 启动 ioc 容器——> 创立嵌入式的 Servlet 容器；
• war 包：启动服务器——> 服务器启动 SpringBoot 利用【SpringBootServletInitializer】——> 启动 ioc 容器；

servlet3.0（Spring 注解版）：

Shared libraries / runtimes pluggability：规定：

1. 服务器启动（web 利用启动）会创立以后 web 利用外面每一个 jar 包外面 ServletContainerInitializer 实例：

2. ServletContainerInitializer 的实现放在 jar 包的 META-INF/services 文件夹下，有一个名为

   javax.servlet.ServletContainerInitializer 的文件，内容就是 ServletContainerInitializer 的实现类的全类名

3. 还能够应用 @HandlesTypes，在利用启动的时候加载咱们感兴趣的类；

流程：

1. 启动 Tomcat

2. org\springframework\spring-web\4.3.14.RELEASE\spring-web-4.3.14.RELEASE.jar!\META- INF\services\javax.servlet.ServletContainerInitializer：

   Spring 的 web 模块外面有这个文件：org.springframework.web.SpringServletContainerInitializer

3. SpringServletContainerInitializer 将 @HandlesTypes(WebApplicationInitializer.class)标注的所有这个类型的类都传入到 onStartup 办法的 Set>；为这些 WebApplicationInitializer 类型的类创立实例；
4. 每一个 WebApplicationInitializer 都调用本人的 onStartup；
5. 相当于咱们的 SpringBootServletInitializer 的类会被创建对象，并执行 onStartup 办法

6. SpringBootServletInitializer 实例执行 onStartup 的时候会 createRootApplicationContext；创立容器

   protected WebApplicationContext createRootApplicationContext(ServletContext servletContext) {
   //1、创立 SpringApplicationBuilder
           SpringApplicationBuilder builder = createSpringApplicationBuilder();
           StandardServletEnvironment environment = new StandardServletEnvironment();
           environment.initPropertySources(servletContext, null);
           builder.environment(environment);
           builder.main(getClass());
           ApplicationContext parent = getExistingRootWebApplicationContext(servletContext);
           if (parent != null) {this.logger.info("Root context already created (using as parent).");
               servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, null);
               builder.initializers(new ParentContextApplicationContextInitializer(parent));
           }
           builder.initializers(new ServletContextApplicationContextInitializer(servletContext));
           builder.contextClass(AnnotationConfigEmbeddedWebApplicationContext.class);
   // 调用 configure 办法，子类重写了这个办法，将 SpringBoot 的主程序类传入了进来
           builder = configure(builder);
   // 应用 builder 创立一个 Spring 利用
           SpringApplication application = builder.build();
           if (application.getSources().isEmpty() && AnnotationUtils
                   .findAnnotation(getClass(), Configuration.class) != null) {application.getSources().add(getClass());
           }
           Assert.state(!application.getSources().isEmpty(),
                   "No SpringApplication sources have been defined. Either override the"
                           + "configure method or add an @Configuration annotation");
   // Ensure error pages are registered
           if (this.registerErrorPageFilter) {application.getSources().add(ErrorPageFilterConfiguration.class);
           }
   // 启动 Spring 利用
           return run(application);
       }

7. Spring 的利用就启动并且创立 IOC 容器

    public ConfigurableApplicationContext run(String... args) {StopWatch stopWatch = new StopWatch();
           stopWatch.start();
           ConfigurableApplicationContext context = null;
           FailureAnalyzers analyzers = null;
           configureHeadlessProperty();
           SpringApplicationRunListeners listeners = getRunListeners(args);
           listeners.starting();
           try {
               ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
               ConfigurableEnvironment environment = prepareEnvironment(listeners,
                       applicationArguments);
               Banner printedBanner = printBanner(environment);
               context = createApplicationContext();
               analyzers = new FailureAnalyzers(context);
               prepareContext(context, environment, listeners, applicationArguments,
                       printedBanner);
   // 刷新 IOC 容器
               refreshContext(context);
               afterRefresh(context, applicationArguments);
               listeners.finished(context, null);
               stopWatch.stop();
               if (this.logStartupInfo) {new StartupInfoLogger(this.mainApplicationClass)
                           .logStarted(getApplicationLog(), stopWatch);
               }
               return context;
           }
           catch (Throwable ex) {handleRunFailure(context, listeners, analyzers, ex);
               throw new IllegalStateException(ex);
           }
       }
   

启动 Servlet 容器，再启动 SpringBoot 利用

五、SpringBoot 与数据拜访

1、JDBC

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring‐boot‐starter‐jdbc</artifactId>
    </dependency>
    <dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql‐connector‐java</artifactId>
    <scope>runtime</scope>
</dependency>

spring:
  datasource:
  username: root
  password: 123456
  url: jdbc:mysql://192.168.15.22:3306/jdbc
  driver‐class‐name: com.mysql.jdbc.Driver

默认是用 org.apache.tomcat.jdbc.pool.DataSource 作为数据源；

数据源的相干配置都在 DataSourceProperties 外面；

主动配置原理：

org.springframework.boot.autoconfigure.jdbc：

1. 参考 DataSourceConfiguration，依据配置创立数据源，默认应用 Tomcat 连接池；能够应用

   spring.datasource.type 指定自定义的数据源类型；

2. SpringBoot 默认能够反对；

   org.apache.tomcat.jdbc.pool.DataSource、HikariDataSource、BasicDataSource、

3. 自定义数据源类型

   /**
   * Generic DataSource configuration.
   */
   @ConditionalOnMissingBean(DataSource.class)
   @ConditionalOnProperty(name = "spring.datasource.type")
   static class Generic {
       @Bean
   public DataSource dataSource(DataSourceProperties properties) {
       // 应用 DataSourceBuilder 创立数据源，利用反射创立响应 type 的数据源，并且绑定相干属性
       return properties.initializeDataSourceBuilder().build();
    }
   }
   

4. DataSourceInitializer：ApplicationListener；

   作用：

• runSchemaScripts(); 运行建表语句；
• runDataScripts(); 运行插入数据的 sql 语句；

默认只须要将文件命名为：

schema‐*.sql、data‐*.sql
默认规定：schema.sql，schema‐all.sql；能够应用
schema:
‐ classpath:department.sql
指定地位

5. 操作数据库：主动配置了 JdbcTemplate 操作数据库

2、整合 Druid 数据源

<dependency>
   <groupId>com.alibaba</groupId>
   <artifactId>druid-spring-boot-starter</artifactId>
   <version>1.1.10</version>
</dependency>

@Configuration
public class DruidConfig {@ConfigurationProperties(prefix = "spring.datasource")
    @Bean
    public DataSource druid(){return new DruidDataSource();
    }
    // 配置 Druid 的监控
//1、配置一个治理后盾的 Servlet
    @Bean
    public ServletRegistrationBean statViewServlet(){ServletRegistrationBean bean = new ServletRegistrationBean(new StatViewServlet(),
                "/druid/*");
        Map<String,String> initParams = new HashMap<>();
        initParams.put("loginUsername","admin");
        initParams.put("loginPassword","123456");
        initParams.put("allow","");// 默认就是容许所有拜访
        initParams.put("deny","192.168.15.21");
        bean.setInitParameters(initParams);
        return bean;
    }
    //2、配置一个 web 监控的 filter
    @Bean
    public FilterRegistrationBean webStatFilter(){FilterRegistrationBean bean = new FilterRegistrationBean();
        bean.setFilter(new WebStatFilter());
        Map<String,String> initParams = new HashMap<>();
        initParams.put("exclusions","*.js,*.css,/druid/*");
        bean.setInitParameters(initParams);
        bean.setUrlPatterns(Arrays.asList("/*"));
        return bean;
    }
}

3、整合MyBatis

<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis‐spring‐boot‐starter</artifactId>
    <version>1.3.1</version>
</dependency>

步骤：

1. 配置数据源相干属性
2. 给数据库建表
3. 创立 JavaBean

4. 注解版

   // 指定这是一个操作数据库的 mapper
   @Mapper
   public interface DepartmentMapper {@Select("select * from department where id=#{id}")
       public Department getDeptById(Integer id);
       @Delete("delete from department where id=#{id}")
       public int deleteDeptById(Integer id);
       @Options(useGeneratedKeys = true,keyProperty = "id")
       @Insert("insert into department(departmentName) values(#{departmentName})")
       public int insertDept(Department department);
       @Update("update department set departmentName=#{departmentName} where id=#{id}")
       public int updateDept(Department department);
   }

   问题：

   自定义 MyBatis 的配置规定；给容器中增加一个 ConfigurationCustomizer；

   @org.springframework.context.annotation.Configuration
   public class MyBatisConfig {
       @Bean
       public ConfigurationCustomizer configurationCustomizer(){return new ConfigurationCustomizer(){
               @Override
               public void customize(Configuration configuration) {configuration.setMapUnderscoreToCamelCase(true);
               }
           };
       }
   }
   
   

   应用 MapperScan 批量扫描所有的 Mapper 接口；@MapperScan(value = "com.atguigu.springboot.mapper")
   @SpringBootApplication
   public class SpringBoot06DataMybatisApplication {public static void main(String[] args) {SpringApplication.run(SpringBoot06DataMybatisApplication.class, args);
       }
   }

5. 配置文件版

   mybatis:
       config‐location: classpath:mybatis/mybatis‐config.xml 指定全局配置文件的地位
       mapper‐locations: classpath:mybatis/mapper/*.xml 指定 sql 映射文件的地位
   

官网教程

4、整合 SpringData JPA

1. 编写一个实体类（bean）和数据表进行映射，并且配置好映射关系；

   // 应用 JPA 注解配置映射关系
   @Entity // 通知 JPA 这是一个实体类（和数据表映射的类）@Table(name = "tbl_user") //@Table 来指定和哪个数据表对应; 如果省略默认表名就是 user；public class User {
       @Id // 这是一个主键
       @GeneratedValue(strategy = GenerationType.IDENTITY)// 自增主键
       private Integer id;
       @Column(name = "last_name",length = 50) // 这是和数据表对应的一个列
       private String lastName;
       @Column // 省略默认列名就是属性名
       private String email;

2. 编写一个 Dao 接口来操作实体类对应的数据表（Repository）

   // 继承 JpaRepository 来实现对数据库的操作
   public interface UserRepository extends JpaRepository<User,Integer> {}

3. 根本的配置 JpaProperties

   spring:
   jpa:
   hibernate:
   # 更新或者创立数据表构造
   ddl‐auto: update
   # 控制台显示 SQL
   show‐sql: true

   ---

六、启动配置原理

几个重要的事件回调机制

配置在 META-INF/spring.factories

ApplicationContextInitializer

SpringApplicationRunListener

只须要放在 ioc 容器中ApplicationRunner CommandLineRunner

启动流程：

1、创立 SpringApplication 对象

    initialize(sources);
    private void initialize(Object[] sources) {
// 保留主配置类
        if (sources != null && sources.length > 0) {this.sources.addAll(Arrays.asList(sources));
        }
// 判断以后是否一个 web 利用
        this.webEnvironment = deduceWebEnvironment();
// 从类门路下找到 META‐INF/spring.factories 配置的所有 ApplicationContextInitializer；而后保留起
        来
        setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
// 从类门路下找到 ETA‐INF/spring.factories 配置的所有 ApplicationListener
        setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
// 从多个配置类中找到有 main 办法的主配置类
        this.mainApplicationClass = deduceMainApplicationClass();}

2、运行 run 办法

public ConfigurableApplicationContext run(String... args) {StopWatch stopWatch = new StopWatch();
        stopWatch.start();
        ConfigurableApplicationContext context = null;
        FailureAnalyzers analyzers = null;
        configureHeadlessProperty();
// 获取 SpringApplicationRunListeners；从类门路下 META‐INF/spring.factories
        SpringApplicationRunListeners listeners = getRunListeners(args);
// 回调所有的获取 SpringApplicationRunListener.starting()办法
        listeners.starting();
        try {
// 封装命令行参数
            ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
// 筹备环境
            ConfigurableEnvironment environment = prepareEnvironment(listeners,
                    applicationArguments);
// 创立环境实现后回调 SpringApplicationRunListener.environmentPrepared()；示意环境准
            备实现
            Banner printedBanner = printBanner(environment);
// 创立 ApplicationContext；决定创立 web 的 ioc 还是一般的 ioc
            context = createApplicationContext();
            analyzers = new FailureAnalyzers(context);
// 筹备上下文环境; 将 environment 保留到 ioc 中；而且 applyInitializers()；//applyInitializers()：回调之前保留的所有的 ApplicationContextInitializer 的 initialize 办法
// 回调所有的 SpringApplicationRunListener 的 contextPrepared()；//
            prepareContext(context, environment, listeners, applicationArguments,
                    printedBanner);
//prepareContext 运行实现当前回调所有的 SpringApplicationRunListener 的 contextLoaded（）；// s 刷新容器；ioc 容器初始化（如果是 web 利用还会创立嵌入式的 Tomcat）；Spring 注解版
// 扫描，创立，加载所有组件的中央；（配置类，组件，主动配置）refreshContext(context);
// 从 ioc 容器中获取所有的 ApplicationRunner 和 CommandLineRunner 进行回调
//ApplicationRunner 先回调，CommandLineRunner 再回调
            afterRefresh(context, applicationArguments);
// 所有的 SpringApplicationRunListener 回调 finished 办法
            listeners.finished(context, null);
            stopWatch.stop();
            if (this.logStartupInfo) {new StartupInfoLogger(this.mainApplicationClass)
                        .logStarted(getApplicationLog(), stopWatch);
            }
// 整个 SpringBoot 利用启动实现当前返回启动的 ioc 容器；return context;
        }
        catch (Throwable ex) {handleRunFailure(context, listeners, analyzers, ex);
            throw new IllegalStateException(ex);
        }
    }

3、事件监听机制

配置在 META-INF/spring.factories ApplicationContextInitializer

public class HelloApplicationContextInitializer implements
    ApplicationContextInitializer<ConfigurableApplicationContext> {
    @Override
    public void initialize(ConfigurableApplicationContext applicationContext) {System.out.println("ApplicationContextInitializer...initialize..."+applicationContext);
    }
}

SpringApplicationRunListener

配置（META-INF/spring.factories）

org.springframework.context.ApplicationContextInitializer=\
com.atguigu.springboot.listener.HelloApplicationContextInitializer
org.springframework.boot.SpringApplicationRunListener=\
com.atguigu.springboot.listener.HelloSpringApplicationRunListener

只须要放在 ioc 容器中

ApplicationRunner

@Component
   public class HelloApplicationRunner implements ApplicationRunner {
   @Override
   public void run(ApplicationArguments args) throws Exception {System.out.println("ApplicationRunner...run....");
   }
}

CommandLineRunner

@Component
public class HelloCommandLineRunner implements CommandLineRunner {
    @Override
    public void run(String... args) throws Exception {System.out.println("CommandLineRunner...run..."+ Arrays.asList(args));
    }
}

七、自定义 starter

starter：

1、这个场景须要应用到的依赖是什么？

2、如何编写主动配置

@Configuration // 指定这个类是一个配置类
@ConditionalOnXXX // 在指定条件成立的状况下主动配置类失效
@AutoConfigureAfter // 指定主动配置类的程序
@Bean // 给容器中增加组件
@ConfigurationPropertie 联合相干 xxxProperties 类来绑定相干的配置
@EnableConfigurationProperties // 让 xxxProperties 失效退出到容器中
主动配置类要能加载
将须要启动就加载的主动配置类，配置在 META‐INF/spring.factories
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.springframework.boot.autoconfigure.admin.SpringApplicationAdminJmxAutoConfiguration,\
org.springframework.boot.autoconfigure.aop.AopAutoConfiguration,\

3、模式：

启动器只用来做依赖导入；专门来写一个主动配置模块；

启动器依赖主动配置；他人只须要引入启动器（starter）

mybatis-spring-boot-starter；自定义启动器名 -spring-boot-starter

步骤：

1）、启动器模块

<?xml version="1.0" encoding="UTF‐8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema‐instance"
      xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
      http://maven.apache.org/xsd/maven‐4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.atguigu.starter</groupId>
<artifactId>atguigu‐spring‐boot‐starter</artifactId>
<version>1.0‐SNAPSHOT</version>
<!‐‐启动器‐‐>
<dependencies>
<!‐‐引入主动配置模块‐‐>
  <dependency>
      <groupId>com.atguigu.starter</groupId>
      <artifactId>atguigu‐spring‐boot‐starter‐autoconfigurer</artifactId>
      <version>0.0.1‐SNAPSHOT</version>
  </dependency>
  </dependencies>
</project>

2）、主动配置模块

<?xml version="1.0" encoding="UTF‐8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema‐instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven‐
4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.atguigu.starter</groupId>
<artifactId>atguigu‐spring‐boot‐starter‐autoconfigurer</artifactId>
<version>0.0.1‐SNAPSHOT</version>
<packaging>jar</packaging>
<name>atguigu‐spring‐boot‐starter‐autoconfigurer</name>
<description>Demo project for Spring Boot</description>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring‐boot‐starter‐parent</artifactId>
<version>1.5.10.RELEASE</version>
<relativePath/> <!‐‐ lookup parent from repository ‐‐>
</parent>
<properties>
<project.build.sourceEncoding>UTF‐8</project.build.sourceEncoding>
<project.reporting.outputEncoding>UTF‐8</project.reporting.outputEncoding>
<java.version>1.8</java.version>
</properties>
<dependencies>
<!‐‐引入 spring‐boot‐starter；所有 starter 的根本配置‐‐>
   <dependency>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring‐boot‐starter</artifactId>
   </dependency>
</dependencies>
</project>

package com.atguigu.starter;
        import org.springframework.boot.context.properties.ConfigurationProperties;
@ConfigurationProperties(prefix = "atguigu.hello")
public class HelloProperties {
    private String prefix;
    private String suffix;
    public String getPrefix() {return prefix;}
    public void setPrefix(String prefix) {this.prefix = prefix;}
    public String getSuffix() {return suffix;}
    public void setSuffix(String suffix) {this.suffix = suffix;}
}

package com.atguigu.starter;
public class HelloService {
    HelloProperties helloProperties;
    public HelloProperties getHelloProperties() {return helloProperties;}
    public void setHelloProperties(HelloProperties helloProperties) {this.helloProperties = helloProperties;}
    public String sayHellAtguigu(String name){return helloProperties.getPrefix()+"‐" +name + helloProperties.getSuffix();}
}

package com.atguigu.starter;
       import org.springframework.beans.factory.annotation.Autowired;
       import org.springframework.boot.autoconfigure.condition.ConditionalOnWebApplication;
       import org.springframework.boot.context.properties.EnableConfigurationProperties;
       import org.springframework.context.annotation.Bean;
       import org.springframework.context.annotation.Configuration;
@Configuration
@ConditionalOnWebApplication //web 利用才失效
@EnableConfigurationProperties(HelloProperties.class)
public class HelloServiceAutoConfiguration {
   @Autowired
   HelloProperties helloProperties;
   @Bean
   public HelloService helloService(){HelloService service = new HelloService();
       service.setHelloProperties(helloProperties);
       return service;
   }
}

SpringBoot 官网文档

本文由 mdnice 多平台公布