一、测试JUnit5

 1.1、Spring Boot Test介绍

Spring Test与JUnit等其他测试框架结合起来，提供了便捷高效的测试手段。而Spring Boot Test 是在Spring Test之上的再次封装，增加了切片测试，增强了mock能力。

整体上，Spring Boot Test支持的测试种类，大致可以分为如下三类：

单元测试：一般面向方法，编写一般业务代码时，测试成本较大。涉及到的注解有@Test。

切片测试：一般面向难于测试的边界功能，介于单元测试和功能测试之间。涉及到的注解有@RunWith @WebMvcTest等。

功能测试：一般面向某个完整的业务功能，同时也可以使用切面测试中的mock能力，推荐使用。涉及到的注解有@RunWith @SpringBootTest等。

功能测试过程中的几个关键要素及支撑方式如下：

测试运行环境：通过@RunWith 和 @SpringBootTest启动spring容器。

mock能力：Mockito提供了强大mock功能。

断言能力：AssertJ、Hamcrest、JsonPath提供了强大的断言能力。

1.2、Junit介绍

JUnit是一个Java语言的单元测试框架。它由Kent Beck和Erich Gamma建立，逐渐成为源于Kent Beck的sUnit的xUnit家族中最为成功的一个JUnit有它自己的JUnit扩展生态圈。多数Java的开发环境都已经集成了JUnit作为单元测试的工具。

官网：https://junit.org/

Junit 测试也是程序员测试，即所谓的白盒测试，它需要程序员知道被测试的代码如何完成功能，以及完成什么样的功能

我们知道 Junit 是一个单元测试框架，那么使用 Junit 能让我们快速的完成单元测试。

通常我们写完代码想要测试这段代码的正确性，那么必须新建一个类，然后创建一个 main() 方法，然后编写测试代码。如果需要测试的代码很多呢？那么要么就会建很多main() 方法来测试，要么将其全部写在一个 main() 方法里面。这也会大大的增加测试的复杂度，降低程序员的测试积极性。而 Junit 能很好的解决这个问题，简化单元测试，写一点测一点，在编写以后的代码中如果发现问题可以较快的追踪到问题的原因，减小回归错误的纠错难度。

1.3、Spring Boot中使用test

1.3.1、添加依赖

增加spring-boot-starter-test依赖，使用@RunWith和@SpringBootTest注解，即可开始测试。

pom中添加依赖

<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-testartifactId>
<scope>testscope>
dependency>

一旦依赖了spring-boot-starter-test，下面这些类库将被一同依赖进去：

Spring Boot2.66的测试起步依赖的pom文件如下：

<?xml version="1.0" encoding="UTF-8"?>
<project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns="http://maven.apache.org/POM/4.0.0"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
  
  
  
  
  
  <modelVersion>4.0.0modelVersion>
  <groupId>org.springframework.bootgroupId>
  <artifactId>spring-boot-starter-testartifactId>
  <version>2.6.6version>
  <name>spring-boot-starter-testname>
  <description>Starter for testing Spring Boot applications with libraries including JUnit Jupiter, Hamcrest and Mockitodescription>
  <url>https://spring.io/projects/spring-booturl>
  <organization>
    <name>Pivotal Software, Inc.name>
    <url>https://spring.iourl>
  organization>
  <licenses>
    <license>
      <name>Apache License, Version 2.0name>
      <url>https://www.apache.org/licenses/LICENSE-2.0url>
    license>
  licenses>
  <developers>
    <developer>
      <name>Pivotalname>
      <email>info@pivotal.ioemail>
      <organization>Pivotal Software, Inc.organization>
      <organizationUrl>https://www.spring.ioorganizationUrl>
    developer>
  developers>
  <scm>
    <connection>scm:git:git://github.com/spring-projects/spring-boot.gitconnection>
    <developerConnection>scm:git:ssh://git@github.com/spring-projects/spring-boot.gitdeveloperConnection>
    <url>https://github.com/spring-projects/spring-booturl>
  scm>
  <issueManagement>
    <system>GitHubsystem>
    <url>https://github.com/spring-projects/spring-boot/issuesurl>
  issueManagement>
  <dependencies>
    <dependency>
      <groupId>org.springframework.bootgroupId>
      <artifactId>spring-boot-starterartifactId>
      <version>2.6.6version>
      <scope>compilescope>
    dependency>
    <dependency>
      <groupId>org.springframework.bootgroupId>
      <artifactId>spring-boot-testartifactId>
      <version>2.6.6version>
      <scope>compilescope>
    dependency>
    <dependency>
      <groupId>org.springframework.bootgroupId>
      <artifactId>spring-boot-test-autoconfigureartifactId>
      <version>2.6.6version>
      <scope>compilescope>
    dependency>
    <dependency>
      <groupId>com.jayway.jsonpathgroupId>
      <artifactId>json-pathartifactId>
      <version>2.6.0version>
      <scope>compilescope>
    dependency>
    <dependency>
      <groupId>jakarta.xml.bindgroupId>
      <artifactId>jakarta.xml.bind-apiartifactId>
      <version>2.3.3version>
      <scope>compilescope>
    dependency>
    <dependency>
      <groupId>org.assertjgroupId>
      <artifactId>assertj-coreartifactId>
      <version>3.21.0version>
      <scope>compilescope>
    dependency>
    <dependency>
      <groupId>org.hamcrestgroupId>
      <artifactId>hamcrestartifactId>
      <version>2.2version>
      <scope>compilescope>
    dependency>
    <dependency>
      <groupId>org.junit.jupitergroupId>
      <artifactId>junit-jupiterartifactId>
      <version>5.8.2version>
      <scope>compilescope>
    dependency>
    <dependency>
      <groupId>org.mockitogroupId>
      <artifactId>mockito-coreartifactId>
      <version>4.0.0version>
      <scope>compilescope>
    dependency>
    <dependency>
      <groupId>org.mockitogroupId>
      <artifactId>mockito-junit-jupiterartifactId>
      <version>4.0.0version>
      <scope>compilescope>
    dependency>
    <dependency>
      <groupId>org.skyscreamergroupId>
      <artifactId>jsonassertartifactId>
      <version>1.5.0version>
      <scope>compilescope>
    dependency>
    <dependency>
      <groupId>org.springframeworkgroupId>
      <artifactId>spring-coreartifactId>
      <version>5.3.18version>
      <scope>compilescope>
    dependency>
    <dependency>
      <groupId>org.springframeworkgroupId>
      <artifactId>spring-testartifactId>
      <version>5.3.18version>
      <scope>compilescope>
    dependency>
    <dependency>
      <groupId>org.xmlunitgroupId>
      <artifactId>xmlunit-coreartifactId>
      <version>2.8.4version>
      <scope>compilescope>
      <exclusions>
        <exclusion>
          <artifactId>jaxb-apiartifactId>
          <groupId>javax.xml.bindgroupId>
        exclusion>
      exclusions>
    dependency>
  dependencies>
project>

spring-boot-starter-test2.66.pom

从依赖的坐标可以看出是junit-jupiter（junit5.0+）

JUnit：Java测试事实上的标准，默认依赖版本与SpringBoot版本相关（JUnit5和JUnit4差别比较大，集成方式有不同）。

Spring Test & Spring Boot Test：Spring的测试支持。

AssertJ：提供了流式的断言方式。

Hamcrest：提供了丰富的matcher。

Mockito：mock框架，可以按类型创建mock对象，可以根据方法参数指定特定的响应，也支持对于mock调用过程的断言。

JSONassert：为JSON提供了断言功能。

JsonPath：为JSON提供了XPATH功能。

1.3.2、注解测试类

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.Assertions;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest  //为测试提供上下文环境
class UsermisApplicationTests {
    @Test  //声明需测试的方法
    void testEqual(){
        int actual=1;
        //断言actual是否与1相等
        Assertions.assertEquals(1,actual);
    }
}

右键运行测试的结果：

1.4、常用注解

1.4.1、SpringBootTest

@SpringBootTest 指定测试的启动类

• args = “–app.test=one” 指定参数
• classes 指定启动类，可以是多个
• value 指定配置属性
• properties 指定配置属性，和value相同
• webEnvironment 指定web环境，
• MOCK 此值为默认值，该类型提供一个mock环境，此时内嵌的服务（servlet容器）并没有真正启动，也不会监听web端口
• RANDOM_PORT 启动一个真实的web服务，监听一个随机端口
• DEFINED_PORT 启动一个真实的web服务，监听一个定义好的端口（从配置中读取）。
• NONE 启动一个非web的ApplicationContext，既不提供mock环境，也不提供真是的web服务

1.4.2、@Test

@Test 指定测试方法

1.4.3、TestMethodOrder、Order 排序，指定先后顺序

@TestMethodOrder(MethodOrderer.Alphanumeric.class)指定测试的顺序，需要配合@Order一起使用

package com.zhangguo.springboottest;

import org.junit.jupiter.api.MethodOrderer;
import org.junit.jupiter.api.Order;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestMethodOrder;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
@TestMethodOrder(MethodOrderer.OrderAnnotation.class)  //设置排序模式
public class MyTests {

    @Test
    @Order(2)   //设置排序值
    public void testA(){
    }
    @Test
    @Order(1)   //设置排序值
    public void testB(){
    }
}

运行效果：

1.4.4、BeforeEach、BeforeAll、AfterEach、AfterAll

@BeforeEach：在每个单元测试方法执行前都执行一遍

@BeforeAll：在所有单元测试方法执行前执行一遍（只执行一次），需静态方法，除非将测试类注解@TestInstance

org.junit.platform.commons.JUnitException: @BeforeAll method 'public void com.gdnf.usermis.UsermisApplicationTests.beforeAll()' must be static unless the test class is annotated with @TestInstance(Lifecycle.PER_CLASS).

@AfterEach：在每个单元测试方法执行后都执行一遍

@AfterAll：在所有单元测试方法执行后执行一遍（只执行一次）

package com.zhangguo.springboottest;

import org.junit.jupiter.api.*;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
@TestMethodOrder(MethodOrderer.OrderAnnotation.class)  //设置排序模式
public class MyTests {

    @BeforeAll
    public static void beforeAll(){
        System.out.println("BeforeAll在所有单元测试方法执行前执行一遍（只执行一次）");
    }
    @BeforeEach
    public void beforeEach(){
        System.out.println("BeforeEach第个测试方法执行前先执行该方法");
    }
    @AfterEach
    public void afterEach(){
        System.out.println("AfterEach在每个单元测试方法执行后都执行一遍");
    }
    @AfterAll
    public static void afterAll(){
        System.out.println("AfterAll在所有单元测试方法执行后执行一遍（只执行一次）");
    }

    @Test
    @Order(2)   //设置排序值
    public void testA(){
    }
    @Test
    @Order(1)   //设置排序值
    public void testB(){
    }
}

运行结果：

BeforeAll在所有单元测试方法执行前执行一遍（只执行一次）

  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::                (v2.6.6)

2022-04-11 10:53:47.481  INFO 2224 --- [           main] com.zhangguo.springboottest.MyTests      : Starting MyTests using Java 1.8.0_111 on PC201501031108 with PID 2224 (started by Administrator in E:\NF\Spring boot\demos\springboottest)
2022-04-11 10:53:47.484  INFO 2224 --- [           main] com.zhangguo.springboottest.MyTests      : No active profile set, falling back to 1 default profile: "default"
2022-04-11 10:53:52.381  INFO 2224 --- [           main] com.zhangguo.springboottest.MyTests      : Started MyTests in 6.147 seconds (JVM running for 8.933)
BeforeEach第个测试方法执行前先执行该方法
AfterEach在每个单元测试方法执行后都执行一遍
BeforeEach第个测试方法执行前先执行该方法
AfterEach在每个单元测试方法执行后都执行一遍
AfterAll在所有单元测试方法执行后执行一遍（只执行一次）
Process finished with exit code 0

控制台日志

@DisplayName("商品入库测试")：用于指定单元测试的名称

1.4.5、Disabled 禁用测试

@Disabled：当前单元测试置为无效，即单元测试时跳过该测试

1.4.6、RepeatedTest 重复测试

@RepeatedTest(n)：重复性测试，即执行n次

package com.zhangguo.springboottest;

import org.junit.jupiter.api.*;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.Random;

@SpringBootTest
public class MyTests {
    Random random=new Random();  //随机数
    @RepeatedTest(3)  //重复执行测试3次
    public void testA(){
        System.out.println(random.nextInt(100));
    }
    @Test
    public void testB(){
    }
}

示例代码

1.4.7、ParameterizedTest、ValueSource 参数化参数

@ParameterizedTest：参数化测试，

参数化测试可以按照多个参数分别运行多次单元测试这里有点类似于重复性测试，只不过每次运行传入的参数不用。需要使用到@ParameterizedTest，同时也需要@ValueSource提供一组数据，它支持八种基本类型以及String和自定义对象类型，使用极其方便。

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package org.junit.jupiter.params.provider;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import org.apiguardian.api.API;
import org.apiguardian.api.API.Status;

@Target({ElementType.ANNOTATION_TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@API(
    status = Status.STABLE,
    since = "5.7"
)
@ArgumentsSource(ValueArgumentsProvider.class)
public @interface ValueSource {
    short[] shorts() default {};

    byte[] bytes() default {};

    int[] ints() default {};

    long[] longs() default {};

    float[] floats() default {};

    double[] doubles() default {};

    char[] chars() default {};

    boolean[] booleans() default {};

    String[] strings() default {};

    Class<?>[] classes() default {};
}

可选参数

@ValueSource(ints = {1, 2, 3})：参数化测试提供数据

package com.zhangguo.springboottest;

import org.junit.jupiter.api.*;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.ValueSource;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.Random;

@SpringBootTest
public class MyTests {

    @ParameterizedTest  //声明该方法为参数化测试
    @ValueSource(ints = {-1,0,1})  //参数源
    public void testB(int a){
        Assertions.assertTrue(a>=0);  //如果结果为true测试测试通过
    }
}

运行结果：

1.5、断言

Jupiter提供了强大的断言方法用以验证结果，在使用时需要借助java8的新特性lambda表达式，均是来自org.junit.jupiter.api.Assertions包的static方法。

1.5.1、assertTrue与assertFalse

assertTrue与assertFalse用来判断条件是否为true或false，assertTrue表示如果值为true则通过，assertFalse表示如果值为false则通过

    @Test
    @DisplayName("测试断言equals")
    void testEquals() {
        assertTrue(3 < 4);
    }

1.5.2、assertNull与assertNotNull

assertNull与assertNotNull用来判断条件是否为null

    @Test
    @DisplayName("测试断言NotNull")
    void testNotNull() {
        assertNotNull(new Object());
    }

package com.zhangguo.springboottest;

import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
public class AssertTest {

    static MyMath myMath;

    @BeforeAll
    public static void beforeAll(){
        myMath=new MyMath();
    }


    @Test
    public void testA(){
        int a=10;
        /**如果为true则测试通过*/
        Assertions.assertTrue(a>0&&a<99);
    }

    @Test
    public void testB(){
        /**执行1加到n的方法获取结果*/
        int actual=myMath.addToN(100);
        /**如果结果为5050则测试通过*/
        Assertions.assertEquals(5050,actual);
    }

    @Test
    public void testC(){
        String str=null;
        Assertions.assertNull(str);  //如果str为null则测试通过
    }

    @Test
    public void testD(){
        String str=null;
        Assertions.assertNotNull(str);//如果str不为null则测试通过
    }
}

结果：

1.5.3、assertThrows异常

assertThrows用来判断执行抛出的异常是否符合预期，并可以使用异常类型接收返回值进行其他操作

lambda要求jdk8以上，如果报错需要设置：错误一(Lambda expressions are not supported at language level '7')，错误二(源发行版 8 需要目标发行版 1.8)

测试通过：

    @Test
    public void testE(){
        Assertions.assertThrows(NullPointerException.class,()->{
            String str=null;
            System.out.println(str.toLowerCase());
        });
    }

测试不通过：

    @Test
    public void testE(){
        Assertions.assertThrows(NullPointerException.class,()->{
            String str="A";
            System.out.println(str.toLowerCase());
        });
    }

1.5.4、assertTimeout超时

assertTimeout用来判断执行过程是否超时

    @Test
    public void testF(){
        long actual=Assertions.assertTimeout(Duration.ofMillis(1000),()->{
            Date start=new Date();  //记住开始时间
            Thread.sleep(700);  //休眠700毫秒
            long span=new Date().getTime()-start.getTime();  //结束时间减去开始时间得到耗时
            return span;  //返回耗时时间
        });
        System.out.println(actual);
        //如果耗时小于1000毫秒则测试通过
        Assertions.assertTrue(actual<=1000);
    }

因为耗时只有700+小于1000的最大耗时结果测试通过。

1.5.5、assertAll组合断言

assertAll是组合断言，当它内部所有断言正确执行完才算通过

不通过示例：

    @Test
    public void testG(){
        String name=null;
        int age=17;
        //第一个参数是标题
        Assertions.assertAll("模拟输入",()->{
            Assertions.assertNotNull(name);  //name不为空
        },()->{
            Assertions.assertTrue(age>0);  //age大于零
        },()->{
            Assertions.assertTrue(age<=130); //age小于130
        });
        //当3个子断言都通过时则整体通过
    }

通过示例：

    @Test
    public void testG(){
        String name="张果";
        int age=19;
        //第一个参数是标题
        Assertions.assertAll("模拟输入",()->{
            Assertions.assertNotNull(name);  //name不为空
        },()->{
            Assertions.assertTrue(age>0);  //age大于零
        },()->{
            Assertions.assertTrue(age<=130); //age小于130
        });
        //当3个子断言都通过时则整体通过
    }

1.5.6、其它断言

这里不能把所有断言方法都列出来，可以查看Assertions类的定义，或使用IDE的智能提示选择：

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package org.junit.jupiter.api;

import java.time.Duration;
import java.util.Collection;
import java.util.List;
import java.util.function.BooleanSupplier;
import java.util.function.Supplier;
import java.util.stream.Stream;
import org.apiguardian.api.API;
import org.apiguardian.api.API.Status;
import org.junit.jupiter.api.function.Executable;
import org.junit.jupiter.api.function.ThrowingSupplier;
import org.opentest4j.MultipleFailuresError;

@API(
    status = Status.STABLE,
    since = "5.0"
)
public class Assertions {
    @API(
        status = Status.STABLE,
        since = "5.3"
    )
    protected Assertions() {
    }

    public static  V fail() {
        AssertionUtils.fail();
        return null;
    }

    public static  V fail(String message) {
        AssertionUtils.fail(message);
        return null;
    }

    public static  V fail(String message, Throwable cause) {
        AssertionUtils.fail(message, cause);
        return null;
    }

    public static  V fail(Throwable cause) {
        AssertionUtils.fail(cause);
        return null;
    }

    public static  V fail(Supplier messageSupplier) {
        AssertionUtils.fail(messageSupplier);
        return null;
    }

    public static void assertTrue(boolean condition) {
        AssertTrue.assertTrue(condition);
    }

    public static void assertTrue(boolean condition, Supplier messageSupplier) {
        AssertTrue.assertTrue(condition, messageSupplier);
    }

    public static void assertTrue(BooleanSupplier booleanSupplier) {
        AssertTrue.assertTrue(booleanSupplier);
    }

    public static void assertTrue(BooleanSupplier booleanSupplier, String message) {
        AssertTrue.assertTrue(booleanSupplier, message);
    }

    public static void assertTrue(boolean condition, String message) {
        AssertTrue.assertTrue(condition, message);
    }

    public static void assertTrue(BooleanSupplier booleanSupplier, Supplier messageSupplier) {
        AssertTrue.assertTrue(booleanSupplier, messageSupplier);
    }

    public static void assertFalse(boolean condition) {
        AssertFalse.assertFalse(condition);
    }

    public static void assertFalse(boolean condition, String message) {
        AssertFalse.assertFalse(condition, message);
    }

    public static void assertFalse(boolean condition, Supplier messageSupplier) {
        AssertFalse.assertFalse(condition, messageSupplier);
    }

    public static void assertFalse(BooleanSupplier booleanSupplier) {
        AssertFalse.assertFalse(booleanSupplier);
    }

    public static void assertFalse(BooleanSupplier booleanSupplier, String message) {
        AssertFalse.assertFalse(booleanSupplier, message);
    }

    public static void assertFalse(BooleanSupplier booleanSupplier, Supplier messageSupplier) {
        AssertFalse.assertFalse(booleanSupplier, messageSupplier);
    }

    public static void assertNull(Object actual) {
        AssertNull.assertNull(actual);
    }

    public static void assertNull(Object actual, String message) {
        AssertNull.assertNull(actual, message);
    }

    public static void assertNull(Object actual, Supplier messageSupplier) {
        AssertNull.assertNull(actual, messageSupplier);
    }

    public static void assertNotNull(Object actual) {
        AssertNotNull.assertNotNull(actual);
    }

    public static void assertNotNull(Object actual, String message) {
        AssertNotNull.assertNotNull(actual, message);
    }

    public static void assertNotNull(Object actual, Supplier messageSupplier) {
        AssertNotNull.assertNotNull(actual, messageSupplier);
    }

    public static void assertEquals(short expected, short actual) {
        AssertEquals.assertEquals(expected, actual);
    }

    public static void assertEquals(short expected, Short actual) {
        AssertEquals.assertEquals(expected, actual);
    }

    public static void assertEquals(Short expected, short actual) {
        AssertEquals.assertEquals(expected, actual);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertEquals(Short expected, Short actual) {
        AssertEquals.assertEquals(expected, actual);
    }

    public static void assertEquals(short expected, short actual, String message) {
        AssertEquals.assertEquals(expected, actual, message);
    }

    public static void assertEquals(short expected, Short actual, String message) {
        AssertEquals.assertEquals(expected, actual, message);
    }

    public static void assertEquals(Short expected, short actual, String message) {
        AssertEquals.assertEquals(expected, actual, message);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertEquals(Short expected, Short actual, String message) {
        AssertEquals.assertEquals(expected, actual, message);
    }

    public static void assertEquals(short expected, short actual, Supplier messageSupplier) {
        AssertEquals.assertEquals(expected, actual, messageSupplier);
    }

    public static void assertEquals(short expected, Short actual, Supplier messageSupplier) {
        AssertEquals.assertEquals(expected, actual, messageSupplier);
    }

    public static void assertEquals(Short expected, short actual, Supplier messageSupplier) {
        AssertEquals.assertEquals(expected, actual, messageSupplier);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertEquals(Short expected, Short actual, Supplier messageSupplier) {
        AssertEquals.assertEquals(expected, actual, messageSupplier);
    }

    public static void assertEquals(byte expected, byte actual) {
        AssertEquals.assertEquals(expected, actual);
    }

    public static void assertEquals(byte expected, Byte actual) {
        AssertEquals.assertEquals(expected, actual);
    }

    public static void assertEquals(Byte expected, byte actual) {
        AssertEquals.assertEquals(expected, actual);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertEquals(Byte expected, Byte actual) {
        AssertEquals.assertEquals(expected, actual);
    }

    public static void assertEquals(byte expected, byte actual, String message) {
        AssertEquals.assertEquals(expected, actual, message);
    }

    public static void assertEquals(byte expected, Byte actual, String message) {
        AssertEquals.assertEquals(expected, actual, message);
    }

    public static void assertEquals(Byte expected, byte actual, String message) {
        AssertEquals.assertEquals(expected, actual, message);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertEquals(Byte expected, Byte actual, String message) {
        AssertEquals.assertEquals(expected, actual, message);
    }

    public static void assertEquals(byte expected, byte actual, Supplier messageSupplier) {
        AssertEquals.assertEquals(expected, actual, messageSupplier);
    }

    public static void assertEquals(byte expected, Byte actual, Supplier messageSupplier) {
        AssertEquals.assertEquals(expected, actual, messageSupplier);
    }

    public static void assertEquals(Byte expected, byte actual, Supplier messageSupplier) {
        AssertEquals.assertEquals(expected, actual, messageSupplier);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertEquals(Byte expected, Byte actual, Supplier messageSupplier) {
        AssertEquals.assertEquals(expected, actual, messageSupplier);
    }

    public static void assertEquals(int expected, int actual) {
        AssertEquals.assertEquals(expected, actual);
    }

    public static void assertEquals(int expected, Integer actual) {
        AssertEquals.assertEquals(expected, actual);
    }

    public static void assertEquals(Integer expected, int actual) {
        AssertEquals.assertEquals(expected, actual);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertEquals(Integer expected, Integer actual) {
        AssertEquals.assertEquals(expected, actual);
    }

    public static void assertEquals(int expected, int actual, String message) {
        AssertEquals.assertEquals(expected, actual, message);
    }

    public static void assertEquals(int expected, Integer actual, String message) {
        AssertEquals.assertEquals(expected, actual, message);
    }

    public static void assertEquals(Integer expected, int actual, String message) {
        AssertEquals.assertEquals(expected, actual, message);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertEquals(Integer expected, Integer actual, String message) {
        AssertEquals.assertEquals(expected, actual, message);
    }

    public static void assertEquals(int expected, int actual, Supplier messageSupplier) {
        AssertEquals.assertEquals(expected, actual, messageSupplier);
    }

    public static void assertEquals(int expected, Integer actual, Supplier messageSupplier) {
        AssertEquals.assertEquals(expected, actual, messageSupplier);
    }

    public static void assertEquals(Integer expected, int actual, Supplier messageSupplier) {
        AssertEquals.assertEquals(expected, actual, messageSupplier);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertEquals(Integer expected, Integer actual, Supplier messageSupplier) {
        AssertEquals.assertEquals(expected, actual, messageSupplier);
    }

    public static void assertEquals(long expected, long actual) {
        AssertEquals.assertEquals(expected, actual);
    }

    public static void assertEquals(long expected, Long actual) {
        AssertEquals.assertEquals(expected, actual);
    }

    public static void assertEquals(Long expected, long actual) {
        AssertEquals.assertEquals(expected, actual);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertEquals(Long expected, Long actual) {
        AssertEquals.assertEquals(expected, actual);
    }

    public static void assertEquals(long expected, long actual, String message) {
        AssertEquals.assertEquals(expected, actual, message);
    }

    public static void assertEquals(long expected, Long actual, String message) {
        AssertEquals.assertEquals(expected, actual, message);
    }

    public static void assertEquals(Long expected, long actual, String message) {
        AssertEquals.assertEquals(expected, actual, message);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertEquals(Long expected, Long actual, String message) {
        AssertEquals.assertEquals(expected, actual, message);
    }

    public static void assertEquals(long expected, long actual, Supplier messageSupplier) {
        AssertEquals.assertEquals(expected, actual, messageSupplier);
    }

    public static void assertEquals(long expected, Long actual, Supplier messageSupplier) {
        AssertEquals.assertEquals(expected, actual, messageSupplier);
    }

    public static void assertEquals(Long expected, long actual, Supplier messageSupplier) {
        AssertEquals.assertEquals(expected, actual, messageSupplier);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertEquals(Long expected, Long actual, Supplier messageSupplier) {
        AssertEquals.assertEquals(expected, actual, messageSupplier);
    }

    public static void assertEquals(float expected, float actual) {
        AssertEquals.assertEquals(expected, actual);
    }

    public static void assertEquals(float expected, Float actual) {
        AssertEquals.assertEquals(expected, actual);
    }

    public static void assertEquals(Float expected, float actual) {
        AssertEquals.assertEquals(expected, actual);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertEquals(Float expected, Float actual) {
        AssertEquals.assertEquals(expected, actual);
    }

    public static void assertEquals(float expected, float actual, String message) {
        AssertEquals.assertEquals(expected, actual, message);
    }

    public static void assertEquals(float expected, Float actual, String message) {
        AssertEquals.assertEquals(expected, actual, message);
    }

    public static void assertEquals(Float expected, float actual, String message) {
        AssertEquals.assertEquals(expected, actual, message);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertEquals(Float expected, Float actual, String message) {
        AssertEquals.assertEquals(expected, actual, message);
    }

    public static void assertEquals(float expected, float actual, Supplier messageSupplier) {
        AssertEquals.assertEquals(expected, actual, messageSupplier);
    }

    public static void assertEquals(float expected, Float actual, Supplier messageSupplier) {
        AssertEquals.assertEquals(expected, actual, messageSupplier);
    }

    public static void assertEquals(Float expected, float actual, Supplier messageSupplier) {
        AssertEquals.assertEquals(expected, actual, messageSupplier);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertEquals(Float expected, Float actual, Supplier messageSupplier) {
        AssertEquals.assertEquals(expected, actual, messageSupplier);
    }

    public static void assertEquals(float expected, float actual, float delta) {
        AssertEquals.assertEquals(expected, actual, delta);
    }

    public static void assertEquals(float expected, float actual, float delta, String message) {
        AssertEquals.assertEquals(expected, actual, delta, message);
    }

    public static void assertEquals(float expected, float actual, float delta, Supplier messageSupplier) {
        AssertEquals.assertEquals(expected, actual, delta, messageSupplier);
    }

    public static void assertEquals(double expected, double actual) {
        AssertEquals.assertEquals(expected, actual);
    }

    public static void assertEquals(double expected, Double actual) {
        AssertEquals.assertEquals(expected, actual);
    }

    public static void assertEquals(Double expected, double actual) {
        AssertEquals.assertEquals(expected, actual);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertEquals(Double expected, Double actual) {
        AssertEquals.assertEquals(expected, actual);
    }

    public static void assertEquals(double expected, double actual, String message) {
        AssertEquals.assertEquals(expected, actual, message);
    }

    public static void assertEquals(double expected, Double actual, String message) {
        AssertEquals.assertEquals(expected, actual, message);
    }

    public static void assertEquals(Double expected, double actual, String message) {
        AssertEquals.assertEquals(expected, actual, message);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertEquals(Double expected, Double actual, String message) {
        AssertEquals.assertEquals(expected, actual, message);
    }

    public static void assertEquals(double expected, double actual, Supplier messageSupplier) {
        AssertEquals.assertEquals(expected, actual, messageSupplier);
    }

    public static void assertEquals(double expected, Double actual, Supplier messageSupplier) {
        AssertEquals.assertEquals(expected, actual, messageSupplier);
    }

    public static void assertEquals(Double expected, double actual, Supplier messageSupplier) {
        AssertEquals.assertEquals(expected, actual, messageSupplier);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertEquals(Double expected, Double actual, Supplier messageSupplier) {
        AssertEquals.assertEquals(expected, actual, messageSupplier);
    }

    public static void assertEquals(double expected, double actual, double delta) {
        AssertEquals.assertEquals(expected, actual, delta);
    }

    public static void assertEquals(double expected, double actual, double delta, String message) {
        AssertEquals.assertEquals(expected, actual, delta, message);
    }

    public static void assertEquals(double expected, double actual, double delta, Supplier messageSupplier) {
        AssertEquals.assertEquals(expected, actual, delta, messageSupplier);
    }

    public static void assertEquals(char expected, char actual) {
        AssertEquals.assertEquals(expected, actual);
    }

    public static void assertEquals(char expected, Character actual) {
        AssertEquals.assertEquals(expected, actual);
    }

    public static void assertEquals(Character expected, char actual) {
        AssertEquals.assertEquals(expected, actual);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertEquals(Character expected, Character actual) {
        AssertEquals.assertEquals(expected, actual);
    }

    public static void assertEquals(char expected, char actual, String message) {
        AssertEquals.assertEquals(expected, actual, message);
    }

    public static void assertEquals(char expected, Character actual, String message) {
        AssertEquals.assertEquals(expected, actual, message);
    }

    public static void assertEquals(Character expected, char actual, String message) {
        AssertEquals.assertEquals(expected, actual, message);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertEquals(Character expected, Character actual, String message) {
        AssertEquals.assertEquals(expected, actual, message);
    }

    public static void assertEquals(char expected, char actual, Supplier messageSupplier) {
        AssertEquals.assertEquals(expected, actual, messageSupplier);
    }

    public static void assertEquals(char expected, Character actual, Supplier messageSupplier) {
        AssertEquals.assertEquals(expected, actual, messageSupplier);
    }

    public static void assertEquals(Character expected, char actual, Supplier messageSupplier) {
        AssertEquals.assertEquals(expected, actual, messageSupplier);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertEquals(Character expected, Character actual, Supplier messageSupplier) {
        AssertEquals.assertEquals(expected, actual, messageSupplier);
    }

    public static void assertEquals(Object expected, Object actual) {
        AssertEquals.assertEquals(expected, actual);
    }

    public static void assertEquals(Object expected, Object actual, String message) {
        AssertEquals.assertEquals(expected, actual, message);
    }

    public static void assertEquals(Object expected, Object actual, Supplier messageSupplier) {
        AssertEquals.assertEquals(expected, actual, messageSupplier);
    }

    public static void assertArrayEquals(boolean[] expected, boolean[] actual) {
        AssertArrayEquals.assertArrayEquals(expected, actual);
    }

    public static void assertArrayEquals(boolean[] expected, boolean[] actual, String message) {
        AssertArrayEquals.assertArrayEquals(expected, actual, message);
    }

    public static void assertArrayEquals(boolean[] expected, boolean[] actual, Supplier messageSupplier) {
        AssertArrayEquals.assertArrayEquals(expected, actual, messageSupplier);
    }

    public static void assertArrayEquals(char[] expected, char[] actual) {
        AssertArrayEquals.assertArrayEquals(expected, actual);
    }

    public static void assertArrayEquals(char[] expected, char[] actual, String message) {
        AssertArrayEquals.assertArrayEquals(expected, actual, message);
    }

    public static void assertArrayEquals(char[] expected, char[] actual, Supplier messageSupplier) {
        AssertArrayEquals.assertArrayEquals(expected, actual, messageSupplier);
    }

    public static void assertArrayEquals(byte[] expected, byte[] actual) {
        AssertArrayEquals.assertArrayEquals(expected, actual);
    }

    public static void assertArrayEquals(byte[] expected, byte[] actual, String message) {
        AssertArrayEquals.assertArrayEquals(expected, actual, message);
    }

    public static void assertArrayEquals(byte[] expected, byte[] actual, Supplier messageSupplier) {
        AssertArrayEquals.assertArrayEquals(expected, actual, messageSupplier);
    }

    public static void assertArrayEquals(short[] expected, short[] actual) {
        AssertArrayEquals.assertArrayEquals(expected, actual);
    }

    public static void assertArrayEquals(short[] expected, short[] actual, String message) {
        AssertArrayEquals.assertArrayEquals(expected, actual, message);
    }

    public static void assertArrayEquals(short[] expected, short[] actual, Supplier messageSupplier) {
        AssertArrayEquals.assertArrayEquals(expected, actual, messageSupplier);
    }

    public static void assertArrayEquals(int[] expected, int[] actual) {
        AssertArrayEquals.assertArrayEquals(expected, actual);
    }

    public static void assertArrayEquals(int[] expected, int[] actual, String message) {
        AssertArrayEquals.assertArrayEquals(expected, actual, message);
    }

    public static void assertArrayEquals(int[] expected, int[] actual, Supplier messageSupplier) {
        AssertArrayEquals.assertArrayEquals(expected, actual, messageSupplier);
    }

    public static void assertArrayEquals(long[] expected, long[] actual) {
        AssertArrayEquals.assertArrayEquals(expected, actual);
    }

    public static void assertArrayEquals(long[] expected, long[] actual, String message) {
        AssertArrayEquals.assertArrayEquals(expected, actual, message);
    }

    public static void assertArrayEquals(long[] expected, long[] actual, Supplier messageSupplier) {
        AssertArrayEquals.assertArrayEquals(expected, actual, messageSupplier);
    }

    public static void assertArrayEquals(float[] expected, float[] actual) {
        AssertArrayEquals.assertArrayEquals(expected, actual);
    }

    public static void assertArrayEquals(float[] expected, float[] actual, String message) {
        AssertArrayEquals.assertArrayEquals(expected, actual, message);
    }

    public static void assertArrayEquals(float[] expected, float[] actual, Supplier messageSupplier) {
        AssertArrayEquals.assertArrayEquals(expected, actual, messageSupplier);
    }

    public static void assertArrayEquals(float[] expected, float[] actual, float delta) {
        AssertArrayEquals.assertArrayEquals(expected, actual, delta);
    }

    public static void assertArrayEquals(float[] expected, float[] actual, float delta, String message) {
        AssertArrayEquals.assertArrayEquals(expected, actual, delta, message);
    }

    public static void assertArrayEquals(float[] expected, float[] actual, float delta, Supplier messageSupplier) {
        AssertArrayEquals.assertArrayEquals(expected, actual, delta, messageSupplier);
    }

    public static void assertArrayEquals(double[] expected, double[] actual) {
        AssertArrayEquals.assertArrayEquals(expected, actual);
    }

    public static void assertArrayEquals(double[] expected, double[] actual, String message) {
        AssertArrayEquals.assertArrayEquals(expected, actual, message);
    }

    public static void assertArrayEquals(double[] expected, double[] actual, Supplier messageSupplier) {
        AssertArrayEquals.assertArrayEquals(expected, actual, messageSupplier);
    }

    public static void assertArrayEquals(double[] expected, double[] actual, double delta) {
        AssertArrayEquals.assertArrayEquals(expected, actual, delta);
    }

    public static void assertArrayEquals(double[] expected, double[] actual, double delta, String message) {
        AssertArrayEquals.assertArrayEquals(expected, actual, delta, message);
    }

    public static void assertArrayEquals(double[] expected, double[] actual, double delta, Supplier messageSupplier) {
        AssertArrayEquals.assertArrayEquals(expected, actual, delta, messageSupplier);
    }

    public static void assertArrayEquals(Object[] expected, Object[] actual) {
        AssertArrayEquals.assertArrayEquals(expected, actual);
    }

    public static void assertArrayEquals(Object[] expected, Object[] actual, String message) {
        AssertArrayEquals.assertArrayEquals(expected, actual, message);
    }

    public static void assertArrayEquals(Object[] expected, Object[] actual, Supplier messageSupplier) {
        AssertArrayEquals.assertArrayEquals(expected, actual, messageSupplier);
    }

    public static void assertIterableEquals(Iterable<?> expected, Iterable<?> actual) {
        AssertIterableEquals.assertIterableEquals(expected, actual);
    }

    public static void assertIterableEquals(Iterable<?> expected, Iterable<?> actual, String message) {
        AssertIterableEquals.assertIterableEquals(expected, actual, message);
    }

    public static void assertIterableEquals(Iterable<?> expected, Iterable<?> actual, Supplier messageSupplier) {
        AssertIterableEquals.assertIterableEquals(expected, actual, messageSupplier);
    }

    public static void assertLinesMatch(List expectedLines, List actualLines) {
        AssertLinesMatch.assertLinesMatch(expectedLines, actualLines);
    }

    public static void assertLinesMatch(List expectedLines, List actualLines, String message) {
        AssertLinesMatch.assertLinesMatch(expectedLines, actualLines, message);
    }

    public static void assertLinesMatch(List expectedLines, List actualLines, Supplier messageSupplier) {
        AssertLinesMatch.assertLinesMatch(expectedLines, actualLines, messageSupplier);
    }

    public static void assertLinesMatch(Stream expectedLines, Stream actualLines) {
        AssertLinesMatch.assertLinesMatch(expectedLines, actualLines);
    }

    public static void assertLinesMatch(Stream expectedLines, Stream actualLines, String message) {
        AssertLinesMatch.assertLinesMatch(expectedLines, actualLines, message);
    }

    public static void assertLinesMatch(Stream expectedLines, Stream actualLines, Supplier messageSupplier) {
        AssertLinesMatch.assertLinesMatch(expectedLines, actualLines, messageSupplier);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(byte unexpected, byte actual) {
        AssertNotEquals.assertNotEquals(unexpected, actual);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(byte unexpected, Byte actual) {
        AssertNotEquals.assertNotEquals(unexpected, actual);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(Byte unexpected, byte actual) {
        AssertNotEquals.assertNotEquals(unexpected, actual);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(Byte unexpected, Byte actual) {
        AssertNotEquals.assertNotEquals(unexpected, actual);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(byte unexpected, byte actual, String message) {
        AssertNotEquals.assertNotEquals(unexpected, actual, message);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(byte unexpected, Byte actual, String message) {
        AssertNotEquals.assertNotEquals(unexpected, actual, message);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(Byte unexpected, byte actual, String message) {
        AssertNotEquals.assertNotEquals(unexpected, actual, message);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(Byte unexpected, Byte actual, String message) {
        AssertNotEquals.assertNotEquals(unexpected, actual, message);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(byte unexpected, byte actual, Supplier messageSupplier) {
        AssertNotEquals.assertNotEquals(unexpected, actual, messageSupplier);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(byte unexpected, Byte actual, Supplier messageSupplier) {
        AssertNotEquals.assertNotEquals(unexpected, actual, messageSupplier);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(Byte unexpected, byte actual, Supplier messageSupplier) {
        AssertNotEquals.assertNotEquals(unexpected, actual, messageSupplier);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(Byte unexpected, Byte actual, Supplier messageSupplier) {
        AssertNotEquals.assertNotEquals(unexpected, actual, messageSupplier);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(short unexpected, short actual) {
        AssertNotEquals.assertNotEquals(unexpected, actual);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(short unexpected, Short actual) {
        AssertNotEquals.assertNotEquals(unexpected, actual);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(Short unexpected, short actual) {
        AssertNotEquals.assertNotEquals(unexpected, actual);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(Short unexpected, Short actual) {
        AssertNotEquals.assertNotEquals(unexpected, actual);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(short unexpected, short actual, String message) {
        AssertNotEquals.assertNotEquals(unexpected, actual, message);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(short unexpected, Short actual, String message) {
        AssertNotEquals.assertNotEquals(unexpected, actual, message);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(Short unexpected, short actual, String message) {
        AssertNotEquals.assertNotEquals(unexpected, actual, message);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(Short unexpected, Short actual, String message) {
        AssertNotEquals.assertNotEquals(unexpected, actual, message);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(short unexpected, short actual, Supplier messageSupplier) {
        AssertNotEquals.assertNotEquals(unexpected, actual, messageSupplier);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(short unexpected, Short actual, Supplier messageSupplier) {
        AssertNotEquals.assertNotEquals(unexpected, actual, messageSupplier);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(Short unexpected, short actual, Supplier messageSupplier) {
        AssertNotEquals.assertNotEquals(unexpected, actual, messageSupplier);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(Short unexpected, Short actual, Supplier messageSupplier) {
        AssertNotEquals.assertNotEquals(unexpected, actual, messageSupplier);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(int unexpected, int actual) {
        AssertNotEquals.assertNotEquals(unexpected, actual);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(int unexpected, Integer actual) {
        AssertNotEquals.assertNotEquals(unexpected, actual);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(Integer unexpected, int actual) {
        AssertNotEquals.assertNotEquals(unexpected, actual);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(Integer unexpected, Integer actual) {
        AssertNotEquals.assertNotEquals(unexpected, actual);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(int unexpected, int actual, String message) {
        AssertNotEquals.assertNotEquals(unexpected, actual, message);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(int unexpected, Integer actual, String message) {
        AssertNotEquals.assertNotEquals(unexpected, actual, message);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(Integer unexpected, int actual, String message) {
        AssertNotEquals.assertNotEquals(unexpected, actual, message);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(Integer unexpected, Integer actual, String message) {
        AssertNotEquals.assertNotEquals(unexpected, actual, message);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(int unexpected, int actual, Supplier messageSupplier) {
        AssertNotEquals.assertNotEquals(unexpected, actual, messageSupplier);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(int unexpected, Integer actual, Supplier messageSupplier) {
        AssertNotEquals.assertNotEquals(unexpected, actual, messageSupplier);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(Integer unexpected, int actual, Supplier messageSupplier) {
        AssertNotEquals.assertNotEquals(unexpected, actual, messageSupplier);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(Integer unexpected, Integer actual, Supplier messageSupplier) {
        AssertNotEquals.assertNotEquals(unexpected, actual, messageSupplier);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(long unexpected, long actual) {
        AssertNotEquals.assertNotEquals(unexpected, actual);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(long unexpected, Long actual) {
        AssertNotEquals.assertNotEquals(unexpected, actual);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(Long unexpected, long actual) {
        AssertNotEquals.assertNotEquals(unexpected, actual);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(Long unexpected, Long actual) {
        AssertNotEquals.assertNotEquals(unexpected, actual);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(long unexpected, long actual, String message) {
        AssertNotEquals.assertNotEquals(unexpected, actual, message);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(long unexpected, Long actual, String message) {
        AssertNotEquals.assertNotEquals(unexpected, actual, message);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(Long unexpected, long actual, String message) {
        AssertNotEquals.assertNotEquals(unexpected, actual, message);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(Long unexpected, Long actual, String message) {
        AssertNotEquals.assertNotEquals(unexpected, actual, message);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(long unexpected, long actual, Supplier messageSupplier) {
        AssertNotEquals.assertNotEquals(unexpected, actual, messageSupplier);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(long unexpected, Long actual, Supplier messageSupplier) {
        AssertNotEquals.assertNotEquals(unexpected, actual, messageSupplier);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(Long unexpected, long actual, Supplier messageSupplier) {
        AssertNotEquals.assertNotEquals(unexpected, actual, messageSupplier);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(Long unexpected, Long actual, Supplier messageSupplier) {
        AssertNotEquals.assertNotEquals(unexpected, actual, messageSupplier);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(float unexpected, float actual) {
        AssertNotEquals.assertNotEquals(unexpected, actual);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(float unexpected, Float actual) {
        AssertNotEquals.assertNotEquals(unexpected, actual);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(Float unexpected, float actual) {
        AssertNotEquals.assertNotEquals(unexpected, actual);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(Float unexpected, Float actual) {
        AssertNotEquals.assertNotEquals(unexpected, actual);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(float unexpected, float actual, String message) {
        AssertNotEquals.assertNotEquals(unexpected, actual, message);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(float unexpected, Float actual, String message) {
        AssertNotEquals.assertNotEquals(unexpected, actual, message);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(Float unexpected, float actual, String message) {
        AssertNotEquals.assertNotEquals(unexpected, actual, message);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(Float unexpected, Float actual, String message) {
        AssertNotEquals.assertNotEquals(unexpected, actual, message);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(float unexpected, float actual, Supplier messageSupplier) {
        AssertNotEquals.assertNotEquals(unexpected, actual, messageSupplier);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(float unexpected, Float actual, Supplier messageSupplier) {
        AssertNotEquals.assertNotEquals(unexpected, actual, messageSupplier);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(Float unexpected, float actual, Supplier messageSupplier) {
        AssertNotEquals.assertNotEquals(unexpected, actual, messageSupplier);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(Float unexpected, Float actual, Supplier messageSupplier) {
        AssertNotEquals.assertNotEquals(unexpected, actual, messageSupplier);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(float unexpected, float actual, float delta) {
        AssertNotEquals.assertNotEquals(unexpected, actual, delta);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(float unexpected, float actual, float delta, String message) {
        AssertNotEquals.assertNotEquals(unexpected, actual, delta, message);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(float unexpected, float actual, float delta, Supplier messageSupplier) {
        AssertNotEquals.assertNotEquals(unexpected, actual, delta, messageSupplier);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(double unexpected, double actual) {
        AssertNotEquals.assertNotEquals(unexpected, actual);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(double unexpected, Double actual) {
        AssertNotEquals.assertNotEquals(unexpected, actual);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(Double unexpected, double actual) {
        AssertNotEquals.assertNotEquals(unexpected, actual);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(Double unexpected, Double actual) {
        AssertNotEquals.assertNotEquals(unexpected, actual);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(double unexpected, double actual, String message) {
        AssertNotEquals.assertNotEquals(unexpected, actual, message);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(double unexpected, Double actual, String message) {
        AssertNotEquals.assertNotEquals(unexpected, actual, message);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(Double unexpected, double actual, String message) {
        AssertNotEquals.assertNotEquals(unexpected, actual, message);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(Double unexpected, Double actual, String message) {
        AssertNotEquals.assertNotEquals(unexpected, actual, message);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(double unexpected, double actual, Supplier messageSupplier) {
        AssertNotEquals.assertNotEquals(unexpected, actual, messageSupplier);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(double unexpected, Double actual, Supplier messageSupplier) {
        AssertNotEquals.assertNotEquals(unexpected, actual, messageSupplier);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(Double unexpected, double actual, Supplier messageSupplier) {
        AssertNotEquals.assertNotEquals(unexpected, actual, messageSupplier);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(Double unexpected, Double actual, Supplier messageSupplier) {
        AssertNotEquals.assertNotEquals(unexpected, actual, messageSupplier);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(double unexpected, double actual, double delta) {
        AssertNotEquals.assertNotEquals(unexpected, actual, delta);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(double unexpected, double actual, double delta, String message) {
        AssertNotEquals.assertNotEquals(unexpected, actual, delta, message);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(double unexpected, double actual, double delta, Supplier messageSupplier) {
        AssertNotEquals.assertNotEquals(unexpected, actual, delta, messageSupplier);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(char unexpected, char actual) {
        AssertNotEquals.assertNotEquals(unexpected, actual);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(char unexpected, Character actual) {
        AssertNotEquals.assertNotEquals(unexpected, actual);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(Character unexpected, char actual) {
        AssertNotEquals.assertNotEquals(unexpected, actual);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(Character unexpected, Character actual) {
        AssertNotEquals.assertNotEquals(unexpected, actual);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(char unexpected, char actual, String message) {
        AssertNotEquals.assertNotEquals(unexpected, actual, message);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(char unexpected, Character actual, String message) {
        AssertNotEquals.assertNotEquals(unexpected, actual, message);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(Character unexpected, char actual, String message) {
        AssertNotEquals.assertNotEquals(unexpected, actual, message);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(Character unexpected, Character actual, String message) {
        AssertNotEquals.assertNotEquals(unexpected, actual, message);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(char unexpected, char actual, Supplier messageSupplier) {
        AssertNotEquals.assertNotEquals(unexpected, actual, messageSupplier);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(char unexpected, Character actual, Supplier messageSupplier) {
        AssertNotEquals.assertNotEquals(unexpected, actual, messageSupplier);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(Character unexpected, char actual, Supplier messageSupplier) {
        AssertNotEquals.assertNotEquals(unexpected, actual, messageSupplier);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(Character unexpected, Character actual, Supplier messageSupplier) {
        AssertNotEquals.assertNotEquals(unexpected, actual, messageSupplier);
    }

    public static void assertNotEquals(Object unexpected, Object actual) {
        AssertNotEquals.assertNotEquals(unexpected, actual);
    }

    public static void assertNotEquals(Object unexpected, Object actual, String message) {
        AssertNotEquals.assertNotEquals(unexpected, actual, message);
    }

    public static void assertNotEquals(Object unexpected, Object actual, Supplier messageSupplier) {
        AssertNotEquals.assertNotEquals(unexpected, actual, messageSupplier);
    }

    public static void assertSame(Object expected, Object actual) {
        AssertSame.assertSame(expected, actual);
    }

    public static void assertSame(Object expected, Object actual, String message) {
        AssertSame.assertSame(expected, actual, message);
    }

    public static void assertSame(Object expected, Object actual, Supplier messageSupplier) {
        AssertSame.assertSame(expected, actual, messageSupplier);
    }

    public static void assertNotSame(Object unexpected, Object actual) {
        AssertNotSame.assertNotSame(unexpected, actual);
    }

    public static void assertNotSame(Object unexpected, Object actual, String message) {
        AssertNotSame.assertNotSame(unexpected, actual, message);
    }

    public static void assertNotSame(Object unexpected, Object actual, Supplier messageSupplier) {
        AssertNotSame.assertNotSame(unexpected, actual, messageSupplier);
    }

    public static void assertAll(Executable... executables) throws MultipleFailuresError {
        AssertAll.assertAll(executables);
    }

    public static void assertAll(String heading, Executable... executables) throws MultipleFailuresError {
        AssertAll.assertAll(heading, executables);
    }

    public static void assertAll(Collection executables) throws MultipleFailuresError {
        AssertAll.assertAll(executables);
    }

    public static void assertAll(String heading, Collection executables) throws MultipleFailuresError {
        AssertAll.assertAll(heading, executables);
    }

    public static void assertAll(Stream executables) throws MultipleFailuresError {
        AssertAll.assertAll(executables);
    }

    public static void assertAll(String heading, Stream executables) throws MultipleFailuresError {
        AssertAll.assertAll(heading, executables);
    }

    @API(
        status = Status.EXPERIMENTAL,
        since = "5.8"
    )
    public static extends Throwable> T assertThrowsExactly(Class expectedType, Executable executable) {
        return AssertThrowsExactly.assertThrowsExactly(expectedType, executable);
    }

    @API(
        status = Status.EXPERIMENTAL,
        since = "5.8"
    )
    public static extends Throwable> T assertThrowsExactly(Class expectedType, Executable executable, String message) {
        return AssertThrowsExactly.assertThrowsExactly(expectedType, executable, message);
    }

    @API(
        status = Status.EXPERIMENTAL,
        since = "5.8"
    )
    public static extends Throwable> T assertThrowsExactly(Class expectedType, Executable executable, Supplier messageSupplier) {
        return AssertThrowsExactly.assertThrowsExactly(expectedType, executable, messageSupplier);
    }

    public static extends Throwable> T assertThrows(Class expectedType, Executable executable) {
        return AssertThrows.assertThrows(expectedType, executable);
    }

    public static extends Throwable> T assertThrows(Class expectedType, Executable executable, String message) {
        return AssertThrows.assertThrows(expectedType, executable, message);
    }

    public static extends Throwable> T assertThrows(Class expectedType, Executable executable, Supplier messageSupplier) {
        return AssertThrows.assertThrows(expectedType, executable, messageSupplier);
    }

    @API(
        status = Status.STABLE,
        since = "5.2"
    )
    public static void assertDoesNotThrow(Executable executable) {
        AssertDoesNotThrow.assertDoesNotThrow(executable);
    }

    @API(
        status = Status.STABLE,
        since = "5.2"
    )
    public static void assertDoesNotThrow(Executable executable, String message) {
        AssertDoesNotThrow.assertDoesNotThrow(executable, message);
    }

    @API(
        status = Status.STABLE,
        since = "5.2"
    )
    public static void assertDoesNotThrow(Executable executable, Supplier messageSupplier) {
        AssertDoesNotThrow.assertDoesNotThrow(executable, messageSupplier);
    }

    @API(
        status = Status.STABLE,
        since = "5.2"
    )
    public static  T assertDoesNotThrow(ThrowingSupplier supplier) {
        return AssertDoesNotThrow.assertDoesNotThrow(supplier);
    }

    @API(
        status = Status.STABLE,
        since = "5.2"
    )
    public static  T assertDoesNotThrow(ThrowingSupplier supplier, String message) {
        return AssertDoesNotThrow.assertDoesNotThrow(supplier, message);
    }

    @API(
        status = Status.STABLE,
        since = "5.2"
    )
    public static  T assertDoesNotThrow(ThrowingSupplier supplier, Supplier messageSupplier) {
        return AssertDoesNotThrow.assertDoesNotThrow(supplier, messageSupplier);
    }

    public static void assertTimeout(Duration timeout, Executable executable) {
        AssertTimeout.assertTimeout(timeout, executable);
    }

    public static void assertTimeout(Duration timeout, Executable executable, String message) {
        AssertTimeout.assertTimeout(timeout, executable, message);
    }

    public static void assertTimeout(Duration timeout, Executable executable, Supplier messageSupplier) {
        AssertTimeout.assertTimeout(timeout, executable, messageSupplier);
    }

    public static  T assertTimeout(Duration timeout, ThrowingSupplier supplier) {
        return AssertTimeout.assertTimeout(timeout, supplier);
    }

    public static  T assertTimeout(Duration timeout, ThrowingSupplier supplier, String message) {
        return AssertTimeout.assertTimeout(timeout, supplier, message);
    }

    public static  T assertTimeout(Duration timeout, ThrowingSupplier supplier, Supplier messageSupplier) {
        return AssertTimeout.assertTimeout(timeout, supplier, messageSupplier);
    }

    public static void assertTimeoutPreemptively(Duration timeout, Executable executable) {
        AssertTimeout.assertTimeoutPreemptively(timeout, executable);
    }

    public static void assertTimeoutPreemptively(Duration timeout, Executable executable, String message) {
        AssertTimeout.assertTimeoutPreemptively(timeout, executable, message);
    }

    public static void assertTimeoutPreemptively(Duration timeout, Executable executable, Supplier messageSupplier) {
        AssertTimeout.assertTimeoutPreemptively(timeout, executable, messageSupplier);
    }

    public static  T assertTimeoutPreemptively(Duration timeout, ThrowingSupplier supplier) {
        return AssertTimeout.assertTimeoutPreemptively(timeout, supplier);
    }

    public static  T assertTimeoutPreemptively(Duration timeout, ThrowingSupplier supplier, String message) {
        return AssertTimeout.assertTimeoutPreemptively(timeout, supplier, message);
    }

    public static  T assertTimeoutPreemptively(Duration timeout, ThrowingSupplier supplier, Supplier messageSupplier) {
        return AssertTimeout.assertTimeoutPreemptively(timeout, supplier, messageSupplier);
    }

    @API(
        status = Status.EXPERIMENTAL,
        since = "5.8"
    )
    public static  T assertInstanceOf(Class expectedType, Object actualValue) {
        return AssertInstanceOf.assertInstanceOf(expectedType, actualValue);
    }

    @API(
        status = Status.EXPERIMENTAL,
        since = "5.8"
    )
    public static  T assertInstanceOf(Class expectedType, Object actualValue, String message) {
        return AssertInstanceOf.assertInstanceOf(expectedType, actualValue, message);
    }

    @API(
        status = Status.EXPERIMENTAL,
        since = "5.8"
    )
    public static  T assertInstanceOf(Class expectedType, Object actualValue, Supplier messageSupplier) {
        return AssertInstanceOf.assertInstanceOf(expectedType, actualValue, messageSupplier);
    }
}

所有断言方法

1.6、Mockito

Mockito 是一种 Java Mock 框架，主要是用来做 Mock 测试，它可以模拟任何 Spring 管理的 Bean、模拟方法的返回值、模拟抛出异常等等，避免你为了测试一个方法，却要自行构建整个 bean 的依赖链。

像是 Mockito 可以在单元测试中模拟一个 Service 返回的数据，而不会真正去调用该 Service，这就是上面提到的 Mock 测试精神，也就是通过模拟一个假的 Service 对象，来快速的测试当前我想要测试的类。

目前在 Java 中主流的 Mock 测试工具有 Mockito、JMock、EasyMock等等，而 SpringBoot 目前内建的是 Mockito 框架。

mock:在软件开发的世界之外, "mock"一词是指模仿或者效仿。
因此可以将“mock”理解为一个替身，替代者。
在软件开发中提及"mock"，通常理解为模拟对象或者Fake

示例：

自定义控制器：

package com.zhangguo.springboottest;

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

@RestController
public class HelloController {
    @RequestMapping("/mock")
    public String hello(@RequestParam(defaultValue = "") String name){
        return "Hello "+name+"!";
    }
}

注意参数是动态的。

测试代码：

package com.zhangguo.springboottest;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
import org.springframework.test.web.servlet.result.MockMvcResultHandlers;
import org.springframework.test.web.servlet.result.MockMvcResultMatchers;

@SpringBootTest
@AutoConfigureMockMvc  //启用MockMVC自动配置
public class MVCTest {
    @Autowired
    MockMvc mockMvc;  //自动装配mockmvc对象，模拟mvc运行环境

    @Test
    public void mvcTest() throws Exception {
        //模拟发送一个请求到/mock
        mockMvc.perform(MockMvcRequestBuilders
                .get("/mock")  //设置请求地址
                .param("name", "zhangguo"))  //请求参数
                .andExpect(MockMvcResultMatchers.status().isOk())  //期待状态为200
                .andExpect(MockMvcResultMatchers.content().string("Hello zhangguo!"))  //期待请求返回的字符为Hello zhangguo!
                .andDo(MockMvcResultHandlers.print())  //将处理结果输出到控制台
                .andReturn();  //返回，可以继续其它操作
    }

}

.perform() 执行一个MockMvcRequestBuilders请求。其中.get()表示发送get请求（可以使用get、post、put、delete等）；.contentType()设置编码格式；.param()请求参数,可以带多个。

andExpect()添加 MockMvcResultMatchers验证规则，验证执行结果是否正确。

.andDo()添加 MockMvcResultHandlers结果处理器,这是可以用于打印结果输出。

.andReturn()结果还回，然后可以进行下一步的处理。

测试结果

"C:\Program Files\Java\jdk1.8.0_111\bin\java.exe" -ea -Didea.test.cyclic.buffer.size=1048576 "-javaagent:C:\Program Files\JetBrains\IntelliJ IDEA 2018.2.7\lib\idea_rt.jar=2605:C:\Program Files\JetBrains\IntelliJ IDEA 2018.2.7\bin" -Dfile.encoding=UTF-8 -classpath "C:\Program Files\JetBrains\IntelliJ IDEA 2018.2.7\lib\idea_rt.jar;C:\Program Files\JetBrains\IntelliJ IDEA 2018.2.7\plugins\junit\lib\junit-rt.jar;C:\Program Files\JetBrains\IntelliJ IDEA 2018.2.7\plugins\junit\lib\junit5-rt.jar;H:\InstallFiles\javaKit\mavenRes\org\junit\platform\junit-platform-launcher\1.8.2\junit-platform-launcher-1.8.2.jar;H:\InstallFiles\javaKit\mavenRes\org\junit\platform\junit-platform-engine\1.8.2\junit-platform-engine-1.8.2.jar;H:\InstallFiles\javaKit\mavenRes\org\opentest4j\opentest4j\1.2.0\opentest4j-1.2.0.jar;H:\InstallFiles\javaKit\mavenRes\org\junit\platform\junit-platform-commons\1.8.2\junit-platform-commons-1.8.2.jar;H:\InstallFiles\javaKit\mavenRes\org\apiguardian\apiguardian-api\1.1.2\apiguardian-api-1.1.2.jar;C:\Program Files\Java\jdk1.8.0_111\jre\lib\charsets.jar;C:\Program Files\Java\jdk1.8.0_111\jre\lib\deploy.jar;C:\Program Files\Java\jdk1.8.0_111\jre\lib\ext\access-bridge-64.jar;C:\Program Files\Java\jdk1.8.0_111\jre\lib\ext\cldrdata.jar;C:\Program Files\Java\jdk1.8.0_111\jre\lib\ext\dnsns.jar;C:\Program Files\Java\jdk1.8.0_111\jre\lib\ext\jaccess.jar;C:\Program Files\Java\jdk1.8.0_111\jre\lib\ext\jfxrt.jar;C:\Program Files\Java\jdk1.8.0_111\jre\lib\ext\localedata.jar;C:\Program Files\Java\jdk1.8.0_111\jre\lib\ext\nashorn.jar;C:\Program Files\Java\jdk1.8.0_111\jre\lib\ext\sunec.jar;C:\Program Files\Java\jdk1.8.0_111\jre\lib\ext\sunjce_provider.jar;C:\Program Files\Java\jdk1.8.0_111\jre\lib\ext\sunmscapi.jar;C:\Program Files\Java\jdk1.8.0_111\jre\lib\ext\sunpkcs11.jar;C:\Program Files\Java\jdk1.8.0_111\jre\lib\ext\zipfs.jar;C:\Program Files\Java\jdk1.8.0_111\jre\lib\javaws.jar;C:\Program Files\Java\jdk1.8.0_111\jre\lib\jce.jar;C:\Program Files\Java\jdk1.8.0_111\jre\lib\jfr.jar;C:\Program Files\Java\jdk1.8.0_111\jre\lib\jfxswt.jar;C:\Program Files\Java\jdk1.8.0_111\jre\lib\jsse.jar;C:\Program Files\Java\jdk1.8.0_111\jre\lib\management-agent.jar;C:\Program Files\Java\jdk1.8.0_111\jre\lib\plugin.jar;C:\Program Files\Java\jdk1.8.0_111\jre\lib\resources.jar;C:\Program Files\Java\jdk1.8.0_111\jre\lib\rt.jar;E:\NF\Spring boot\demos\springboottest\target\test-classes;E:\NF\Spring boot\demos\springboottest\target\classes;H:\InstallFiles\javaKit\mavenRes\org\springframework\boot\spring-boot-starter-web\2.6.6\spring-boot-starter-web-2.6.6.jar;H:\InstallFiles\javaKit\mavenRes\org\springframework\boot\spring-boot-starter\2.6.6\spring-boot-starter-2.6.6.jar;H:\InstallFiles\javaKit\mavenRes\org\springframework\boot\spring-boot\2.6.6\spring-boot-2.6.6.jar;H:\InstallFiles\javaKit\mavenRes\org\springframework\boot\spring-boot-autoconfigure\2.6.6\spring-boot-autoconfigure-2.6.6.jar;H:\InstallFiles\javaKit\mavenRes\org\springframework\boot\spring-boot-starter-logging\2.6.6\spring-boot-starter-logging-2.6.6.jar;H:\InstallFiles\javaKit\mavenRes\ch\qos\logback\logback-classic\1.2.11\logback-classic-1.2.11.jar;H:\InstallFiles\javaKit\mavenRes\ch\qos\logback\logback-core\1.2.11\logback-core-1.2.11.jar;H:\InstallFiles\javaKit\mavenRes\org\apache\logging\log4j\log4j-to-slf4j\2.17.2\log4j-to-slf4j-2.17.2.jar;H:\InstallFiles\javaKit\mavenRes\org\apache\logging\log4j\log4j-api\2.17.2\log4j-api-2.17.2.jar;H:\InstallFiles\javaKit\mavenRes\org\slf4j\jul-to-slf4j\1.7.36\jul-to-slf4j-1.7.36.jar;H:\InstallFiles\javaKit\mavenRes\jakarta\annotation\jakarta.annotation-api\1.3.5\jakarta.annotation-api-1.3.5.jar;H:\InstallFiles\javaKit\mavenRes\org\yaml\snakeyaml\1.29\snakeyaml-1.29.jar;H:\InstallFiles\javaKit\mavenRes\org\springframework\boot\spring-boot-starter-json\2.6.6\spring-boot-starter-json-2.6.6.jar;H:\InstallFiles\javaKit\mavenRes\com\fasterxml\jackson\core\jackson-databind\2.13.2.2\jackson-databind-2.13.2.2.jar;H:\InstallFiles\javaKit\mavenRes\com\fasterxml\jackson\core\jackson-annotations\2.13.2\jackson-annotations-2.13.2.jar;H:\InstallFiles\javaKit\mavenRes\com\fasterxml\jackson\core\jackson-core\2.13.2\jackson-core-2.13.2.jar;H:\InstallFiles\javaKit\mavenRes\com\fasterxml\jackson\datatype\jackson-datatype-jdk8\2.13.2\jackson-datatype-jdk8-2.13.2.jar;H:\InstallFiles\javaKit\mavenRes\com\fasterxml\jackson\datatype\jackson-datatype-jsr310\2.13.2\jackson-datatype-jsr310-2.13.2.jar;H:\InstallFiles\javaKit\mavenRes\com\fasterxml\jackson\module\jackson-module-parameter-names\2.13.2\jackson-module-parameter-names-2.13.2.jar;H:\InstallFiles\javaKit\mavenRes\org\springframework\boot\spring-boot-starter-tomcat\2.6.6\spring-boot-starter-tomcat-2.6.6.jar;H:\InstallFiles\javaKit\mavenRes\org\apache\tomcat\embed\tomcat-embed-core\9.0.60\tomcat-embed-core-9.0.60.jar;H:\InstallFiles\javaKit\mavenRes\org\apache\tomcat\embed\tomcat-embed-el\9.0.60\tomcat-embed-el-9.0.60.jar;H:\InstallFiles\javaKit\mavenRes\org\apache\tomcat\embed\tomcat-embed-websocket\9.0.60\tomcat-embed-websocket-9.0.60.jar;H:\InstallFiles\javaKit\mavenRes\org\springframework\spring-web\5.3.18\spring-web-5.3.18.jar;H:\InstallFiles\javaKit\mavenRes\org\springframework\spring-beans\5.3.18\spring-beans-5.3.18.jar;H:\InstallFiles\javaKit\mavenRes\org\springframework\spring-webmvc\5.3.18\spring-webmvc-5.3.18.jar;H:\InstallFiles\javaKit\mavenRes\org\springframework\spring-aop\5.3.18\spring-aop-5.3.18.jar;H:\InstallFiles\javaKit\mavenRes\org\springframework\spring-context\5.3.18\spring-context-5.3.18.jar;H:\InstallFiles\javaKit\mavenRes\org\springframework\spring-expression\5.3.18\spring-expression-5.3.18.jar;H:\InstallFiles\javaKit\mavenRes\org\springframework\boot\spring-boot-starter-test\2.6.6\spring-boot-starter-test-2.6.6.jar;H:\InstallFiles\javaKit\mavenRes\org\springframework\boot\spring-boot-test\2.6.6\spring-boot-test-2.6.6.jar;H:\InstallFiles\javaKit\mavenRes\org\springframework\boot\spring-boot-test-autoconfigure\2.6.6\spring-boot-test-autoconfigure-2.6.6.jar;H:\InstallFiles\javaKit\mavenRes\com\jayway\jsonpath\json-path\2.6.0\json-path-2.6.0.jar;H:\InstallFiles\javaKit\mavenRes\net\minidev\json-smart\2.4.8\json-smart-2.4.8.jar;H:\InstallFiles\javaKit\mavenRes\net\minidev\accessors-smart\2.4.8\accessors-smart-2.4.8.jar;H:\InstallFiles\javaKit\mavenRes\org\ow2\asm\asm\9.1\asm-9.1.jar;H:\InstallFiles\javaKit\mavenRes\org\slf4j\slf4j-api\1.7.36\slf4j-api-1.7.36.jar;H:\InstallFiles\javaKit\mavenRes\jakarta\xml\bind\jakarta.xml.bind-api\2.3.3\jakarta.xml.bind-api-2.3.3.jar;H:\InstallFiles\javaKit\mavenRes\jakarta\activation\jakarta.activation-api\1.2.2\jakarta.activation-api-1.2.2.jar;H:\InstallFiles\javaKit\mavenRes\org\assertj\assertj-core\3.21.0\assertj-core-3.21.0.jar;H:\InstallFiles\javaKit\mavenRes\org\hamcrest\hamcrest\2.2\hamcrest-2.2.jar;H:\InstallFiles\javaKit\mavenRes\org\junit\jupiter\junit-jupiter\5.8.2\junit-jupiter-5.8.2.jar;H:\InstallFiles\javaKit\mavenRes\org\junit\jupiter\junit-jupiter-api\5.8.2\junit-jupiter-api-5.8.2.jar;H:\InstallFiles\javaKit\mavenRes\org\junit\jupiter\junit-jupiter-params\5.8.2\junit-jupiter-params-5.8.2.jar;H:\InstallFiles\javaKit\mavenRes\org\junit\jupiter\junit-jupiter-engine\5.8.2\junit-jupiter-engine-5.8.2.jar;H:\InstallFiles\javaKit\mavenRes\org\mockito\mockito-core\4.0.0\mockito-core-4.0.0.jar;H:\InstallFiles\javaKit\mavenRes\net\bytebuddy\byte-buddy\1.11.22\byte-buddy-1.11.22.jar;H:\InstallFiles\javaKit\mavenRes\net\bytebuddy\byte-buddy-agent\1.11.22\byte-buddy-agent-1.11.22.jar;H:\InstallFiles\javaKit\mavenRes\org\objenesis\objenesis\3.2\objenesis-3.2.jar;H:\InstallFiles\javaKit\mavenRes\org\mockito\mockito-junit-jupiter\4.0.0\mockito-junit-jupiter-4.0.0.jar;H:\InstallFiles\javaKit\mavenRes\org\skyscreamer\jsonassert\1.5.0\jsonassert-1.5.0.jar;H:\InstallFiles\javaKit\mavenRes\com\vaadin\external\google\android-json\0.0.20131108.vaadin1\android-json-0.0.20131108.vaadin1.jar;H:\InstallFiles\javaKit\mavenRes\org\springframework\spring-core\5.3.18\spring-core-5.3.18.jar;H:\InstallFiles\javaKit\mavenRes\org\springframework\spring-jcl\5.3.18\spring-jcl-5.3.18.jar;H:\InstallFiles\javaKit\mavenRes\org\springframework\spring-test\5.3.18\spring-test-5.3.18.jar;H:\InstallFiles\javaKit\mavenRes\org\xmlunit\xmlunit-core\2.8.4\xmlunit-core-2.8.4.jar" com.intellij.rt.execution.junit.JUnitStarter -ideVersion5 -junit5 com.zhangguo.springboottest.MVCTest,mvcTest
10:59:00.689 [main] DEBUG org.springframework.test.context.BootstrapUtils - Instantiating CacheAwareContextLoaderDelegate from class [org.springframework.test.context.cache.DefaultCacheAwareContextLoaderDelegate]
10:59:00.715 [main] DEBUG org.springframework.test.context.BootstrapUtils - Instantiating BootstrapContext using constructor [public org.springframework.test.context.support.DefaultBootstrapContext(java.lang.Class,org.springframework.test.context.CacheAwareContextLoaderDelegate)]
10:59:00.820 [main] DEBUG org.springframework.test.context.BootstrapUtils - Instantiating TestContextBootstrapper for test class [com.zhangguo.springboottest.MVCTest] from class [org.springframework.boot.test.context.SpringBootTestContextBootstrapper]
10:59:00.851 [main] INFO org.springframework.boot.test.context.SpringBootTestContextBootstrapper - Neither @ContextConfiguration nor @ContextHierarchy found for test class [com.zhangguo.springboottest.MVCTest], using SpringBootContextLoader
10:59:00.864 [main] DEBUG org.springframework.test.context.support.AbstractContextLoader - Did not detect default resource location for test class [com.zhangguo.springboottest.MVCTest]: class path resource [com/zhangguo/springboottest/MVCTest-context.xml] does not exist
10:59:00.866 [main] DEBUG org.springframework.test.context.support.AbstractContextLoader - Did not detect default resource location for test class [com.zhangguo.springboottest.MVCTest]: class path resource [com/zhangguo/springboottest/MVCTestContext.groovy] does not exist
10:59:00.866 [main] INFO org.springframework.test.context.support.AbstractContextLoader - Could not detect default resource locations for test class [com.zhangguo.springboottest.MVCTest]: no resource found for suffixes {-context.xml, Context.groovy}.
10:59:00.868 [main] INFO org.springframework.test.context.support.AnnotationConfigContextLoaderUtils - Could not detect default configuration classes for test class [com.zhangguo.springboottest.MVCTest]: MVCTest does not declare any static, non-private, non-final, nested classes annotated with @Configuration.
10:59:01.021 [main] DEBUG org.springframework.test.context.support.ActiveProfilesUtils - Could not find an 'annotation declaring class' for annotation type [org.springframework.test.context.ActiveProfiles] and class [com.zhangguo.springboottest.MVCTest]
10:59:01.249 [main] DEBUG org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider - Identified candidate component class: file [E:\NF\Spring boot\demos\springboottest\target\classes\com\zhangguo\springboottest\SpringboottestApplication.class]
10:59:01.254 [main] INFO org.springframework.boot.test.context.SpringBootTestContextBootstrapper - Found @SpringBootConfiguration com.zhangguo.springboottest.SpringboottestApplication for test class com.zhangguo.springboottest.MVCTest
10:59:01.553 [main] DEBUG org.springframework.boot.test.context.SpringBootTestContextBootstrapper - @TestExecutionListeners is not present for class [com.zhangguo.springboottest.MVCTest]: using defaults.
10:59:01.554 [main] INFO org.springframework.boot.test.context.SpringBootTestContextBootstrapper - Loaded default TestExecutionListener class names from location [META-INF/spring.factories]: [org.springframework.boot.test.mock.mockito.MockitoTestExecutionListener, org.springframework.boot.test.mock.mockito.ResetMocksTestExecutionListener, org.springframework.boot.test.autoconfigure.restdocs.RestDocsTestExecutionListener, org.springframework.boot.test.autoconfigure.web.client.MockRestServiceServerResetTestExecutionListener, org.springframework.boot.test.autoconfigure.web.servlet.MockMvcPrintOnlyOnFailureTestExecutionListener, org.springframework.boot.test.autoconfigure.web.servlet.WebDriverTestExecutionListener, org.springframework.boot.test.autoconfigure.webservices.client.MockWebServiceServerTestExecutionListener, org.springframework.test.context.web.ServletTestExecutionListener, org.springframework.test.context.support.DirtiesContextBeforeModesTestExecutionListener, org.springframework.test.context.event.ApplicationEventsTestExecutionListener, org.springframework.test.context.support.DependencyInjectionTestExecutionListener, org.springframework.test.context.support.DirtiesContextTestExecutionListener, org.springframework.test.context.transaction.TransactionalTestExecutionListener, org.springframework.test.context.jdbc.SqlScriptsTestExecutionListener, org.springframework.test.context.event.EventPublishingTestExecutionListener]
10:59:01.600 [main] DEBUG org.springframework.boot.test.context.SpringBootTestContextBootstrapper - Skipping candidate TestExecutionListener [org.springframework.test.context.transaction.TransactionalTestExecutionListener] due to a missing dependency. Specify custom listener classes or make the default listener classes and their required dependencies available. Offending class: [org/springframework/transaction/interceptor/TransactionAttributeSource]
10:59:01.605 [main] DEBUG org.springframework.boot.test.context.SpringBootTestContextBootstrapper - Skipping candidate TestExecutionListener [org.springframework.test.context.jdbc.SqlScriptsTestExecutionListener] due to a missing dependency. Specify custom listener classes or make the default listener classes and their required dependencies available. Offending class: [org/springframework/transaction/interceptor/TransactionAttribute]
10:59:01.606 [main] INFO org.springframework.boot.test.context.SpringBootTestContextBootstrapper - Using TestExecutionListeners: [org.springframework.test.context.web.ServletTestExecutionListener@6440112d, org.springframework.test.context.support.DirtiesContextBeforeModesTestExecutionListener@31ea9581, org.springframework.test.context.event.ApplicationEventsTestExecutionListener@231f98ef, org.springframework.boot.test.mock.mockito.MockitoTestExecutionListener@7c137fd5, org.springframework.boot.test.autoconfigure.SpringBootDependencyInjectionTestExecutionListener@183ec003, org.springframework.test.context.support.DirtiesContextTestExecutionListener@7d9d0818, org.springframework.test.context.event.EventPublishingTestExecutionListener@221a3fa4, org.springframework.boot.test.mock.mockito.ResetMocksTestExecutionListener@451001e5, org.springframework.boot.test.autoconfigure.restdocs.RestDocsTestExecutionListener@2b40ff9c, org.springframework.boot.test.autoconfigure.web.client.MockRestServiceServerResetTestExecutionListener@3e08ff24, org.springframework.boot.test.autoconfigure.web.servlet.MockMvcPrintOnlyOnFailureTestExecutionListener@4d1c005e, org.springframework.boot.test.autoconfigure.web.servlet.WebDriverTestExecutionListener@8462f31, org.springframework.boot.test.autoconfigure.webservices.client.MockWebServiceServerTestExecutionListener@24569dba]
10:59:01.617 [main] DEBUG org.springframework.test.context.support.AbstractDirtiesContextTestExecutionListener - Before test class: context [DefaultTestContext@6d60fe40 testClass = MVCTest, testInstance = [null], testMethod = [null], testException = [null], mergedContextConfiguration = [WebMergedContextConfiguration@792b749c testClass = MVCTest, locations = '{}', classes = '{class com.zhangguo.springboottest.SpringboottestApplication}', contextInitializerClasses = '[]', activeProfiles = '{}', propertySourceLocations = '{}', propertySourceProperties = '{org.springframework.boot.test.context.SpringBootTestContextBootstrapper=true}', contextCustomizers = set[[ImportsContextCustomizer@23e84203 key = [org.springframework.boot.test.autoconfigure.web.servlet.MockMvcAutoConfiguration, org.springframework.boot.test.autoconfigure.web.servlet.MockMvcWebClientAutoConfiguration, org.springframework.boot.test.autoconfigure.web.servlet.MockMvcWebDriverAutoConfiguration, org.springframework.boot.autoconfigure.security.oauth2.client.servlet.OAuth2ClientAutoConfiguration, org.springframework.boot.autoconfigure.security.oauth2.resource.servlet.OAuth2ResourceServerAutoConfiguration, org.springframework.boot.autoconfigure.security.servlet.SecurityAutoConfiguration, org.springframework.boot.autoconfigure.security.servlet.SecurityFilterAutoConfiguration, org.springframework.boot.autoconfigure.security.servlet.UserDetailsServiceAutoConfiguration, org.springframework.boot.test.autoconfigure.web.servlet.MockMvcSecurityConfiguration, org.springframework.boot.test.autoconfigure.web.reactive.WebTestClientAutoConfiguration]], org.springframework.boot.test.context.filter.ExcludeFilterContextCustomizer@6c64cb25, org.springframework.boot.test.json.DuplicateJsonObjectContextCustomizerFactory$DuplicateJsonObjectContextCustomizer@5c5eefef, org.springframework.boot.test.mock.mockito.MockitoContextCustomizer@0, org.springframework.boot.test.web.client.TestRestTemplateContextCustomizer@7f0eb4b4, org.springframework.boot.test.autoconfigure.actuate.metrics.MetricsExportContextCustomizerFactory$DisableMetricExportContextCustomizer@223191a6, org.springframework.boot.test.autoconfigure.properties.PropertyMappingContextCustomizer@4b3fa0b3, org.springframework.boot.test.autoconfigure.web.servlet.WebDriverContextCustomizerFactory$Customizer@74f0ea28, org.springframework.boot.test.context.SpringBootTestArgs@1, org.springframework.boot.test.context.SpringBootTestWebEnvironment@7921b0a2], resourceBasePath = 'src/main/webapp', contextLoader = 'org.springframework.boot.test.context.SpringBootContextLoader', parent = [null]], attributes = map['org.springframework.test.context.web.ServletTestExecutionListener.activateListener' -> true]], class annotated with @DirtiesContext [false] with mode [null].

  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::                (v2.6.6)

2022-04-12 10:59:07.515  INFO 7828 --- [           main] com.zhangguo.springboottest.MVCTest      : Starting MVCTest using Java 1.8.0_111 on PC201501031108 with PID 7828 (started by Administrator in E:\NF\Spring boot\demos\springboottest)
2022-04-12 10:59:07.536  INFO 7828 --- [           main] com.zhangguo.springboottest.MVCTest      : The following 1 profile is active: "pro"
2022-04-12 10:59:20.170  INFO 7828 --- [           main] o.s.b.t.m.w.SpringBootMockServletContext : Initializing Spring TestDispatcherServlet ''
2022-04-12 10:59:20.170  INFO 7828 --- [           main] o.s.t.web.servlet.TestDispatcherServlet  : Initializing Servlet ''
2022-04-12 10:59:20.174  INFO 7828 --- [           main] o.s.t.web.servlet.TestDispatcherServlet  : Completed initialization in 3 ms
2022-04-12 10:59:20.308  INFO 7828 --- [           main] com.zhangguo.springboottest.MVCTest      : Started MVCTest in 18.562 seconds (JVM running for 21.385)

MockHttpServletRequest:
      HTTP Method = GET
      Request URI = /mock
       Parameters = {name=[zhangguo]}
          Headers = []
             Body = null
    Session Attrs = {}

Handler:
             Type = com.zhangguo.springboottest.HelloController
           Method = com.zhangguo.springboottest.HelloController#hello(String)

Async:
    Async started = false
     Async result = null

Resolved Exception:
             Type = null

ModelAndView:
        View name = null
             View = null
            Model = null

FlashMap:
       Attributes = null

MockHttpServletResponse:
           Status = 200
    Error message = null
          Headers = [Content-Type:"text/plain;charset=UTF-8", Content-Length:"15"]
     Content type = text/plain;charset=UTF-8
             Body = Hello zhangguo!
    Forwarded URL = null
   Redirected URL = null
          Cookies = []

Process finished with exit code 0

控制台日志

 更多

二、SpringBoot 配置

SpringBoot是基于约定的，所以很多配置都有默认值，但如果想使用自己的配置替换默认配置的话，就可以使用 application.properties或者application.yml（application.yaml）进行配置。

2.1、配置文件分类

• properties：

server.port=8080

• yml:

server: 
    port: 8080

• SpringBoot提供了2种配置文件类型：properteis和yml/yaml

• 默认配置文件名称：application

• 在同一级目录下优先级为：properties > yml > yaml

2.2、YAML

• YAML全称是 YAML Ain't Markup Language 。
• YAML是一种直观的能够被电脑识别的的数据序列化格式，并且容易被人类阅读，容易和脚本语言交互的，可以被支持YAML库的不同的编程语言程序导入，比如： C/C++, Ruby, Python, Java, Perl, C#, PHP 等。
• YML文件是以数据为核心的，比传统的xml方式更加简洁。
• YAML文件的扩展名可以使用.yml或者.yaml。

2.2.1、3种常用配置格式比较

properties

server.port=8082
server.address=127.0.0.1

yml:

server:
  port: 8081
  address: 127.0.0.1

xml:

<server>
	<port>8080port>
	<address>127.0.0.1address>
server>

可见yml格式更加简洁，以数据为核心。

2.2.2、YAML格式的基本语法

• 大小写敏感

• 数据值前边必须有空格，作为分隔符

• 使用缩进表示层级关系

• 缩进时不允许使用Tab键，只允许使用空格（各个系统 Tab对应的 空格数目可能不同，导致层次混乱）。

• 缩进的空格数目不重要，只要相同层级的元素左侧对齐即可

• # 表示注释，从这个字符一直到行尾，都会被解析器忽略。

server:
  port: 8081
  address: 127.0.0.1

name: zhang

2.2.3、YAML数据格式

• 对象(map)：键值对的集合。

server:
  port: 8082

name: zhang
name2: wang

#对象
person:
  name2: ${name}
  name: li
  age: 20
  gender: 男
  address:
    - beijing
    - shanghai

#对象行内写法
person2: { name: zhao,age: 21 }

• 数组：一组按次序排列的值

#数组
address:
  - beijing
  - shanghai

#数组 行内写法

address2: [ beijing,shanghai ]

• 纯量（常量）：单个的、不可再分的值 （双引号原样输出，不转义）

#纯量、常量
msg1: 'hello \n world'
msg2: "hello \n world"

• yml 多文档格式

# yml 多文档 格式  --- 进行分隔  配置特定环境

#激活环境
spring:
  profiles:
    active: pro

---
#开发环境
server:
     port: 8081
spring:
  config:
    activate:
      on-profile: dev

---
#测试环境
server:
  port: 8082
spring:
  config:
    activate:
      on-profile: test

---
#生产环境
server:
  port: 8083
spring:
  config:
    activate:
      on-profile: pro

2.2.4、YAML参数引用

name: zhang
name2: zhang

#对象
person:
  name2: ${name} # 引用上边定义的name值
  name: zhang

2.2.4、YAML小结

1. 配置文件类型

   • properties：和以前一样
   • yml/yaml：注意空格

2. yaml：简洁，以数据为核心

   • 基本语法

     • 大小写敏感

     • 数据值前边必须有空格，作为分隔符

     • 使用空格缩进表示层级关系，相同缩进表示同一级

   • 数据格式

     • 对象

     • 数组: 使用 “- ”表示数组每个元素

     • 纯量(常量)

   • 参数引用

     • ${key}

2.3、读取配置内容

SpringBoot分别提供3中方式读取项目的application.properties配置文件的内容。这个方式分别为：Environment类、@Value注解以及@ConfigurationProperties注解。

2.3.1、使用@Value注解读取 

package com.zhangguo.springboottest;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class ParamController {

    @Value("${name}")
    String name;
    @Value("${server.port}")
    String port;

    @RequestMapping("/param")
    public String param(){
        return "Hello "+name+" from "+port+"!";
    }
}

配置文件：

server:
  port: 8088
spring:
  config:
    activate:
      on-profile: pro

name: zhangguo
age: 18

运行结果：

其实@Value底层就是Environment

2.3.2、Environment

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.env.Environment;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.HashMap;
import java.util.Map;
import java.util.Properties;
import java.util.Set;

@RestController
public class ReadPropertiesEnvironment {

    @Autowired
    private Environment environment;


    @GetMapping("/read/file")
    public Map readInfo(){
        Map map = new HashMap<>();
        map.put("port",environment.getProperty("server.port"));
        map.put("appid",environment.getProperty("alipay.pay.appid"));
        map.put("notify",environment.getProperty("alipay.pay.notify"));
        map.put("javaversion",environment.getProperty("java.version"));
        map.put("javahome",environment.getProperty("JAVA_HOME"));
        map.put("mavenhome",environment.getProperty("MAVEN_HOME"));
        return  map;
    }

    public static void main(String[] args) {
        Properties properties = System.getProperties();
        Set strings = properties.stringPropertyNames();
        for (String string : strings) {
            System.out.println(string+"===>"+properties.get(string));
        }

    }

}

2.3.3、@ConfigurationProperties

首先建立一个Person类，定义姓名年龄，重写tostring方法
写入两个注解

@Component //让Springboot 识别这是一个bean
@ConfigurationProperties // 读取配置文件中的 name和age
public class Person {
private String name;
private int age;
}

在控制器类中用@AutoWired读入Person

@Autowired
private Person per;

该配置方法只能读到第一层的name与age数据。如果想读取配置文件中次级目录如Person分级下，需要在person类中的@ConfigurationProperties设置分级。

// 读取配置文件前缀为person键对应的对象中的 name和age
@ConfigurationProperties(prefix = "person")
public class Person {
private String name;
private int age;
}

配置后在控制器中的

@Autowired
private Person per;
//输出就是配置中person对象内的字段信息了
System.out.println(per.getName()+" "+per.getAge());

小结：

1、@Environment @Value 不具有面向对象的特征，属性过多就不方便管理和控制，太多就会现得杂乱无章。而且也没用自动提示的功能。

2、@ConfigurationProperties 就是面向对象的机制，可以自动提示。所以底层springboto用的是@ConfigurationProperties

2.4、profile

我们在开发Spring Boot应用时，通常同一套程序会被安装到不同环境，比如：开发、测试、生产等。其中数据库地址、服务 器端口等等配置都不同，如果每次打包时，都要修改配置文件，那么非常麻烦。profile功能就是来进行动态配置切换的。

profile是用来完成不同环境下，配置动态切换功能的。

2.4.1、profile配置方式

• 多profile文件方式：提供多个配置文件，每个代表一种环境
  • application-dev.properties/yml 开发环境
  • application-test.properties/yml 测试环境
  • application-pro.properties/yml 生产环境
• yml多文档方式：
  • 在yml中使用 --- 分隔不同配置

2.4.2、profile激活方式

• 配置文件： 再配置文件中配置：spring.profiles.active=dev
• 虚拟机参数：在VM options 指定：-Dspring.profiles.active=dev
• 命令行参数：java –jar xxx.jar --spring.profiles.active=dev

2.4.3、内部配置加载顺序

Springboot程序启动时，会从以下位置加载配置文件：

1. file:./config/：当前项目下的/config目录下
2. file:./ ：当前项目的根目录
3. classpath:/config/：classpath的/config目录
4. classpath:/ ：classpath的根目录

加载顺序为上文的排列顺序，高优先级配置的属性会生效。

三、Spring IoC与自动装配

四、作业

五、视频

https://www.bilibili.com/video/BV1fi4y1S79P?share_source=copy_web

https://space.bilibili.com/87194917/video

作业解答：https://www.bilibili.com/video/BV1Hs411F71x?share_source=copy_web