199 SpringBoot 常用组件集成

1 配置Druid数据源

【1】添加依赖

<druid-spring-boot-starter>1.1.20</druid-spring-boot-starter>

<!--druid的springboot配置-->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid-spring-boot-starter</artifactId>
    <version>${druid-spring-boot-starter}</version>
</dependency>

【2】添加yml配置

#服务配置
server:
  #端口
  port: 8081
  servlet:
    #项目路径
    context-path: /platform
  #服务编码
  tomcat:
    uri-encoding: UTF-8
#spring相关配置
spring:
  #应用配置
  application:
    #应用名称
    name: springboot-basic-project
  #数据源配置
  datasource:
    #选择druid数据源
    druid:
      driver-class-name: com.mysql.jdbc.Driver
      url: jdbc:mysql://localhost:3306/spring-travel?useUnicode=true&characterEncoding=utf8
      username: root
      password: root

注意：这里关于AOP和事务的配置，只要springboot添加了打他source配置就会自动开启

3、配置Mybatis-Plus框架

【1】添加依赖

<!--mybatis-plus版本-->
<mybatis-plus-boot-starter.version>3.2.0</mybatis-plus-boot-starter.version>
<!--mybatis-plus代码生成器引擎-->
<mybatis-plus-generator.version>3.3.1.tmp</mybatis-plus-generator.version>

<!--springboot关于mybatis-plus-->
<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-boot-starter</artifactId>
    <version>${mybatis-plus-boot-starter.version}</version>
</dependency>

<!--代码生成器模板引擎 相关依赖-->
<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-generator</artifactId>
    <version>${mybatis-plus-generator.version}</version>
</dependency>

<!--springboot的freemarker支持-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-freemarker</artifactId>
</dependency>

【2】添加yml配置

#服务配置
server:
  #端口
  port: 8081
  servlet:
    #项目路径
    context-path: /platform
  #服务编码
  tomcat:
    uri-encoding: UTF-8
#spring相关配置
spring:
  #应用配置
  application:
    #应用名称
    name: springboot-basic-project
  #数据源配置
  datasource:
    #选择druid数据源
    druid:
      driver-class-name: com.mysql.jdbc.Driver
      url: jdbc:mysql://localhost:3306/spring-boot?serverTimezone=UTC&useUnicode=true&characterEncoding=utf8
      username: root
      password: root
#mubatis配置
mybatis-plus:
  # MyBaits 别名包扫描路径，通过该属性可以给包中的类注册别名
  type-aliases-package: com.it.springboot.pojo
  # 该配置请和 typeAliasesPackage 一起使用，如果配置了该属性，则仅仅会扫描路径下以该类作为父类的域对象 。
  type-aliases-super-type: com.it.springboot.basic.BasicPojo
  configuration:
    # 这个配置会将执行的sql打印出来，在开发或测试的时候可以用
    log-impl: org.apache.ibatis.logging.slf4j.Slf4jImpl
    # 驼峰下划线转换
    map-underscore-to-camel-case: true
    use-generated-keys: true
    default-statement-timeout: 60
    default-fetch-size: 100
  global-config:
    db-config:
      #主键类型(雪花ID)
      id-type: assign_id
    #机器 ID 部分(影响雪花ID)
    worker-id: 1
    #数据标识 ID 部分(影响雪花ID)
    datacenter-id: 1
logging:
  config: classpath:logback.xml

【3】代码生成器

mybatis-plus-generrator.properties

#数据库地址
url=jdbc:mysql://127.0.0.1:3306/spring-boot?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8&tinyInt1isBit=false
#数据库账号
userName=root
#数据库密码
password=root
#此处为本项目src所在路径（代码生成器输出路径）
projectPath=E:/spring-boot-project/springboot-/springboot-basic-project
#设置作者
author=Admin
#自定义包路径
parent=com.it
#装代码的文件夹名
moduleName=springboot
#设置表前缀，不设置则默认无前缀
tablePrefix =sh_
#数据库表名(此处切不可为空，如果为空，则默认读取数据库的所有表名)
tableName=sh_resource,sh_role,sh_role_resource,sh_user,sh_user_role
#生成的层级
entity=true
entity.ftl.path=/templates/entity.java
mapper=true
mapper.ftl.path=/templates/mapper.java
service=true
service.ftl.path=/templates/service.java
serviceImp=true
serviceImp.ftl.path=/templates/serviceImpl.java
controller=true
controller.ftl.path=/templates/controller.java

4】分页、回填插件

package com.it.springboot.config;

import com.baomidou.mybatisplus.autoconfigure.MybatisPlusProperties;
import com.baomidou.mybatisplus.extension.plugins.PaginationInterceptor;
import com.it.springboot.handler.MyBatisMetaObjectHandler;
import com.it.springboot.utils.SnowflakeIdWorker;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @Description：配置文件
 */
@Configuration
@EnableConfigurationProperties(MybatisPlusProperties.class)
public class MyBatisPlusConfig {

    @Autowired
    MybatisPlusProperties mybatisPlusProperties;

    /**
     * @Description 雪花算法工具
     */
    @Bean("snowflakeIdWorker")
    public SnowflakeIdWorker seqGeneratorSharding(){
        return new SnowflakeIdWorker(mybatisPlusProperties.getGlobalConfig().getWorkerId(),
                mybatisPlusProperties.getGlobalConfig().getDatacenterId());
    }

    /**
     * 自动填充
     */
    @Bean
    public MyBatisMetaObjectHandler myMetaObjectHandler() {
        return new MyBatisMetaObjectHandler();
    }

    /**
     * 分页插件
     */
    @Bean
    public PaginationInterceptor paginationInterceptor() {
        return new PaginationInterceptor();
    }
}

4、配置Swagger2

【1】为什么使用swagger

由于Spring Boot能够快速开发、便捷部署等特性，相信有很大一部分Spring Boot的用户会用来构建RESTful API。而我们构建RESTful API的目的通常都是由于多终端的原因，这些终端会共用很多底层业务逻辑，因此我们会抽象出这样一层来同时服务于多个移动端或者Web前端。

这样一来，我们的RESTful API就有可能要面对多个开发人员或多个开发团队：IOS开发、Android开发或是Web开发等。为了减少与其他团队平时开发期间的频繁沟通成本，传统做法我们会创建一份RESTful API文档来记录所有接口细节，然而这样的做法有以下几个问题：

	由于接口众多，并且细节复杂（需要考虑不同的HTTP请求类型、HTTP头部信息、HTTP请求内容等），高质量地创建这份文档本身就是件非常吃力的事，下游的抱怨声不绝于耳。
	随着时间推移，不断修改接口实现的时候都必须同步修改接口文档，而文档与代码又处于两个不同的媒介，除非有严格的管理机制，不然很容易导致不一致现象。

【2】配置swagger2

【2.1】添加pom依赖

<!--swagger2版本支持-->
<swagger2>2.9.2</swagger2>

<!--swagger2支持-->
<dependency>
    <groupId>io.springfox</groupId>
    <artifactId>springfox-swagger2</artifactId>
    <version>${swagger2}</version>
</dependency>
<dependency>
    <groupId>io.springfox</groupId>
    <artifactId>springfox-swagger-ui</artifactId>
    <version>${swagger2}</version>
</dependency>

【2.2】SwaggerConfig

package com.it.springboot.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import springfox.documentation.builders.ApiInfoBuilder;
import springfox.documentation.builders.PathSelectors;
import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.service.Contact;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.swagger2.annotations.EnableSwagger2;

@Configuration
@EnableSwagger2
@ComponentScan("springfox.documentation.swagger.web")
public class SwaggerConfig {

    @Bean
    public Docket createRestApi() {
        // 构建API文档  文档类型为swagger2
        return new Docket(DocumentationType.SWAGGER_2)
                .select()
                // 配置 api扫描路径
                .apis(RequestHandlerSelectors.basePackage("com.it.springboot"))
                // 指定路径的设置  any代表所有路径
                .paths(PathSelectors.any())
                // api的基本信息
                .build().apiInfo(new ApiInfoBuilder()
                        // api文档名称
                        .title("整合Swagger接口文档")
                        // api文档描述
                        .description("整合Swagger，描述信息......")
                        // api文档版本
                        .version("1.0") // 版本
                        // api作者信息
                        .contact(new Contact("mrchen", "blog.csdn.net", "aaa@gmail.com"))
                        .build());
    }

}

放过静态资源

package com.it.springboot.config;

import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.CorsRegistry;
import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurationSupport;

/**
 * @ClassName WebMvcConfig.java
 * @Description webMvc高级配置
 */
@Configuration
public class WebMvcConfig extends WebMvcConfigurationSupport {
    
    /**
     * 资源路径 映射
     */
    @Override
    protected void addResourceHandlers(ResourceHandlerRegistry registry) {
        /**
         * 支持webjars
         */
        registry.addResourceHandler("/webjars/**")
                .addResourceLocations("classpath:/META-INF/resources/webjars/");
        /**
         * 支持swagger
         */
        registry.addResourceHandler("swagger-ui.html")
                .addResourceLocations("classpath:/META-INF/resources/");
        super.addResourceHandlers(registry);
    }
}

【2.3】swagger注解

@Api：

作用在类上，用来标注该类具体实现内容。表示标识这个类是swagger的资源 。
参数：
tags：可以使用tags()允许您为操作设置多个标签的属性，而不是使用该属性。

​ description：可描述描述该类作用。

@ApiImplicitParam：

作用在方法上，表示单独的请求参数
参数：
name ：参数名。
value ： 参数的具体意义，作用。
required ： 参数是否必填。
dataType ：参数的数据类型。
paramType ：查询参数类型，这里有几种形式：

类型	作用
path	以地址的形式提交数据
query	直接跟参数完成自动映射赋值
body	以流的形式提交 仅支持POST
header	参数在request headers 里边提交
form	以form表单的形式提交 仅支持POST

在这里我被坑过一次：当我发POST请求的时候，当时接受的整个参数，不论我用body还是query，后台都会报Body Missing错误。这个参数和SpringMvc中的@RequestBody冲突，索性我就去掉了paramType，对接口测试并没有影响。

@ApiImplicitParams：

用于方法，包含多个 @ApiImplicitParam：
例：

@ApiImplicitParams({
	@ApiImplicitParam(name = "id", value = "book's name", required = true, dataType = "Long", paramType = "query"),
	@ApiImplicitParam(name = "date", value = "book's date", required = false, dataType = "string", paramType = "query")})

@ApiModel：

用于类，表示对类进行说明，用于参数用实体类接收；

@ApiModelProperty：

用于方法，字段 ，表示对model属性的说明或者数据操作更改
例：

@ApiModel(value = "User", description = "用户")
public class User implements Serializable{

    private static final long serialVersionUID = 1546481732633762837L;

    /**
     * 用户ID
     */
    @ApiModelProperty(value = "用户ID", required = true)
    @NotEmpty(message = "{id.empty}", groups = {Default.class,New.class,Update.class})
    protected String id;

    /**
     * code/登录帐号
     */
    @ApiModelProperty(value = "code/登录帐号")
    @NotEmpty(message = "{itcode.empty}", groups = {Default.class,New.class,Update.class})
    protected String itcode;

    /**
     * 用户姓名
     */
    @ApiModelProperty(value = "用户姓名")
    @NotEmpty(message = "{name.empty}", groups = {Default.class,New.class,Update.class})
    protected String name;
}

@ApiOperation：

用于方法，表示一个http请求的操作 。

@ApiOperation(value = "获取图书信息", notes = "获取图书信息", response = Book.class, responseContainer = "Item", produces = "application/json")
@ApiImplicitParams({
            @ApiImplicitParam(name = "id", value = "book's name", required = true, dataType = "Long", paramType = "query"),
            @ApiImplicitParam(name = "date", value = "book's date", required = false, dataType = "string", paramType = "query")})
@RequestMapping(value = "/{id}", method = RequestMethod.GET)
@ResponseBody
public Book getBook(@PathVariable Long id, String date) {
    return books.get(id);
}

5、配置SpringCache+Redis缓存【重点】

【1】添加依赖

<!--springboot的cache支持-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-cache</artifactId>
</dependency>

<!--springboot的redis支持-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

<!--对象序列化-->
<dependency>
    <groupId>com.esotericsoftware</groupId>
    <artifactId>kryo</artifactId>
    <version>${kryo.version}</version>
</dependency>

【2】添加yml配置

#服务配置
server:
  #端口
  port: 8081
  servlet:
    #项目路径
    context-path: /platform
  #服务编码
  tomcat:
    uri-encoding: UTF-8
#spring相关配置
spring:
  #应用配置
  application:
    #应用名称
    name: springboot-basic-project
  #数据源配置
  datasource:
    #选择druid数据源
    druid:
      driver-class-name: com.mysql.jdbc.Driver
      url: jdbc:mysql://localhost:3306/spring-boot?serverTimezone=UTC&useUnicode=true&characterEncoding=utf8
      username: root
      password: root
  redis:
    host: 127.0.0.1 #Redis服务器地址
    port: 7379 #Redis服务器连接端口
    timeout: 2000 #请求redis服务的超时时间,这里注意设置成0时取默认时间2000
    jedis: #阻塞的
      pool:
        #连接池最大连接数（使用负值表示没有限制）
        #建议为业务期望QPS/一个连接的QPS,例如50000/1000=50
        #一次命令时间(borrow|return resource+Jedis执行命令+网络延迟)的平均耗时约为1ms,一个连接的QPS大约是1000
        max-active: 50
        #连接池中的最大空闲连接
        #建议和最大连接数一致,这样做的好处是连接数从不减少,从而避免了连接池伸缩产生的性能开销。
        max-idle: 50
        #连接池中的最小空闲连接
        #建议为0，在无请求的状况下从不创建链接
        min-idle: 0
        #连接池最大阻塞等待时间 毫秒（-1表示没有限制）
        #建议不要为-1，连接池占满后无法获取连接时将在该时间内阻塞等待，超时后将抛出异常。
        max-wait: 2000
#mubatis配置
mybatis-plus:
  # MyBaits 别名包扫描路径，通过该属性可以给包中的类注册别名
  type-aliases-package: com.it.springboot.pojo
  # 该配置请和 typeAliasesPackage 一起使用，如果配置了该属性，则仅仅会扫描路径下以该类作为父类的域对象 。
  type-aliases-super-type: com.it.springboot.basic.BasicPojo
  configuration:
    # 这个配置会将执行的sql打印出来，在开发或测试的时候可以用
    log-impl: org.apache.ibatis.logging.slf4j.Slf4jImpl
    # 驼峰下划线转换
    map-underscore-to-camel-case: true
    use-generated-keys: true
    default-statement-timeout: 60
    default-fetch-size: 100
  global-config:
    db-config:
      #主键类型(雪花ID)
      id-type: assign_id
    #机器 ID 部分(影响雪花ID)
    worker-id: 1
    #数据标识 ID 部分(影响雪花ID)
    datacenter-id: 1
logging:
  config: classpath:logback.xml

【3】RedisCacheConfig配置

package com.it.springboot.config;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.annotation.JsonTypeInfo;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.MapperFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
import com.it.springboot.serializer.KryoRedisSerializer;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.*;

import java.time.Duration;

/**
 * @ClassName RedisCacheConfig.java
 * @Description redis配置
 */
@Configuration
@EnableCaching
public class RedisCacheConfig {


    /**
     * 申明缓存管理器，会创建一个切面（aspect）并触发Spring缓存注解的切点（pointcut）
     * 根据类或者方法所使用的注解以及缓存的状态，这个切面会从缓存中获取数据，将数据添加到缓存之中或者从缓存中移除某个值

     * @return
     */
    @Bean
    public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
        RedisSerializer<String> redisSerializer = new StringRedisSerializer();
        GenericJackson2JsonRedisSerializer genericJackson2JsonRedisSerializer = new GenericJackson2JsonRedisSerializer();
        // KryoRedisSerializer 替换默认序列化
//        KryoRedisSerializer kryoRedisSerializer = new KryoRedisSerializer(Object.class);

        // 配置序列化（解决乱码的问题）
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
                .entryTtl(Duration.ofSeconds(60))
                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(redisSerializer))
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(genericJackson2JsonRedisSerializer))
                .disableCachingNullValues();

        return RedisCacheManager.builder(redisConnectionFactory)
                .cacheDefaults(config)
                .build();
    }
}

【4】注解详解

对于缓存声明，spring的缓存提供了一组java注解:

• @Cacheable:触发缓存写入。
• @CacheEvict:触发缓存清除。
• @CachePut:更新缓存(不会影响到方法的运行)。
• @Caching:重新组合要应用于方法的多个缓存操作
• @CacheConfig:设置类级别上共享的一些常见缓存设置【了解】

【4.1】@Cacheable注解

​ 如果缓存中没有：查询数据库，存储缓存，返回结果，如果缓存中有：直接返回结果

​ 作用：可以用来进行缓存的写入，将结果存储在缓存中，以便于在后续调用的时候可以直接返回缓存中的值，而不必再执行实际的方法。 最简单的使用方式,注解名称=缓存名称,使用例子如下:

【4.2】@CacheEvict注解

@CacheEvict:删除缓存的注解,这对删除旧的数据和无用的数据是非常有用的。这里还多了一个参数(allEntries),设置allEntries=true时，可以对整个条目进行批量删除

【4.3】@CachePut注解

@CachePut:当需要更新缓存而不干扰方法的运行时 ，可以使用该注解。也就是说，始终执行该方法，并将结果放入缓存

【4.4】@Caching注释

在使用缓存的时候，有可能会同时进行更新和删除，会出现同时使用多个注解的情况.而@Caching可以实现

//添加user缓存的同时，移除userPage的缓存
@Caching(put =@CachePut(value = "user",key ="#userVo.id"),
evict = @CacheEvict(value = "userPage",allEntries = true))

【4.5】@CacheConfig注解

缓存提供了许多的注解选项，但是有一些公用的操作，我们可以使用@CacheConfig在类上进行全局设置。 以下是个简单的例子

@CacheConfig("books") 
public class BookRepositoryImpl implements BookRepository {

    @Cacheable
    public Book findBook(ISBN isbn) {...}
} 

【5】使用示例

UserController

package com.it.springboot.web;


import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.it.springboot.basic.ResponseWrap;
import com.it.springboot.enums.StatusEnum;
import com.it.springboot.exception.ProjectException;
import com.it.springboot.pojo.User;
import com.it.springboot.service.IUserService;
import com.it.springboot.utils.BeanConv;
import com.it.springboot.utils.EmptyUtil;
import com.it.springboot.utils.ExceptionsUtil;
import com.it.springboot.vo.UserVo;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;
import lombok.extern.log4j.Log4j2;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.CachePut;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.cache.annotation.Caching;
import org.springframework.web.bind.annotation.*;

import java.util.Date;

/**
 * @Description：用户表 前端控制器
 */
@RestController
@RequestMapping("/springboot/user")
@Api(tags = "用户操作")
@Log4j2
@CrossOrigin
public class UserController {

    @Autowired
    IUserService userService;

    /***
     * @description 注册用户
     * @param userVo 注册信息
     * @return: java.lang.Boolean
     */
    @PostMapping
    @ApiOperation(value = "用户注册",notes = "用户注册")
    @ApiImplicitParam(name = "userVo",value = "注册信息",required = true,dataType = "UserVo")
    @Caching(put =@CachePut(value = "user",key ="#result.data.id"),evict = @CacheEvict(value = "userPage",allEntries = true))
    public ResponseWrap<UserVo> saveUser(@RequestBody UserVo userVo) throws ProjectException {
        try {
            User user = BeanConv.toBean(userVo, User.class);
            userService.save(user);
            BeanConv.toBean(user, userVo);
            return ResponseWrap.<UserVo>builder()
                    .code(StatusEnum.SUCCEED.getCode())
                    .msg(StatusEnum.SUCCEED.getMsg())
                    .operationTime(new Date())
                    .data(userVo)
                    .build();
        }catch (Exception e){
            log.error("用户注册：{}", ExceptionsUtil.getStackTraceAsString(e));
            throw new ProjectException(StatusEnum.REGISTER_USER_FAIL.getCode(),
                    StatusEnum.REGISTER_USER_FAIL.getMsg());
        }
    }

    /***
     * @description 删除用户
     * @param userId 用户Id
     * @return: java.lang.Boolean
     */
    @DeleteMapping("{userId}")
    @ApiOperation(value = "删除用户",notes = "删除用户")
    @ApiImplicitParam(name = "userId",value = "删除用户",required = true,dataType = "Long")
    @Caching(evict = {@CacheEvict(value = "user",key ="#userId"),@CacheEvict(value = "userPage",allEntries = true)})
    public ResponseWrap<Boolean> deleteUser(@PathVariable("userId") Long userId) throws ProjectException {
        try {
            Boolean flag = userService.removeById(userId);
            return ResponseWrap.<Boolean>builder()
                    .code(StatusEnum.SUCCEED.getCode())
                    .msg(StatusEnum.SUCCEED.getMsg())
                    .operationTime(new Date())
                    .data(flag)
                    .build();
        }catch (Exception e){
            log.error("删除用户：{}", ExceptionsUtil.getStackTraceAsString(e));
            throw new ProjectException(StatusEnum.DELETE_USER_FAIL.getCode(),
                    StatusEnum.DELETE_USER_FAIL.getMsg());
        }
    }

    /***
     * @description 编辑用户
     * @param userVo 注册信息
     * @return: java.lang.Boolean
     */
    @PutMapping
    @ApiOperation(value = "编辑用户",notes = "编辑用户")
    @ApiImplicitParam(name = "userVo",value = "编辑用户",required = true,dataType = "UserVo")
    @Caching(put =@CachePut(value = "user",key ="#userVo.id"),evict = @CacheEvict(value = "userPage",allEntries = true))
    public ResponseWrap<Boolean> updateUser(@RequestBody UserVo userVo) throws ProjectException {
        try {
            Boolean flag = userService.saveOrUpdate(BeanConv.toBean(userVo, User.class));
            return ResponseWrap.<Boolean>builder()
                    .code(StatusEnum.SUCCEED.getCode())
                    .msg(StatusEnum.SUCCEED.getMsg())
                    .operationTime(new Date())
                    .data(flag)
                    .build();
        }catch (Exception e){
            log.error("查询用户：{}", ExceptionsUtil.getStackTraceAsString(e));
            throw new ProjectException(StatusEnum.UPDATE_USER_FAIL.getCode(),
                    StatusEnum.UPDATE_USER_FAIL.getMsg());
        }
    }

    /***
     * @description 查询用户
     * @param userId 用户Id
     * @return: java.lang.Boolean
     */
    @GetMapping("/{userId}")
    @ApiOperation(value = "查询用户",notes = "查询用户")
    @ApiImplicitParam(name = "userId",value = "查询用户",required = true,dataType = "Long")
    @Cacheable(value = "user",key ="#userId")
    public ResponseWrap<UserVo> findUserById(@PathVariable("userId") Long userId) throws ProjectException {
        try {
            User user = userService.getById(userId);
            return ResponseWrap.<UserVo>builder()
                    .code(StatusEnum.SUCCEED.getCode())
                    .msg(StatusEnum.SUCCEED.getMsg())
                    .operationTime(new Date())
                    .data(BeanConv.toBean(user,UserVo.class))
                    .build();
        }catch (Exception e){
            log.error("查询用户：{}", ExceptionsUtil.getStackTraceAsString(e));
            throw new ProjectException(StatusEnum.FIND_USER_FAIL.getCode(),
                    StatusEnum.FIND_USER_FAIL.getMsg());
        }
    }

    /***
     * @description 分页查询用户
     * @param current 当前页面
     * @param size 每页条数
     * @return: java.lang.Boolean
     */
    @PostMapping("{current}/{size}")
    @ApiOperation(value = "分页查询用户",notes = "查询用户")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "current",value = "当前页码",required = true,dataType = "Long"),
            @ApiImplicitParam(name = "size",value = "每页条数",required = true,dataType = "Long"),
            @ApiImplicitParam(name = "userVo",value = "用户条件",required = true,dataType = "UserVo")
    })
    @Cacheable(value = "userPage",key ="'current_'+#current+'_userVo_'+#userVo.hashCode()")
    public ResponseWrap<Page<UserVo>> findUserPage(@PathVariable("current") Long current,
                                                   @PathVariable("size") Long size,
                                                   @RequestBody UserVo userVo) throws ProjectException {
        try {
            //构建分页
            Page<User> page = new Page<>(current,size);
            //查询条件
            QueryWrapper<User> queryWrapper = new QueryWrapper<>();
            if (!EmptyUtil.isNullOrEmpty(userVo.getLoginName())) {
                queryWrapper.likeRight(StringUtils.camelToUnderline(User.Fields.loginName),userVo.getLoginName());
            }
            if (!EmptyUtil.isNullOrEmpty(userVo.getMobil())) {
                queryWrapper.likeRight(StringUtils.camelToUnderline(User.Fields.mobil),userVo.getMobil());
            }
            if (!EmptyUtil.isNullOrEmpty(userVo.getEnableFlag())) {
                queryWrapper.eq(StringUtils.camelToUnderline(User.Fields.enableFlag),userVo.getEnableFlag());
            }
            //执行查询
            Page<User> userPageResult = userService.page(page, queryWrapper);
            Page<UserVo> userVoPageResult = new Page<>();
            BeanConv.toBean(userPageResult,userVoPageResult);
            userVoPageResult.setRecords(BeanConv.toBeanList(userPageResult.getRecords(),UserVo.class));
            return ResponseWrap.<Page<UserVo>>builder()
                    .code(StatusEnum.SUCCEED.getCode())
                    .msg(StatusEnum.SUCCEED.getMsg())
                    .operationTime(new Date())
                    .data(userVoPageResult)
                    .build();
        }catch (Exception e){
            log.error("用户注册：{}", ExceptionsUtil.getStackTraceAsString(e));
            throw new ProjectException(StatusEnum.FIND_USER_FAIL.getCode(),
                    StatusEnum.FIND_USER_FAIL.getMsg());
        }
    }

}

6、配置SpringBoot测试

【1】springboot测试配置

<!--springboot的测试支持-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
</dependency>

注解

注解	说明
@RunWith(SpringRunner.class)	替换底层运行期
@SpringBootTest	使用springboot启动项目并且添加测试

注意:如果springboot的版本为2.2.X以上版本则可以不添加@RunWith(SpringRunner.class)