【03】SpringBoot2核心技术-核心功能—数据访问_单元测试_指标监控

3、数据访问（SQL）

3.1 数据库连接池的自动配置-HikariDataSource

1、导入JDBC场景

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

• HikariCP：数据源（数据库连接池）
• jdbc：jdbc
• tx：事务

为什么导入JDBC场景的时候，没有导入数据库驱动？

因为此时并不知道程序员要操作哪个数据库，要使用哪个数据库驱动。但是对于要导入的数据库驱动，springboot已经做好了版本仲裁，只需要导入一下即可，无需注明版本（但如果数据库的版本不符，则需要显示声明版本）。

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
</dependency>
修改版本的方法：
	1、直接依赖引入的具体版本（Maven依赖就近原则） <version>版本号</version>
	2、重新声明版本（Maven属性就近原则）
		    <properties>
        		<mysql.version>5.1.49</mysql.version>
    		</properties>

2、分析自动配置

• DataSourceAutoConfiguration.class ： 数据源（数据库连接池）的自动配置

• • 修改数据源相关的配置：spring.datasource

    

  • 数据库连接池的配置（DataSourceConfiguration.class），是自己容器中没有DataSource才自动配置的

    

    ​ 可以看到怎么初始化数据库连接池，以及各个数据库连接池创建的条件，我们可以通过spring.datasource.type去指定数据库连接池

    

• • 底层配置好的连接池是：HikariDataSource

@Configuration(proxyBeanMethods = false)
@Conditional(PooledDataSourceCondition.class)
@ConditionalOnMissingBean({ DataSource.class, XADataSource.class })
@Import({ DataSourceConfiguration.Hikari.class, DataSourceConfiguration.Tomcat.class,
         DataSourceConfiguration.Dbcp2.class, DataSourceConfiguration.OracleUcp.class,
         DataSourceConfiguration.Generic.class, DataSourceJmxConfiguration.class })
protected static class PooledDataSourceConfiguration{
    ...
}

• DataSourceTransactionManagerAutoConfiguration： 事务管理器的自动配置

• JdbcTemplateAutoConfiguration： JdbcTemplate的自动配置，可以来对数据库进行crud（Spring操作数据库的小组件，一般用MyBatis）

• • 可以修改这个配置项@ConfigurationProperties(prefix = "spring.jdbc") 来修改JdbcTemplate

  • @Bean@Primary JdbcTemplate；容器中有这个组件

    @Configuration(proxyBeanMethods = false)
    @ConditionalOnMissingBean(JdbcOperations.class)
    class JdbcTemplateConfiguration {
    
    	@Bean
    	@Primary
    	JdbcTemplate jdbcTemplate(DataSource dataSource, JdbcProperties properties) {
    		JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
    		JdbcProperties.Template template = properties.getTemplate();
    		jdbcTemplate.setFetchSize(template.getFetchSize());
    		jdbcTemplate.setMaxRows(template.getMaxRows());
    		if (template.getQueryTimeout() != null) {
    			jdbcTemplate.setQueryTimeout((int) template.getQueryTimeout().getSeconds());
    		}
    		return jdbcTemplate;
    	}
    
    }
    

• JndiDataSourceAutoConfiguration： jndi的自动配置

• XADataSourceAutoConfiguration： 分布式事务相关的

3、修改配置项

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/ssm_crud?allowMultiQueries=true
    username: root
    password: zouwenhao
    driver-class-name: com.mysql.cj.jdbc.Driver
#    type: com.zaxxer.hikari.HikariDataSource
  jdbc:
    template:
      query-timeout: 3

4、测试

@SpringBootTest
class Boot05WebAdminApplicationTests {

    @Autowired
    JdbcTemplate jdbcTemplate;

    @Test
    void contextLoads() {
        Long aLong = jdbcTemplate.queryForObject("select count(*) from tbl_emp", Long.class);
        System.out.println(aLong); // 600
    }
}

3.2 使用Druid数据源

1、Druid官方地址

https://github.com/alibaba/druid

整合第三方技术的两种方式：

• 自定义（自己配置）
• springboot官方是否提供了启动器starter

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.2.8</version>
</dependency>

2、自定义数据库连接池方式（不推荐）

@Configuration
public class DBSourceConfig {

    /*
    * 默认的自动配置生效，是在@ConditionalOnMissingBean(DataSource.class)条件成立时
    *   如果我们现在需要引入一个第三方的DataSource，此时创建一个数据库连接池组件放入容器中
    *       那么自动配置的数据库连接池HikariDataSource就会失效
    * */
    @Bean
    @ConfigurationProperties("spring.datasource")
    public DataSource dataSource() {
        DruidDataSource druidDataSource = new DruidDataSource();
        // 可以使用配置文件导入，springboot会自动将属性值封装，这样就无需再配置
//        druidDataSource.setUrl();
//        druidDataSource.setName();
//        druidDataSource.setPassword();
        return druidDataSource;
    }

    /**
     * 配置 druid的监控页功能
     * @return
     */
   @Bean
    public ServletRegistrationBean statViewServlet(){
        StatViewServlet statViewServlet = new StatViewServlet();
        ServletRegistrationBean<StatViewServlet> registrationBean = new ServletRegistrationBean<>(statViewServlet, "/druid/*");

        // 给监控页设置登录账号和密码
        registrationBean.addInitParameter("loginUsername","admin");
        registrationBean.addInitParameter("loginPassword","123456");

        return registrationBean;
    }

    /**
     * WebStatFilter 用于采集web-jdbc关联监控的数据。
     */
	@Bean
    public FilterRegistrationBean webStatFilter(){
        WebStatFilter webStatFilter = new WebStatFilter();

        FilterRegistrationBean<WebStatFilter> filterRegistrationBean = new FilterRegistrationBean<>(webStatFilter);
        filterRegistrationBean.setUrlPatterns(Arrays.asList("/*")); // 监控的请求路径
        filterRegistrationBean.addInitParameter("exclusions","*.js,*.gif,*.jpg,*.png,*.css,*.ico,/druid/*"); // 哪些请求不需要监控（被拦截）

        return filterRegistrationBean;
    }
}

3、使用官方starter方式

1、引入druid-starter

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

2、分析Druid自动配置

• DruidDataSourceAutoConfigure.class

  Druid数据库连接池的配置需要在官方数据库连接池自动配置之前，因为需要在官方配置之前在容器中创建好DruidDataSource。

  

• 涉及到两个配置类DataSourceProperties和DruidStatProperties，其中扩展配置类的前缀配置是 spring.datasource.druid

• 此外，导入了四个类：

  

  • DruidSpringAopConfiguration.class：监控SpringBean（监控spring组件）

    • 配置项：spring.datasource.druid.aop-patterns**

  • DruidStatViewServletConfiguration.class：监控页的配置

    • spring.datasource.druid.stat-view-servlet；默认开启

  • DruidWebStatFilterConfiguration.class：web监控配置

    • spring.datasource.druid.web-stat-filter；默认开启

  • DruidFilterConfiguration.class：所有Druid涉及到filter的组件配置

    • private static final String FILTER_STAT_PREFIX = "spring.datasource.druid.filter.stat";
      private static final String FILTER_CONFIG_PREFIX = "spring.datasource.druid.filter.config";
      private static final String FILTER_ENCODING_PREFIX = "spring.datasource.druid.filter.encoding";
      private static final String FILTER_SLF4J_PREFIX = "spring.datasource.druid.filter.slf4j";
      private static final String FILTER_LOG4J_PREFIX = "spring.datasource.druid.filter.log4j";
      private static final String FILTER_LOG4J2_PREFIX = "spring.datasource.druid.filter.log4j2";
      private static final String FILTER_COMMONS_LOG_PREFIX = "spring.datasource.druid.filter.commons-log";
      private static final String FILTER_WALL_PREFIX = "spring.datasource.druid.filter.wall";
      private static final String FILTER_WALL_CONFIG_PREFIX = FILTER_WALL_PREFIX + ".config";
      

• 最后，我们只需要将相应配置属性在配置文件（yaml或properties）中使用相应的前缀进行设置即可。配置示例：

  spring:
    datasource:
      url: jdbc:mysql://localhost:3306/ssm_crud?allowMultiQueries=true
      username: root
      password: zouwenhao
      driver-class-name: com.mysql.cj.jdbc.Driver
  
      druid:
        aop-patterns: com.atguigu.admin.*  #监控SpringBean
        filters: stat,wall     # 底层开启功能，stat（sql监控），wall（防火墙）
  
        stat-view-servlet: # 配置监控页功能
          enabled: true
          login-username: admin
          login-password: admin
          resetEnable: false
  
        web-stat-filter: # 监控web
          enabled: true
          urlPattern: /*
          exclusions: '*.js,*.gif,*.jpg,*.png,*.css,*.ico,/druid/*'
  
        filter:
          stat: # 对上面filters里面的stat的详细配置
            slow-sql-millis: 1000
            logSlowSql: true
            enabled: true
          wall:
            enabled: true
            config:
              drop-table-allow: false
  

  Druid SpringBoot starter

  DruidDataSource配置属性列表

3.3 整合MyBatis操作

https://github.com/mybatis

引入starter

• SpringBoot官方的Starter：spring-boot-starter-*

• 第三方的： *-spring-boot-starter

<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>2.2.0</version>
</dependency>

1、自动配置原理

• 全局配置文件：MybatisAutoConfiguration.class

  

  • MyBatis的配置在当前环境中只有一个数据库连接池的条件下才自动配置

  • MyBatis的配置类是：MybatisProperties.class

    • @ConfigurationProperties(prefix = MybatisProperties.MYBATIS_PREFIX)
      public class MybatisProperties {
          ...
      }
      

  • 是在数据库连接池配置完之后，才对MyBatis进行配置

• SqlSessionFactory: 自动配置好了

  

  • MyBatis自动配置当前环境中配置好的数据库连接池

• SqlSession：自动配置了 SqlSessionTemplate（这个类实现了SqlSession接口）

  

  

• @Import(AutoConfiguredMapperScannerRegistrar.class）；

  • Mapper： 只要我们写的操作MyBatis的接口标准了 @Mapper 就会被自动扫描进来

    

2、配置并测试

1、文件目录

• 静态资源目录resources下（idea下可以安装MyBatisX插件）

  

• dao层、bean层、service层

  

2、配置MyBatis

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/ssm_crud?allowMultiQueries=true
    username: root
    password: password
    driver-class-name: com.mysql.cj.jdbc.Driver

# 配置Mybatis的规则
mybatis:
#  config-location: classpath:mybatis/mybatisConfig.xml
  mapper-locations: classpath:mybatis/mapper/*.xml
  configuration: # 一旦使用yaml或者properties进行配置，就不能再使用config-location
    # 开启驼峰命名
    map-underscore-to-camel-case: true

​ 当然也可以使用xml配置方式，但是需要注明配置文件的位置，注意的是：一旦我们在yaml或者是properties文件中进行了config配置，那么config-location就不能使用，否则mybatis不知道应该加载哪个配置文件，会造成冲突。

3、测试

• dao：注意，在spring中是需要配置扫描自定义Mybatis的mapper接口的，而在SpringBoot中，由于我们使用了starter，只需要在dao层下的接口文件添加上@Mapper注解，就会被扫描到并添加到IOC容器中。

  @Mapper
  public interface empMapper {
  
      public Emp getEmpById(int id);
  }
  

• service（service+serviceImpl）

  public interface empService {
      public Emp getEmpById(int id);
  }
  

  @Service
  public class EmpServiceImpl implements empService {
  
      @Autowired
      empMapper empMapper;
      @Override
      public Emp getEmpById(int id) {
          return empMapper.getEmpById(id);
      }
  }
  

• mapper.xml映射

  <?xml version="1.0" encoding="UTF-8" ?>
  <!DOCTYPE mapper
          PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
          "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  <mapper namespace="com.atguigu.admin.dao.empMapper">
      <!--public Emp getEmpById(int id);-->
      <select id="getEmpById" resultType="com.atguigu.admin.bean.Emp">
          select * from tbl_emp where emp_id = #{id}
      </select>
  </mapper>
  

• 测试

  @Controller
  public class MyBatisController {
  
      @Autowired
      empService empService;
  
      @ResponseBody
      @RequestMapping("/emp")
      public Emp getempById(@RequestParam("id")int id){
          return empService.getEmpById(id);
      }
  }
  

  

3、纯注解开发及注解配置混合开发

1、纯注解版（适用于查询sql语句比较简单的情况）

​ 在上一小节中，不难发现如果在yaml文件中进行配置的话，是可以省去mybatisConfig.xml。对于mapper.xml映射文件也可以省去，使用@Select注解。

​ 在dao层的接口文件中：

@Mapper
public interface empMapper {
    @Select("select * from tbl_emp where emp_id = #{id}")
    public Emp getEmpById(int id);
}

2、注解配置混合开发

​ 对于一些比较复杂的sql查询功能的实现，显然仅仅使用纯注解开发是行不通的，因此还是需要在mapper.xml文件中进行复杂sql查询功能的实现。

@Mapper
public interface empMapper {
    @Select("select * from tbl_emp where emp_id = #{id}")
    public Emp getEmpById(int id);

    pubilc void insertEmp(Emp emp);
}

​ 对于上面例子中的insert方法，还是能用注解的：

@Insert("insert into  tbl_emp(`emp_name`,`mail`,`gender`) values(#{name},#{mail},#{gender})")
@Options(useGeneratedKeys = true,keyProperty = "emp_id")
public void insertEmp(Emp emp)

4、最佳实战

• 引入mybatis-starter

• 配置application.yaml中，指定mapper-location位置即可

• 编写Mapper接口并标注@Mapper注解

• 简单方法直接注解方式

• 复杂方法编写mapper.xml进行绑定映射

• 在配置类上添加@MapperScan("com.atguigu.admin.dao") ，可以是主程序类。就可以简化在其他的接口不用标注@Mapper注解（在MyBatis中，最好还是在dao层接口上一个一个加上吧）

3.4 整合MyBatis-Plus完成CURD

1、什么是MyBatis-Plus

​ MyBatis-Plus（简称 MP）是一个 MyBatis 的增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生。

​ Mybatis plus 官网

​ 建议安装 MybatisX 插件

2、整合Mybatis-plus

• 引入Mybatis-plus的starter，就可以不用引入jdbc和mybatis了

<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-boot-starter</artifactId>
    <version>3.4.3.4</version>
</dependency>

• 自动配置

  • MybatisPlusAutoConfiguration 配置类，MybatisPlusProperties 配置项绑定。

    • 前缀为**mybatis-plus：xxx **，就是对mybatis-plus的配置定制

  • SqlSessionFactory 自动配置好（与mybatis同）。底层是容器中已经配置好的数据库连接池

  • mapperLocations 自动配置好的。

    • 有默认值：classpath*:/mapper/**/*.xml；任意包的类路径下的所有mapper文件夹下任意路径下的所有xml都是sql映射文件。 （即，类路径文件夹下mapper文件夹中）

      /* 是拦截所有的文件夹，不包含子文件夹
      
      /** 是拦截所有的文件夹及里面的子文件夹

    • 建议以后sql映射文件，放在类路径下mapper文件夹中

  • 容器中也自动配置好了 SqlSessionTemplate

  • @Mapper 标注的接口也会被自动扫描

    • @MapperScan("com.atguigu.admin.mapper") 批量扫描也行（MyBatisPlus中推荐使用这种）

• 优点：

  • 只需要我们的Mapper继承 BaseMapper 就可以拥有crud能力

  @Mapper
  public interface empMapperPlus extends BaseMapper<Emp> {
  
  }
  

  

  • 如果bean类中，有参数不是数据库中的元素，可以使用@TableField(exist = false)声明不是数据库中表的属性。这样表中不存在，也就不会去查询这些属性的值。

  

  • 如果bean类与数据库中对应的表的名字不一致的话，可以使用@TableName进行指定。（数据库表与bean类的映射关系）

    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    @TableName("tbl_emp")
    public class Emp {
        private Integer emp_id;
        private String emp_name;
        private char gender;
        private String email;
        @TableField(exist = false)
        private String dept_id;
    }
    

3、一次完整的使用流程（MyBatisPlus）

后台管理模板的数据显示与删除操作（数据库相关配置已经配置完成，上文有）

• bean层（entity层）：注意，如果不声明@TableName和@TableId，可能会造成绑定失败，报500的错误

  @Data
  @AllArgsConstructor
  @NoArgsConstructor
  @TableName("tbl_emp") // 将该类与数据库中tbl_emp表建立映射关系
  public class Emp {
      @TableId
      private Integer empId; // 需使用注解声明主键
      private String empName;
      private String gender;
      private String email;
      @TableField(exist = false)
      private String deptId;  // 数据库表中外的数据
  }
  

• dao层：Mapper 继承BaseMapper接口后，无需编写 mapper.xml 文件，即可获得CRUD功能，需要和IService顶级service类结合使用

  @Mapper // 注明@Mapper，相当于进行了mybatis自定义mapper接口扫描
  public interface empMapperPlus extends BaseMapper<Emp> {
  
  }
  

  

• service层：由业务逻辑接口和业务逻辑实现类组成

  • service接口：继承了IService类（IService），无需手动添加CURD操作方法

    public interface empServicePlus extends IService<Emp> {
    
    }
    

  • 业务逻辑实现类：同样，需要继承IService 实现类（ServiceImpl），才能使用CURD方法

    @Service
    public class EmpServicePlusImpl extends ServiceImpl<empMapperPlus, Emp> implements empServicePlus {
    
    }
    

• controller层：

  @Slf4j
  @Controller
  public class TableController {
  
      @Autowired
      empServicePlus empServicePlus;
  
      @GetMapping("/dynamic_table")
      public String dynamic_table(@RequestParam(value = "pn", defaultValue = "1")Integer pn,
                                  Model model){
  //        // 表格的内容动态遍历出来
  //        List<User> users = Arrays.asList(new User("zhangsan", "123456"),
  //                new User("lisi", "12365"),
  //                new User("wangwu", "656"),
  //                new User("xiaoming", "6545465"));
  //        model.addAttribute("users", users);
  
          // 一来到这个请求，就要从数据库中获取数据，并展示
          List<Emp> emps = empServicePlus.list();
  //        log.info(emps.toString());
          for (Emp emp : emps) {
              if(emp.getGender().equals(String.valueOf('M'))) {
                  emp.setGender("男");
              } else {
                  emp.setGender("女");
              }
          }
          model.addAttribute("emps", emps);
  
          // 使用分页查询数据，必须整合分页插件（需要配置一个拦截器，见官方文档使用）
          Page<Emp> empPage = new Page<>(pn, 15);
          // 分页查询的结果
          Page<Emp> page = empServicePlus.page(empPage, null);
          List<Emp> records = page.getRecords(); // 查询结果封装在page.getRecords()，等同于 List<Emp> emps = empServicePlus.list();
          long pages = page.getPages();
          long current = page.getCurrent();
          long total = page.getTotal();
  
          model.addAttribute("page", page);
  
          return "table/dynamic_table";
      }
  
      @GetMapping("/emp/delete/{id}")
      public String deleteEmpById(@PathVariable("id")Long id,
                                  @RequestParam("pn")Integer pn,
                                  RedirectAttributes ra){
          empServicePlus.removeById(id);
          ra.addAttribute("pn", pn); // 重定向携带参数
          return "redirect:/dynamic_table";
      }
      .......
  }
  

• html

  <div class="panel-body">
      <div class="adv-table">
          <table class="display table table-bordered" id="hidden-table-info">
              <thead>
                  <tr>
                      <th>#</th>
                      <th>用户名</th>
                      <th>性别</th>
                      <th>邮箱</th>
                      <th>操作</th>
                  </tr>
              </thead>
              <tbody>
                  <tr class="gradeX" th:each="emp, status:${emps}">
                      <td th:text="${status.count}">Trident</td>
                      <td th:text="${emp.empName}">name</td>
                      <td>[[${emp.gender}]]</td>
                      <td th:text="${emp.email}">email</td>
                      <td>
                          <a th:href="@{/emp/delete/{id}(id=${emp.empId},pn=${page.current})}" class="btn btn-danger btn-sm" type="button">
                              删除
                          </a>
                      </td>
                  </tr>
              </tbody>
          </table>
      </div>
      <!--                        <div class="row-fluid">-->
      <!--                            <div class="span6">-->
      <!--                                <div class="dataTables_info" id="hidden-table-info_info">-->
      <!--                                    当前第 [[${page.current}]] 页 总计 [[${page.pages}]] 页 共 [[${page.total}]] 条记录-->
      <!--                                </div>-->
      <!--                            </div>-->
      <!--                        </div>-->
  </div>
  

3.5 NoSQL（待更新）

4、SpringBoot与单元测试

4.1 JUnit5的变化

• Spring Boot 2.2.0 版本开始引入 JUnit 5 作为单元测试默认库

• 作为最新版本的JUnit框架，JUnit5与之前版本的Junit框架有很大的不同。由三个不同子项目的几个不同模块组成。

  • JUnit 5 = JUnit Platform + JUnit Jupiter + JUnit Vintage

    • JUnit Platform: Junit Platform是在JVM上启动测试框架的基础，不仅支持Junit自制的测试引擎，其他测试引擎也都可以接入。

    • JUnit Jupiter: JUnit Jupiter提供了JUnit5的新的编程模型，是JUnit5新特性的核心。内部包含了一个测试引擎，用于在Junit Platform上运行。

    • JUnit Vintage: 由于JUint已经发展多年，为了照顾老的项目，JUnit Vintage提供了兼容JUnit4.x,Junit3.x的测试引擎

注意：

​ SpringBoot 2.4 以上版本移除了默认对 Vintage 的依赖。如果需要兼容junit4需要自行引入（不能使用junit4的功能 @Test）

​ JUnit 5’s Vintage Engine Removed from spring-boot-starter-test，如果需要继续兼容junit4需要自行引入vintage

<!--兼容Junit4-->
<dependency>
    <groupId>org.junit.vintage</groupId>
    <artifactId>junit-vintage-engine</artifactId>
    <scope>test</scope>
    <exclusions>
        <exclusion>
            <groupId>org.hamcrest</groupId>
            <artifactId>hamcrest-core</artifactId>
        </exclusion>
    </exclusions>
</dependency>

使用Junit5：在项目生成的时候，spring-boot-starter-test会导入Junit的包，会默认生成了测试环境，如果需要在整个项目中使用，那么需要把test去掉。

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

项目中会生成一个test测试环境：@SpringBootTest

@Slf4j
@SpringBootTest
class Boot05WebAdminApplicationTests {

    @Autowired
    JdbcTemplate jdbcTemplate;

    @Autowired
    DataSource dataSource;

    @Test
    void contextLoads() {
        Long aLong = jdbcTemplate.queryForObject("select count(*) from tbl_emp", Long.class);
        log.info("记录总数：{}", aLong);
        log.info("数据库连接池的类型：{}", dataSource.getClass());

    }
}

以前的老版本操作：

@SpringBootTest + @RunWith(SpringTest.class)

SpringBoot整合Junit以后：

• 编写测试方法：@Test标注（注意需要使用Junit5版本的注解）
• Junit类具有Spring的功能，@Autowired、比如 @Transactional 标注测试方法，测试完成后自动回滚
• 导入Junit5的包路径：org.junit.jupiter.api.Test
• 导入Junit4的包路径：org.junit.Test

4.2 JUnit5常用注解

JUnit5的注解与JUnit4的注解有所变化

https://junit.org/junit5/docs/current/user-guide/#writing-tests-annotations

• @Test :表示方法是测试方法。但是与JUnit4的@Test不同，他的职责非常单一不能声明任何属性，拓展的测试将会由Jupiter提供额外测试

• @ParameterizedTest :表示方法是参数化测试，下方会有详细介绍

• @RepeatedTest :表示方法可重复执行，下方会有详细介绍

• @DisplayName :为测试类或者测试方法设置展示名称

  

• @BeforeEach :表示在每个单元测试之前执行

• @AfterEach :表示在每个单元测试之后执行

• @BeforeAll :表示在所有单元测试之前执行

• @AfterAll :表示在所有单元测试之后执行

• @Tag :表示单元测试类别，类似于JUnit4中的@Categories

• @Disabled :表示测试类或测试方法不执行，类似于JUnit4中的@Ignore

• @Timeout :表示测试方法运行如果超过了指定时间将会返回错误

• @ExtendWith :为测试类或测试方法提供扩展类引用

• @SpringBootTest：使用SpringBoot环境进行测试，使用AOP容器

• @RepeatedTest：重复测试，例如@RepeatedTest(5)重复测试五次

/*@RunWith*/

/**
 * @BootstrapWith(SpringBootTestContextBootstrapper.class)
 * @ExtendWith(SpringExtension.class)
 */
//@SpringBootTest
@DisplayName("junit5功能测试类")
public class Junit5Test {

    @Autowired
    JdbcTemplate jdbcTemplate;

    /**
     * 测试前置条件
     */
    @DisplayName("测试前置条件")
    @Test
    void testassumptions(){
        Assumptions.assumeTrue(false,"结果不是true");
        System.out.println("111111");

    }

    @DisplayName("测试displayname注解")
    @Test
    void testDisplayName() {
        System.out.println(1);
        System.out.println(jdbcTemplate); //null值，只有加上@SpringBootTest注解后，才能使用SpringBoot的配置，使用AOP容器
    }

    @Disabled
    @DisplayName("测试方法2")
    @Test
    void test2() {
        System.out.println(2);
    }

    @RepeatedTest(5)
    @Test
    void test3() {
        System.out.println(5);
    }

    /**
     * 规定方法超时时间。超出时间测试出异常
     *
     * @throws InterruptedException
     */
    @Timeout(value = 500, unit = TimeUnit.MILLISECONDS)
    @Test
    void testTimeout() throws InterruptedException {
        Thread.sleep(600);
    }

    @BeforeEach
    void testBeforeEach() {
        System.out.println("测试就要开始了...");
    }

    @AfterEach
    void testAfterEach() {
        System.out.println("测试结束了...");
    }

    @BeforeAll
    static void testBeforeAll() {
        System.out.println("所有测试就要开始了...");
    }

    @AfterAll
    static void testAfterAll() {
        System.out.println("所有测试以及结束了...");

    }
}

4.3 断言（assertions）

​ 断言（assertions）是测试方法中的核心部分，用来对测试需要满足的条件进行验证。这些断言方法都是 org.junit.jupiter.api.Assertions 的静态方法。JUnit 5 内置的断言可以分成如下几个类别：

• 检查业务逻辑返回的数据是否合理；

• 所有的测试运行结束以后，会有一个详细的测试报告；

4.3.1 简单断言

用来对单个值进行简单的验证。如：

方法	说明
assertEquals	判断两个对象或两个原始类型是否相等
assertNotEquals	判断两个对象或两个原始类型是否不相等
assertSame	判断两个对象引用是否指向同一个对象
assertNotSame	判断两个对象引用是否指向不同的对象
assertTrue	判断给定的布尔值是否为 true
assertFalse	判断给定的布尔值是否为 false
assertNull	判断给定的对象引用是否为 null
assertNotNull	判断给定的对象引用是否不为 null
assertArrayEquals	判断两个对象或原始类型的数组是否相等

//@SpringBootTest // 使用该注解，就可以使用SpringBoot的环境配置，比如AOP容器
@DisplayName("Junit5Test")
public class Junit5Test {

    @BeforeAll
    static public void beforeAll(){
        System.out.println("启动测试....");
    }

    int cal(int a, int b){
        return a + b;
    }

    /**
     * 断言：若是在方法中，前面有一个断言判断条件失败，那么后面的代码都不会执行
     */
    @Test
    @DisplayName("测试简单断言（1）")
    public void testSimpleAssertions(){
        int cal = cal(3, 4);
        // 断言的判断：错误会有提示信息，当然也可以自定义断言失败时的错误信息
        Assertions.assertEquals(6, cal, "加法结果错误");

        Object o = new Object();
        Object o1 = new Object();
        Assertions.assertSame(o, o1, "两个对象不一样");
    }

    @AfterAll
    static public void afterAll(){
        System.out.println("测试结束....");
    }
}

• 没有自定义错误信息时

  

• 自定义错误信息时

  

  可以看到前一个断言判断条件失败后，下一个判断对象的断言并没有执行

• 第一个断言判断成功，往下执行下一个断言

  

4.3.2 组合断言

​ assertAll 方法接受多个 org.junit.jupiter.api.Executable 函数式接口的实例作为要验证的断言，可以通过 lambda 表达式很容易的提供这些断言。

@Test
@DisplayName("assert all")
public void all() { // 第一个参数传入组合断言的名称
 assertAll("Math",
    () -> assertEquals(2, 1 + 1),
    () -> assertTrue(1 > 0)
 );
}

4.3.3 异常断言

​ 在JUnit4时期，想要测试方法的异常情况时，需要用@Rule注解的ExpectedException变量还是比较麻烦的。而JUnit5提供了一种新的断言方式Assertions.assertThrows() ,配合函数式编程就可以进行使用。

断定业务逻辑一定会出现异常

@Test
@DisplayName("异常测试")
public void exceptionTest() { //断定业务逻辑一定会出现异常
    ArithmeticException exception = Assertions.assertThrows(
           //扔出断言异常
            ArithmeticException.class, () -> System.out.println(1 % 0));

   // 另一种写法
    assertThrows(ArithmeticException.class, ()->{
        int i = 10/2;
    }, "业务逻辑仍然在执行中.....");
}

4.3.4 超时断言

​ Junit5还提供了Assertions.assertTimeout() 为测试方法设置了超时时间

@Test
@DisplayName("超时测试")
public void timeoutTest() {
    //如果测试方法时间超过1s将会异常
    Assertions.assertTimeout(Duration.ofMillis(1000), () -> Thread.sleep(500));
}

4.3.5 快速失败

​ 通过 fail 方法直接使得测试失败

@Test
@DisplayName("快速失败")
public void shouldFail() {
    // 快速失败
    if(1 == 1) {
        fail("测试失败");
    }
}

4.4 前置条件（assumptions）

​ JUnit 5 中的前置条件（assumptions【假设】）类似于断言，不同之处在于不满足的断言会使得测试方法失败，而不满足的前置条件只会使得测试方法的执行终止。前置条件可以看成是测试方法执行的前提，当该前提不满足时，就没有继续执行的必要，就跳过。

@DisplayName("前置条件")
@Test
public void assumptionsTest(){
    assumeTrue(false, "前置执行条件不满足");
    System.out.println("执行程序中.......");
}

当前置条件不满足时，只是不执行，打印信息，执行结束（相当于跳过）。并不会像断言那样报错。

4.5 嵌套测试（assumptions）

​ JUnit 5 可以通过 Java 中的内部类和@Nested 注解实现嵌套测试，从而可以更好的把相关的测试方法组织在一起。在内部类中可以使用@BeforeEach 和@AfterEach 注解，而且嵌套的层次没有限制。

@Nested：注明这是一个嵌套测试类

下面的例子好好看看，帮助理解：

@DisplayName("A stack")
class TestingAStackDemo {

    Stack<Object> stack; // 并没有创建一个对象实例

    @Test
    @DisplayName("new Stack()")
    void isInstantiatedWithNew() {
        new Stack<>();
        // 嵌套测试的情况下，外层的Test不能驱动内层测试类的方法（如BeforeEach等）
        assertNotNull(stack); // false，stack为null，这条断言条件不成立，报错
    }

    @Nested // 这是一个嵌套测试
    @DisplayName("when new")
    class WhenNew {

        @BeforeEach
        void createNewStack() {
            stack = new Stack<>();
        }

        @Test
        @DisplayName("is empty")
        void isEmpty() { //@BeforeEach会创建一个栈的实例，但现在栈中没有元素，所以是empty的
            assertTrue(stack.isEmpty());// true
        }

        @Test
        @DisplayName("throws EmptyStackException when popped")
        void throwsExceptionWhenPopped() {
            // 由于栈空，执行不了pop操作，肯定会抛出栈空的异常，所以这条断言能顺利执行
            assertThrows(EmptyStackException.class, stack::pop);
        }

        @Test
        @DisplayName("throws EmptyStackException when peeked")
        void throwsExceptionWhenPeeked() {
            //栈为空，想查看第一个元素，必定会抛出栈空的异常。这也是我们希望的，所以也是能够执行的，断言是成功的
            assertThrows(EmptyStackException.class, stack::peek);
        }

        @Nested
        @DisplayName("after pushing an element")
        class AfterPushing {

            String anElement = "an element";

            @BeforeEach
            void pushAnElement() {// 注意这个嵌套方法，测试之前添加了元素，而栈的实例化，是已经在外层测试中创建了。也就是内层Test能够驱动外层的Test
                stack.push(anElement);
            }

            @Test
            @DisplayName("it is no longer empty")
            void isNotEmpty() {// 此时栈中已经有元素了，不再为空
                assertFalse(stack.isEmpty());// 当前断言成功，即栈不是空栈
            }

            @Test
            @DisplayName("returns the element when popped and is empty")
            void returnElementWhenPopped() {
                assertEquals(anElement, stack.pop());// 一定等于
                assertTrue(stack.isEmpty());// 因为出栈了，所以栈一定为空，断言成功
            }

            @Test
            @DisplayName("returns the element when peeked but remains not empty")
            void returnElementWhenPeeked() {
                assertEquals(anElement, stack.peek());//只查看元素，不弹出移除元素
                assertFalse(stack.isEmpty());// 所以当前栈肯定不为空，断言成功
            }
        }
    }
}

• 嵌套测试的情况下，外层的Test不能驱动内层测试类的方法（如BeforeEach等）
• 而内层Test能够驱动外层的Test

4.6 参数化测试

​ 参数化测试是JUnit5很重要的一个新特性，可以用不同的参数多次运行测试。

​ 利用@ValueSource等注解，指定入参，我们将可以使用不同的参数进行多次单元测试，而不需要每新增一个参数就新增一个单元测试。

参数测试的一些注解：

@ParameterizedTest：这是一个参数化测试（必须注明）

@ValueSource: 为参数化测试指定入参来源，支持八大基础类以及String类型,Class类型

@NullSource: 表示为参数化测试提供一个null的入参

@EnumSource: 表示为参数化测试提供一个枚举入参

@CsvFileSource：表示读取指定CSV文件内容作为参数化测试入参

@MethodSource：表示读取指定方法的返回值作为参数化测试入参(注意方法返回需要是一个流)

    @ParameterizedTest
    @DisplayName("参数化测试")
    @ValueSource(ints = {1,2,3,4,5})
    public void parameterizedTest(int i){
        System.out.println(i);
    }

    @ParameterizedTest
    @DisplayName("参数化测试2")
    @MethodSource("stringProvider")
    public void parameterizedTest2(String str){
        System.out.println(str);
    }

    static Stream<String> stringProvider(){
        return Stream.of("apple", "banana", "orange");
    }

4.7 迁移指南

5、指标监控（SpringBoot Actuator）

5.1 简介

​ 未来每一个微服务在云上部署以后，我们都需要对其进行监控、追踪、审计、控制等。SpringBoot就抽取了Actuator场景，使得我们每个微服务快速引用即可获得生产级别的应用监控、审计等功能。

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

5.2 如何使用

EndPoints

• 引入场景（starter）

• 访问 http://localhost:8080/actuator/**（注意actuator前缀）

  • 监控端点

  • 默认在web中只开启了health这个端点，JMX开启的可以去Jconsol查看

    

• 暴露所有监控信息为HTTP（给web方式开启监控端点）

  在配置管理文件文件yaml或properties中进行配置：

  management:
    endpoints:
      enabled-by-default: true # 默认开启所有端点
      web:
        exposure:
          include: '*'  # 以web方式暴露
  

• 测试

  http://localhost:8080/actuator/beans

  http://localhost:8080/actuator/configprops

  http://localhost:8080/actuator/metrics

  http://localhost:8080/actuator/metrics/jvm.gc.pause

  http://localhost:8080/actuator/endpointName/detailPath

5.3 常用端点

ID	描述
auditevents	暴露当前应用程序的审核事件信息。需要一个AuditEventRepository组件。
beans	显示应用程序中所有Spring Bean的完整列表。
caches	暴露可用的缓存。
conditions	显示自动配置的所有条件信息，包括匹配或不匹配的原因。
configprops	显示所有@ConfigurationProperties。
env	暴露Spring的属性ConfigurableEnvironment
flyway	显示已应用的所有Flyway数据库迁移。 需要一个或多个Flyway组件。
health	显示应用程序运行状况信息。
httptrace	显示HTTP跟踪信息（默认情况下，最近100个HTTP请求-响应）。需要一个HttpTraceRepository组件。
info	显示应用程序信息。
integrationgraph	显示Spring integrationgraph 。需要依赖spring-integration-core。
loggers	显示和修改应用程序中日志的配置。
liquibase	显示已应用的所有Liquibase数据库迁移。需要一个或多个Liquibase组件。
metrics	显示当前应用程序的“指标”信息。
mappings	显示所有@RequestMapping路径列表。
scheduledtasks	显示应用程序中的计划任务。
sessions	允许从Spring Session支持的会话存储中检索和删除用户会话。需要使用Spring Session的基于Servlet的Web应用程序。
shutdown	使应用程序正常关闭。默认禁用。
startup	显示由ApplicationStartup收集的启动步骤数据。需要使用SpringApplication进行配置BufferingApplicationStartup。
threaddump	执行线程转储。

​ 如果您的应用程序是Web应用程序（Spring MVC，Spring WebFlux或Jersey），则可以使用以下附加端点：

ID	描述
heapdump	返回hprof堆转储文件。
jolokia	通过HTTP暴露JMX bean（需要引入Jolokia，不适用于WebFlux）。需要引入依赖jolokia-core。
logfile	返回日志文件的内容（如果已设置logging.file.name或logging.file.path属性）。支持使用HTTPRange标头来检索部分日志文件的内容。
prometheus	以Prometheus服务器可以抓取的格式公开指标。需要依赖micrometer-registry-prometheus。

最常用的Endpoint

• Health：监控状况

• Metrics：运行时指标

• Loggers：日志记录

5.4 Health Endpoint

​ 健康检查端点，我们一般用于在云平台，平台会定时的检查应用的健康状况，我们就需要Health Endpoint可以为平台返回当前应用的一系列组件健康状况的集合。

http://localhost:8080/actuator/health

重要的几点：

• health endpoint返回的结果，应该是一系列健康检查后的一个总汇总报告

• 很多的健康检查默认已经自动配置好了，比如：数据库、redis等

• 可以很容易的添加自定义的健康检查机制

• 在yaml或者properties中的配置文件

  # management：是所有actuator的配置
  # management.endpoint.端口名.xxx 对某个端点的具体配置
  management:
    endpoints: # 所有端点的设置
      enabled-by-default: false # 默认是开启所有端点 true（相当于总开关）
      web:
        exposure:
          include: '*'  # 以web方式暴露
    endpoint: # 单个端点的设置
      health:
        show-details: always
        enabled: true
      beans:
        enabled: true # 如果关闭总开关的话，就要分别挨个开启组件
      metrics:
        enabled: true
  

5.5 Metrics Endpoint

提供详细的、层级的、空间指标信息，这些信息可以被pull（主动推送）或者push（被动获取）方式得到；

• 通过Metrics对接多种监控系统

• 简化核心Metrics开发

• 添加自定义Metrics或者扩展已有Metrics

• 测试：

  • 访问：http://localhost:8080/actuator/metrics/

    

  • 进一步查看某行的具体信息，如jvm.buffer.memory.used

    http://localhost:8080/actuator/metrics/jvm.buffer.memory.used

    

5.6 定制EndPoint

5.6.1 定制Health信息

继承 extends AbstractHealthIndicator

@Component
public class MyComHealthIndicator extends AbstractHealthIndicator {

    /**
     * 真实的检查方法
     * @param builder
     * @throws Exception
     */
    @Override
    protected void doHealthCheck(Health.Builder builder) throws Exception {
        //mongodb。  获取连接进行测试
        Map<String,Object> map = new HashMap<>();
        // 检查完成
        if(1 == 1){
//            builder.up(); //健康
            builder.status(Status.UP);
            map.put("count",1);
            map.put("ms",100);
        }else {
//            builder.down();
            builder.status(Status.OUT_OF_SERVICE);
            map.put("err","连接超时");
            map.put("ms",3000);
        }

        builder.withDetail("code",100)
                .withDetails(map);

    }
}

management:
    health:
      enabled: true
      show-details: always #总是显示详细信息。可显示每个模块的状态信息

5.6.2 定制info信息

http://localhost:8080/actuator/info 会输出所有的info信息

一般常用有两种方式：

• 通过配置文件定制

  info:
    appName: SpringBoot-Admin
    appVersion: 1.0.0
    mavenProjectName: "@project.artifactId@" #使用@@可以获取maven的pom文件值
    mavenProjectVersion: "@project.version@"
  

• 实现InfoContributor接口

  @Component
  public class AppInfoInfoContributor implements InfoContributor {
  
      @Override
      public void contribute(Info.Builder builder) {
  
          builder.withDetail("msg","你好")
                  .withDetail("hello","atguigu")
                  .withDetails(Collections.singletonMap("world","666600"));
      }
  }
  

5.6.3 定制Metrics信息

1、SpringBoot支持自动适配的Metrics

• JVM metrics, report utilization of:

• • Various memory and buffer pools
  • Statistics related to garbage collection
• • Threads utilization
  • Number of classes loaded/unloaded

• CPU metrics

• File descriptor metrics

• Kafka consumer and producer metrics

• Log4j2 metrics: record the number of events logged to Log4j2 at each level

• Logback metrics: record the number of events logged to Logback at each level

• Uptime metrics: report a gauge for uptime and a fixed gauge representing the application’s absolute start time

• Tomcat metrics (server.tomcat.mbeanregistry.enabled must be set to true for all Tomcat metrics to be registered)

• Spring Integration metrics

2、增加定制Metrics

class MyService{
    Counter counter;
    public MyService(MeterRegistry meterRegistry){
         counter = meterRegistry.counter("myservice.method.running.counter");
    }

    public void hello() {
        counter.increment();
    }
}

//也可以使用下面的方式
@Bean
MeterBinder queueSize(Queue queue) {
    return (registry) -> Gauge.builder("queueSize", queue::size).register(registry);
}

5.6.4 定制Endpoint

@Component
@Endpoint(id = "myservice")
public class MyServiceEndPoint {

    @ReadOperation
    public Map getDockerInfo(){
        //端点的读操作  http://localhost:8080/actuator/myservice
        return Collections.singletonMap("dockerInfo","docker started.....");
    }

    @WriteOperation
    public void stopDocker(){
        System.out.println("docker stopped.....");
    }

}

6、Boot-Admin-Server

https://github.com/codecentric/spring-boot-admin

开源的可视化监控平台

快速开始

客户端：

  boot:
    admin:
      client:
        url: http://localhost:8888
        instance:
          prefer-ip: true  #使用ip注册进来
  application: # 应用名称
    name: boot-05-web-admin