SpringBoot笔记

Spring Boot 入门

简介

百度百科
优点

  • 快速创建独立运行的Spring项目以及与主流框架集成
  • 使用嵌入式的Servlet容器，应用无需打成WAR包
  • starters自动依赖与版本控制
  • 大量的自动配置，简化开发，也可修改默认值
  • 无需配置XML，无代码生成，开箱即用
  • 准生产环境的运行时应用监控
  • 与云计算的天然集成

微服务

2014，martin fowler

微服务：架构风格（服务微化）

一个应用应该是一组小型服务；可以通过HTTP的方式进行互通；

单体应用：ALL IN ONE

微服务：每一个功能元素最终都是一个可独立替换和独立升级的软件单元；

详细参照微服务文档

集群、分布式、微服务概念和区别

环境约束

–jdk1.8：Spring Boot 推荐jdk1.7及以上；

–maven3.x：maven 3.3以上版本；

Maven设置

给maven 的settings.xml配置文件的profiles标签添加：（设置使用的jdk版本）

开发工具中的maven设置为自己配置的maven

1
2
3
4
5
6
7
8
9
10
11
12
<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>Copy to clipboardErrorCopied

创建一个maven工程

  1. 导入spring boot相关的依赖

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.2.1.RELEASE</version>
        <relativePath/>
    </parent>
       
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>Copy to clipboardErrorCopied

  2. 编写一个主程序；启动Spring Boot应用

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    package cn.clboy.springboot;

    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;

    /**
     * @Author cloudlandboy
     * @Date 2019/11/13 下午2:58
     * @Since 1.0.0
     * springBootApplication：标注一个主程序类，表示这个是一个Springboot应用
     */

    @SpringBootApplication
    public class HelloWorldMainApplication {

        public static void main(String[] args) {
            //启动
            SpringApplication.run(HelloWorldMainApplication.class, args);
        }
    }Copy to clipboardErrorCopied

  3. 编写一个Controller

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    package cn.clboy.springboot.controller;

    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;

    /**
     * @Author cloudlandboy
     * @Date 2019/11/13 下午3:05
     * @Since 1.0.0
     * RestController：是spring4里的新注解，是@ResponseBody和@Controller的缩写。
     */

    @RestController
    public class HelloController {

        @RequestMapping("/hello")
        public String hello(){
            return "hello SpringBoot,this is my first Application";
        }
    }Copy to clipboardErrorCopied

  4. 运行主程序Main方法测试

  5. 访问 localhost:8080/hello

简化部署

  1. 添加maven插件

    1
    2
    3
    4
    5
    6
    7
    8
    9
    <!-- 这个插件，可以将应用打包成一个可执行的jar包；-->
       <build>
           <plugins>
               <plugin>
                   <groupId>org.springframework.boot</groupId>
                   <artifactId>spring-boot-maven-plugin</artifactId>
               </plugin>
           </plugins>
       </build>Copy to clipboardErrorCopied

  2. 使用mvn package进行打包

  3. 进入打包好的jar包所在目录

  4. 使用 java -jar jar包名称 运行

Hello World探究

依赖

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
  <!--Hello World项目的父工程是org.springframework.boot-->
  <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>2.2.1.RELEASE</version>
      <relativePath/>
  </parent>

  <!--
      org.springframework.boot他的父项目是spring-boot-dependencies
      他来真正管理Spring Boot应用里面的所有依赖版本；
      Spring Boot的版本仲裁中心；
      以后我们导入依赖默认是不需要写版本；（没有在dependencies里面管理的依赖自然需要声明版本号）
  -->
<parent>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-dependencies</artifactId>
  <version>2.2.1.RELEASE</version>
  <relativePath>../../spring-boot-dependencies</relativePath>
</parent>Copy to clipboardErrorCopied

启动器

1
2
3
4
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>Copy to clipboardErrorCopied

spring-boot-starter-web：

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

Spring Boot将所有的功能场景都抽取出来，做成一个个的starters（启动器），只需要在项目里面引入这些starter相关场景的所有依赖都会导入进来。要用什么功能就导入什么场景的启动器

主程序类，主入口类

1
2
3
4
5
6
7
8
@SpringBootApplication
public class HelloWorldMainApplication {

    public static void main(String[] args) {
        //启动
        SpringApplication.run(HelloWorldMainApplication.class, args);
    }
}Copy to clipboardErrorCopied

@SpringBootApplication: Spring Boot应用标注在某个类上说明这个类是SpringBoot的主配置类，SpringBoot就应该运行这个类的main方法来启动SpringBoot应用；

看一下@SpringBootApplication这个注解类的源码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
@Target({ElementType.TYPE})    //可以给一个类型进行注解，比如类、接口、枚举
@Retention(RetentionPolicy.RUNTIME)    //可以保留到程序运行的时候，它会被加载进入到 JVM 中
@Documented    //将注解中的元素包含到 Javadoc 中去。
@Inherited    //继承，比如A类上有该注解，B类继承A类，B类就也拥有该注解

@SpringBootConfiguration

@EnableAutoConfiguration

/*
*创建一个配置类，在配置类上添加 @ComponentScan 注解。
*该注解默认会扫描该类所在的包下所有的配置类，相当于之前的 <context:component-scan>。
*/
@ComponentScan(
    excludeFilters = {@Filter(
    type = FilterType.CUSTOM,
    classes = {TypeExcludeFilter.class}
), @Filter(
    type = FilterType.CUSTOM,
    classes = {AutoConfigurationExcludeFilter.class}
)}
)
public @interface SpringBootApplicationCopy to clipboardErrorCopied

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

    1
    2
    3
    4
    5
    @Target({ElementType.TYPE})
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    @Configuration
    public @interface SpringBootConfigurationCopy to clipboardErrorCopied

    • @Configuration：配置类上来标注这个注解；

      配置类 —– 配置文件；配置类也是容器中的一个组件；@Component

      1
      2
      3
      4
      5
      @Target({ElementType.TYPE})
      @Retention(RetentionPolicy.RUNTIME)
      @Documented
      @Component
      public @interface Configuration Copy to clipboardErrorCopied

  • @EnableAutoConfiguration：开启自动配置功能；

    以前我们需要配置的东西，Spring Boot帮我们自动配置；@EnableAutoConfiguration告诉SpringBoot开启自动配置功能；这样自动配置才能生效；

    1
    2
    3
    4
    5
    6
    7
    @Target({ElementType.TYPE})
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    @Inherited
    @AutoConfigurationPackage
    @Import({AutoConfigurationImportSelector.class})
    public @interface EnableAutoConfigurationCopy to clipboardErrorCopied

    • @AutoConfigurationPackage：自动配置包

      1
      2
      3
      4
      5
      6
      @Target({ElementType.TYPE})
      @Retention(RetentionPolicy.RUNTIME)
      @Documented
      @Inherited
      @Import({Registrar.class})
      public @interface AutoConfigurationPackageCopy to clipboardErrorCopied

      • @Import：Spring的底层注解@Import，给容器中导入一个组件

        导入的组件由org.springframework.boot.autoconfigure.AutoConfigurationPackages.Registrar将主配置类（@SpringBootApplication标注的类）的所在包及下面所有子包里面的所有组件扫描到Spring容器；

        DEBUG

        这里controller包是在主程序所在的包下，所以会被扫描到，我们在springboot包下创建一个test包，把主程序放在test包下，这样启动就只会去扫描test包下的内容而controller包就不会被扫描到，再访问开始的hello就是404

        DEBUG

    • @Import({AutoConfigurationImportSelector.class})

      AutoConfigurationImportSelector.class将所有需要导入的组件以全类名的方式返回；这些组件就会被添加到容器中；会给容器中导入非常多的自动配置类（xxxAutoConfiguration）；就是给容器中导入这个场景需要的所有组件，并配置好这些组件；

      有了自动配置类，免去了我们手动编写配置注入功能组件等的工作；

      Configuration

Spring Boot在启动的时候从类路径下的META-INF/spring.factories中获取EnableAutoConfiguration指定的值，将这些值作为自动配置类导入到容器中，自动配置类就生效，帮我们进行自动配置工作；以前我们需要自己配置的东西，自动配置类都帮我们完成了；

使用Spring Initializer快速创建Spring Boot项目

IDE都支持使用Spring的项目创建向导快速创建一个Spring Boot项目；

选择我们需要的模块；向导会联网创建Spring Boot项目；

需要联网

IDEA

  1. 创建项目时选择Spring Initializr

    idea01

  2. 完善项目信息

    idea02

    出现 Artifact contains illegal characters 是因为Artifact中使用了大写，只能是全小写，单词之间用-分隔

  3. 选择需要的starter

    idea03

  4. 创建完成后 不要的文件可以删除

    idea04

Eclipse

  1. 需要安装插件，或者使用STS版本

  2. 创建项目时选择Spring Starter Project

    eclipse01

  3. 完善信息

    eclipse02

  4. 选择需要的选择需要的starter

    eclipse03

默认生成的Spring Boot项目

  • 主程序已经生成好了，我们只需要完成我们自己的逻辑

  • resources

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42

      文件夹中目录结构

      - `static`：保存所有的静态资源； js、css、images；
      - `templates`：保存所有的模板页面；（Spring Boot默认jar包使用嵌入式的Tomcat，`默认`不支持JSP页面）；可以使用模板引擎（freemarker、thymeleaf）；
      - `application.properties`：Spring Boot应用的配置文件；可以修改一些默认设置；



    # 配置文件

    SpringBoot使用一个全局的配置文件，配置文件名`application`是固定的；

    - application.properties
    - application.yml
    - application.yaml

    配置文件的作用：修改SpringBoot自动配置的默认值；SpringBoot在底层都给我们自动配置好；

    ## YAML

    YAML（YAML Ain't Markup Language）

     YAML A Markup Language：是一个标记语言

     YAML isn't Markup Language：不是一个标记语言；

    标记语言：

     以前的配置文件；大多都使用的是 **xxxx.xml**文件；

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

    ### YAML语法：

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

    次等级的前面是空格，不能使用制表符(tab)

    冒号之后如果有值，那么冒号和值之间至少有一个空格，不能紧贴着

    ### 字面量：普通的值（数字，字符串，布尔）
    
k: v

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20

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

    `""`：双引号；不会转义字符串里面的特殊字符；特殊字符会作为本身想表示的意思

    *eg：* name: "zhangsan \n lisi"：输出；zhangsan 换行 lisi

    `''`：单引号；会转义特殊字符，特殊字符最终只是一个普通的字符串数据

    *eg：* name: ‘zhangsan \n lisi’：输出；zhangsan \n lisi

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

    `k: v`在下一行来写对象的属性和值的关系；注意缩进

    1. ```yaml
       person:
         name: 张三
         gender: 男
         age: 22Copy to clipboardErrorCopied

  1. 行内写法

    1
    person: {name: 张三,gender: 男,age: 22}Copy to clipboardErrorCopied

数组（List、Set）

  1. fruits: 
  - 苹果
  - 桃子
  - 香蕉Copy to clipboardErrorCopied

    1
    2

    2. 行内写法
    
fruits: [苹果,桃子,香蕉]Copy to clipboardErrorCopied

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11

    ## 配置文件值注入

    <details style="-webkit-font-smoothing: antialiased; -webkit-tap-highlight-color: rgba(0, 0, 0, 0); text-size-adjust: none; box-sizing: border-box; font-size: 15px; color: rgb(52, 73, 94); font-family: "Source Sans Pro", "Helvetica Neue", Arial, sans-serif; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; white-space: normal; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; background-color: rgb(255, 255, 255); text-decoration-style: initial; text-decoration-color: initial;"><summary style="-webkit-font-smoothing: antialiased; -webkit-tap-highlight-color: rgba(0, 0, 0, 0); text-size-adjust: none; box-sizing: border-box; font-weight: bold; color: green;">JavaBean：</summary></details>
    ```xml
            <!--导入配置文件处理器，配置文件进行绑定就会有提示-->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-configuration-processor</artifactId>
                <optional>true</optional>
            </dependency>Copy to clipboardErrorCopied

配置文件：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
person:
  name: 张三
  gender: 男
  age: 36
  boss: true
  birth: 1982/10/1
  maps: {k1: v1,k2: v2}
  lists:
    - apple
    - peach
    - banana
  pet:
    name: 小狗
    age: 12
Copy to clipboardErrorCopied

测试

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
package cn.clboy.helloworldquickstart;

import cn.clboy.helloworldquickstart.model.Person;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
class HelloworldquickstartApplicationTests {

    @Autowired
    private Person person;

    @Test
    void contextLoads() {
        System.out.println(person);
    }

}
Copy to clipboardErrorCopied

properties

上面yaml对应的properties配置文件写法

1
2
3
4
5
6
7
8
9
10
person.name=李四
person.age=34
person.birth=1986/09/12
person.boss=true
person.gender=女
person.lists=cat,dog,pig
person.maps.k1=v1
person.maps.k2=v2
person.pet.name="小黑"
person.pet.age=10Copy to clipboardErrorCopied

测试，发现中文会乱码，而且char类型还会抛出Failed to bind properties under ‘person.gender’ to java.lang.Character异常

中文乱码解决方法：

在设置中找到File Encodings，将配置文件字符集改为UTF-8，并勾选：

  • Transparent native-to-ascii conversion

乱码解决

yaml和properties配置文件同时存在，properties配置文件的内容会覆盖yaml配置文件的内容

配置文件值注入两种方式对比

配置文件值注入有两种方式，一个是Spring Boot的@ConfigurationProperties注解，另一个是spring原先的@value注解

@ConfigurationProperties @Value
功能 批量注入配置文件中的属性 一个个指定
松散绑定（松散语法） 支持 不支持
SpEL 不支持 支持
JSR303数据校验 支持 不支持
复杂类型封装 支持 不支持

松散绑定：例如Person中有lastName属性，在配置文件中可以写成

lastName或lastname或last-name或last_name等等

SpEL：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
##　properties配置文件
persion.age=#{2019-1986+1}

# Person类
#--------------------使用@ConfigurationProperties注解，会抛出异常--------------------
@Component
@ConfigurationProperties(prefix = "person")
public class Person {
    private Integer age;


#--------------------使用@value注解 OK--------------------
@Component
public class Person {
    @Value("${person.age}")
    private Integer age;Copy to clipboardErrorCopied

JSR303数据校验

@ConfigurationProperties支持校验，如果校验不通过，会抛出异常

数据校验

@value注解不支持数据校验

数据校验

复杂类型封装

1
@value`注解无法注入map等对象的复杂类型，但`list、数组可以

1573716770263

@PropertySource

@PropertySource注解的作用是加载指定的配置文件，值可以是数组，也就是可以加载多个配置文件

springboot默认加载的配置文件名是application，如果配置文件名不是这个是不会被容器加载的，所以这里Person并没有被注入任何属性值

1573718577827

使用@PropertySource({"classpath:person.properties"})指定加载person.properties配置文件

1573718679208

使用这个注解加载配置文件就需要配置类使用@component等注解而不是等待@EnableConfigurationProperties激活m，而且不支持yaml，只能是properties

@ImportResource

@ImportResource注解用于导入Spring的配置文件，让配置文件里面的内容生效；(就是以前写的springmvc.xml、applicationContext.xml)

Spring Boot里面没有Spring的配置文件，我们自己编写的配置文件，也不能自动识别；

1573719440710

想让Spring的配置文件生效，加载进来；@ImportResource标注在一个配置类上

1573720006428

注意！这个注解是放在主入口函数的类上，而不是测试类上

@Configuration

SpringBoot推荐给容器中添加组件的方式；推荐使用全注解的方式

配置类@Configuration —equals—> Spring配置文件

@Bean

使用@Bean给容器中添加组件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
package cn.clboy.helloworldquickstart.config;

import cn.clboy.helloworldquickstart.model.Pet;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @Author cloudlandboy
 * @Date 2019/11/14 下午4:33
 * @Since 1.0.0
 *
 * Configuration：指明当前类是一个配置类；就是来替代之前的Spring配置文件
 */


@Configuration
public class BeanConfiguration {

    /**
     *相当于在配置文件中用<bean><bean/>标签添加组件
     */
    @Bean
    public Pet myPet() {
        Pet pet = new Pet();
        pet.setName("嘟嘟");
        pet.setAge(3);
        return pet;
    }
}Copy to clipboardErrorCopied

配置文件占位符

随机

1
2
3
4
5
${random.value}
${random.int}
${random.long}
${random.int(10)}
${random.int[1024,65536]}Copy to clipboardErrorCopied

1573721695426

可以引用在配置文件中配置的其他属性的值，如果使用一个没有在配置文件中的属性，则会原样输出

1573722018302

可以使用:指定默认值

1573722098119

Profile

Profile是Spring对不同环境提供不同配置功能的支持，可以通过激活、指定参数等方式快速切换环境

多profile文件形式

文件名格式：application-{profile}.properties/yml，例如：

  • application-dev.properties
  • application-prod.properties

1573723830627

程序启动时会默认加载application.properties，启动的端口就是8080

可以在主配置文件中指定激活哪个配置文件

1573724084979

yml支持多文档块方式

每个文档块使用---分割

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
server:
  port: 8080
spring:
  profiles:
    active: prod
---
server:
  port: 8081
spring:
  profiles: dev
---
server:
  port: 8082
spring:
  profiles: prodCopy to clipboardErrorCopied

1573724588671

激活指定profile的三种方式

  1. 在配置文件中指定 spring.profiles.active=dev（如上）

  2. 项目打包后在命令行启动

    1
    java -jar xxx.jar --spring.profiles.active=dev；Copy to clipboardErrorCopied

    1573724952868

  3. 虚拟机参数

    1
    -Dspring.profiles.active=devCopy to clipboardErrorCopied

    1573725631649

配置文件加载位置

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

1
2
3
4
5
6
7
file: ./config/

    file: ./

        classpath: /config/

            classpath: /        -->first load ↑

优先级由高到底，高优先级的配置会覆盖低优先级的配置（优先级低的先加载）；

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

1573728449451

这里项目根路径下的配置文件maven编译时不会打包过去，需要修改pom

1
2
3
4
5
6
7
8
9
10
<resources>
    <resource>
        <directory>.</directory>
        <filtering>true</filtering>
        <includes>
            <include>**/*.properties</include>
            <include>**/*.yaml</include>
        </includes>
    </resource>
</resources>Copy to clipboardErrorCopied

我们还可以通过spring.config.location来改变默认的配置文件位置

项目打包好以后，我们可以使用命令行参数的形式，启动项目的时候来指定配置文件的新位置；指定配置文件和默认加载的这些配置文件共同起作用形成互补配置；

1
java -jar xxx.jar --spring.config.location=/home/cloudlandboy/application.yamlCopy to clipboardErrorCopied

外部配置加载顺序

SpringBoot也可以从以下位置加载配置； 优先级从高到低；高优先级的配置覆盖低优先级的配置，所有的配置会形成互补配置

  1. 命令行参数 point_up_2

    所有的配置都可以在命令行上进行指定

    1
    java -jar xxx.jar --server.port=8087  --server.context-path=/abcCopy to clipboardErrorCopied

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

  2. 来自java:comp/env的JNDI属性 ⤴️

  3. Java系统属性（System.getProperties()） ⤴️

  4. 操作系统环境变量 ⤴️

  5. RandomValuePropertySource配置的random.*属性值 ⤴️

由jar包外向jar包内进行寻找；

再来加载不带profile

  1. jar包外部的application.properties或application.yml(不带spring.profile)配置文件 ⤴️
  2. **jar包内部的application.properties或application.yml(不带spring.profile)配置文件 ⤴️

优先加载带profile

  1. **jar包外部的application-{profile}.properties或application.yml(带spring.profile)配置文件 ⤴️

  2. **jar包内部的application-{profile}.properties或application.yml(带spring.profile)配置文件 ⤴️

  3. @Configuration注解类上的@PropertySource ⤴️

  4. 通过SpringApplication.setDefaultProperties指定的默认属性 ⤴️

所有支持的配置加载来源：

参考官方文档

1573735371567

自动配置原理

配置文件到底能写什么？怎么写？自动配置原理；

配置文件能配置的属性参照

SpringBoot启动的时候加载主配置类，开启了自动配置功能

1
2
@SpringBootApplication
    @EnableAutoConfigurationCopy to clipboardErrorCopied

@EnableAutoConfiguration 作用

  • 利用EnableAutoConfigurationImportSelector给容器中导入一些组件

  • getAutoConfigurationEntry方法中

    1
    2
    //获取候选的配置
    List<String> configurations = getCandidateConfigurations(annotationMetadata,attributes);Copy to clipboardErrorCopied

  • getCandidateConfigurations方法中，SpringFactoriesLoader.loadFactoryNames()，扫描所有jar包类路径下 META-INF/spring.factories，把扫描到的这些文件的内容包装成properties对象，从properties中获取到EnableAutoConfiguration.class（类名）对应的值，然后把它们添加在容器中

    1573805094643

  • 每一个这样的 xxxAutoConfiguration类都是容器中的一个组件，都加入到容器中；用他们来做自动配置；

  • 每一个自动配置类进行自动配置功能；

以HttpEncodingAutoConfiguration（Http编码自动配置）为例解释自动配置原理

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
package org.springframework.boot.autoconfigure.web.servlet;

......

//表示这是一个配置类，以前编写的配置文件一样，也可以给容器中添加组件
@Configuration(
    proxyBeanMethods = false
)

/**
 * 启动指定类的ConfigurationProperties功能；
 * 将配置文件中对应的值和HttpProperties绑定起来；
 * 并把HttpProperties加入到ioc容器中
 */
@EnableConfigurationProperties({HttpProperties.class})

/**
 * Spring底层@Conditional注解
 * 根据不同的条件，如果满足指定的条件，整个配置类里面的配置就会生效；
 * 判断当前应用是否是web应用，如果是，当前配置类生效
 */
@ConditionalOnWebApplication(
    type = Type.SERVLET
)

//判断当前项目有没有这个类
@ConditionalOnClass({CharacterEncodingFilter.class})

/**
 * 判断配置文件中是否存在某个配置  spring.http.encoding.enabled；如果不存在，判断也是成立的
 * 即使我们配置文件中不配置pring.http.encoding.enabled=true，也是默认生效的；
 */
@ConditionalOnProperty(
    prefix = "spring.http.encoding",
    value = {"enabled"},
    matchIfMissing = true
)
public class HttpEncodingAutoConfiguration {

    //它已经和SpringBoot的配置文件映射了
    private final Encoding properties;

    //只有一个有参构造器的情况下，参数的值就会从容器中拿
    public HttpEncodingAutoConfiguration(HttpProperties properties) {
        this.properties = properties.getEncoding();
    }

    @Bean     //给容器中添加一个组件，这个组件的某些值需要从properties中获取
    @ConditionalOnMissingBean    //判断容器有没有这个组件？（容器中没有才会添加这个组件）
    public CharacterEncodingFilter characterEncodingFilter() {
        CharacterEncodingFilter filter = new OrderedCharacterEncodingFilter();
        filter.setEncoding(this.properties.getCharset().name());
        filter.setForceRequestEncoding(this.properties.shouldForce(org.springframework.boot.autoconfigure.http.HttpProperties.Encoding.Type.REQUEST));
        filter.setForceResponseEncoding(this.properties.shouldForce(org.springframework.boot.autoconfigure.http.HttpProperties.Encoding.Type.RESPONSE));
        return filter;
    }

    ......Copy to clipboardErrorCopied
  1. 根据当前不同的条件判断，决定这个配置类是否生效
  2. 一但这个配置类生效；这个配置类就会给容器中添加各种组件；这些组件的属性是从对应的properties类中获取的，这些类里面的每一个属性又是和配置文件绑定的；

所有在配置文件中能配置的属性都是在xxxxProperties类中封装着；配置文件能配置什么就可以参照某个功能对应的这个属性类

1
2
3
4
5
6
@ConfigurationProperties(
    prefix = "spring.http"
)
public class HttpProperties {
    private boolean logRequestDetails;
    private final HttpProperties.Encoding encoding = new HttpProperties.Encoding();Copy to clipboardErrorCopied

总结

  • SpringBoot启动会加载大量的自动配置类
  • 我们看我们需要的功能有没有SpringBoot默认写好的自动配置类
  • 再来看这个自动配置类中到底配置了哪些组件；（只要我们要用的组件有，我们就不需要再来配置了）
  • 给容器中自动配置类添加组件的时候，会从properties类中获取某些属性。我们就可以在配置文件中指定这些属性的值

xxxxAutoConfigurartion：自动配置类；

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

@Conditional派生注解

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

@Conditional扩展注解 作用（判断是否满足当前指定条件）
@ConditionalOnJava 系统的java版本是否符合要求
@ConditionalOnBean 容器中存在指定Bean；
@ConditionalOnMissingBean 容器中不存在指定Bean；
@ConditionalOnExpression 满足SpEL表达式指定
@ConditionalOnClass 系统中有指定的类
@ConditionalOnMissingClass 系统中没有指定的类
@ConditionalOnSingleCandidate 容器中只有一个指定的Bean，或者这个Bean是首选Bean
@ConditionalOnProperty 系统中指定的属性是否有指定的值
@ConditionalOnResource 类路径下是否存在指定资源文件
@ConditionalOnWebApplication 当前是web环境
@ConditionalOnNotWebApplication 当前不是web环境
@ConditionalOnJndi JNDI存在指定项

查看那些自动配置类生效了

自动配置类必须在一定的条件下才能生效；

我们怎么知道哪些自动配置类生效了；

我们可以通过配置文件启用 debug=true属性；来让控制台打印自动配置报告，这样我们就可以很方便的知道哪些自动配置类生效；

  • Positive matches ：（自动配置类启用的）
  • Negative matches：（没有启动，没有匹配成功的自动配置类）

springboot日志配置

市面上的日志框架

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

日志门面 （日志的抽象层） 日志门面 （日志的抽象层）
JCL（Jakarta Commons Logging SLF4j（Simple Logging Facade for Java） jboss-loggi JUL（java.util.logging） Log4j Log4j2 Logback

左边选一个门面（抽象层）、右边来选一个实现；

例：SLF4j–>Logback

SpringBoot选用 SLF4j和logback

SLF4j使用

如何在系统中使用SLF4j ：https://www.slf4j.org

以后开发的时候，日志记录方法的调用，不应该来直接调用日志的实现类，而是调用日志抽象层里面的方法；

给系统里面导入slf4j的jar和 logback的实现jar

1
2
3
4
5
6
7
8
9
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");
  }
}Copy to clipboardErrorCopied

日志

每一个日志的实现框架都有自己的配置文件。使用slf4j以后，配置文件还是做成日志实现框架自己本身的配置文件；

遗留问题

项目中依赖的框架可能使用不同的日志：

Spring（commons-logging）、Hibernate（jboss-logging）、MyBatis、xxxx

当项目是使用多种日志API时，可以统一适配到SLF4J，中间使用SLF4J或者第三方提供的日志适配器适配到SLF4J，SLF4J在底层用开发者想用的一个日志框架来进行日志系统的实现，从而达到了多种日志的统一实现。

统一日志

如何让系统中所有的日志都统一到slf4j

  1. 将系统中其他日志框架先排除出去；
  2. 用中间包来替换原有的日志框架（适配器的类名和包名与替换的被日志框架一致）；
  3. 我们导入slf4j其他的实现

SpringBoot日志关系

1
2
3
4
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter</artifactId>
</dependency>Copy to clipboardErrorCopied

SpringBoot使用它来做日志功能；

1
2
3
4
<dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-logging</artifactId>
    </dependency>Copy to clipboardErrorCopied

底层依赖关系

img

总结：

  1. SpringBoot底层也是使用slf4j+logback的方式进行日志记录
  2. SpringBoot也把其他的日志都替换成了slf4j；
  3. 中间替换包？
1
2
3
4
5
6
@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();Copy to clipboardErrorCopied

img

如果我们要引入其他框架？一定要把这个框架的默认日志依赖移除掉？

Spring框架用的是commons-logging；

1
2
3
4
5
6
7
8
9
10
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-core</artifactId>
    <exclusions>
        <exclusion>
            <groupId>commons-logging</groupId>
            <artifactId>commons-logging</artifactId>
        </exclusion>
    </exclusions>
</dependency>Copy to clipboardErrorCopied

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

日志使用

默认配置

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
    //记录器
    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日志...");


    }Copy to clipboardErrorCopied
    日志输出格式：
        %d表示日期时间，
        %thread表示线程名，
        %-5level：级别从左显示5个字符宽度
        %logger{50} 表示logger名字最长50个字符，否则按照句点分割。 
        %msg：日志消息，
        %n是换行符
    -->
    %d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n
Copy to clipboardErrorCopied

SpringBoot修改日志的默认配置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# 也可以指定一个包路径 logging.level.com.xxx=error
logging.level.root=error


#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%nCopy to clipboardErrorCopied
logging.file logging.path Example Description
(none) (none) 只在控制台输出
指定文件名 (none) my.log 输出日志到my.log文件
(none) 指定目录 /var/log 输出到指定目录的 spring.log 文件中

指定配置

给类路径下放上每个日志框架自己的配置文件即可；SpringBoot就不使用他默认配置的了

Logging System Customization
Logback logback-spring.xml, logback-spring.groovy, logback.xml or logback.groovy
Log4j2 log4j2-spring.xml or log4j2.xml
JDK (Java Util Logging) logging.properties

logback.xml：直接就被日志框架识别了；

logback-spring.xml：日志框架就不直接加载日志的配置项，由SpringBoot解析日志配置，可以使用SpringBoot的高级Profile功能

1
2
3
4
5
<springProfile name="staging">
    <!-- configuration to be enabled when the "staging" profile is active -->
      可以指定某段配置只在某个环境下生效
</springProfile>
Copy to clipboardErrorCopied

如：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
<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>Copy to clipboardErrorCopied

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

1
no applicable action for [springProfile]

切换日志框架

可以按照slf4j的日志适配图，进行相关的切换；

slf4j+log4j的方式；

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
<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>
Copy to clipboardErrorCopied

切换为log4j2

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
   <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>

SpringBoot Web开发

  1. 创建SpringBoot应用，选中我们需要的模块
  2. SpringBoot已经默认将这些场景配置好了，只需要在配置文件中指定少量配置就可以运行起来
  3. 自己编写业务代码

web自动配置规则

  1. WebMvcAutoConfiguration
  2. WebMvcProperties
  3. ViewResolver自动配置
  4. 静态资源自动映射
  5. Formatter与Converter自动配置
  6. HttpMessageConverter自动配置
  7. 静态首页
  8. favicon
  9. 错误处理

SpringBoot对静态资源的映射规则

WebMvcAutoConfiguration类的addResourceHandlers方法：（添加资源映射）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public void addResourceHandlers(ResourceHandlerRegistry registry) {
    if (!this.resourceProperties.isAddMappings()) {
        logger.debug("Default resource handling disabled");
    } else {
        Duration cachePeriod = this.resourceProperties.getCache().getPeriod();
        CacheControl cacheControl = this.resourceProperties.getCache().getCachecontrol().toHttpCacheControl();
        if (!registry.hasMappingForPattern("/webjars/**")) {
            this.customizeResourceHandlerRegistration(registry.addResourceHandler(new String[]{"/webjars/**"}).addResourceLocations(new String[]{"classpath:/META-INF/resources/webjars/"}).setCachePeriod(this.getSeconds(cachePeriod)).setCacheControl(cacheControl));
        }

        String staticPathPattern = this.mvcProperties.getStaticPathPattern();
        if (!registry.hasMappingForPattern(staticPathPattern)) {
            this.customizeResourceHandlerRegistration(registry.addResourceHandler(new String[]{staticPathPattern}).addResourceLocations(WebMvcAutoConfiguration.getResourceLocations(this.resourceProperties.getStaticLocations())).setCachePeriod(this.getSeconds(cachePeriod)).setCacheControl(cacheControl));
        }

    }
}Copy to clipboardErrorCopied

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

webjars：以jar包的方式引入静态资源；

webjars官网

1573815091111

例如：添加jquery的webjars

1
2
3
4
5
<dependency>
    <groupId>org.webjars</groupId>
    <artifactId>jquery</artifactId>
    <version>3.4.1</version>
</dependency>Copy to clipboardErrorCopied

1573815506777

访问地址对应就是：http://localhost:8080/webjars/jquery/3.4.1/jquery.js

非webjars，自己的静态资源怎么访问

资源配置类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
@ConfigurationProperties(    //说明可以在配置文件中配置相关参数
    prefix = "spring.resources",
    ignoreUnknownFields = false
)
public class ResourceProperties {
    private static final String[] CLASSPATH_RESOURCE_LOCATIONS = new String[]{"classpath:/META-INF/resources/", "classpath:/resources/", "classpath:/static/", "classpath:/public/"};
    private String[] staticLocations;
    private boolean addMappings;
    private final ResourceProperties.Chain chain;
    private final ResourceProperties.Cache cache;

    public ResourceProperties() {
        this.staticLocations = CLASSPATH_RESOURCE_LOCATIONS;
        this.addMappings = true;
        this.chain = new ResourceProperties.Chain();
        this.cache = new ResourceProperties.Cache();
    }Copy to clipboardErrorCopied

1573817274649

上图中添加的映射访问路径staticPathPattern值是/**，对应的资源文件夹就是上面配置类ResourceProperties中的CLASSPATH_RESOURCE_LOCATIONS数组中的文件夹：

数组中的值 在项目中的位置
classpath:/META-INF/resources/ src/main/resources/META-INF/resources/
classpath:/resources/ src/main/resources/resources/
classpath:/static/ src/main/resources/static/
classpath:/public/ src/main/resources/public/

localhost:8080/abc —> 去静态资源文件夹里面找abc

欢迎页映射

1573819949494

location就是静态资源路径，所以欢迎页的页面就是上面静态资源下的index.html，被/**映射，因此直接访问项目就是访问欢迎页

网站图标映射（favicon.ico）

所有的 favicon.ico 都是在静态资源文件下找；

模板引擎

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

SpringBoot推荐使用Thymeleaf；

引入thymeleaf

1
2
3
4
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>Copy to clipboardErrorCopied

如需切换thymeleaf版本：

1
2
3
4
5
6
7
8
9
<properties>

        <thymeleaf.version>X.X.X.RELEASE</thymeleaf.version>

        <!-- 布局功能的支持程序  thymeleaf3主程序  layout2以上版本 -->
        <!-- thymeleaf2   layout1-->
        <thymeleaf-layout-dialect.version>2.2.2</thymeleaf-layout-dialect.version>

  </properties>Copy to clipboardErrorCopied

Thymeleaf使用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package org.springframework.boot.autoconfigure.thymeleaf;

......

@ConfigurationProperties(
    prefix = "spring.thymeleaf"
)
public class ThymeleafProperties {
    private static final Charset DEFAULT_ENCODING;
    public static final String DEFAULT_PREFIX = "classpath:/templates/";
    public static final String DEFAULT_SUFFIX = ".html";
    private boolean checkTemplate = true;
    private boolean checkTemplateLocation = true;
    private String prefix = "classpath:/templates/";
    private String suffix = ".html";
    private String mode = "HTML";Copy to clipboardErrorCopied

默认只要我们把HTML页面放在classpath:/templates/，thymeleaf就能自动渲染；

  1. 创建模板文件t1.html，并导入thymeleaf的名称空间

    1
    <html lang="en" xmlns:th="http://www.thymeleaf.org">Copy to clipboardErrorCopied
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    <!DOCTYPE html>
    <html lang="en" xmlns:th="http://www.thymeleaf.org">
    <head>
        <meta charset="UTF-8">
        <title>Title</title>
    </head>
    <body>

    </body>
    </html>Copy to clipboardErrorCopied

  2. 使用模板

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    <!DOCTYPE html>
    <html lang="en" xmlns:th="http://www.thymeleaf.org">
    <head>
        <meta charset="UTF-8">
        <title>[[${title}]]</title>
    </head>
    <body>
    <h1 th:text="${title}"></h1>
    <div th:text="${info}">这里的文本之后将会被覆盖</div>
    </body>
    </html>Copy to clipboardErrorCopied

  3. 在controller中准备数据

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    @Controller
    public class HelloT {

        @RequestMapping("/ht")
        public String ht(Model model) {
            model.addAttribute("title","hello Thymeleaf")
                 .addAttribute("info","this is first thymeleaf test");
            return "t1";
        }
    }Copy to clipboardErrorCopied

语法规则

th:text –> 改变当前元素里面的文本内容；

th：任意html属性 –> 来替换原生属性的值

thymeleaf

更多配置参考官方文档：https://www.thymeleaf.org/documentation.html

中文参考书册：https://www.lanzous.com/i7dzr2j

SpringMVC自动配置

Spring Boot为Spring MVC提供了自动配置，可与大多数应用程序完美配合。

以下是SpringBoot对SpringMVC的默认配置

org.springframework.boot.autoconfigure.web.servlet.WebMvcAutoConfiguration

自动配置在Spring的默认值之上添加了以下功能：

  • 包含ContentNegotiatingViewResolver和BeanNameViewResolver。–> 视图解析器
  • 支持服务静态资源，包括对WebJars的支持（官方文档中有介绍）。–> 静态资源文件夹路径
  • 自动注册Converter，GenericConverter和Formatterbeans。–> 转换器，格式化器
  • 支持HttpMessageConverters（官方文档中有介绍）。–> SpringMVC用来转换Http请求和响应的；User—Json；
  • 自动注册MessageCodesResolver（官方文档中有介绍）。–> 定义错误代码生成规则
  • 静态index.html支持。–> 静态首页访问
  • 定制Favicon支持（官方文档中有介绍）。–> 网站图标
  • 自动使用ConfigurableWebBindingInitializerbean（官方文档中有介绍）。

如果您想保留 Spring Boot MVC 的功能，并且需要添加其他 MVC 配置（拦截器，格式化程序和视图控制器等），可以添加自己的 WebMvcConfigurer 类型的 @Configuration 类，但不能带 @EnableWebMvc 注解。如果您想自定义 RequestMappingHandlerMapping、RequestMappingHandlerAdapter 或者 ExceptionHandlerExceptionResolver 实例，可以声明一个 WebMvcRegistrationsAdapter 实例来提供这些组件。

如果您想完全掌控 Spring MVC，可以添加自定义注解了 @EnableWebMvc 的 @Configuration 配置类。

视图解析器

视图解析器：根据方法的返回值得到视图对象（View），视图对象决定如何渲染（转发？重定向？）

  • 自动配置了ViewResolver
  • ContentNegotiatingViewResolver：组合所有的视图解析器的；

1573873741438

视图解析器从哪里来的？

1573874365778

所以我们可以自己给容器中添加一个视图解析器；自动的将其组合进来

1
2
3
4
5
6
7
8
@Component
public class MyViewResolver implements ViewResolver {

    @Override
    public View resolveViewName(String s, Locale locale) throws Exception {
        return null;
    }
}Copy to clipboardErrorCopied

1573875409759

转换器、格式化器

  • Converter：转换器； public String hello(User user)：类型转换使用Converter（表单数据转为user）
  • Formatter 格式化器； 2017.12.17===Date；
1
2
3
4
5
6
@Bean
//在配置文件中配置日期格式化的规则
@ConditionalOnProperty(prefix = "spring.mvc", name = "date-format")
public Formatter<Date> dateFormatter() {
    return new DateFormatter(this.mvcProperties.getDateFormat());//日期格式化组件
}Copy to clipboardErrorCopied

自己添加的格式化器转换器，我们只需要放在容器中即可

HttpMessageConverters

  • HttpMessageConverter：SpringMVC用来转换Http请求和响应的；User—Json；
  • HttpMessageConverters 是从容器中确定；获取所有的HttpMessageConverter；

自己给容器中添加HttpMessageConverter，只需要将自己的组件注册容器中（@Bean,@Component）

MessageCodesResolver

我们可以配置一个ConfigurableWebBindingInitializer来替换默认的；（添加到容器）

扩展SpringMVC

以前的配置文件中的配置

1
<mvc:view-controller path="/hello" view-name="success"/>Copy to clipboardErrorCopied

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

1
2
3
4
5
6
7
8
@Configuration
public class MyMvcConfig implements WebMvcConfigurer {

    @Override
    public void addViewControllers(ViewControllerRegistry registry) {
        registry.addViewController("/hi").setViewName("success");
    }
}Copy to clipboardErrorCopied

访问：http://localhost:8080/hi

原理：

我们知道WebMvcAutoConfiguration是SpringMVC的自动配置类

下面这个类是WebMvcAutoConfiguration中的一个内部类

1573891167026

看一下@Import({WebMvcAutoConfiguration.EnableWebMvcConfiguration.class})中的这个类，

这个类依旧是WebMvcAutoConfiguration中的一个内部类

1573891478014

重点看一下这个类继承的父类DelegatingWebMvcConfiguration

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
public class DelegatingWebMvcConfiguration extends WebMvcConfigurationSupport {
    private final WebMvcConfigurerComposite configurers = new WebMvcConfigurerComposite();

    public DelegatingWebMvcConfiguration() {
    }

    //自动注入，从容器中获取所有的WebMvcConfigurer
    @Autowired(
        required = false
    )
    public void setConfigurers(List<WebMvcConfigurer> configurers) {
        if (!CollectionUtils.isEmpty(configurers)) {
            this.configurers.addWebMvcConfigurers(configurers);
        }

    }

    ......

    /**
     * 查看其中一个方法
      * this.configurers：也是WebMvcConfigurer接口的一个实现类
      * 看一下调用的configureViewResolvers方法 ↓
      */
    protected void configureViewResolvers(ViewResolverRegistry registry) {
        this.configurers.configureViewResolvers(registry);
    }Copy to clipboardErrorCopied
    public void configureViewResolvers(ViewResolverRegistry registry) {
        Iterator var2 = this.delegates.iterator();

        while(var2.hasNext()) {
            WebMvcConfigurer delegate = (WebMvcConfigurer)var2.next();
            //将所有的WebMvcConfigurer相关配置都来一起调用；  
            delegate.configureViewResolvers(registry);
        }

    }Copy to clipboardErrorCopied

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

我们的配置类也会被调用；

效果：SpringMVC的自动配置和我们的扩展配置都会起作用；

1573892805539

全面接管SpringMVC

SpringBoot对SpringMVC的自动配置不需要了，所有都是由我们自己来配置；所有的SpringMVC的自动配置都失效了

我们只需要在配置类中添加@EnableWebMvc即可；

1
2
3
@Configuration
@EnableWebMvc
public class MyMvcConfig implements WebMvcConfigurerCopy to clipboardErrorCopied

1573892899452

原理：

为什么@EnableWebMvc自动配置就失效了；

我们看一下EnableWebMvc注解类

1
2
3
4
5
6
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE})
@Documented
@Import({DelegatingWebMvcConfiguration.class})
public @interface EnableWebMvc {
}Copy to clipboardErrorCopied

重点在于@Import({DelegatingWebMvcConfiguration.class})

DelegatingWebMvcConfiguration是WebMvcConfigurationSupport的子类

我们再来看一下springmvc的自动配置类WebMvcAutoConfiguration

1
2
3
4
5
6
7
8
9
10
11
12
13
14
@Configuration(
    proxyBeanMethods = false
)
@ConditionalOnWebApplication(
    type = Type.SERVLET
)
@ConditionalOnClass({Servlet.class, DispatcherServlet.class, WebMvcConfigurer.class})

//重点是这个注解，只有当容器中没有这个类型组件的时候该配置类才会生效
@ConditionalOnMissingBean({WebMvcConfigurationSupport.class})

@AutoConfigureOrder(-2147483638)
@AutoConfigureAfter({DispatcherServletAutoConfiguration.class, TaskExecutionAutoConfiguration.class, ValidationAutoConfiguration.class})
public class WebMvcAutoConfiguration Copy to clipboardErrorCopied
  1. @EnableWebMvc将WebMvcConfigurationSupport组件导入进来；
  2. 导入的WebMvcConfigurationSupport只是SpringMVC最基本的功能；

如何修改SpringBoot的默认配置

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

  • 在SpringBoot中会有非常多的xxxConfigurer帮助我们进行扩展配置
  • 在SpringBoot中会有很多的xxxCustomizer帮助我们进行定制配置

restful风格的增删改查

静态资源文件：https://www.lanzous.com/i7eenib

  1. 将静态资源(css,img,js)添加到项目中，放到springboot默认的静态资源文件夹下
  2. 将模板文件(html)放到template文件夹下

1573896827010

如果你的静态资源明明放到了静态资源文件夹下却无法访问，请检查一下是不是在自定义的配置类上加了@EnableWebMvc注解

默认访问首页

template文件加不是静态资源文件夹，默认是无法直接访问的，所以要添加视图映射

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
package cn.clboy.hellospringbootweb.config;

import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.ViewControllerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

/**
 * @Author cloudlandboy
 * @Date 2019/11/16 下午3:32
 * @Since 1.0.0
 */

@Configuration
public class MyMvcConfig implements WebMvcConfigurer {

    @Override
    public void addViewControllers(ViewControllerRegistry registry) {
        registry.addViewController("/").setViewName("login");
        registry.addViewController("/index").setViewName("login");
        registry.addViewController("/index.html").setViewName("login");
    }
}Copy to clipboardErrorCopied

访问：http://localhost:8080/

i18n国际化

  1. 编写国际化配置文件，抽取页面需要显示的国际化消息

    SpringBoot自动配置好了管理国际化资源文件的组件

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    @Configuration(
        proxyBeanMethods = false
    )
    @ConditionalOnMissingBean(
        name = {"messageSource"},
        search = SearchStrategy.CURRENT
    )
    @AutoConfigureOrder(-2147483648)
    @Conditional({MessageSourceAutoConfiguration.ResourceBundleCondition.class})
    @EnableConfigurationProperties
    public class MessageSourceAutoConfiguration {
        private static final Resource[] NO_RESOURCES = new Resource[0];

        public MessageSourceAutoConfiguration() {
        }

        @Bean
        @ConfigurationProperties(
            prefix = "spring.messages"
        )
        public MessageSourceProperties messageSourceProperties() {
            return new MessageSourceProperties();
        }

        @Bean
        public MessageSource messageSource(MessageSourceProperties properties) {
            ResourceBundleMessageSource messageSource = new ResourceBundleMessageSource();
            if (StringUtils.hasText(properties.getBasename())) {
                messageSource.setBasenames(StringUtils.commaDelimitedListToStringArray(StringUtils.trimAllWhitespace(properties.getBasename())));
            }

            if (properties.getEncoding() != null) {
                messageSource.setDefaultEncoding(properties.getEncoding().name());
            }

            messageSource.setFallbackToSystemLocale(properties.isFallbackToSystemLocale());
            Duration cacheDuration = properties.getCacheDuration();
            if (cacheDuration != null) {
                messageSource.setCacheMillis(cacheDuration.toMillis());
            }

            messageSource.setAlwaysUseMessageFormat(properties.isAlwaysUseMessageFormat());
            messageSource.setUseCodeAsDefaultMessage(properties.isUseCodeAsDefaultMessage());
            return messageSource;
        }Copy to clipboardErrorCopied

    创建i18n文件夹存放配置文件，文件名格式为基础名(login)+语言代码(zh)+国家代码(CN)

    1573900332686

  2. 在配置文件中添加国际化文件的位置和基础名

    1
    spring.messages.basename=i18n.loginCopy to clipboardErrorCopied

    如果配置文件中没有配置基础名，就在类路径下找基础名为message的配置文件

  3. 将页面文字改为获取国际化配置，格式#{key}

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    <body class="text-center">
        <form class="form-signin" action="dashboard.html">
            <img class="mb-4" 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">Username</label>
            <input type="text" class="form-control" th:placeholder="#{login.username}" placeholder="Username" required="" autofocus="">
            <label class="sr-only">Password</label>
            <input type="password" class="form-control" th:placeholder="#{login.password}" placeholder="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>Copy to clipboardErrorCopied

  4. 然后就可以更改浏览器语言，页面就会使用对应的国际化配置文件

    1573900071209

  5. 原理

    国际化Locale（区域信息对象）；

    LocaleResolver（获取区域信息对象的组件）；

    在springmvc配置类WebMvcAutoConfiguration中注册了该组件

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    @Bean
    /**
      *前提是容器中不存在这个组件，
       　　　　　　*所以使用自己的对象就要配置@Bean让这个条件不成立（实现LocaleResolver 即可）
       　　　　　　*/
    @ConditionalOnMissingBean
       
    /**
      * 如果在application.properties中有配置国际化就用配置文件的
      * 没有配置就用AcceptHeaderLocaleResolver 默认request中获取
      */
    @ConditionalOnProperty(
        prefix = "spring.mvc",
        name = {"locale"}
    )
    public LocaleResolver localeResolver() {
        if (this.mvcProperties.getLocaleResolver() == org.springframework.boot.autoconfigure.web.servlet.WebMvcProperties.LocaleResolver.FIXED) {
            return new FixedLocaleResolver(this.mvcProperties.getLocale());
        } else {
            AcceptHeaderLocaleResolver localeResolver = new AcceptHeaderLocaleResolver();
            localeResolver.setDefaultLocale(this.mvcProperties.getLocale());
            return localeResolver;
        }
    }Copy to clipboardErrorCopied

    默认的就是根据请求头带来的区域信息获取Locale进行国际化

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    public Locale resolveLocale(HttpServletRequest request) {
        Locale defaultLocale = this.getDefaultLocale();
        if (defaultLocale != null && request.getHeader("Accept-Language") == null) {
            return defaultLocale;
        } else {
            Locale requestLocale = request.getLocale();
            List<Locale> supportedLocales = this.getSupportedLocales();
            if (!supportedLocales.isEmpty() && !supportedLocales.contains(requestLocale)) {
                Locale supportedLocale = this.findSupportedLocale(request, supportedLocales);
                if (supportedLocale != null) {
                    return supportedLocale;
                } else {
                    return defaultLocale != null ? defaultLocale : requestLocale;
                }
            } else {
                return requestLocale;
            }
        }
    }Copy to clipboardErrorCopied

点击连接切换语言

  1. 实现点击连接切换语言，而不是更改浏览器

    • 修改页面，点击连接携带语言参数

      1
      2
      <a class="btn btn-sm" href="?l=zh_CN">中文</a>
      <a class="btn btn-sm" href="?l=en_US">English</a>Copy to clipboardErrorCopied

    • 自己实现区域信息解析器

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      24
      public class MyLocaleResolver implements LocaleResolver {

          @Override
          public Locale resolveLocale(HttpServletRequest httpServletRequest) {
              //获取请求参数中的语言
              String language = httpServletRequest.getParameter("l");
              //没带区域信息参数就用系统默认的
              Locale locale = Locale.getDefault();
              if (!StringUtils.isEmpty(language)) {
                  //提交的参数是zh_CN （语言代码_国家代码）
                  String[] s = language.split("_");

                  locale = new Locale(s[0], s[1]);

              }

              return locale;
          }

          @Override
          public void setLocale(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Locale locale) {

          }
      }Copy to clipboardErrorCopied

    • 在配置类中将其注册到容器中

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      @Configuration
      public class MyMvcConfig implements WebMvcConfigurer {

          @Override
          public void addViewControllers(ViewControllerRegistry registry) {
              registry.addViewController("/").setViewName("login");
              registry.addViewController("/index").setViewName("login");
              registry.addViewController("/index.html").setViewName("login");
          }

          @Bean
          public LocaleResolver localeResolver() {
              return new MyLocaleResolver();
          }

      }Copy to clipboardErrorCopied

如果没有生效，请检查@Bean的那个方法的名称是否为localeResolver

实现登录功能

  1. 提供登录的controller

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    @Controller
    public class UserController {

        @PostMapping("/user/login")
        public String login(@RequestParam String username, @RequestParam String password, HttpSession session, Model model) {
            if (!StringUtils.isEmpty(username) && "123456".equals(password)) {

                //登录成功，把用户信息方法哦session中，防止表单重复提交，重定向到后台页面
                session.setAttribute("loginUser", username);
                return "redirect:/main.html";
            }
            //登录失败,返回到登录页面
            model.addAttribute("msg", "用户名或密码错误！");
            return "login";
        }
    }Copy to clipboardErrorCopied

  2. 修改表单提交地址，输入框添加name值与参数名称对应

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    <form class="form-signin" action="dashboard.html" th:action="@{/user/login}" method="post">
        <img class="mb-4" 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">Username</label>
        <input type="text" name="username" class="form-control" th:placeholder="#{login.username}" placeholder="Username" autofocus="">
        <label class="sr-only">Password</label>
        <input type="password" name="password" class="form-control" th:placeholder="#{login.password}" placeholder="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" href="?l=zh_CN">中文</a>
        <a class="btn btn-sm" href="?l=en_US">English</a>
    </form>Copy to clipboardErrorCopied

  3. 由于登录失败是转发，所以页面的静态资源请求路径会不正确，使用模板引擎语法替换

    1
    2
    3
    <link  href="asserts/css/bootstrap.min.css" th:href="@{/asserts/css/bootstrap.min.css}" rel="stylesheet">
    <!-- Custom styles for this template -->
    <link href="asserts/css/signin.css" th:href="@{/asserts/css/signin.css}" rel="stylesheet">Copy to clipboardErrorCopied

  4. 添加登录失败页面显示

    1
    2
    3
    <h1 class="h3 mb-3 font-weight-normal" th:text="#{login.tip}">Please sign in</h1>
    <!--msg存在才显示该p标签-->
    <p th:text="${msg}" th:if="${not #strings.isEmpty(msg)}" style="color: red"></p>Copy to clipboardErrorCopied

修改页面立即生效

1
2
# 禁用缓存
spring.thymeleaf.cache=falseCopy to clipboardErrorCopied

在页面修改完成以后按快捷键ctrl+f9，重新编译；

拦截器进行登陆检查

  1. 实现拦截器

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    package cn.clboy.hellospringbootweb.interceptor;

    import org.springframework.web.servlet.HandlerInterceptor;
    import org.springframework.web.servlet.ModelAndView;

    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;

    /**
     * @Author cloudlandboy
     * @Date 2019/11/17 上午11:44
     * @Since 1.0.0
     */

    public class LoginHandlerInterceptor implements HandlerInterceptor {
        @Override
        public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {

            Object loginUser = request.getSession().getAttribute("loginUser");
            if (loginUser == null) {
                //未登录，拦截，并转发到登录页面
                request.setAttribute("msg", "您还没有登录，请先登录！");
                request.getRequestDispatcher("/index").forward(request, response);
                return false;
            }
            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 {

        }
    }Copy to clipboardErrorCopied

  2. 注册拦截器

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    package cn.clboy.hellospringbootweb.config;

    import cn.clboy.hellospringbootweb.interceptor.LoginHandlerInterceptor;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.web.servlet.LocaleResolver;
    import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
    import org.springframework.web.servlet.config.annotation.ViewControllerRegistry;
    import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

    /**
     * @Author cloudlandboy
     * @Date 2019/11/16 下午3:32
     * @Since 1.0.0
     */

    @Configuration
    public class MyMvcConfig implements WebMvcConfigurer {
        //定义不拦截路径
        private static final String[] excludePaths = {"/", "/index", "/index.html", "/user/login", "/asserts/**"};

        @Override
        public void addViewControllers(ViewControllerRegistry registry) {
            registry.addViewController("/").setViewName("login");
            registry.addViewController("/index").setViewName("login");
            registry.addViewController("/index.html").setViewName("login");
            registry.addViewController("/main.html").setViewName("dashboard");
        }

        @Bean
        public LocaleResolver localeResolver() {
            return new MyLocaleResolver();
        }

        @Override
        public void addInterceptors(InterceptorRegistry registry) {
            //添加不拦截的路径，SpringBoot已经做好了静态资源映射，所以我们不用管
            registry.addInterceptor(new LoginHandlerInterceptor())
                    .excludePathPatterns(excludePaths);
        }
    }Copy to clipboardErrorCopied

    在spring2.0+的版本中，只要用户自定义了拦截器，则静态资源会被拦截。但是在spring1.0+的版本中，是不会拦截静态资源的。

    因此，在使用spring2.0+时，配置拦截器之后，我们要把静态资源的路径加入到不拦截的路径之中。

CRUD-员工列表

使用rest风格

实验功能 请求URI 请求方式
查询所有员工 emps GET
查询某个员工(来到修改页面) emp/1 GET
来到添加页面 emp GET
添加员工 emp POST
来到修改页面（查出员工进行信息回显） emp/1 GET
修改员工 emp PUT
删除员工 emp/1 DELETE

  1. 为了页面结构清晰，在template文件夹下新建emp文件夹，将list.html移动到emp文件夹下

  2. 将dao层和实体层java代码复制到项目中dao，entities

  3. 添加员工controller，实现查询员工列表的方法

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    @Controller
    public class EmpController {

        @Autowired
        private EmployeeDao employeeDao;

        @GetMapping("/emps")
        public String emps(Model model) {
            Collection<Employee> empList = employeeDao.getAll();
            model.addAttribute("emps", empList);
            return "emp/list";
        }

    }Copy to clipboardErrorCopied

  4. 修改后台页面，更改左侧侧边栏，将customer改为员工列表，并修改请求路径

    1
    2
    3
    4
    5
    6
    7
    8
    <li class="nav-item">
        <a class="nav-link" th:href="@{/emps}">
            <svg .....>
                ......
            </svg>
            员工列表
        </a>
    </li>Copy to clipboardErrorCopied

  5. 同样emp/list页面的左边侧边栏是和后台页面一模一样的，每个都要修改很麻烦，接下来，抽取公共片段

thymeleaf公共页面元素抽取

语法

~{templatename::selector}：模板名::选择器

~{templatename::fragmentname}:模板名::片段名

1
2
3
4
5
6
7
8
9
10
/*公共代码片段*/
<footer th:fragment="copy">
    &copy; 2011 The Good Thymes Virtual Grocery
</footer>

/*引用代码片段*/
<div th:insert="~{footer :: copy}"></di

/*（〜{...}包围是完全可选的，所以上⾯的代码 将等价于：*/
<div th:insert="footer :: copy"></diCopy to clipboardErrorCopied

具体参考官方文档：https://www.thymeleaf.org/doc/tutorials/3.0/usingthymeleaf.html#including-template-fragments

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

  • th:insert：将公共片段整个插入到声明引入的元素中
  • th:replace：将声明引入的元素替换为公共片段
  • th:include：将被引入的片段的内容包含进这个标签中
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
/*公共片段*/
<footer th:fragment="copy">
&copy; 2011 The Good Thymes Virtual Grocery
</footer>

/*引入方式*/
<div th:insert="footer :: copy"></div>
<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>Copy to clipboardErrorCopied

后台页面抽取

  1. 将后台主页中的顶部导航栏作为片段，在list页面引入

    dashboard.html：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    <nav th:fragment="topbar" class="navbar navbar-dark sticky-top bg-dark flex-md-nowrap p-0">
        <a class="navbar-brand col-sm-3 col-md-2 mr-0" href="http://getbootstrap.com/docs/4.0/examples/dashboard/#">Company name</a>
        <input class="form-control form-control-dark w-100" type="text" placeholder="Search" aria-label="Search">
        <ul class="navbar-nav px-3">
            <li class="nav-item text-nowrap">
                <a class="nav-link" href="http://getbootstrap.com/docs/4.0/examples/dashboard/#">Sign out</a>
            </li>
        </ul>
    </nav>Copy to clipboardErrorCopied

    list.html：

    1
    2
    3
    4
    5
    <body>

    <div th:replace="dashboard::topbar"></div>

    ......Copy to clipboardErrorCopied

  2. 使用选择器的方式 抽取左侧边栏代码

    dashboard.html：

    1
    2
    3
    <div class="container-fluid">
        <div class="row">
            <nav id="sidebar" class="col-md-2 d-none d-md-block bg-light sidebar" ......Copy to clipboardErrorCopied

    list.html：

    1
    2
    3
    4
    <div class="container-fluid">
        <div class="row">
            <div th:replace="dashboard::#sidebar"></div>
            ......Copy to clipboardErrorCopied

引入片段传递参数

实现点击当前项高亮

将dashboard.html中的公共代码块抽出为单独的html文件，放到commos文件夹下

在引入代码片段的时候可以传递参数，然后在sidebar代码片段模板中判断当前点击的链接

语法：

1
2
3
4
5
6
~{templatename::selector(变量名=值)}

/*或者在定义代码片段时，定义参数*/
<nav th:fragment="topbar(A,B)"
/*引入时直接传递参数*/
~{templatename::fragmentname(A值,B值)}Copy to clipboardErrorCopied

topbar.html

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<!doctype html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<body>
<nav th:fragment="topbar" class="navbar navbar-dark sticky-top bg-dark flex-md-nowrap p-0">
    <a class="navbar-brand col-sm-3 col-md-2 mr-0" href="http://getbootstrap.com/docs/4.0/examples/dashboard/#">Company
        name</a>
    <input class="form-control form-control-dark w-100" type="text" placeholder="Search" aria-label="Search">
    <ul class="navbar-nav px-3">
        <li class="nav-item text-nowrap">
            <a class="nav-link" href="http://getbootstrap.com/docs/4.0/examples/dashboard/#">Sign out</a>
        </li>
    </ul>
</nav>
</body>
</html>Copy to clipboardErrorCopied

sidebar.html

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<nav id="sidebar" class="col-md-2 d-none d-md-block bg-light sidebar">
    <div class="sidebar-sticky">
        <ul class="nav flex-column">
            <li class="nav-item">
                <a class="nav-link active" th:class="${currentURI}=='main.html'?'nav-link active':'nav-link'" th:href="@{/main.html}">
      .....
</body>
</html>Copy to clipboardErrorCopied

然后在dashboard.html和list.html中引入

1
2
3
4
5
6
7
8
9
10
11
12
13
<body>
<div th:replace="commons/topbar::topbar"></div>
<div class="container-fluid">
    <div class="row">
        <div th:replace="commons/sidebar::#sidebar(currentURI='main.html')"></div>
        ......Copy to clipboardErrorCopied
<body>
<div th:replace="commons/topbar::topbar"></div>

<div class="container-fluid">
    <div class="row">
        <div th:replace="commons/sidebar::#sidebar(currentURI='emps')"></div>
        ......Copy to clipboardErrorCopied

  1. 显示员工数据，添加增删改按钮

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    <main role="main" class="col-md-9 ml-sm-auto col-lg-10 pt-3 px-4">
        <h2>
            <button class="btn btn-sm btn-success">添加员工</button>
        </h2>
        <div class="table-responsive">
            <table class="table table-striped table-sm">
                <thead>
                <tr>
                    <th>员工号</th>
                    <th>姓名</th>
                    <th>邮箱</th>
                    <th>性别</th>
                    <th>部门</th>
                    <th>生日</th>
                    <th>操作</th>
                </tr>
                </thead>
                <tbody>
                <tr th:each="emp:${emps}">
                    <td th:text="${emp.id}"></td>
                    <td th:text="${emp.lastName}"></td>
                    <td th:text="${emp.email}"></td>
                    <td th:text="${emp.gender}==1?'男':'女'"></td>
                    <td th:text="${emp.department.departmentName}"></td>
                    <td th:text="${#dates.format(emp.birth,'yyyy-MM-dd')}"></td>
                    <td>
                        <button class="btn btn-sm btn-primary">修改</button>
                        <button class="btn btn-sm btn-danger">删除</button>
                    </td>
                </tr>
                </tbody>
            </table>
        </div>
    </main>Copy to clipboardErrorCopied

员工添加

  1. 创建员工添加页面add.html

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    ......
    <body>
    <div th:replace="commons/topbar::topbar"></div>

    <div class="container-fluid">
        <div class="row">
            <div th:replace="commons/sidebar::#sidebar(currentURI='emps')"></div>
            <main role="main" class="col-md-9 ml-sm-auto col-lg-10 pt-3 px-4">
                <form>
                    <div class="form-group">
                        <label>LastName</label>
                        <input name="lastName" type="text" class="form-control" placeholder="zhangsan">
                    </div>
                    <div class="form-group">
                        <label>Email</label>
                        <input  name="email" type="email" class="form-control" placeholder="zhangsan@atguigu.com">
                    </div>
                    <div class="form-group">
                        <label>Gender</label><br/>
                        <div class="form-check form-check-inline">
                            <input class="form-check-input" type="radio" name="gender" value="1">
                            <label class="form-check-label">男</label>
                        </div>
                        <div class="form-check form-check-inline">
                            <input class="form-check-input" type="radio" name="gender" value="0">
                            <label class="form-check-label">女</label>
                        </div>
                    </div>
                    <div class="form-group">
                        <label>department</label>
                        <select name="department.id" class="form-control">
                            <option th:each="dept:${departments}" th:text="${dept.departmentName}" th:value="${dept.id}"></option>
                        </select>
                    </div>
                    <div class="form-group">
                        <label>Birth</label>
                        <input name="birth" type="text" class="form-control" placeholder="zhangsan">
                    </div>
                    <button type="submit" class="btn btn-primary">添加</button>
                </form>
            </main>
        </div>
    </div>
    ......Copy to clipboardErrorCopied

  2. 点击链接跳转到添加页面

    1
    <a href="/emp" th:href="@{/emp}" class="btn btn-sm btn-success">添加员工</a>Copy to clipboardErrorCopied

  3. EmpController添加映射方法

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    @Autowired
    private DepartmentDao departmentDao;
       
    @GetMapping("/emp")
    public String toAddPage(Model model) {
        //准备部门下拉框数据
        Collection<Department> departments = departmentDao.getDepartments();
        model.addAttribute("departments",departments);
        return "emp/add";
    }Copy to clipboardErrorCopied

  4. 修改页面遍历添加下拉选项

    1
    2
    3
    <select class="form-control">
        <option th:each="dept:${departments}" th:text="${dept.departmentName}"></option>
    </select>Copy to clipboardErrorCopied

  5. 表单提交，添加员工

    1
    <form th:action="@{/emp}" method="post">Copy to clipboardErrorCopied
    1
    2
    3
    4
    5
    6
    7
    8
    @PostMapping("/emp")
    public String add(Employee employee) {
        System.out.println(employee);
        //模拟添加到数据库
        employeeDao.save(employee);
        //添加成功重定向到列表页面
        return "redirect:/emps";
    }Copy to clipboardErrorCopied

日期格式修改

表单提交的日期格式必须是yyyy/MM/dd的格式，可以在配置文件中修改格式

1
spring.mvc.date-format=yyyy-MM-ddCopy to clipboardErrorCopied

员工修改

  1. 点击按钮跳转到编辑页面

    1
    <a th:href="@{/emp/}+${emp.id}" class="btn btn-sm btn-primary">修改</a>Copy to clipboardErrorCopied

  2. 添加编辑页面，表单的提交要为post方式，提供_method参数

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    <body>
    <div th:replace="commons/topbar::topbar"></div>

    <div class="container-fluid">
        <div class="row">
            <div th:replace="commons/sidebar::#sidebar(currentURI='emps')"></div>
            <main role="main" class="col-md-9 ml-sm-auto col-lg-10 pt-3 px-4">
                <form th:action="@{/emp}" method="post">
                    <!--员工id-->
                    <input type="hidden" name="id" th:value="${emp.id}">
                    <!--http请求方式-->
                    <input type="hidden" name="_method" value="put">
                    <div class="form-group">
                        <label>LastName</label>
                        <input name="lastName" th:value="${emp.lastName}" type="text" class="form-control" placeholder="zhangsan">
                    </div>
                    <div class="form-group">
                        <label>Email</label>
                        <input  name="email" th:value="${emp.email}" type="email" class="form-control" placeholder="zhangsan@atguigu.com">
                    </div>
                    <div class="form-group">
                        <label>Gender</label><br/>
                        <div class="form-check form-check-inline">
                            <input class="form-check-input" type="radio" name="gender" value="1" th:checked="${emp.gender==1}">
                            <label class="form-check-label">男</label>
                        </div>
                        <div class="form-check form-check-inline">
                            <input class="form-check-input" type="radio" name="gender" value="0" th:checked="${emp.gender==0}">
                            <label class="form-check-label">女</label>
                        </div>
                    </div>
                    <div class="form-group">
                        <label>department</label>
                        <select name="department.id" class="form-control">
                            <option th:each="dept:${departments}" th:value="${dept.id}" th:selected="${dept.id}==${emp.department.id}" th:text="${dept.departmentName}"></option>
                        </select>
                    </div>
                    <div class="form-group">
                        <label>Birth</label>
                        <input name="birth" type="text" class="form-control" placeholder="zhangsan" th:value="${#dates.format(emp.birth,'yyyy-MM-dd')}">
                    </div>
                    <button type="submit" class="btn btn-primary">添加</button>
                </form>
            </main>
        </div>
    </div>

    ......Copy to clipboardErrorCopied

  3. Controller转发到编辑页面，回显员工信息

    1
    2
    3
    4
    5
    6
    7
    8
    @GetMapping("/emp/{id}")
    public String toEditPage(@PathVariable Integer id, Model model) {
        Employee employee = employeeDao.get(id);
        //准备部门下拉框数据
        Collection<Department> departments = departmentDao.getDepartments();
        model.addAttribute("emp", employee).addAttribute("departments", departments);
        return "emp/edit";
    }Copy to clipboardErrorCopied

  4. 提交表单修改员工信息

    1
    2
    3
    4
    5
    @PutMapping("/emp")
    public String update(Employee employee) {
        employeeDao.save(employee);
        return "redirect:/emps";
    }Copy to clipboardErrorCopied

员工删除

  1. 点击删除提交发出delete请求

    1
    2
    3
    4
    5
    @DeleteMapping("/emp/{id}")
    public String delete(@PathVariable String id){
        employeeDao.delete(id);
        return "redirect:/emps";
    }Copy to clipboardErrorCopied

    如果提示不支持POST请求，在确保代码无误的情况下查看是否配置启动HiddenHttpMethodFilter

    1
    spring.mvc.hiddenmethod.filter.enabled=trueCopy to clipboardErrorCopied

    1573987255217

    这个好像是2.0版本以后修改的

    1573988088629

    如果删除不掉，请修改EmployeeDao，把String转为Integer类型

    1
    2
    3
    public void delete(String id) {
        employees.remove(Integer.parseInt(id));
    }

SpringBoot默认的错误处理机制

当访问一个不存在的页面，或者程序抛出异常时

默认效果：

  • 浏览器返回一个默认的错误页面， 注意看浏览器发送请求的请求头：

    1573993746920

  • 其他客户端返回json数据，注意看请求头

    1573996455049

查看org.springframework.boot.autoconfigure.web.servlet.error.ErrorMvcAutoConfiguration源码，

这里是springboot错误处理的自动配置信息

主要给日容器中注册了以下组件：

  • ErrorPageCustomizer 系统出现错误以后来到error请求进行处理；相当于（web.xml注册的错误页面规则）
  • BasicErrorController 处理/error请求
  • DefaultErrorViewResolver 默认的错误视图解析器
  • DefaultErrorAttributes 错误信息
  • defaultErrorView 默认错误视图

ErrorPageCustomizer

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
@Bean
public ErrorMvcAutoConfiguration.ErrorPageCustomizer errorPageCustomizer(DispatcherServletPath dispatcherServletPath) {
    return new ErrorMvcAutoConfiguration.ErrorPageCustomizer(this.serverProperties, dispatcherServletPath);
}Copy to clipboardErrorCopied
private static class ErrorPageCustomizer implements ErrorPageRegistrar, Ordered {
    private final ServerProperties properties;
    private final DispatcherServletPath dispatcherServletPath;

    protected ErrorPageCustomizer(ServerProperties properties, DispatcherServletPath dispatcherServletPath) {
        this.properties = properties;
        this.dispatcherServletPath = dispatcherServletPath;
    }

    //注册错误页面
    public void registerErrorPages(ErrorPageRegistry errorPageRegistry) {
        //getPath()获取到的是"/error"，见下图
        ErrorPage errorPage = new ErrorPage(this.dispatcherServletPath.getRelativePath(this.properties.getError().getPath()));
        errorPageRegistry.addErrorPages(new ErrorPage[]{errorPage});
    }

    public int getOrder() {
        return 0;
    }
}Copy to clipboardErrorCopied

1573994730632

当请求出现错误后就会转发到/error

然后这个error请求就会被BasicErrorController处理；

BasicErrorController

1
2
3
4
5
6
7
8
@Bean
@ConditionalOnMissingBean(
    value = {ErrorController.class},
    search = SearchStrategy.CURRENT
)
public BasicErrorController basicErrorController(ErrorAttributes errorAttributes, ObjectProvider<ErrorViewResolver> errorViewResolvers) {
    return new BasicErrorController(errorAttributes, this.serverProperties.getError(), (List)errorViewResolvers.orderedStream().collect(Collectors.toList()));
}Copy to clipboardErrorCopied

处理/error请求

1
2
3
4
5
6
7
8
@Controller
/**
  * 使用配置文件中server.error.path配置
  * 如果server.error.path没有配置使用error.path
  * 如果error.path也没有配置就使用/error
  */
@RequestMapping({"${server.error.path:${error.path:/error}}"})
public class BasicErrorController extends AbstractErrorControllerCopy to clipboardErrorCopied

1573996271708

这两个方法一个用于浏览器请求响应html页面，一个用于其他客户端请求响应json数据

处理浏览器请求的方法 中，modelAndView存储到哪个页面的页面地址和页面内容数据

看一下调用的resolveErrorView方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
protected ModelAndView resolveErrorView(HttpServletRequest request, HttpServletResponse response, HttpStatus status, Map<String, Object> model) {
    Iterator var5 = this.errorViewResolvers.iterator();

    ModelAndView modelAndView;
    do {
        if (!var5.hasNext()) {
            return null;
        }

        ErrorViewResolver resolver = (ErrorViewResolver)var5.next();
        //从所有的ErrorViewResolver得到ModelAndView
        modelAndView = resolver.resolveErrorView(request, status, model);
    } while(modelAndView == null);

    return modelAndView;
}Copy to clipboardErrorCopied

ErrorViewResolver从哪里来的呢？

已经在容器中注册了一个DefaultErrorViewResolver

DefaultErrorViewResolver

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
@Configuration(
    proxyBeanMethods = false
)
static class DefaultErrorViewResolverConfiguration {
    private final ApplicationContext applicationContext;
    private final ResourceProperties resourceProperties;

    DefaultErrorViewResolverConfiguration(ApplicationContext applicationContext, ResourceProperties resourceProperties) {
        this.applicationContext = applicationContext;
        this.resourceProperties = resourceProperties;
    }

    //注册默认错误视图解析器
    @Bean
    @ConditionalOnBean({DispatcherServlet.class})
    @ConditionalOnMissingBean({ErrorViewResolver.class})
    DefaultErrorViewResolver conventionErrorViewResolver() {
        return new DefaultErrorViewResolver(this.applicationContext, this.resourceProperties);
    }
}Copy to clipboardErrorCopied

然后调用ErrorViewResolver的resolveErrorView()方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public ModelAndView resolveErrorView(HttpServletRequest request, HttpStatus status, Map<String, Object> model) {
    //把状态码和model传过去获取视图
    ModelAndView modelAndView = this.resolve(String.valueOf(status.value()), model);

    //上面没有获取到视图就使用把状态吗替换再再找，以4开头的替换为4xx，5开头替换为5xx，见下文（如果定制错误响应）
    if (modelAndView == null && SERIES_VIEWS.containsKey(status.series())) {
        modelAndView = this.resolve((String)SERIES_VIEWS.get(status.series()), model);
    }

    return modelAndView;
}

private ModelAndView resolve(String viewName, Map<String, Object> model) {
    //viewName传过来的是状态码，例：/error/404
    String errorViewName = "error/" + viewName;
    TemplateAvailabilityProvider provider = this.templateAvailabilityProviders.getProvider(errorViewName, this.applicationContext);
    //模板引擎可以解析这个页面地址就用模板引擎解析
    return provider != null ? new ModelAndView(errorViewName, model) : this.resolveResource(errorViewName, model);
}Copy to clipboardErrorCopied

如果模板引擎不可用，就调用resolveResource方法获取视图

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
private ModelAndView resolveResource(String viewName, Map<String, Object> model) {
    //获取的是静态资源文件夹
    String[] var3 = this.resourceProperties.getStaticLocations();
    int var4 = var3.length;

    for(int var5 = 0; var5 < var4; ++var5) {
        String location = var3[var5];

        try {
            Resource resource = this.applicationContext.getResource(location);
            //例：static/error.html
            resource = resource.createRelative(viewName + ".html");
            //存在则返回视图
            if (resource.exists()) {
                return new ModelAndView(new DefaultErrorViewResolver.HtmlResourceView(resource), model);
            }
        } catch (Exception var8) {
        }
    }

    return null;
}Copy to clipboardErrorCopied

所以：

如何定制错误响应页面

  • 有模板引擎的情况下；将错误页面命名为 错误状态码.html 放在模板引擎文件夹里面的 error文件夹下发生此状态码的错误就会来到这里找对应的页面；

    比如我们在template文件夹下创建error/404.html当浏览器请求是404错误，就会使用我们创建的404.html页面响应，如果是其他状态码错误，还是使用默认的视图，但是如果404.html没有找到就会替换成4XX.html再查找一次，看DefaultErrorViewResolver中的静态代码块

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
        static {
            Map<Series, String> views = new EnumMap(Series.class);
            views.put(Series.CLIENT_ERROR, "4xx");
            views.put(Series.SERVER_ERROR, "5xx");
            SERIES_VIEWS = Collections.unmodifiableMap(views);
        }

    .....
     //再看解析方法
                //把状态码和model传过去过去视图
            ModelAndView modelAndView = this.resolve(String.valueOf(status.value()), model);

            //上面没有获取到视图就把状态吗替换再找，以4开头的替换为4xx，5开头替换为5xx，见下文（如果定制错误响应）
            if (modelAndView == null && SERIES_VIEWS.containsKey(status.series())) {
                modelAndView = this.resolve((String)SERIES_VIEWS.get(status.series()), model);
            }Copy to clipboardErrorCopied

    页面可以获取哪些数据

DefaultErrorAttributes

再看一下BasicErrorController的errorHtml方法

1
2
3
4
5
6
7
8
9
public ModelAndView errorHtml(HttpServletRequest request, HttpServletResponse response) {
    HttpStatus status = this.getStatus(request);

    //model的数据
    Map<String, Object> model = Collections.unmodifiableMap(this.getErrorAttributes(request, this.isIncludeStackTrace(request, MediaType.TEXT_HTML)));
    response.setStatus(status.value());
    ModelAndView modelAndView = this.resolveErrorView(request, response, status, model);
    return modelAndView != null ? modelAndView : new ModelAndView("error", model);
}Copy to clipboardErrorCopied

看一下调用的this.getErrorAttributes()方法

1
2
3
4
protected Map<String, Object> getErrorAttributes(HttpServletRequest request, boolean includeStackTrace) {
    WebRequest webRequest = new ServletWebRequest(request);
    return this.errorAttributes.getErrorAttributes(webRequest, includeStackTrace);
}Copy to clipboardErrorCopied

再看 this.errorAttributes.getErrorAttributes()方法， this.errorAttributes是接口类型ErrorAttributes，实现类就一个DefaultErrorAttributes，看一下DefaultErrorAttributes的 getErrorAttributes()方法

1
2
3
4
5
6
7
8
public Map<String, Object> getErrorAttributes(WebRequest webRequest, boolean includeStackTrace) {
    Map<String, Object> errorAttributes = new LinkedHashMap();
    errorAttributes.put("timestamp", new Date());
    this.addStatus(errorAttributes, webRequest);
    this.addErrorDetails(errorAttributes, webRequest, includeStackTrace);
    this.addPath(errorAttributes, webRequest);
    return errorAttributes;
}Copy to clipboardErrorCopied
  • timestamp：时间戳
  • status：状态码
  • error：错误提示
  • exception：异常对象
  • message：异常消息
  • errors：JSR303数据校验的错误都在这里

2.0以后默认是不显示exception的，需要在配置文件中开启

1
server.error.include-exception=trueCopy to clipboardErrorCopied

原因：

1574001983704

在注册时

1574002101183

  • 没有模板引擎（模板引擎找不到这个错误页面），就会在静态资源文件夹下找；
  • 如果以上都没有找到错误页面，就是默认来到SpringBoot默认的错误提示页面；

defaultErrorView

1574146899180

1574146843810

如何定制JSON数据

springboot做了自适应效果，浏览器访问响应错误页面。客户端访问响应错误信息的json数据

  1. 第一种方法，定义全局异常处理器类注入到容器中，捕获到异常返回json格式的数据

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    @ControllerAdvice
    public class MyExceptionHandler {

        @ResponseBody
        @ExceptionHandler(Exception.class)
        public Map<String, Object> handleException(Exception e) {
            Map<String, Object> map = new HashMap(2);
            map.put("code", "100011");
            map.put("msg", e.getMessage());
            return map;
        }
    }Copy to clipboardErrorCopied

    访问localhost:8080/hello?str=hi

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    @RestController
    public class Hello {

        @RequestMapping("/hello")
        public String hello(String str) {
            if ("hi".equals(str)) {
                int i = 10 / 0;
            }
            return "hello world";
        }
    }Copy to clipboardErrorCopied

    这样的话，不管是浏览器访问还是客户端访问都是响应json数据，就没有了自适应效果

    1. 第二种方法，捕获到异常后转发到/error

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      @ControllerAdvice
      public class MyExceptionHandler {

          @ExceptionHandler(Exception.class)
          public String handleException(Exception e) {
              Map<String, Object> map = new HashMap(2);
              map.put("code", "100011");
              map.put("msg", e.getMessage());
              return "forward:/error";
          }
      }Copy to clipboardErrorCopied

      访问localhost:8080/hello?str=hi，但这样异常被我们捕获然后转发，显示的状态码就是200，所以在转发之前还要设置一下状态码

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      @ExceptionHandler(Exception.class)
      public String handleException(Exception e, HttpServletRequest request) {
          Map<String, Object> map = new HashMap(2);
          map.put("code", "100011");
          map.put("msg", e.getMessage());
            
          //设置状态码
          request.setAttribute("javax.servlet.error.status_code", 500);
          return "forward:/error";
      }Copy to clipboardErrorCopied

      但是设置的数据就没有用了，只能使用默认的

      由上面我们已经知道数据的来源是调用DefaultErrorAttributes的getErrorAttributes方法得到的，而这个DefaultErrorAttributes是在ErrorMvcAutoConfiguration配置类中注册的，并且注册之前会检查容器中是否已经拥有

      1
      2
      3
      4
      5
      6
      7
      8
      @Bean
      @ConditionalOnMissingBean(
          value = {ErrorAttributes.class},
          search = SearchStrategy.CURRENT
      )
      public DefaultErrorAttributes errorAttributes() {
          return new DefaultErrorAttributes(this.serverProperties.getError().isIncludeException());
      }Copy to clipboardErrorCopied

      所以我们可以只要实现ErrorAttributes接口或者继承DefaultErrorAttributes类，然后注册到容器中就行了

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      @ControllerAdvice
      public class MyExceptionHandler {

          @ExceptionHandler(Exception.class)
          public String handleException(Exception e, HttpServletRequest request) {
              Map<String, Object> map = new HashMap(2);
              map.put("name", "hello");
              map.put("password", "123456");

              //设置状态码
              request.setAttribute("javax.servlet.error.status_code", 500);

              //把数据放到request域中
              request.setAttribute("ext", map);
              return "forward:/error";
          }
      }Copy to clipboardErrorCopied
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      @Configuration
      public class MyMvcConfig implements WebMvcConfigurer {

          @Bean
          public DefaultErrorAttributes errorAttributes() {
              return new MyErrorAttributes();
          }

          class MyErrorAttributes extends DefaultErrorAttributes {
              @Override
              public Map<String, Object> getErrorAttributes(WebRequest webRequest, boolean includeStackTrace) {
                  //调用父类的方法获取默认的数据
                  Map<String, Object> map = new HashMap<>(super.getErrorAttributes(webRequest, includeStackTrace));
                  //从request域从获取到自定义数据
                  Map<String, Object> ext = (Map<String, Object>) webRequest.getAttribute("ext", RequestAttributes.SCOPE_REQUEST);
                  map.putAll(ext);
                  return map;
              }
          }

          ......

配置嵌入式Servlet容器

如何定制和修改Servlet容器的相关配置

  1. 修改和server有关的配置

    1
    2
    3
    4
    5
    6
    7
    8
    9
    server.port=8081
    server.context-path=/crud

    server.tomcat.uri-encoding=UTF-8

    //通用的Servlet容器设置
    server.xxx
    //Tomcat的设置
    server.tomcat.xxxCopy to clipboardErrorCopied

  2. 编写一个EmbeddedServletContainerCustomizer，2.0以后改为WebServerFactoryCustomizer：嵌入式的Servlet容器的定制器；来修改Servlet容器的配置

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    @Configuration
    public class MyMvcConfig implements WebMvcConfigurer {
        @Bean
        public WebServerFactoryCustomizer webServerFactoryCustomizer() {
            return new WebServerFactoryCustomizer<ConfigurableWebServerFactory>() {
                @Override
                public void customize(ConfigurableWebServerFactory factory) {
                    factory.setPort(8088);
                }
            };
        }
    ......Copy to clipboardErrorCopied

代码方式的配置会覆盖配置文件的配置

小Tips： 如果使用的是360极速浏览器就不要用8082端口了

注册Servlet三大组件

由于SpringBoot默认是以jar包的方式启动嵌入式的Servlet容器来启动SpringBoot的web应用，没有web.xml文件。

Servlet

向容器中添加ServletRegistrationBean

1
2
3
4
5
6
7
8
9
10
@Configuration
public class MyMvcConfig implements WebMvcConfigurer {

    @Bean
    public ServletRegistrationBean myServlet() {
        ServletRegistrationBean register = new ServletRegistrationBean(new MyServlet(), "/myServlet");
        register.setLoadOnStartup(1);
        return register;
    }
    ......Copy to clipboardErrorCopied
MyServlet
### Filter

向容器中添加FilterRegistrationBean

1
2
3
4
5
6
7
8
9
10
11
12
@Configuration
public class MyMvcConfig implements WebMvcConfigurer {


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

    ......Copy to clipboardErrorCopied
MyFilter
### Listener

向容器中注入ServletListenerRegistrationBean

1
2
3
4
5
6
7
8
9
10
@Configuration
public class MyMvcConfig implements WebMvcConfigurer {

    @Bean
    public ServletListenerRegistrationBean myServletContextListener(){
        return new ServletListenerRegistrationBean(new MyServletContextListener());
    }

    ......
Copy to clipboardErrorCopied
MyListener
## 替换为其他嵌入式web服务器

SpringBoot默认使用的是Tomcat

1574170320042

如果要换成其他的就把Tomcat的依赖排除掉，然后引入其他嵌入式Servlet容器的以来，如Jetty，Undertow

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
<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>

<dependency>
    <artifactId>spring-boot-starter-jetty</artifactId>
    <groupId>org.springframework.boot</groupId>
</dependency>Copy to clipboardErrorCopied
<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>

<dependency>
    <artifactId>spring-boot-starter-undertow</artifactId>
    <groupId>org.springframework.boot</groupId>
</dependency>Copy to clipboardErrorCopied

原理

查看web容器自动配置类

2.0以下是：EmbeddedServletContainerAutoConfiguration

ServletWebServerFactoryAutoConfiguration：嵌入式的web服务器自动配置

1
2
3
4
5
6
7
8
9
10
11
12
13
@Configuration(
    proxyBeanMethods = false
)
@AutoConfigureOrder(-2147483648)
@ConditionalOnClass({ServletRequest.class})
@ConditionalOnWebApplication(
    type = Type.SERVLET
)
@EnableConfigurationProperties({ServerProperties.class})

//---看这里---
@Import({ServletWebServerFactoryAutoConfiguration.BeanPostProcessorsRegistrar.class, EmbeddedTomcat.class, EmbeddedJetty.class, EmbeddedUndertow.class})
public class ServletWebServerFactoryAutoConfiguration {Copy to clipboardErrorCopied

EmbeddedTomcat.class：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
@Configuration(
    proxyBeanMethods = false
)
//判断当前是否引入了Tomcat依赖；
@ConditionalOnClass({Servlet.class, Tomcat.class, UpgradeProtocol.class})
/**
  *判断当前容器没有用户自己定义ServletWebServerFactory：嵌入式的web服务器工厂；
  *作用：创建嵌入式的web服务器
  */
@ConditionalOnMissingBean(
    value = {ServletWebServerFactory.class},
    search = SearchStrategy.CURRENT
)
public static class EmbeddedTomcat {Copy to clipboardErrorCopied

ServletWebServerFactory：嵌入式的web服务器工厂

1
2
3
4
5
@FunctionalInterface
public interface ServletWebServerFactory {
    //获取嵌入式的Servlet容器
    WebServer getWebServer(ServletContextInitializer... initializers);
}Copy to clipboardErrorCopied

工厂实现类

1574172121748

WebServer：嵌入式的web服务器实现

1574172310812

以TomcatServletWebServerFactory为例，下面是TomcatServletWebServerFactory类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
public WebServer getWebServer(ServletContextInitializer... initializers) {
    if (this.disableMBeanRegistry) {
        Registry.disableRegistry();
    }

    //创建一个Tomcat
    Tomcat tomcat = new Tomcat();

    //配置Tomcat的基本环境，（tomcat的配置都是从本类获取的，tomcat.setXXX）
    File baseDir = this.baseDirectory != null ? this.baseDirectory : this.createTempDir("tomcat");
    tomcat.setBaseDir(baseDir.getAbsolutePath());
    Connector connector = new Connector(this.protocol);
    connector.setThrowOnFailure(true);
    tomcat.getService().addConnector(connector);
    this.customizeConnector(connector);
    tomcat.setConnector(connector);
    tomcat.getHost().setAutoDeploy(false);
    this.configureEngine(tomcat.getEngine());
    Iterator var5 = this.additionalTomcatConnectors.iterator();

    while(var5.hasNext()) {
        Connector additionalConnector = (Connector)var5.next();
        tomcat.getService().addConnector(additionalConnector);
    }

    this.prepareContext(tomcat.getHost(), initializers);

    //将配置好的Tomcat传入进去，返回一个WebServer；并且启动Tomcat服务器
    return this.getTomcatWebServer(tomcat);
}Copy to clipboardErrorCopied

我们对嵌入式容器的配置修改是怎么生效的？

配置修改原理

ServletWebServerFactoryAutoConfiguration在向容器中添加web容器时还添加了一个组件

1574235580031

BeanPostProcessorsRegistrar：后置处理器注册器(也是给容器注入一些组件)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
    public static class BeanPostProcessorsRegistrar implements ImportBeanDefinitionRegistrar, BeanFactoryAware {
        private ConfigurableListableBeanFactory beanFactory;

        public BeanPostProcessorsRegistrar() {...}

        public void setBeanFactory(BeanFactory beanFactory) throws BeansException {...}

        public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
            if (this.beanFactory != null) {
                //注册了下面两个组件
                this.registerSyntheticBeanIfMissing(registry, "webServerFactoryCustomizerBeanPostProcessor", WebServerFactoryCustomizerBeanPostProcessor.class);
                this.registerSyntheticBeanIfMissing(registry, "errorPageRegistrarBeanPostProcessor", ErrorPageRegistrarBeanPostProcessor.class);
            }
        }

        private void registerSyntheticBeanIfMissing(BeanDefinitionRegistry registry, String name, Class<?> beanClass) {...}
    }Copy to clipboardErrorCopied
webServerFactoryCustomizerBeanPostProcessor
public class WebServerFactoryCustomizerBeanPostProcessor implements BeanPostProcessor, BeanFactoryAware {

    ......

    //在Bean初始化之前
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        //判断添加的Bean是不是WebServerFactory类型的
        if (bean instanceof WebServerFactory) {
            this.postProcessBeforeInitialization((WebServerFactory)bean);
        }

        return bean;
    }

    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }

    private void postProcessBeforeInitialization(WebServerFactory webServerFactory) {
        //获取所有的定制器，调用每一个定制器的customize方法来给Servlet容器进行属性赋值；
        ((Callbacks)LambdaSafe.callbacks(WebServerFactoryCustomizer.class, this.getCustomizers(), webServerFactory, new Object[0]).withLogger(WebServerFactoryCustomizerBeanPostProcessor.class)).invoke((customizer) -> {
            customizer.customize(webServerFactory);
        });
    }Copy to clipboardErrorCopied

关于配置文件是如何设置的，参考EmbeddedWebServerFactoryCustomizerAutoConfiguration类，最后还是使用上面的方便

总结：

  1. SpringBoot根据导入的依赖情况，给容器中添加相应的XXXServletWebServerFactory

  2. 容器中某个组件要创建对象就会惊动后置处理器 webServerFactoryCustomizerBeanPostProcessor

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

  3. 后置处理器，从容器中获取所有的WebServerFactoryCustomizer，调用定制器的定制方法给工厂添加配置

嵌入式Servlet容器启动原理

  1. SpringBoot应用启动运行run方法

    1574242390909

  2. 153行，创建IOC容器对象，根据当前环境创建

    1574242209298

  3. 156行，刷新IOC容器

  4. 刷新IOC容器中272行，onRefresh()；web的ioc容器重写了onRefresh方法，查看ServletWebServerApplicationContext类的onRefresh方法，在方法中调用了this.createWebServer();方法创建web容器

    1
    2
    3
    4
    5
    6
    7
    8
    9
    protected void onRefresh() {
        super.onRefresh();
       
        try {
            this.createWebServer();
        } catch (Throwable var2) {
            throw new ApplicationContextException("Unable to start web server", var2);
        }
    }Copy to clipboardErrorCopied

    98行获取嵌入式的web容器工厂

    1574243084120

  5. 接下来就是上面的上面的相关配置流程，在创建web容器工厂时会触发webServerFactoryCustomizerBeanPostProcessor

  6. 然后99行使用容器工厂获取嵌入式的Servlet容器

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

  8. 嵌入式的Servlet容器启动后，再将ioc容器中剩下没有创建出的对象获取出来(Controller,Service等)；

使用外置的Servlet容器

  1. 将项目的打包方式改为war

  2. 编写一个类继承SpringBootServletInitializer，并重写configure方法，调用参数的sources方法springboot启动类传过去然后返回

    1
    2
    3
    4
    5
    6
    public class ServletInitializer extends SpringBootServletInitializer {
        @Override
        protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
            return application.sources(HelloSpringBootWebApplication.class);
        }
    }Copy to clipboardErrorCopied

  3. 然后把tomcat的依赖范围改为provided

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
            <version>2.2.1.RELEASE</version>
            <scope>provided</scope>
        </dependency>
       
        ......
       
    </dependencies>Copy to clipboardErrorCopied

  4. 最后就可以把项目打包成war放到tomcat中了

  5. 在IDEA中可以这样配置

    1574247311250

  6. 在创建项目时使用Spring Initializr创建选择打包方式为war，1，2，3步骤会自动配置

如果启动tomcat，报了一大堆错误，不妨把Tomcat改为更高的版本试试，如果你项目中的Filter是继承了HttpFilter，请使用tomcat9版本，9以下好像没有HttpFilter

原理

TODO 2019-11-20

  1. Servlet3.0标准ServletContainerInitializer扫描所有jar包中METAINF/services/javax.servlet.ServletContainerInitializer文件指定的类并加载

  2. 还可以使用@HandlesTypes，在应用启动的时候加载我们感兴趣的类；

  3. 在spring-web-xxx.jar包中的METAINF/services下有javax.servlet.ServletContainerInitializer这个文件

    文件中的类是：

    1
    org.springframework.web.SpringServletContainerInitializerCopy to clipboardErrorCopied

    对应的类：

    1
    2
    3
    4
    5
    6
    7
    8
    @HandlesTypes({WebApplicationInitializer.class})
    public class SpringServletContainerInitializer implements ServletContainerInitializer {
        public SpringServletContainerInitializer() {
        }

        public void onStartup(@Nullable Set<Class<?>> webAppInitializerClasses, ServletContext servletContext) throws ServletException {

            ......Copy to clipboardErrorCopied

  4. SpringServletContainerInitializer将@HandlesTypes(WebApplicationInitializer.class)标注的所有这个类型的类都传入到onStartup方法的Set>；为这些WebApplicationInitializer类型的类创建实例；

  5. 每一个WebApplicationInitializer都调用自己的onStartup方法；

  6. WebApplicationInitializer的实现类

    1574256076145

  7. 相当于我们的SpringBootServletInitializer的类会被创建对象，并执行onStartup方法

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

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    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);
    }Copy to clipboardErrorCopied

  9. Spring的应用就启动并且创建IOC容器

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    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);
       }
    }

Docker基本使用

Docker是一个开源的应用容器引擎；是一个轻量级容器技术；

Docker支持将软件编译成一个镜像；然后在镜像中各种软件做好配置，将镜像发布出去，其他使用者可以直接使用这个镜像；

运行中的这个镜像称为容器，容器启动是非常快速的。

img

img

核心概念

docker主机(Host)：安装了Docker程序的机器（Docker直接安装在操作系统之上）；

docker客户端(Client)：连接docker主机进行操作；

docker仓库(Registry)：用来保存各种打包好的软件镜像；

docker镜像(Images)：软件打包好的镜像；放在docker仓库中；

docker容器(Container)：镜像启动后的实例称为一个容器；容器是独立运行的一个或一组应用

img

使用Docker的步骤：

  1. 确认要安装docker的系统的linux内核高于3.10，低于3.10使用yum update更新

    1
    uname -rCopy to clipboardErrorCopied

  2. 安装docker

    1
    yum install dockerCopy to clipboardErrorCopied

  3. 查看docker版本

    1
    docker -vCopy to clipboardErrorCopied

  4. 查看docker状态

    1
    service docker statusCopy to clipboardErrorCopied

  5. 启动docker

    1
    service docker startCopy to clipboardErrorCopied

  6. 停止docker

    1
    service docker stopCopy to clipboardErrorCopied

  7. 设置docker开机自启

    1
    systemctl enable dockerCopy to clipboardErrorCopied

docker常用命令

镜像操作

操作 命令 说明
检索 docker search 关键字 eg：docker search redis 我们经常去docker hub上检索镜像的详细信息，如镜像的TAG。
拉取 docker pull 镜像名:tag :tag是可选的，tag表示标签，多为软件的版本，默认是latest
列表 docker images 查看所有本地镜像
删除 docker rmi image-id 删除指定的本地镜像

修改镜像源

修改 /etc/docker/daemon.json ，写入如下内容（如果文件不存在请新建该文件）

1
2
3
4
5
6
7
vim /etc/docker/daemon.json

#　内容：

{
"registry-mirrors":["http://hub-mirror.c.163.com"]
}Copy to clipboardErrorCopied
国内镜像源 地址
Docker 官方中国区 https://registry.docker-cn.com
网易 http://hub-mirror.c.163.com
中国科技大学 https://docker.mirrors.ustc.edu.cn
阿里云 https://pee6w651.mirror.aliyuncs.com

容器操作

以tomcat为例：

  1. 下载tomcat镜像

    1
    docker pull tomcatCopy to clipboardErrorCopied

    如需选择具体版本，可以在https://hub.docker.com/搜索tomcat

    1
    docker pull tomcat:7.0.96-jdk8-adoptopenjdk-hotspotCopy to clipboardErrorCopied

  2. 根据镜像启动容器，不加TAG默认latest，如果没有下载latest会先去下载再启动

    1
    docker run --name mytomcat -d tomcat:latestCopy to clipboardErrorCopied

    --name：给容器起个名字

    -d：后台启动，不加就是前端启动，然后你就只能开一个新的窗口连接，不然就望着黑乎乎的窗口，啥也干不了，Ctrl+C即可退出，当然，容器也会关闭

  3. 查看运行中的容器

    1
    docker psCopy to clipboardErrorCopied

  4. 停止运行中的容器

    1
    2
    3
    4
    5
    docker stop  容器的id

    # 或者

    docker stop  容器的名称，就是--name给起的哪个名字Copy to clipboardErrorCopied

  5. 查看所有的容器

    1
    docker ps -aCopy to clipboardErrorCopied

  6. 启动容器

    1
    docker start 容器id/名字Copy to clipboardErrorCopied

  7. 删除一个容器

    1
    docker rm 容器id/名字Copy to clipboardErrorCopied

  8. 启动一个做了端口映射的tomcat

    1
    docker run -d -p 8888:8080 tomcatCopy to clipboardErrorCopied

    -d：后台运行 -p: 将主机的端口映射到容器的一个端口 主机端口(8888):容器内部的端口(8080)

    外界通过主机的8888端口就可以访问到tomcat，前提是8888端口开放

  9. 关闭防火墙

    1
    2
    3
    4
    5
    # 查看防火墙状态
    service firewalld status

    # 关闭防火墙
    service firewalld stopCopy to clipboardErrorCopied

  10. 查看容器的日志

    1
    docker logs 容器id/名字Copy to clipboardErrorCopied

以mysql为例：

1
2
3
4
5
# 拉取镜像
docker pull mysql:5.7.28

# 运行mysql容器
 docker run --name mysql -e MYSQL_ROOT_PASSWORD=root -d mysql:5.7.28Copy to clipboardErrorCopied

--name mysql：容器的名字是mysql；

MYSQL_ROOT_PASSWORD=root：root用户的密码是root (必须指定)

连接容器内mysql

在使用 -d 参数时，容器启动后会进入后台。此时想要进入容器，可以通过以下指令进入：

  • docker attach
  • docker exec：推荐使用 docker exec 命令，因为此退出容器终端，不会导致容器的停止。
1
docker exec -it mysql bashCopy to clipboardErrorCopied

-i: 交互式操作。

-t: 终端。

mysql: 名为mysql的 镜像。

bash：放在镜像名后的是命令，这里我们希望有个交互式 Shell，因此用的是 bash，也可以用/bin/bash。

连接上以后就可以正常使用mysql命令操作了

1
mysql -uroot -prootCopy to clipboardErrorCopied

直接使用端口映射更加方便

1
docker run --name mysql -p 3306:3306 -e MYSQL_ROOT_PASSWORD=root -d mysql:5.7.28

SpringBoot与数据库连接

依赖

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-jdbc</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-thymeleaf</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.mybatis.spring.boot</groupId>
        <artifactId>mybatis-spring-boot-starter</artifactId>
        <version>2.1.1</version>
    </dependency>

    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <scope>runtime</scope>
    </dependency>
</dependencies>Copy to clipboardErrorCopied

配置数据库连接信息

1
2
3
4
5
6
spring:
  datasource:
    username: root
    password: root
    url: jdbc:mysql://172.16.145.137:3306/springboot
    driver-class-name: com.mysql.cj.jdbc.DriverCopy to clipboardErrorCopied

测试能否连接上数据库

1
2
3
4
5
6
7
8
9
10
11
12
13
@SpringBootTest
class SpringbootJdbcApplicationTests {

    @Autowired
    private DataSource dataSource;

    @Test
    void contextLoads() throws SQLException {
        System.out.println(dataSource.getClass());
        System.out.println(dataSource.getConnection());
    }

}Copy to clipboardErrorCopied

springboot默认是使用com.zaxxer.hikari.HikariDataSource作为数据源，2.0以下是用org.apache.tomcat.jdbc.pool.DataSource作为数据源；

数据源的相关配置都在DataSourceProperties里面；

自动配置原理

TODO

jdbc的相关配置都在org.springframework.boot.autoconfigure.jdbc包下

参考DataSourceConfiguration，根据配置创建数据源，默认使用Hikari连接池；可以使用spring.datasource.type指定自定义的数据源类型；

springboot默认支持的连池：

  • org.apache.commons.dbcp2.BasicDataSource
  • com.zaxxer.hikari.HikariDataSource
  • org.apache.tomcat.jdbc.pool.DataSource

自定义数据源类型：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
@Configuration(
    proxyBeanMethods = false
)
@ConditionalOnMissingBean({DataSource.class})
@ConditionalOnProperty(
    name = {"spring.datasource.type"}
)
static class Generic {
    Generic() {
    }

    @Bean
    DataSource dataSource(DataSourceProperties properties) {
         //使用DataSourceBuilder创建数据源，利用反射创建响应type的数据源，并且绑定相关属性
        return properties.initializeDataSourceBuilder().build();
    }
}Copy to clipboardErrorCopied

启动应用执行sql

SpringBoot在创建连接池后还会运行预定义的SQL脚本文件，具体参考org.springframework.boot.autoconfigure.jdbc.DataSourceInitializationConfiguration配置类，

在该类中注册了dataSourceInitializerPostProcessor

下面是获取schema脚本文件的方法

1
List<Resource> scripts = this.getScripts("spring.datasource.schema", this.properties.getSchema(), "schema");Copy to clipboardErrorCopied

1574409852703

可以看出，如果我们没有在配置文件中配置脚本的具体位置，就会在classpath下找schema-all.sql和schema.sql platform获取的是all，platform可以在配置文件中修改

具体查看createSchema()方法和initSchema()方法

initSchema()方法获取的是data-all.sql，data.sql

我们也可以在配置文件中配置sql文件的位置

1
2
3
4
5
spring:
  datasource:
    schema:
      - classpath:department.sql
      - 指定位置Copy to clipboardErrorCopied

测试：

在类路径下创建schema.sql，运行程序查看数据库是否存在该表

1
2
3
4
5
6
DROP TABLE IF EXISTS `department`;
CREATE TABLE `department` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `departmentName` varchar(255) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;Copy to clipboardErrorCopied

程序启动后发现表并没有被创建，DEBUG查看以下，发现在运行之前会有一个判断

1574411869052

1574412098885

上面方法也不知道在干什么，反正就是只要是NEVER和EMBEDDED就为true，而DataSourceInitializationMode枚举类中除了这两个就剩下ALWAYS了，可以在配置文件中配置为ALWAYS

1574412237660

1
2
3
4
5
6
7
spring:
  datasource:
    username: root
    password: root
    url: jdbc:mysql://172.16.145.137:3306/springboot
    driver-class-name: com.mysql.cj.jdbc.Driver
    initialization-mode: alwaysCopy to clipboardErrorCopied

schema.sql：建表语句

data.sql：插入数据

当然混合使用也可以，愿意咋来咋来

注意：项目每次启动都会执行一次sql

整合Druid数据源

选择哪个数据库连接池

  • DBCP2 是 Appache 基金会下的项目，是最早出现的数据库连接池 DBCP 的第二个版本。
  • C3P0 最早出现时是作为 Hibernate 框架的默认数据库连接池而进入市场。
  • Druid 是阿里巴巴公司开源的一款数据库连接池，其特点在于有丰富的附加功能。
  • HikariCP 相较而言比较新，它最近两年才出现，据称是速度最快的数据库连接池。最近更是被 Spring 设置为默认数据库连接池。

不选择 C3P0 的原因：

  • C3P0 的 Connection 是异步释放。这个特性会导致释放的在某些情况下 Connection 实际上 still in use ，并未真正释放掉，从而导致连接池中的 Connection 耗完，等待状况。
  • Hibernate 现在对所有数据库连接池一视同仁，官方不再指定『默认』数据库连接池。因此 C3P0 就失去了『官方』光环。

不选择 DBCP2 的原因：

  • 相较于 Druid 和 HikariCP，DBCP2 没有什么特色功能/卖点。基本上属于 能用，没毛病 的情况，地位显得略有尴尬。

  1. 在 Spring Boot 项目中加入druid-spring-boot-starter依赖 (点击查询最新版本)

    1
    2
    3
    4
    5
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid-spring-boot-starter</artifactId>
        <version>1.1.20</version>
    </dependency>Copy to clipboardErrorCopied

  2. 在配置文件中指定数据源类型

    1
    2
    3
    4
    5
    6
    7
    8
    spring:
      datasource:
        username: root
        password: root
        url: jdbc:mysql://172.16.145.137:3306/springboot
        driver-class-name: com.mysql.cj.jdbc.Driver
        initialization-mode: always
        type: com.alibaba.druid.pool.DruidDataSourceCopy to clipboardErrorCopied

  3. 测试类查看使用的数据源

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    @SpringBootTest
    class SpringbootJdbcApplicationTests {

        @Autowired
        private DataSource dataSource;

        @Test
        void contextLoads() throws SQLException {
            System.out.println(dataSource.getClass());
            System.out.println(dataSource.getConnection());
        }

    }Copy to clipboardErrorCopied

配置参数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
spring:
  datasource:
    username: root
    password: root
    url: jdbc:mysql://172.16.145.137:3306/springboot
    driver-class-name: com.mysql.cj.jdbc.Driver
    initialization-mode: always
    type: com.alibaba.druid.pool.DruidDataSource
    druid:
      # 连接池配置
      # 配置初始化大小、最小、最大
      initial-size: 1
      min-idle: 1
      max-active: 20
      # 配置获取连接等待超时的时间
      max-wait: 3000
      validation-query: SELECT 1 FROM DUAL
      test-on-borrow: false
      test-on-return: false
      test-while-idle: true
      pool-prepared-statements: true
      time-between-eviction-runs-millis: 60000
      min-evictable-idle-time-millis: 300000
      filters: stat,wall,slf4j
      # 配置web监控,默认配置也和下面相同(除用户名密码，enabled默认false外)，其他可以不配
      web-stat-filter:
        enabled: true
        url-pattern: /*
        exclusions: "*.js,*.gif,*.jpg,*.png,*.css,*.ico,/druid/*"
      stat-view-servlet:
        enabled: true
        url-pattern: /druid/*
        login-username: admin
        login-password: root
        allow: 127.0.0.1Copy to clipboardErrorCopied

后台页面，访问http://localhost:8080/druid/login.html

SpringBoot整合Mybatis

引入依赖

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
<dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.1.1</version>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.20</version>
        </dependency>
    </dependencies>Copy to clipboardErrorCopied

依赖关系

1574423628318

项目构建

  1. 在resources下创建department.sql和employee.sql，项目启动时创建表

    1
    2
    3
    4
    5
    6
    DROP TABLE IF EXISTS `department`;
    CREATE TABLE `department` (
      `id` int(11) NOT NULL AUTO_INCREMENT,
      `departmentName` varchar(255) DEFAULT NULL,
      PRIMARY KEY (`id`)
    ) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;Copy to clipboardErrorCopied
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    DROP TABLE IF EXISTS `employee`;
    CREATE TABLE `employee` (
      `id` int(11) NOT NULL AUTO_INCREMENT,
      `lastName` varchar(255) DEFAULT NULL,
      `email` varchar(255) DEFAULT NULL,
      `gender` int(2) DEFAULT NULL,
      `d_id` int(11) DEFAULT NULL,
      PRIMARY KEY (`id`)
    ) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;
    Copy to clipboardErrorCopied

  2. 实体类

    Department
Employee
1. 配置文件 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
spring:
  datasource:
    username: root
    password: root
    url: jdbc:mysql://172.16.145.137:3306/springboot
    driver-class-name: com.mysql.cj.jdbc.Driver
    initialization-mode: always
    type: com.alibaba.druid.pool.DruidDataSource
    druid:
      # 连接池配置
      # 配置初始化大小、最小、最大
      initial-size: 1
      min-idle: 1
      max-active: 20
      # 配置获取连接等待超时的时间
      max-wait: 3000
      validation-query: SELECT 1 FROM DUAL
      test-on-borrow: false
      test-on-return: false
      test-while-idle: true
      pool-prepared-statements: true
      time-between-eviction-runs-millis: 60000
      min-evictable-idle-time-millis: 300000
      filters: stat,wall,slf4j
      # 配置web监控,默认配置也和下面相同(除用户名密码，enabled默认false外)，其他可以不配
      web-stat-filter:
        enabled: true
        url-pattern: /*
        exclusions: "*.js,*.gif,*.jpg,*.png,*.css,*.ico,/druid/*"
      stat-view-servlet:
        enabled: true
        url-pattern: /druid/*
        login-username: admin
        login-password: root
        allow: 127.0.0.1
    schema:
      - classpath:department.sql
      - classpath:employee.sqlCopy to clipboardErrorCopied

Mybatis增删改查

  1. 创建mapper接口

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    @Mapper
    public interface DepartmentMapper {

        @Select("select * from department")
        public List<Department> selectAll();

        @Select("select * from department where id=#{id}")
        public Department selectById(Integer id);

        @Options(useGeneratedKeys = true, keyProperty = "id")
        @Insert("insert into department(departmentName) values(#{departmentName})")
        public int save(Department department);

        @Update("update department set departmentName=#{departmentName}")
        public int update(Department department);

        @Delete("delete from department where id =#{id}")
        public int delete(Integer id);
    }Copy to clipboardErrorCopied

  2. 创建Controller

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    @RestController
    public class DepartmentController {

        @Autowired
        private DepartmentMapper departmentMapper;

        @RequestMapping("/dep/{id}")
        public List<Department> getDepById(@PathVariable Integer id) {
            return departmentMapper.selectAll();
        }

        @RequestMapping("/dep")
        public Department getDepById(Department department) {
            departmentMapper.save(department);
            return department;
        }
    }Copy to clipboardErrorCopied

  3. 访问：http://localhost:8080/dep?departmentName=PeppaPig 添加一条数据

    访问：http://localhost:8080/dep/1获取数据

Mybatis配置

开启驼峰命名法

我们的实体类和表中的列名一致，一点问题也没有

我们把department表的departmentName列名改为department_name看看会发生什么

访问：http://localhost:8080/dep/1获取数据

1
[{"id":1,"departmentName":null}]Copy to clipboardErrorCopied

由于列表和属性名不一致，所以就没有封装进去，我们表中的列名和实体类属性名都是遵循驼峰命名规则的，可以开启mybatis的开启驼峰命名配置

1
2
3
mybatis:
  configuration:
    map-underscore-to-camel-case: trueCopy to clipboardErrorCopied

然后重启项目，重新插入数据，再查询就发现可以封装进去了

也可以通过向spring容器中注入org.mybatis.spring.boot.autoconfigure.ConfigurationCustomizer的方法设置mybatis参数

1
2
3
4
5
6
7
8
9
10
11
12
13
@Configuration
public class MybatisConfig {

    @Bean
    public ConfigurationCustomizer mybatisConfigurationCustomizer() {
        return new ConfigurationCustomizer() {
            @Override
            public void customize(org.apache.ibatis.session.Configuration configuration) {
                configuration.setMapUnderscoreToCamelCase(true);
            }
        };
    }
}Copy to clipboardErrorCopied

1574430056512

1574430280791

Mapper扫描

使用@mapper注解的类可以被扫描到容器中，但是每个Mapper都要加上这个注解就是一个繁琐的工作，能不能直接扫描某个包下的所有Mapper接口呢，当然可以，在springboot启动类上加上@MapperScan

1
2
3
4
5
6
7
8
9
@MapperScan("cn.clboy.springbootmybatis.mapper")
@SpringBootApplication
public class SpringbootMybatisApplication {

    public static void main(String[] args) {
        SpringApplication.run(SpringbootMybatisApplication.class, args);
    }

}Copy to clipboardErrorCopied

使用xml配置文件

  1. 创建mybatis全局配置文件

    1
    2
    3
    4
    5
    6
    7
    <?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">
    <configuration>
        <typeAliases>
            <package name="cn.clboy.springbootmybatis.model"/>
        </typeAliases>
    </configuration>Copy to clipboardErrorCopied

  2. 创建EmployeeMapper接口

    1
    2
    3
    4
    5
    6
    public interface EmployeeMapper {

        List<Employee> selectAll();

        int save(Employee employee);
    }Copy to clipboardErrorCopied

  3. 创建EmployeeMapper.xml映射文件

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    <?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    <mapper namespace="cn.clboy.springbootmybatis.mapper.EmployeeMapper">
        <select id="selectAll" resultType="employee">
            SELECT * FROM employee
        </select>
        <insert id="save" parameterType="employee" useGeneratedKeys="true" keyProperty="id">
           INSERT INTO employee(lastName,email,gender,d_id) VALUES (#{lastName},#{email},#{gender},#{d_id})
        </insert>
    </mapper>Copy to clipboardErrorCopied

  4. 配置文件(application.yaml)中指定配置文件和映射文件的位置

    1
    2
    3
    mybatis:
      config-location: classpath:mybatis/mybatis-config.xml
      mapper-locations: classpath:mybatis/mapper/*.xmlCopy to clipboardErrorCopied

  5. 给表中插入两个数据，用于测试

    1
    2
    INSERT INTO employee(lastName,email,gender,d_id) VALUES ('张三','123456@qq.com',1,1);
    INSERT INTO employee(lastName,email,gender,d_id) VALUES ('lisi','245612@qq.com',1,1);Copy to clipboardErrorCopied

  6. 创建EmployeeController

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    @RestController
    public class EmployeeController {

        @Autowired
        private EmployeeMapper employeeMapper;

        @RequestMapping("/emp/list")
        public List<Employee> getALl() {
            return employeeMapper.selectAll();
        }

        @RequestMapping("/emp/{id}")
        public Employee save(Employee employee) {
            employeeMapper.save(employee);
            return employee;
        }
    }Copy to clipboardErrorCopied

    访问：http://localhost:8080/emp/list

SpringBoot整合JPA

SpringData：

SpringData

依赖

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
<dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>Copy to clipboardErrorCopied

1574481366615

实体类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
package cn.clboy.springbootjpa.entity;


import javax.persistence.*;


@Entity //使用JPA注解配置映射关系,告诉JPA这是一个实体类（和数据表映射的类）
@Table(name = "tbl_user")   //@Table来指定和哪个数据表对应;如果省略默认表名类名小写；
public class User {

    @Id //这是一个主键
    @GeneratedValue(strategy = GenerationType.IDENTITY) //自增主键
    private Integer id;

    @Column(name = "last_name",length = 50) //这是和数据表对应的一个列
    private String lastName;
    @Column //省略默认列名就是属性名
    private String email;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getLastName() {
        return lastName;
    }

    public void setLastName(String lastName) {
        this.lastName = lastName;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }
}
Copy to clipboardErrorCopied

DAO

1
2
3
4
5
6
7
8
9
10
11
12
package cn.clboy.springbootjpa.repository;

import cn.clboy.springbootjpa.entity.User;
import org.springframework.data.jpa.repository.JpaRepository;

/**
 * 继承JpaRepository来完成对数据库的操作
 * 泛型是（实体类，主键）
 */
public interface UserRepository extends JpaRepository<User, Integer> {

}Copy to clipboardErrorCopied

配置文件

1
2
3
4
5
6
7
8
9
10
spring:
  datasource:
    username: root
    password: root
    url: jdbc:mysql://172.16.145.137:3306/springboot
    driver-class-name: com.mysql.cj.jdbc.Driver
  jpa:
    hibernate:
      ddl-auto: update
    show-sql: trueCopy to clipboardErrorCopied

Controller

1
Copy to clipboardErrorCopied

添加User，访问：

http://localhost:8080/user?lastName=zhangsan&email=123456@qq.com

http://localhost:8080/user?lastName=lisi&email=78215646@qq.com

查询用户访问：

http://localhost:8080/user/1，然后你就会发现抛出500错误，原因是getOne方法使用的懒加载，获取到的只是代理对象，转换为json时会报错

解决方法有两种：

  1. 关闭懒加载，在实体类上加@Proxy(lazy = false)注解

    1
    2
    3
    4
    @Entity
    @Table(name = "tbl_user")
    @Proxy(lazy = false)
    public class UserCopy to clipboardErrorCopied

  2. 转json的时候忽略hibernateLazyInitializer和handler属性

    1
    2
    3
    4
    @Entity
    @Table(name = "tbl_user")
    @JsonIgnoreProperties(value = {"hibernateLazyInitializer", "handler"})
    public class User

SpringBoot启动流程

1574497298469

启动原理

1
2
3
4
public static void main(String[] args) {
    //xxx.class：主配置类，（可以传多个）
    SpringApplication.run(xxx.class, args);
}Copy to clipboardErrorCopied

  1. 从run方法开始，创建SpringApplication，然后再调用run方法

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    /**
     * ConfigurableApplicationContext(可配置的应用程序上下文)
     */
    public static ConfigurableApplicationContext run(Class<?> primarySource, String... args) {
        //调用下面的run方法
        return run(new Class[]{primarySource}, args);
    }

    public static ConfigurableApplicationContext run(Class<?>[] primarySources, String[] args) {
        return (new SpringApplication(primarySources)).run(args);
    }Copy to clipboardErrorCopied

  2. 创建SpringApplication

    1
    2
    //primarySources：主配置类
    new SpringApplication(primarySources)Copy to clipboardErrorCopied
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    public SpringApplication(Class<?>... primarySources) {
        //调用下面构造方法
        this((ResourceLoader) null, primarySources);
    }
       
    public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
        this.sources = new LinkedHashSet();
        this.bannerMode = Mode.CONSOLE;
        this.logStartupInfo = true;
        this.addCommandLineProperties = true;
        this.addConversionService = true;
        this.headless = true;
        this.registerShutdownHook = true;
        this.additionalProfiles = new HashSet();
        this.isCustomEnvironment = false;
        this.lazyInitialization = false;
        this.resourceLoader = resourceLoader;
        Assert.notNull(primarySources, "PrimarySources must not be null");
        //保存主配置类
        this.primarySources = new LinkedHashSet(Arrays.asList(primarySources));
        //获取当前应用的类型，是不是web应用，见2.1
        this.webApplicationType = WebApplicationType.deduceFromClasspath();
        //从类路径下找到META‐INF/spring.factories配置的所有ApplicationContextInitializer；然后保存起来，见2.2
        this.setInitializers(this.getSpringFactoriesInstances(ApplicationContextInitializer.class));
        //从类路径下找到META‐INF/spring.ApplicationListener；然后保存起来,原理同上
        this.setListeners(this.getSpringFactoriesInstances(ApplicationListener.class));
        //从多个配置类中找到有main方法的主配置类，见下图(在调run方法的时候是可以传递多个配置类的)
        this.mainApplicationClass = this.deduceMainApplicationClass();
        //执行完毕，SpringApplication对象就创建出来了，返回到1处，调用SpringApplication对象的run方法，到3
    }Copy to clipboardErrorCopied

    1574503716694

    2.1 判断是不是web 应用
2.2 getSpringFactoriesInstances(ApplicationContextInitializer.class)
1. 调用SpringApplication对象的run方法

1574512218795

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
public ConfigurableApplicationContext run(String... args) {
    StopWatch stopWatch = new StopWatch();
    stopWatch.start();
    //声明IOC容器
    ConfigurableApplicationContext context = null;
    Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList();
    this.configureHeadlessProperty();
    //从类路径下META‐INF/spring.factories获取SpringApplicationRunListeners，原理同2中获取ApplicationContextInitializer和ApplicationListener
    SpringApplicationRunListeners listeners = this.getRunListeners(args);
    //遍历上一步获取的所有SpringApplicationRunListener，调用其starting方法
    listeners.starting();
   
    Collection exceptionReporters;
    try {
        //封装命令行
        ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
        //准备环境，把上面获取到的listeners传过去，见3.1
        ConfigurableEnvironment environment = this.prepareEnvironment(listeners, applicationArguments);
        this.configureIgnoreBeanInfo(environment);
        //打印Banner，就是控制台那个Spring字符画
        Banner printedBanner = this.printBanner(environment);
        //根据当前环境利用反射创建IOC容器
        context = this.createApplicationContext();
    //从类路径下META‐INF/spring.factories获取SpringBootExceptionReporter，原理同2中获取ApplicationContextInitializer和ApplicationListener
        exceptionReporters = this.getSpringFactoriesInstances(SpringBootExceptionReporter.class, new Class[]{ConfigurableApplicationContext.class}, context);
        //准备IOC容器，见3.3
        this.prepareContext(context, environment, listeners, applicationArguments, printedBanner);
        //刷新IOC容器，可查看配置嵌入式Servlet容器原理 链接在3.4
        this.refreshContext(context);
        //这是一个空方法
        this.afterRefresh(context, applicationArguments);
        stopWatch.stop();
        if (this.logStartupInfo) {
            (new StartupInfoLogger(this.mainApplicationClass)).logStarted(this.getApplicationLog(), stopWatch);
        }
        //调用所有SpringApplicationRunListener的started方法
        listeners.started(context);
        //见3.5 ，从ioc容器中获取所有的ApplicationRunner和CommandLineRunner进行回调ApplicationRunner先回调，CommandLineRunner再
        this.callRunners(context, applicationArguments);
    } catch (Throwable var10) {
        this.handleRunFailure(context, var10, exceptionReporters, listeners);
        throw new IllegalStateException(var10);
    }
   
    try {
        //调用所有SpringApplicationRunListener的running方法
        listeners.running(context);
        return context;
    } catch (Throwable var9) {
        this.handleRunFailure(context, var9, exceptionReporters, (SpringApplicationRunListeners)null);
        throw new IllegalStateException(var9);
    }
}Copy to clipboardErrorCopied

//容器创建完成，返回步骤1处，最后返回到启动类

3.1
3.2
3.3
3.4
3.5
## 几个重要的事件回调机制

配置在META-INF/spring.factories

  • ApplicationContextInitializer
  • SpringApplicationRunListener

只需要放在ioc容器中

  • ApplicationRunner
  • CommandLineRunner

测试

  1. 创建ApplicationContextInitializer和SpringApplicationRunListener的实现类，并在META-INF/spring.factories文件中配置

    1
    2
    3
    4
    5
    6
    7
    public class TestApplicationContextInitializer implements ApplicationContextInitializer {

        @Override
        public void initialize(ConfigurableApplicationContext configurableApplicationContext) {
            System.out.println("TestApplicationContextInitializer.initialize");
        }
    }Copy to clipboardErrorCopied
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    public class TestSpringApplicationRunListener implements SpringApplicationRunListener {
        @Override
        public void starting() {
            System.out.println("TestSpringApplicationRunListener.starting");
        }

        @Override
        public void environmentPrepared(ConfigurableEnvironment environment) {
            System.out.println("TestSpringApplicationRunListener.environmentPrepared");
        }

        @Override
        public void contextPrepared(ConfigurableApplicationContext context) {
            System.out.println("TestSpringApplicationRunListener.contextPrepared");
        }

        @Override
        public void contextLoaded(ConfigurableApplicationContext context) {
            System.out.println("TestSpringApplicationRunListener.contextLoaded");
        }

        @Override
        public void started(ConfigurableApplicationContext context) {
            System.out.println("TestSpringApplicationRunListener.started");
        }

        @Override
        public void running(ConfigurableApplicationContext context) {
            System.out.println("TestSpringApplicationRunListener.running");
        }

        @Override
        public void failed(ConfigurableApplicationContext context, Throwable exception) {
            System.out.println("TestSpringApplicationRunListener.failed");
        }
    }Copy to clipboardErrorCopied
    1
    2
    3
    4
    5
    org.springframework.context.ApplicationContextInitializer=\
    cn.clboy.springbootprocess.init.TestApplicationContextInitializer

    org.springframework.boot.SpringApplicationRunListener=\
    cn.clboy.springbootprocess.init.TestSpringApplicationRunListenerCopy to clipboardErrorCopied

    启动报错：说是没有找到带org.springframework.boot.SpringApplication和String数组类型参数的构造器，给TestSpringApplicationRunListener添加这样的构造器

    1574515721669

    1
    2
    public TestSpringApplicationRunListener(SpringApplication application,String[] args) {
    }Copy to clipboardErrorCopied

  2. 创建ApplicationRunner实现类和CommandLineRunner实现类，注入到容器中

    1
    2
    3
    4
    5
    6
    7
    8
    @Component
    public class TestApplicationRunner implements ApplicationRunner {

        @Override
        public void run(ApplicationArguments args) throws Exception {
            System.out.println("TestApplicationRunner.run\t--->"+args);
        }
    }Copy to clipboardErrorCopied
    1
    2
    3
    4
    5
    6
    7
    8
    @Component
    public class TestCommandLineRunn implements CommandLineRunner {

        @Override
        public void run(String... args) throws Exception {
            System.out.println("TestCommandLineRunn.runt\t--->"+ Arrays.toString(args));
        }
    }Copy to clipboardErrorCopied

    1574517578711

修改Banner

默认是找类路径下的banner.txt，可以在配置文件中修改

1
spring.banner.location=xxx.txtCopy to clipboardErrorCopied

生成banner的网站：http://patorjk.com/software/taag

1574508283758

也可以使用图片(将其像素解析转换成assii编码之后打印)，默认是在类路径下找名为banner后缀为"gif", "jpg", "png"的图片

1
static final String[] IMAGE_EXTENSION = new String[]{"gif", "jpg", "png"};Copy to clipboardErrorCopied

也可以在配置文件中指定

1
spring.banner.image.location=classpath:abc.png

自定义Starter

  • 启动器只用来做依赖导入

  • 专门来写一个自动配置模块；

  • 启动器依赖自动配置模块，项目中引入相应的starter就会引入启动器的所有传递依赖

    1574561125363

启动器

启动器模块是一个空 JAR 文件，仅提供辅助性依赖管理，这些依赖可能用于自动 装配或者其他类库

命名规约

  • 官方命名

    spring-boot-starter-模块名

    eg：spring-boot-starter-web、spring-boot-starter-jdbc、spring-boot-starter-thymeleaf

  • 自定义命名

    模块名-spring-boot-starter

    eg：mybatis-spring-boot-start

如何编写自动配置

1
2
3
4
5
6
7
@Configuration //指定这个类是一个配置类
@ConditionalOnXXX //在指定条件成立的情况下自动配置类生效
@AutoConfigureAfter //指定自动配置类的顺序
@Bean //给容器中添加组件
@ConfigurationPropertie结合相关xxxProperties类来绑定相关的配置
@EnableConfigurationProperties //让xxxProperties生效加入到容器中
public class XxxxAutoConfiguration {Copy to clipboardErrorCopied

自动配置类要能加载,需要将启动就加载的自动配置类配置在META-INF/spring.factories中

eg：

1
2
3
4
# Auto Configure
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.mybatis.spring.boot.autoconfigure.MybatisLanguageDriverAutoConfiguration,\
org.mybatis.spring.boot.autoconfigure.MybatisAutoConfigurationCopy to clipboardErrorCopied

案例

  1. 创建一个自动配置模块，和创建普通springboot项目一样，不需要引入其他starter

  2. 删除掉多余的文件和依赖

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    <?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
        <parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>2.2.1.RELEASE</version>
            <relativePath/>
        </parent>
        <groupId>cn.clboy.spring.boot</groupId>
        <artifactId>clboy-spring-boot-autoconfigure</artifactId>
        <version>0.0.1-SNAPSHOT</version>
        <name>clboy-spring-boot-autoconfigure</name>

        <properties>
            <java.version>1.8</java.version>
        </properties>

        <dependencies>
            <!--引入spring‐boot‐starter；所有starter的基本配置-->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter</artifactId>
            </dependency>
            <!--可以生成配置类提示文件-->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-configuration-processor</artifactId>
                <optional>true</optional>
            </dependency>
        </dependencies>

    </project>Copy to clipboardErrorCopied

    1574563050873

  3. 创建配置类和自动配置类

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    package cn.clboy.spring.boot.autoconfigure;

    import org.springframework.boot.context.properties.ConfigurationProperties;

    @ConfigurationProperties(prefix = "clboy")
    public class ClboyProperties {

        private String prefix;
        private String suffix;

        public ClboyProperties() {
            this.prefix = "";
            this.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;
        }
    }Copy to clipboardErrorCopied
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    package cn.clboy.spring.boot.autoconfigure;

    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;

    /**
     * @Author cloudlandboy
     * @Date 2019/11/24 上午10:40
     * @Since 1.0.0
     */

    @Configuration
    @ConditionalOnWebApplication //web应用才生效
    @EnableConfigurationProperties(ClboyProperties.class) //让配置类生效，(注入到容器中)
    public class ClboyAutoConfiguration {

        private final ClboyProperties clboyProperties;

        /**
         * 构造器注入clboyProperties
         *
         * @param clboyProperties
         */
        public ClboyAutoConfiguration(ClboyProperties clboyProperties) {
            this.clboyProperties = clboyProperties;
        }

        @Bean
        public HelloService helloService() {
            return new HelloService();
        }

        public class HelloService {

            public String sayHello(String name) {
                return clboyProperties.getPrefix() + name + clboyProperties.getSuffix();
            }
        }
    }Copy to clipboardErrorCopied

  4. 在resources文件夹下创建META-INF/spring.factories

    1574568406300

    1
    2
    org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
    cn.clboy.spring.boot.autoconfigure.ClboyAutoConfigurationCopy to clipboardErrorCopied

  5. 安装到本地仓库

  6. 创建starter，选择maven工程即可，只是用于管理依赖，添加对AutoConfiguration模块的依赖

    1574565106397

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    <?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>cn.clboy.spring.boot</groupId>
        <artifactId>clboy-spring-boot-starter</artifactId>
        <version>1.0-SNAPSHOT</version>

        <dependencies>
            <dependency>
                <groupId>cn.clboy.spring.boot</groupId>
                <artifactId>clboy-spring-boot-autoconfigure</artifactId>
                <version>0.0.1-SNAPSHOT</version>
            </dependency>
        </dependencies>

    </project>Copy to clipboardErrorCopied

  7. 安装到本地仓库

  8. 创建项目测试，选择添加web场景，因为设置是web场景才生效

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    <?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
        <parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>2.2.1.RELEASE</version>
            <relativePath/> <!-- lookup parent from repository -->
        </parent>
        <groupId>cn.clboy</groupId>
        <artifactId>starter-test</artifactId>
        <version>0.0.1-SNAPSHOT</version>
        <name>starter-test</name>
        <description>Demo project for Spring Boot</description>

        <properties>
            <java.version>1.8</java.version>
        </properties>

        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
            <dependency>
                <groupId>cn.clboy.spring.boot</groupId>
                <artifactId>clboy-spring-boot-starter</artifactId>
                <version>1.0-SNAPSHOT</version>
            </dependency>
        </dependencies>

    </project>Copy to clipboardErrorCopied

  9. 创建Controller

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    @RestController
    public class HelloController {

        @Autowired
        private HelloService helloService;

        @RequestMapping("/hello")
        public String sayHello() {
            String hello = helloService.sayHello("Peppa Pig");
            return hello;
        }
    }Copy to clipboardErrorCopied

  10. 在配置文件中配置

    1
    2
    clboy.prefix=hello！
    clboy.suffix=，你好啊...Copy to clipboardErrorCopied

  11. 启动项目访问：http://localhost:8080/hello

注意查看文件夹的命名是否正确，最好是从别的包中复制过去，正确的情况下spring.factories是有小绿叶图标的

Cache

搭建基本环境

  1. 导入数据库文件 创建出department和employee表

  2. 创建javaBean封装数据

  3. 整合MyBatis操作数据库

    1. 配置数据源信息
    1
    2
    3
    4
    spring.datasource.url=jdbc:mysql://localhost:3306/spring_cache?serverTimezone=UTC
    spring.datasource.username=root
    spring.datasource.password=root
    mybatis.configuration.map-underscore-to-camel-case=true

  1. 使用注解版的MyBatis；

    ​ 1）@MapperScan指定需要扫描的mapper接口所在的包

    1
    2
    3
    4
    5
    6
    7
    @MapperScan("com.zzl.mapper")
    @SpringBootApplication
    @EnableCaching
    public class Springboot01CahceApplication {
        public static void main(String[] args) {   			 SpringApplication.run(Springboot01CahceApplication.class, args);
        }
    }

快速体验缓存

步骤：

  1. 开启基于注解的缓存 @EnableCaching（如上图）

  2. 标注缓存注解即可

    @Cacheable

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    /**Cacheable中的参数：
        * cacheNames/value:缓存组件的名字
        * key:缓存数据用的key，默认是参数的值
        * keyGenerator:key的生成器;  key和keyGenerator 二选一
        * cacheManager:缓存管理器，或者cacheResolver指定获取解析器
        * condition:符合条件的情况才缓存
        *      #a0>1第一个参数大于1
        * unless：否定缓存，当unless指定的条件为true，方法的返回值就不会被缓存
        * sync：是否使用异步
        * */
       
       @Cacheable()
       public Employee getEmp(Integer id){
           System.out.println("查询"+id+"号员工");
           Employee emp = employeeMapper.getEmpById(id);
           return emp;
       }

@CacheEvict

1
2
3
4
5
6
7
8
9
10
11
/**
    * @CacheEvict: 缓存清除
    * 通过key指定要清除的数据
    * allEntries:删除emp中所有的缓存
    * beforeInvocation=false:缓存的清除是否方法之前执行
    *      默认缓存的清除是在方法执行之后执行；如果出现异常缓存就不会清除
    * */
   @CacheEvict(key = "#id",allEntries = true)
   public void deleteEmp(Integer id){
       System.out.println("deleteEmp" + id);
   }

@CachePut

1
2
3
4
5
6
7
8
9
10
11
/**
     * @CachePut:既调用方法，有更新缓存数据       同步更新缓存！！要求Cacheable和CachePut用的是一个key
     * 修改了数据库的某个数据，同时更新缓存
     *
     * */
    @CachePut(key = "#employee.id")
    public Employee updateEmp(Employee employee){
        System.out.println("updateEmp:"+employee);
        employeeMapper.updateEmp(employee);
        return employee;
    }

自定义keyGenerator

1
2
3
4
5
6
7
8
9
10
11
12
13
14
@Configuration
public class MyCacheConfig {

    @Bean("myKeyGenerator")
    public KeyGenerator keyGenerator(){
        KeyGenerator keyGenerator1 = new KeyGenerator() {
            @Override
            public Object generate(Object o, Method method, Object... objects) {
                return method.getName()+"["+Arrays.asList(objects).toString()+"]";
            }
        };
        return keyGenerator1;
    }
}

使用： 

1
@Cacheable（keyGenerator = "myKeyGenerator"）

默认使用的是ConcurrentMapCacheManager==ConcurrentMapCache；将数据保存在 ConcurrentMap<Object, Object>中

整合Redis作为缓存

Redis 是一个开源（BSD许可）的，内存中的数据结构存储系统，它可以用作数据库、缓存和消息中间件。

  1. 安装Redis：使用docker
1
2
docker pull redis
docker run -d -p 6379:6379 --name myredis ******
  1. 引入redis的starter
1
2
3
4
<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
  1. 配置redis
1
spring.redis.host=111.229.141.185
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
//序列化为Json，Emp类要实现序列化接口，默认序列化为jdk序列化
@Configuration
public class MyRedisConfig {

    @Bean
    public RedisTemplate<Object, Employee> empRedisTemplate(
            RedisConnectionFactory redisConnectionFactory)
            throws UnknownHostException {
        RedisTemplate<Object,Employee> template = new RedisTemplate<Object, Employee>();
        template.setConnectionFactory(redisConnectionFactory);
        Jackson2JsonRedisSerializer<Employee> ser = new Jackson2JsonRedisSerializer<Employee>(Employee.class);
        template.setDefaultSerializer(ser);
        return template;
    }

    @Bean
    public RedisCacheManager cacheManager(RedisConnectionFactory redisConnectionFactory){
        RedisCacheConfiguration cacheConfiguration = RedisCacheConfiguration
                .defaultCacheConfig().entryTtl(Duration.ofDays(1))
                .disableCachingNullValues()
                .serializeValuesWith(RedisSerializationContext.SerializationPair
                .fromSerializer(new GenericJackson2JsonRedisSerializer()));
        return RedisCacheManager.builder(redisConnectionFactory).cacheDefaults(cacheConfiguration).build();
    }

}
    
    
//测试
@Autowired
StringRedisTemplate stringRedisTemplate;//操作k-v都是String的
@Autowired
RedisTemplate redisTemplate;            //操作k-v都是对象的
@Autowired
RedisTemplate<Object, Employee> empRedisTemplate;
/**
	 * Redis常见的五大数据类型
	 *  String（字符串）、List（列表）、Set（集合）、Hash（散列）、ZSet（有序集合）
	 *  stringRedisTemplate.opsForValue()[String（字符串）]
	 *  stringRedisTemplate.opsForList()[List（列表）]
	 *  stringRedisTemplate.opsForSet()[Set（集合）]
	 *  stringRedisTemplate.opsForHash()[Hash（散列）]
	 *  stringRedisTemplate.opsForZSet()[ZSet（有序集合）]
	 */
	@Test
	public void test01(){
		//给redis中保存数据
	    //stringRedisTemplate.opsForValue().append("msg","hello");
//		String msg = stringRedisTemplate.opsForValue().get("msg");
//		System.out.println(msg);

//		stringRedisTemplate.opsForList().leftPush("mylist","1");
//		stringRedisTemplate.opsForList().leftPush("mylist","2");
	}

	@Test
    public void test02(){
        Employee employee = employeeMapper.getEmpById(1);
//        redisTemplate.opsForValue().set("emp01",employee);
        empRedisTemplate.opsForValue().set("emp-01",employee);
    }

	@Test
    public void contextLoads() {
        Employee employee = employeeMapper.getEmpById(1);
        System.out.println(employee);
    }

消息

RabbitMQ安装使用

采用docker安装

1
2
3
docker pull rabbitmq:3-management
docker run -d -p 5672:5672 -p 15672:15672 --name myrabbitmq *******
浏览器中访问 ip:15672

1585195794687

创建exchange：direct、fanout、topic

创建队列：atguigu , atguigu.news , atguigu.emps , gulixueyuan.news

绑定exchange和队列

​ 设置Routing key：direct、fanout与队列名相同，topic为尾缀

发布消息，即可在队列中收到消息

使用SpringBoot发送接受消息

  1. 在initializer中选择rabbitMQ,会引入相应的包
  2. 设置配置
1
2
3
spring.rabbitmq.host=111.229.141.185
spring.rabbitmq.username=guest
spring.rabbitmq.password=guest
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
@Autowired
   RabbitTemplate rabbitTemplate;

   @Test
   void contextLoads() {
       //message自己构造；可以定制消息体内容和消息头
       //rabbitTemplate.send(exchange,routeKey,message);

       //只需要传入要发送的对象，自动序列化发送给给rabbitmq
       //rabbitTemplate.convertAndSend(exchange,routeKey,message);
       Map<String,Object> map = new HashMap<>();
       map.put("msg","这是第一个消息");
       map.put("data", Arrays.asList("helloworld",123,true));
       //对象被默认序列化之后发送出去
       rabbitTemplate.convertAndSend("exchange.direct","atguigu.news",new Book("西游记","吴承恩"));
   }


   //接受数据
   @Test
   public void receive(){
       Object o = rabbitTemplate.receiveAndConvert("atguigu.news");
       System.out.println(o.getClass());
       System.out.println(o);
   }

   @Test
   public void sendMsg(){
       rabbitTemplate.convertAndSend("exchange.fanout","",new Book("红楼梦","曹雪芹"));
   }

设置序列化转换器

1
2
3
4
5
6
7
@Configuration
public class MyAMQPConfig {
    @Bean
    public MessageConverter messageConverter(){
        return new Jackson2JsonMessageConverter();
    }
}

基于注解的RabbitMQ

  1. 开启基于注解的RabbitMQ
1
2
3
4
5
6
7
@EnableRabbit           //开启基于注解的RabbitMQ
@SpringBootApplication
public class Springboot02AmqpApplication {
    public static void main(String[] args) {
        SpringApplication.run(Springboot02AmqpApplication.class, args);
    }
}
  1. 使用RabbitListenner监听队列消息
1
2
3
4
5
6
7
8
9
10
11
12
@Service
public class BookService {
    @RabbitListener(queues = "atguigu.news")
    public void receive(Book book){
        System.out.println("收到消息："+book);
    }
    @RabbitListener(queues = "atguigu")
    public void receive02(Message message){
        System.out.println(message.getBody());
        System.out.println(message.getMessageProperties());
    }
}

AmqpAdmin管理组件的使用（利用java程序创建exchange，队列，绑定规则）

1
2
3
4
5
6
7
8
9
10
11
12
13
@Autowired
AmqpAdmin amqpAdmin;

@Test
public void createExchange(){
    //        amqpAdmin.declareExchange(new DirectExchange("amqpadmin.exchange"));
    //        System.out.println("创建完成");
    //        amqpAdmin.declareQueue(new Queue("amqpadmin.queue",true));
    amqpAdmin.declareBinding(new Binding("amqpadmin.queue",
                                         Binding.DestinationType.QUEUE,"amqpadmin.exchange",
                                         "amqp.haha",null));

}

检索ElasticSearch

ElasticSearch安装和基本使用

使用docker安装

1
2
docker pull elasticsearch:6.8.6
docker run -e ES_JAVA_OPTS="-Xms256m -Xmx256m" -d -p 9200:9200 -p 9300:9300 --name ES01 *****

注意：elasticsearch版本应与springboot内版本向对应 springboot2.2.6 对应 elasticsearch6.8.6

在浏览器中访问 ip：9200可查看相关信息

在elasticsearch / 面向文档中 可快速入门elasticsearch

在Springboot中使用ElasticSearch

在Spring Initializer中选择Nosql中的ElasticSearch，导入相应的pom包

Jest(已过时)

  1. 配置jest
1
spring.elasticsearch.jest.uris=http://111.229.141.185:9200/
  1. 创建Article实体类
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
public class Article {
    @JestId
    private Integer id;
    private String author;
    private String title;
    private String content;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getAuthor() {
        return author;
    }

    public void setAuthor(String author) {
        this.author = author;
    }

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public String getContent() {
        return content;
    }
    public void setContent(String content) {
        this.content = content;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
@Autowired
JestClient jestClient;
@Test
    void contextLoads() {
        //1、给Es中索引（保存）一个文档；
        Article article = new Article();
        article.setId(1);
        article.setTitle("好消息");
        article.setAuthor("zhangsan");
        article.setContent("Hello World");
        //构建一个索引功能
        Index index = new Index.Builder(article).index("atguigu").type("news").build();

        try {
            //执行
            jestClient.execute(index);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
//测试搜索
@Test
public void search(){

    //查询表达式
    String json ="{\n" +
        "    \"query\" : {\n" +
        "        \"match\" : {\n" +
        "            \"content\" : \"hello\"\n" +
        "        }\n" +
        "    }\n" +
        "}";

    //更多操作：https://github.com/searchbox-io/Jest/tree/master/jest
    //构建搜索功能
    Search search = new Search.Builder(json).addIndex("atguigu").addType("news").build();

    //执行
    try {
        SearchResult result = jestClient.execute(search);
        System.out.println(result.getJsonString());
    } catch (IOException e) {
        e.printStackTrace();
    }
}

在浏览器中访问ip:9200/atguigu/news/{id}

SpringData

  1. 配置文件
1
2
3
#相关的信息在ip:9200中查看
spring.data.elasticsearch.cluster-name=docker-cluster
spring.data.elasticsearch.cluster-nodes=111.229.141.185:9300

两种用法：https://github.com/spring-projects/spring-data-elasticsearch

1）、编写一个接口继承ElasticSearchReoisitory

1
2
3
public interface BookRepository extends ElasticsearchRepository<Book,Integer> {
    public List<Book> findBookByBookNameLike(String bookName);
}

其中的Book实体类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
@Document(indexName = "atguigu",type = "book")
public class Book {

    private Integer id;
    private String bookName;
    private String author;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getBookName() {
        return bookName;
    }

    public void setBookName(String bookName) {
        this.bookName = bookName;
    }

    public String getAuthor() {
        return author;
    }

    public void setAuthor(String author) {
        this.author = author;
    }

    @Override
    public String toString() {
        return "Book{" +
                "id=" + id +
                ", bookName='" + bookName + '\'' +
                ", author='" + author + '\'' +
                '}';
    }
}

测试

1
2
3
4
5
6
7
8
9
10
11
12
@Autowired
BookRepository bookRepository;
@Test
public void test02(){
    //        Book book = new Book();
    //        book.setId(1);
    //        book.setBookName("西游记");
    //        book.setAuthor("吴承恩");
    //        bookRepository.index(book);
    for (Book book: bookRepository.findBookByBookNameLike("游")){
        System.out.println(book);
    }

任务

异步任务

1 开启异步注解

1
2
3
4
5
6
7
@EnableAsync
@SpringBootApplication
public class Springboot04TaskApplication {
    public static void main(String[] args) {
        SpringApplication.run(Springboot04TaskApplication.class, args);
    }
}

2 Service类

1
2
3
4
5
6
7
8
9
10
11
12
@Service
public class AsyncService {
    @Async	//告诉Spring这是一个异步方法
    public void hello(){
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("数据处理中。。。");
    }
}

3 Controller类

1
2
3
4
5
6
7
8
9
10
11
@RestController
public class AsyncController {
    @Autowired
    AsyncService asyncService;

    @GetMapping("/hello")
    public String hello(){
        asyncService.hello();
        return "success";
    }
}

定时任务

开启Schedule注解

1
2
3
4
5
6
7
8
@EnableAsync
@EnableScheduling
@SpringBootApplication
public class Springboot04TaskApplication {
    public static void main(String[] args) {
        SpringApplication.run(Springboot04TaskApplication.class, args);
    }
}

Service类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
/**
     * second(秒), minute（分）, hour（时）, day of month（日）, month（月）, day of week（周几）.
     * 0 * * * * MON-FRI
     *  【0 0/5 14,18 * * ?】 每天14点整，和18点整，每隔5分钟执行一次
     *  【0 15 10 ? * 1-6】 每个月的周一至周六10:15分执行一次
     *  【0 0 2 ? * 6L】每个月的最后一个周六凌晨2点执行一次
     *  【0 0 2 LW * ?】每个月的最后一个工作日凌晨2点执行一次
     *  【0 0 2-4 ? * 1#1】每个月的第一个周一凌晨2点到4点期间，每个整点都执行一次；
     */
   // @Scheduled(cron = "0 * * * * MON-SAT")
    //@Scheduled(cron = "0,1,2,3,4 * * * * MON-SAT")
   // @Scheduled(cron = "0-4 * * * * MON-SAT")
    @Scheduled(cron = "0/4 * * * * MON-SAT")  //每4秒执行一次
    public void hello(){
        System.out.println("hello ... ");
    }

邮件任务

1 引入邮件相关的starter

1
2
3
4
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-mail</artifactId>
</dependency>

2 配置相关配置

1
2
3
4
spring.mail.username=1422181938@qq.com
spring.mail.password=ajoxvbftvasxfejd	#授权码在QQ邮箱网站中获取
spring.mail.host=smtp.qq.com
spring.mail.properties.mail.smtp.ssl.enable=true

3 测试

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
@Autowired
JavaMailSender mailSender;

@Test
void contextLoads() {
    SimpleMailMessage message = new SimpleMailMessage();
    message.setSubject("通知今晚开会");
    message.setText("今晚7：30开会");
    message.setTo("420305623@qq.com");
    message.setFrom("1422181938@qq.com");
    mailSender.send(message);
}


@Test
public void test02() throws Exception{
    //SimpleMailMessage message = new SimpleMailMessage();
    //创建一个复杂的消息邮件
    MimeMessage message = mailSender.createMimeMessage();
    MimeMessageHelper helper = new MimeMessageHelper(message, true);
    
    //邮件设置
    helper.setSubject("通知今晚开会");
    helper.setText("<b style='color:red'>今晚7：30开会</b>",true);
    helper.setTo("420305623@qq.com");
    helper.setFrom("1422181938@qq.com");
    
    //上传文件
    helper.addAttachment("1.png",new File("C:\\Users\\zzl\\Pictures\\Screenshots\\1.png"));
    helper.addAttachment("2.png",new File("C:\\Users\\zzl\\Pictures\\Screenshots\\2.png"));
    
    mailSender.send(message);
}

安全

SpringSecurity

1 创建工程时选择Security

2 编写SpringSecurity的配置类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
@EnableWebSecurity
public class MySecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        //super.configure(http);
        //定制请求的授权规则
        http.authorizeRequests().antMatchers("/").permitAll()
                .antMatchers("/level1/**").hasRole("VIP1")
                .antMatchers("/level2/**").hasRole("VIP2")
                .antMatchers("/level3/**").hasRole("VIP3");
        //自定配置登录的登录功能
        //1./login来到登录页
        //2.重定向到/login?error表示登录失败
        http.formLogin().loginPage("/userlogin")
            .usernameParameter("user")
            .passwordParameter("pwd");
        //1、/login来到登陆页
        //2、重定向到/login?error表示登陆失败
        //3、更多详细规定
        //4、默认post形式的 /login代表处理登陆
        //5、一但定制loginPage；那么 loginPage的post请求就是登陆
        http.logout().logoutSuccessUrl("/");
        //1、访问 /logout 表示用户注销，清空session
        //2、注销成功会返回 /login?logout 页面；
        http.rememberMe().rememberMeParameter("remember");
        //登陆成功以后，将cookie发给浏览器保存，以后访问页面带上这个cookie，只要通过检查就可以免登录
        //点击注销会删除cookie
    }

    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        //super.configure(auth);
        auth.inMemoryAuthentication().passwordEncoder(new BCryptPasswordEncoder())
                .withUser("zhangsan").password(new BCryptPasswordEncoder().encode("123456")).roles("VIP1","VIP2")
                .and()
                .withUser("lisi").password(new BCryptPasswordEncoder().encode("123456")).roles("VIP2","VIP3")
                .and()
                .withUser("wangwu").password(new BCryptPasswordEncoder().encode("123456")).roles("VIP1","VIP3");
    }
}

3 页面配置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
<html xmlns:th="http://www.thymeleaf.org"
	  xmlns:sec="http://www.thymeleaf.org/thymeleaf-extras-springsecurity4">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
</head>
<body>
<h1 align="center">欢迎光临武林秘籍管理系统</h1>
<div sec:authorize="!isAuthenticated()">
	<h2 align="center">游客您好，如果想查看武林秘籍 <a th:href="@{/userlogin}">请登录</a></h2>
</div>
<div sec:authorize="isAuthenticated()">
	<h2>
		<span sec:authentication="name"></span>你好，你的角色有:
		<span sec:authentication="principal.authorities"></span>
	</h2>
	<form th:action="@{/logout}" method="post">
		<input type="submit" value="注销" />
	</form>
</div>
<hr>

<div sec:authorize="hasRole('VIP1')">
<h3>普通武功秘籍</h3>
<ul>
	<li><a th:href="@{/level1/1}">罗汉拳</a></li>
	<li><a th:href="@{/level1/2}">武当长拳</a></li>
	<li><a th:href="@{/level1/3}">全真剑法</a></li>
</ul>
</div>
<div sec:authorize="hasRole('VIP2')">
<h3>高级武功秘籍</h3>
<ul>
	<li><a th:href="@{/level2/1}">太极拳</a></li>
	<li><a th:href="@{/level2/2}">七伤拳</a></li>
	<li><a th:href="@{/level2/3}">梯云纵</a></li>
</ul>
</div>
<div sec:authorize="hasRole('VIP3')">
<h3>绝世武功秘籍</h3>
<ul>
	<li><a th:href="@{/level3/1}">葵花宝典</a></li>
	<li><a th:href="@{/level3/2}">龟派气功</a></li>
	<li><a th:href="@{/level3/3}">独孤九剑</a></li>
</ul>
</div>
</body>
</html>

4 自定义登陆页面

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
<html xmlns:th="http://www.thymeleaf.org">
<head>
<meta charset="UTF-8">
</head>
<body>
	<h1 align="center">欢迎登陆武林秘籍管理系统</h1>
	<hr>
	<div align="center">
		<!--参数名称在config中定义-->
        <form th:action="@{/userlogin}" method="post">
			用户名:<input name="user"/><br>
			密码:<input name="pwd"><br/>
			<input type="checkbox" name="remember">记住我<br/>
			<input type="submit" value="登陆">
		</form>
	</div>
</body>
</html>

avatar

开发热部署

热部署实现：

1 引入开发者工具

1
2
3
4
5
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-devtools</artifactId>
    <optional>true</optional>
</dependency>

2 按Ctrl+F9（build）

监控管理

实现监控

1 创建项目时选择Ops中的Actuator

2 SpringBoot2.x 配置

1
management.endpoints.web.exposure.include=*

在Springboot2.x中，大多数监控已不再有用。可用的如图。

1585204893160

赏

谢谢你请我吃糖果

支付宝
微信

扫一扫，分享到微信

微信分享二维码

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

一个辣鸡小破站