【springboot+vue项目（五）】Spring Boot 项目基础配置（一）

目录

一、 项目基础代码建设

  1、依赖配置

  2、数据库配置

  3、MyBatis-Plus 配置(config/MybatisPlusConfig )

  4 、HTTP 响应状态码

  5、 统一返回结果类(common)

  6、统一异常处理

6.1 编写自定义异常类

 6.2 编写异常处理器

6.3 统一异常处理：

7、跨域问题

8、字面值处理

9、Bean拷贝工具类封装

10、快速生成代码的插件

10.1 entity模板

10.2 Mapper

10.3 Service

10.4 ServiceImpl

11.在线接口文档

11.1 添加依赖

11.2 Knife4jConfig配置类

 11.3 使用案例：

 11.4 访问地址

12、通用的分页对象

12.1 新建 PageVo

12.2   使用示例

13、Security 配置

14、统一管理登录日志和操作日志

14.1 引入Spring AOP 依赖

14.2 自定义日志注解类

14.3 SysUserLogMapper接口

14.4 SysUserLogService接口

 14.5 SysUserLogServiceImpl类

14.6 WebLogAspect切面类

14.7  Controller 请求处理层添加注解

【知识点】

1、HTTP 响应状态码

         2、当Spring Boot 2.6.x 和Swagger 3.0.0 整合的时候会报错

---

---

一、 项目基础代码建设

        在Spring Boot + MyBatis-Plus项目中，在建立新的项目时，经常需要做一些重复的工作，比如说拷贝一下常用的工具类，通用代码等等。为了方便开发和提高生产力，可以事先编写一些和业务无关的代码，例如：     

  1、依赖配置

在 pom.xml 文件中添加以下依赖：（此处只是添加了通用的依赖，项目中需要的依赖请自行添加）

    4.0.0

    com.example
    demo
    0.0.1-SNAPSHOT
    demo
    Demo project for Spring Boot

    
        org.springframework.boot
        spring-boot-starter-parent
        2.5.3
         
    

    
        11
        3.4.3.1
        8.0.23
        0.11.2
    

    
        
        
            org.springframework.boot
            spring-boot-starter-web
        

        
        
            com.baomidou
            mybatis-plus-boot-starter
            ${mybatis-plus.version}
        

        
        
            mysql
            mysql-connector-java
            ${mysql.version}
        

        
        
            org.springframework.boot
            spring-boot-starter-security
        

        
        
            io.jsonwebtoken
            jjwt-api
            ${jwt.version}
        
        
            io.jsonwebtoken
            jjwt-impl
            ${jwt.version}
            runtime
        
        
            io.jsonwebtoken
            jjwt-jackson
            ${jwt.version}
            runtime
        

        
        
            io.springfox
            springfox-swagger2
            2.9.2
        
        
            io.springfox
            springfox-swagger-ui
            2.9.2
        

        
        
            org.projectlombok
            lombok
            true
        

        
        
            org.springframework.boot
            spring-boot-starter-test
            test
        
    

    
        
            
            
                org.springframework.boot
                spring-boot-maven-plugin
            
        
    

  2、数据库配置

在 application.yml（或 application.properties）文件中配置数据库连接信息，如下所示：

server:
  port: 8080
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/demo_db?characterEncoding=utf-8&serverTimezone=Asia/Shanghai
    username: root
    password: 123456
    driver-class-name: com.mysql.cj.jdbc.Driver
  servlet:
    multipart:
      max-file-size: 2MB
      max-request-size: 5MB
  mvc:
    pathmatch:
      matching-strategy: ant_path_matcher

mybatis-plus:
  configuration:
    # 日志
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
  global-config:
    db-config:
      logic-delete-field: delFlag
      logic-delete-value: 1
      logic-not-delete-value: 0
      id-type: auto

  3、MyBatis-Plus 配置(config/MybatisPlusConfig )

在MyBatis-Plus 的配置类中添加以下配置：

/**
 * mybatis-plus 的分页插件

 */
@Configuration
@MapperScan("com.example.demo.mapper")
public class MybatisPlusConfig {

    /**
     * 新的分页插件
     */
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
        return interceptor;
    }
}

4 、HTTP 响应状态码​​​​​​​

public enum AppHttpCodeEnum {
    // 成功状态码
    SUCCESS(200,"操作成功"),
    CREATED(201, "创建成功"),
    ACCEPTED(202, "请求已接受"),
    NO_CONTENT(204, "请求已成功处理，但无返回内容"),

    // 客户端错误状态码
    BAD_REQUEST(400, "请求参数错误"),
    UNAUTHORIZED(401,"需要登录后操作"),
    FORBIDDEN(403,"无权限操作"),
    NOT_FOUND(404, "请求资源不存在"),
    METHOD_NOT_ALLOWED(405, "请求方法不支持"),
    UNSUPPORTED_MEDIA_TYPE(415, "请求媒体类型不支持"),
    TOO_MANY_REQUESTS(429, "请求过于频繁，请稍后再试"),

    // 服务器错误状态码
    INTERNAL_SERVER_ERROR(500,"出现错误"),
    NOT_IMPLEMENTED(501, "请求未实现"),
    SERVICE_UNAVAILABLE(503, "服务不可用"),
    GATEWAY_TIMEOUT(504, "网关超时"),

    // 业务错误状态码
    USERNAME_EXIST(1001,"用户名已存在"),
    PHONENUMBER_EXIST(1002,"手机号已存在"),
    EMAIL_EXIST(1003, "邮箱已存在"),
    REQUIRE_USERNAME(1004, "必需填写用户名"),
    LOGIN_ERROR(1005,"用户名或密码错误");

    int code; // 状态码
    String msg; // 错误信息

    /**
     * 构造函数，初始化枚举值
     * @param code 状态码
     * @param errorMessage 错误信息
     */
    AppHttpCodeEnum(int code, String errorMessage){
        this.code = code;
        this.msg = errorMessage;
    }

    /**
     * 获取状态码
     * @return 状态码
     */
    public int getCode() {
        return code;
    }

    /**
     * 获取错误信息
     * @return 错误信息
     */
    public String getMsg() {
        return msg;
    }
}

 5、 统一返回结果类(common)

    统一返回结果类：例如Result，用于封装API接口的返回结果，规范接口返回格式，避免在不同接口返回结果格式不一致的问题。

@JsonInclude(JsonInclude.Include.NON_NULL)
public class ResponseResult implements Serializable {
    private Integer code; // 状态码
    private String msg; // 响应消息
    private T data; // 响应数据

    // 无参构造函数，默认为成功响应
    public ResponseResult() {
        this.code = AppHttpCodeEnum.SUCCESS.getCode();
        this.msg = AppHttpCodeEnum.SUCCESS.getMsg();
    }

    // 构造函数，传入状态码和响应数据
    public ResponseResult(Integer code, T data) {
        this.code = code;
        this.data = data;
    }

    // 构造函数，传入状态码、响应消息和响应数据
    public ResponseResult(Integer code, String msg, T data) {
        this.code = code;
        this.msg = msg;
        this.data = data;
    }

    // 构造函数，传入状态码和响应消息
    public ResponseResult(Integer code, String msg) {
        this.code = code;
        this.msg = msg;
    }

    // 返回错误响应结果
    public static ResponseResult errorResult(int code, String msg) {
        ResponseResult result = new ResponseResult();
        return result.error(code, msg);
    }

    // 返回成功响应结果
    public static ResponseResult okResult() {
        ResponseResult result = new ResponseResult();
        return result;
    }

    // 返回成功响应结果，传入状态码和响应消息
    public static ResponseResult okResult(int code, String msg) {
        ResponseResult result = new ResponseResult();
        return result.ok(code, null, msg);
    }

    // 返回成功响应结果，传入响应数据
    public static ResponseResult okResult(Object data) {
        ResponseResult result = setAppHttpCodeEnum(AppHttpCodeEnum.SUCCESS, AppHttpCodeEnum.SUCCESS.getMsg());
        if(data!=null) {
            result.setData(data);
        }
        return result;
    }

    // 返回错误响应结果，传入AppHttpCodeEnum枚举类型
    public static ResponseResult errorResult(AppHttpCodeEnum enums){
        return setAppHttpCodeEnum(enums,enums.getMsg());
    }

    // 返回错误响应结果，传入AppHttpCodeEnum枚举类型和响应消息
    public static ResponseResult errorResult(AppHttpCodeEnum enums, String msg){
        return setAppHttpCodeEnum(enums,msg);
    }

    // 返回成功响应结果，传入AppHttpCodeEnum枚举类型
    public static ResponseResult setAppHttpCodeEnum(AppHttpCodeEnum enums){
        return okResult(enums.getCode(),enums.getMsg());
    }

    // 私有方法，传入AppHttpCodeEnum枚举类型和响应消息，返回成功响应结果
    private static ResponseResult setAppHttpCodeEnum(AppHttpCodeEnum enums, String msg){
        return okResult(enums.getCode(),msg);
    }

    // 返回错误响应结果，传入状态码和响应消息
    public ResponseResult error(Integer code, String msg) {
        this.code = code;
        this.msg = msg;
        return this;
    }

    // 返回成功响应结果，传入状态码和响应数据
    public ResponseResult ok(Integer code, T data) {
        this.code = code;
        this.data = data;
        return this;
    }

    // 返回成功响应结果，传入状态码、响应数据和响应消息
    public ResponseResult ok(Integer code, T data, String msg) {
        this.code = code;
        this.data = data;
        this.msg = msg;
        return this;
    }

    // 返回成功响应结果，传入响应数据
    public ResponseResult ok(T data) {
        this.data = data;
        return this;
    }

    // getter和setter方法
    public Integer getCode() {
        return code;
    }

    public void setCode(Integer code) {
        this.code = code;
    }

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }

    public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }
}

使用案例：

        假设我们有一个控制器类 UserController，其中的一个方法需要返回用户信息。我们可以使用统一返回结果类 ResponseResult 封装返回结果，代码示例如下：

@RestController
@RequestMapping("/user")
public class UserController {

    @Autowired
    private UserService userService;

    @GetMapping("/{id}")
    public ResponseResult getUserById(@PathVariable Long id) {
        UserDTO userDTO = userService.getUserById(id);
        if (userDTO == null) {
            return ResponseResult.error(AppHttpCodeEnum.USER_NOT_FOUND);
        }
        UserVO userVO = UserConverter.convertToUserVO(userDTO);
        return ResponseResult.success(userVO);
    }

}

        在上面的代码中，我们使用了 ResponseResult.success 方法创建了一个成功结果对象，并将返回的用户信息 userVO 作为数据放入结果对象中，最终在控制器层返回这个结果对象。如果查询用户信息失败，就会返回一个状态码为 404 的错误结果对象，并将错误信息放入结果对象中，最终在控制器层返回这个结果对象。

6、统一异常处理

通过编写自定义异常类和异常处理器来实现统一异常处理。具体步骤如下：

        编写自定义异常类：根据应用程序的实际情况，可以定义多种自定义异常类，包括系统异常、业务异常、用户异常等。通常情况下，自定义异常类继承自 Exception 类或         RuntimeException 类，并添加一些自定义的属性和方法。

编写异常处理器：异常处理器是用于处理应用程序中出现的异常的类，可以捕获应用程序中抛出的异常，并根据不同的异常类型进行相应的处理。在处理异常时，可以将异常信息记录到日志文件中，返回友好的错误提示信息给用户。

        统一异常处理：将编写好的异常处理器配置到应用程序中，使其能够对应用程序中出现的所有异常进行统一处理。当应用程序中出现异常时，异常处理器会自动捕获并进行处理，从而避免因为异常而导致应用程序崩溃或无法正常运行。

6.1 编写自定义异常类

public class SystemException extends RuntimeException{

    private int code;

    private String msg;

    public int getCode() {
        return code;
    }

    public String getMsg() {
        return msg;
    }

    public SystemException(AppHttpCodeEnum httpCodeEnum) {
        super(httpCodeEnum.getMsg());
        this.code = httpCodeEnum.getCode();
        this.msg = httpCodeEnum.getMsg();
    }
    
}

 6.2 编写异常处理器

@RestControllerAdvice
@Slf4j
public class GlobalExceptionHandler {

    @ExceptionHandler(SystemException.class)
    public ResponseResult systemExceptionHandler(SystemException e){
        //打印异常信息
        log.error("出现了异常！ {}",e);
        //从异常对象中获取提示信息封装返回
        return ResponseResult.errorResult(e.getCode(),e.getMsg());
    }


    @ExceptionHandler(Exception.class)
    public ResponseResult exceptionHandler(Exception e){
        //打印异常信息
        log.error("出现了异常！ {}",e);
        //从异常对象中获取提示信息封装返回
        return ResponseResult.errorResult(AppHttpCodeEnum.SYSTEM_ERROR.getCode(),e.getMessage());
    }
}

6.3 统一异常处理：

假设我们有一个 UserController 类，其中包含了一个 getUserById 方法，用于根据用户 ID 获取用户信息。如果用户不存在，则抛出一个 SystemException 异常，异常的状态码为 404，提示信息为“用户不存在”。如果发生其他异常，则抛出一个 Exception 异常，异常的状态码为 500，提示信息为“系统异常，请稍后再试”。

下面是一个使用全局异常处理器的示例代码： 

@RestController
@RequestMapping("/user")
public class UserController {

    @Autowired
    private UserService userService;

    @GetMapping("/{id}")
    public ResponseResult getUserById(@PathVariable("id") Long id) {
        User user = userService.getUserById(id);
        if (user == null) {
            throw new SystemException(AppHttpCodeEnum.USER_NOT_EXIST);
        }
        return ResponseResult.successResult(user);
    }
}

 在上述代码中，我们使用了一个自定义的 AppHttpCodeEnum 枚举类，它定义了应用程序中可能出现的 HTTP 状态码和提示信息。在 getUserById 方法中，我们根据用户 ID 获取用户信息，并判断用户是否存在。如果用户不存在，则抛出一个 SystemException 异常，并传入 AppHttpCodeEnum.USER_NOT_EXIST 枚举类来设置异常的状态码和提示信息。如果用户存在，则将用户信息封装到 ResponseResult 对象中返回。

 下面是一个 GlobalExceptionHandler 全局异常处理器的示例代码：

@RestControllerAdvice
@Slf4j
public class GlobalExceptionHandler {

    @ExceptionHandler(SystemException.class)
    public ResponseResult systemExceptionHandler(SystemException e){
        //打印异常信息
        log.error("出现了异常！ {}",e);
        //从异常对象中获取提示信息封装返回
        return ResponseResult.errorResult(e.getCode(),e.getMsg());
    }

    @ExceptionHandler(Exception.class)
    public ResponseResult exceptionHandler(Exception e){
        //打印异常信息
        log.error("出现了异常！ {}",e);
        //从异常对象中获取提示信息封装返回
        return ResponseResult.errorResult(AppHttpCodeEnum.SYSTEM_ERROR.getCode(),e.getMessage());
    }
}

在上述代码中，我们使用了 @RestControllerAdvice 注解来声明一个全局异常处理器，并定义了两个异常处理方法：systemExceptionHandler 和 exceptionHandler。在 systemExceptionHandler 方法中，我们处理 SystemException 异常，从异常对象中获取提示信息并封装返回 ResponseResult 对象。在 exceptionHandler 方法中，我们处理其他异常，并返回一个默认的错误提示信息。 

7、跨域问题

       实现 WebMvcConfigurer 接口，并重写 addCorsMappings 方法，用于配置跨域访问的参数。使用 CorsRegistry 对象来配置跨域参数，包括允许跨域的路径、允许跨域请求的域名、是否允许发送 Cookie、允许的请求方式、允许的请求头、以及跨域允许时间等参数。

@Configuration
public class WebConfig implements WebMvcConfigurer {

    @Override
    public void addCorsMappings(CorsRegistry registry) {
        // 设置允许跨域的路径
        registry.addMapping("/**")
                // 设置允许跨域请求的域名
                .allowedOriginPatterns("*")
                // 是否允许cookie
                .allowCredentials(true)
                // 设置允许的请求方式
                .allowedMethods("GET", "POST", "DELETE", "PUT")
                // 设置允许的header属性
                .allowedHeaders("*")
                // 跨域允许时间
                .maxAge(3600);
    }
}

8、字面值处理

        字面值处理是指将程序中的字面值（如字符串、数字、布尔值等）提取出来作为常量，以便于程序的维护和修改。在 Java 中，可以使用 final 关键字定义常量：

public class TimeUtils {
    
    // 每分钟的秒数常量
    public static final int SECONDS_PER_MINUTE = 60; 
    // 每小时的分钟数常量
    public static final int MINUTES_PER_HOUR = 60; 
    public static final int HOURS_PER_DAY = 24; // 每天的小时数常量
    
    /**
     * 将秒数转换为时分秒格式的字符串
     * @param seconds 秒数
     * @return 时分秒格式的字符串，如 "02:30:05"
     */
    public static String formatSeconds(int seconds) {
        int hours = seconds / (SECONDS_PER_MINUTE * MINUTES_PER_HOUR); // 计算小时数
        int minutes = (seconds % (SECONDS_PER_MINUTE * MINUTES_PER_HOUR)) / SECONDS_PER_MINUTE; // 计算分钟数
        seconds = seconds % SECONDS_PER_MINUTE; // 计算剩余秒数
        return String.format("%02d:%02d:%02d", hours, minutes, seconds); // 格式化输出
    }
    
    /**
     * 将秒数转换为天时分秒格式的字符串
     * @param seconds 秒数
     * @return 天时分秒格式的字符串，如 "1天02:30:05"
     */
    public static String formatSecondsWithDays(int seconds) {
        int days = seconds / (SECONDS_PER_MINUTE * MINUTES_PER_HOUR * HOURS_PER_DAY); // 计算天数
        seconds = seconds % (SECONDS_PER_MINUTE * MINUTES_PER_HOUR * HOURS_PER_DAY); // 计算剩余秒数
        return String.format("%d天%s", days, formatSeconds(seconds)); // 格式化输出
    }
}

9、Bean拷贝工具类封装

 Bean 拷贝工具类的示例，其中包含了两个方法：

        copyBean() 方法：将一个对象的属性值拷贝到另一个对象中，并返回拷贝后的目标对象。
        copyBeanList() 方法：将一个对象列表中的每个对象的属性值拷贝到相应的目标对象中，并返回拷贝后的目标对象列表。

        通过该工具类，我们可以方便地实现对象之间的属性拷贝操作，提高了代码的可重用性和可维护性。同时，通过使用泛型和流式编程的方式，我们可以更加灵活地处理不同类型的对象拷贝，并避免了手动编写循环拷贝的代码。

import org.springframework.beans.BeanUtils;

import java.util.List;
import java.util.stream.Collectors;

public class BeanCopyUtils {

    /**
     * 将源对象的属性值拷贝到目标对象中，并返回拷贝后的目标对象
     * @param source 源对象
     * @param clazz  目标对象的 Class 对象
     * @param     目标对象的类型
     * @return 拷贝后的目标对象
     */
    public static  V copyBean(Object source,Class clazz) {
        //创建目标对象
        V result = null;
        try {
            result = clazz.newInstance();
            //实现属性copy
            BeanUtils.copyProperties(source, result);
        } catch (Exception e) {
            e.printStackTrace();
        }
        //返回结果
        return result;
    }
    
    /**
     * 将源对象列表中的每个对象的属性值拷贝到相应的目标对象中，并返回拷贝后的目标对象列表
     * @param list  源对象列表
     * @param clazz 目标对象的 Class 对象
     * @param    源对象的类型
     * @param    目标对象的类型
     * @return 拷贝后的目标对象列表
     */
    public static  List copyBeanList(List list,Class clazz){
        return list.stream()
                .map(o -> copyBean(o, clazz))
                .collect(Collectors.toList());
    }
}

10、快速生成代码的插件

        EasyCode 是一款基于 IntelliJ IDEA 平台的插件，可以根据数据库表结构和自定义模板来生成 Java、MyBatis、Spring 等多种类型的代码文件。

        Mybatis-X 是一款基于 IntelliJ IDEA 平台的插件，主要用于辅助开发者在使用 MyBatis 进行开发时提高开发效率。它提供了多种功能，包括 SQL 语句智能补全、参数映射智能提示、生成 MyBatis 代码模板、自动生成 Mapper 接口、自动生成 Mapper XML 文件等。

        两种都可以，这里使用EasyCode！使用教程参考EasyCode自动生成代码（超详细）

先配置EasyCode代码模板：

10.1 entity模板

##导入宏定义
$!{define.vm}

##保存文件（宏定义）
#save("/entity", ".java")

##包路径（宏定义）
#setPackageSuffix("entity")

##自动导入包（全局变量）
$!{autoImport.vm}

import java.io.Serializable;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
##表注释（宏定义）
#tableComment("表实体类")
@SuppressWarnings("serial")
@Data
@AllArgsConstructor
@NoArgsConstructor
@TableName("$!{tableInfo.obj.name}")
public class $!{tableInfo.name}  {
#foreach($column in $tableInfo.pkColumn)
    #if(${column.comment})//${column.comment}#end
@TableId
    private $!{tool.getClsNameByFullName($column.type)} $!{column.name};
#end

#foreach($column in $tableInfo.otherColumn)
    #if(${column.comment})//${column.comment}#end

    private $!{tool.getClsNameByFullName($column.type)} $!{column.name};
#end

}

10.2 Mapper

##导入宏定义
$!{define.vm}

##设置表后缀（宏定义）
#setTableSuffix("Mapper")

##保存文件（宏定义）
#save("/mapper", "Mapper.java")

##包路径（宏定义）
#setPackageSuffix("mapper")

import com.baomidou.mybatisplus.core.mapper.BaseMapper;


##表注释（宏定义）
#tableComment("表数据库访问层")
public interface $!{tableName} extends BaseMapper<$!tableInfo.name> {

}

10.3 Service

##导入宏定义
$!{define.vm}

##设置表后缀（宏定义）
#setTableSuffix("Service")

##保存文件（宏定义）
#save("/service", "Service.java")

##包路径（宏定义）
#setPackageSuffix("service")

import com.baomidou.mybatisplus.extension.service.IService;


##表注释（宏定义）
#tableComment("表服务接口")
public interface $!{tableName} extends IService<$!tableInfo.name> {

}

10.4 ServiceImpl

##导入宏定义
$!{define.vm}

##设置表后缀（宏定义）
#setTableSuffix("ServiceImpl")

##保存文件（宏定义）
#save("/service/impl", "ServiceImpl.java")

##包路径（宏定义）
#setPackageSuffix("service.impl")

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.stereotype.Service;

##表注释（宏定义）
#tableComment("表服务实现类")
@Service("$!tool.firstLowerCase($tableInfo.name)Service")
public class $!{tableName} extends ServiceImpl<$!{tableInfo.name}Mapper, $!{tableInfo.name}> implements $!{tableInfo.name}Service {

}

11.在线接口文档

        使用基于 Swagger 的开源的 API 文档管理工具Knife4j ，它可以在开发过程中自动生成文档，提高 API 的可读性和可维护性。

        Spring Boot 整合 Knife4j 的步骤：

11.1 添加依赖

        
        
            io.springfox
            springfox-swagger2
            3.0.0
        
        
        
            io.springfox
            springfox-swagger-ui
            3.0.0
        
        
        
            com.github.xiaoymin
            knife4j-spring-boot-starter
            3.0.3
        

11.2 Knife4jConfig配置类

/**
 * knife4j 配置
 *
 */
@Configuration
@EnableSwagger2
public class Knife4jConfig {

    /**
     * 创建Swagger Docket对象
     * @return Swagger Docket对象
     */
    @Bean
    public Docket createRestApi() {
        return new Docket(DocumentationType.SWAGGER_2)
                .apiInfo(apiInfo())
                .select()
                .apis(RequestHandlerSelectors.basePackage("com.example.demo.SystemCode.controller")) // 扫描的包路径
                .paths(PathSelectors.any())
                .build();
    }

    /**
     * 配置Swagger文档基本信息
     * @return Swagger文档基本信息
     */
    private ApiInfo apiInfo() {
        return new ApiInfoBuilder()
                .title("SpringBoot项目 后台服务API接口文档") // 文档标题
                .description("使用 knife4j 搭建的后台服务API接口文档") // 文档描述
                .termsOfServiceUrl("http://localhost:8080/") // 服务条款url
                .version("1.0.0") // 版本号
                .build();
    }
}

 11.3 使用案例：

        使用 @Api 注解来指定 API 所属的标签，

        使用 @ApiOperation 注解来指定 API 的名称和描述，

        使用 @ApiImplicitParam 注解来指定 API 的参数。

/**
 * 用户表(User)表控制层
 *
 * @author makejava
 * @since 2023-07-04 12:12:26
 */
@RestController
@RequestMapping("user")
@Api(tags = "用户管理")
public class UserController {
    /**
     * 服务对象
     */
    @Resource
    private UserService userService;


    /**
     * 获取用户列表
     */
    @GetMapping("/list")
    @ApiOperation(value = "查询用户信息", notes = "根据传入的用户信息和分页参数查询用户信息")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "user", value = "用户信息", dataType = "User", required = true),
            @ApiImplicitParam(name = "pageNum", value = "页码", dataType = "int", required = true),
            @ApiImplicitParam(name = "pageSize", value = "每页数量", dataType = "int", required = true)
    })
    @ApiResponses({
            @ApiResponse(code = 200, message = "请求成功"),
            @ApiResponse(code = 400, message = "请求参数错误"),
            @ApiResponse(code = 401, message = "未经授权访问"),
            @ApiResponse(code = 403, message = "禁止访问"),
            @ApiResponse(code = 404, message = "请求路径不存在"),
            @ApiResponse(code = 500, message = "服务器内部错误")
    })
    public ResponseResult list(@RequestBody User user, @RequestParam Integer pageNum, @RequestParam Integer pageSize) {
        return userService.selectUserPage(user, pageNum, pageSize);
    }

}

 11.4 访问地址

        启动应用程序：启动应用程序后，在浏览器中输入 http://localhost:port/doc.html，即可查看生成的 API 文档。

12、通用的分页对象

 通用的分页对象通常包含以下属性：

1. pageNum：当前页码，从 1 开始计数。

2. pageSize：每页显示的记录数。

3. total：总记录数。

4. pages：总页数。

5. list：当前页的数据列表。

        一般情况下不需要那么多属性，我们只选择保留【 总记录数】和【list】，pageNum和pageSize 为默认属性。

12.1 新建 PageVo

@Data
@NoArgsConstructor
@AllArgsConstructor
public class PageVo {

    /**
     * 当前页的数据列表
     */
    private List list;

    /**
     * 总记录数
     */
    private Long total;
}

12.2   使用示例

        假设我们有一个 User 实体类，它包含了 id、name 和 age 三个属性。我们需要编写一个分页查询用户信息的方法，并将查询结果封装成 PageVo 对象返回。可以按照以下步骤实现：

        定义一个 UserController 类，包含一个分页查询用户信息的方法：

@RestController
@RequestMapping("/users")
public class UserController {

    @Autowired
    private UserService userService;

    @GetMapping
    public PageVo listUsers(@RequestParam(defaultValue = "1") int pageNum,
                            @RequestParam(defaultValue = "10") int pageSize) {
        Page page = userService.listUsers(pageNum, pageSize);
        return new PageVo(page.getList(), page.getTotal());
    }

}

        在上述代码中，从客户端获取 pageNum 和 pageSize 参数，并调用 UserService 接口的 listUsers 方法查询用户信息。然后将查询结果封装成 PageVo 对象返回给客户端。由于查询结果是一个通用的分页对象，因此我们只需要将 list 和 total 这两个属性赋值给 PageVo 对象即可。

13、统一管理登录日志和操作日志

13.1 引入Spring AOP 依赖

   org.springframework.boot
   spring-boot-starter-aop

13.2 自定义日志注解类

创建一个SysUserLog实体类，用于存储请求日志的各个属性，例如：

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;

import java.time.LocalDateTime;

@TableName("base_user_log")
public class BaseUserLog {

    @TableId(type = IdType.AUTO)
    private Long id;

    @TableField("channel")
    private String channel;

    @TableField("name")
    private String name;

    @TableField("action")
    private String action;

    @TableField("ip")
    private String ip;

    @TableField("method")
    private String method;

    @TableField("param")
    private String param;

    @TableField("create_time")
    private LocalDateTime createTime;

    // getter/setter方法省略
}

 数据库建表语句，该表包含以下列：

• id：日志ID，主键，自增长。
• channel：日志所属的渠道，例如web、app等。
• name：请求的名称，例如登录、注册等。
• action：请求的操作，例如新增、修改、删除等。
• ip：请求的IP地址。
• method：请求的方法，例如GET、POST等。
• param：请求的参数。
• create_time：日志的创建时间。

CREATE TABLE base_user_log (
id BIGINT NOT NULL AUTO_INCREMENT COMMENT '日志ID',
channel VARCHAR(50) COMMENT '日志所属的渠道',
name VARCHAR(50) COMMENT '请求的名称',
action VARCHAR(10) COMMENT '请求的操作',
ip VARCHAR(50) COMMENT '请求的IP地址',
method VARCHAR(10) COMMENT '请求的方法',
param VARCHAR(2000) COMMENT '请求的参数',
create_time TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '日志的创建时间',
PRIMARY KEY (id)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='用户操作日志表';

虚拟出10条数据： 

INSERT INTO base_user_log (channel, name, action, ip, method, param)
VALUES 
('app', 'login', 'POST', '192.168.1.100', 'HTTP', '{"username": "user1", "password": "password1"}'),
('web', 'register', 'POST', '192.168.1.101', 'HTTP', '{"username": "user2", "password": "password2", "email": "[email protected]"}'),
('app', 'logout', 'POST', '192.168.1.102', 'HTTP', '{"username": "user1"}'),
('web', 'reset_password', 'POST', '192.168.1.103', 'HTTP', '{"username": "user2", "new_password": "newpassword2"}'),
('app', 'get_user_info', 'GET', '192.168.1.100', 'HTTP', '{"username": "user1"}'),
('web', 'update_profile', 'PUT', '192.168.1.101', 'HTTP', '{"username": "user2", "email": "[email protected]"}'),
('app', 'search', 'GET', '192.168.1.102', 'HTTP', '{"keywords": "product1"}'),
('web', 'add_to_cart', 'POST', '192.168.1.103', 'HTTP', '{"username": "user2", "product_id": 12345, "quantity": 2}'),
('app', 'checkout', 'POST', '192.168.1.100', 'HTTP', '{"username": "user1", "product_id": 54321, "quantity": 1, "total_price": 100}'),
('web', 'view_order', 'GET', '192.168.1.101', 'HTTP', '{"order_id": 123456}');

13.3 SysUserLogMapper接口

创建一个SysUserLogMapper接口，用于操作数据库，

public interface BaseUserLogMapper extends BaseMapper {

}

在SysUserLogMapper接口中，我们继承了MyBatis-Plus提供的BaseMapper接口，该接口提供了各种常用的数据库操作方法。

13.4 SysUserLogService接口

public interface BaseUserLogService extends IService {

}

 13.5 SysUserLogServiceImpl类

import org.springframework.stereotype.Service;

@Service
public class SysUserLogServiceImpl implements SysUserLogService {

    private final SysUserLogMapper sysUserLogMapper;

    public SysUserLogServiceImpl(SysUserLogMapper sysUserLogMapper) {
        this.sysUserLogMapper = sysUserLogMapper;
    }

    @Override
    public void save(SysUserLog sysUserLog) {
        sysUserLogMapper.insert(sysUserLog);
    }
}

13.6 WebLogAspect切面类

@Component
@Aspect
public class WebLogAspect {

   private static final Logger logger = LoggerFactory.getLogger(WebLogAspect.class);

   private final SysUserLogService sysUserLogService;

   public WebLogAspect(SysUserLogService sysUserLogService) {
      this.sysUserLogService = sysUserLogService;
   }

   /**
    * 连接点（切入点）
    * 切入点表达式：匹配 web包及子包 Controller类的任何公共方法
    */
   @Pointcut("execution(public * com.liyafei.skillset.web..*Controller.*(..))")
   public void webLog() {
   }

   /**
    * 通知：前置通知（Before advice），在连接点之前运行但不能阻止执行流继续到连接点的通知(除非它抛出异常)。
    * 在日志文件或控制台输出请求信息
    * 
    * @param joinPoint
    */
   @Before("webLog()")
   public void doBefore(JoinPoint joinPoint) {

      // 利用RequestContextHolder获取HttpServletRequest对象
      ServletRequestAttributes servletRequestAttributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
      HttpServletRequest httpServletRequest = servletRequestAttributes.getRequest();

      // 重组请求信息
      StringBuffer sb = new StringBuffer();
      sb.append("收到请求：");
      sb.append("\r\n访问URI   ：" + httpServletRequest.getRequestURI().toString());
      sb.append("\r\nSession ：" + httpServletRequest.getSession().getId());
      sb.append("\r\n访问IP    ：" + RequestUtil.getIP(httpServletRequest));
      sb.append("\r\n响应类 ：" + joinPoint.getSignature().getDeclaringTypeName());
      sb.append("\r\n方法     ：" + joinPoint.getSignature().getName());

      Object[] objects = joinPoint.getArgs();
      for (Object arg : objects) {
         if (arg != null) {
            sb.append("\r\n参数     ：" + arg.toString());
         }
      }

      // 打印请求信息
      logger.info(sb.toString());

   }

   /**
    * 通知：后置通知（After returning advice），通知在连接点正常完成后运行
    * 处理请求日志信息
    * 
    * @param joinPoint
    */
   @AfterReturning(pointcut = "webLog()", returning = "rvt")
   public void doAfterReturning(JoinPoint joinPoint, Object rvt) {
      // 处理日志信息
      handleLog(joinPoint, null);
   }

   /**
    * 通知：异常通知（After throwing advice），方法通过抛出异常退出，则要执行的通知
    * 处理请求异常日志信息
    * 
    * @param joinPoint
    * @param e
    */
   @AfterThrowing(pointcut = "webLog()", throwing = "e")
   public void afterThrowing(JoinPoint joinPoint, Exception e) {
      // 处理日志信息
       handleLog(joinPoint, e);
   }

   /**
    * 日志处理
    * 
    * @param joinPoint
    * @param e
    */
   private void handleLog(JoinPoint joinPoint, Exception e) {
      // 利用RequestContextHolder获取HttpServletRequest对象
      ServletRequestAttributes servletRequestAttributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
      HttpServletRequest httpServletRequest = servletRequestAttributes.getRequest();

      // 获取执行的方法
      Signature signature = joinPoint.getSignature();
      if(!(signature instanceof MethodSignature)) {
         throw new IllegalArgumentException("暂不支持非方法注解");
      }
      MethodSignature methodSignature = (MethodSignature) signature;
      Method method = methodSignature.getMethod();

      if (method != null) {
         // 获取注解
         WebLog controllerLog = method.getAnnotation(WebLog.class);

         if (controllerLog != null) {

            // 保存日志到数据库
            if (controllerLog.saveFlag()) {
               SysUserLog sysUserLog = new SysUserLog();
               // SessionId
               sysUserLog.setAccount(httpServletRequest.getRequestedSessionId());
               // 渠道
               sysUserLog.setChannel(controllerLog.channel());
               // 功能名称
               sysUserLog.setName(controllerLog.name());
               // 响应类.方法
               sysUserLog.setAction(signature.getDeclaringTypeName() + "." + method.getName());
               // URI
               sysUserLog.setUrl(httpServletRequest.getRequestURI());
               // 参数
               sysUserLog.setParams(JSONObject.toJSONString(httpServletRequest.getParameterMap()).replace("\"", ""));
               // 请求IP
               sysUserLog.setIp(RequestUtil.getIP(httpServletRequest));
               // 操作时间
               sysUserLog.setLogTime(new Date());

               // 异常信息
               if (e != null) {
                  sysUserLog.setErrMsg(e.getMessage());
               }

               sysUserLogService.insert(sysUserLog);

            }
         }
      }

      // 发生异常时打印错误信息
      if (e != null) {
         StringBuffer sb = new StringBuffer();
         sb.append("时间：");
         sb.append(DateFormat.getDateTimeInstance().format(new Date()));
         sb.append("方法：");
         sb.append(joinPoint.getSignature() + "\n");
         sb.append("异常信息：" + e.getMessage());

         logger.error(sb.toString());
      }

   }
}

13.7  Controller 请求处理层添加注解

/**
 * 系统用户 列表页
 *
 * @param sysUserCriteria
 * @param model
 * @return
 */
@WebLog(channel = "web", name = "系统用户列表", action = "/sysUser", saveFlag = true)
@GetMapping("")
public String list(SysUserCriteria sysUserCriteria, Model model) {
   model.addAttribute("sysUserCriteria", sysUserCriteria);
   return "sysUser/list";
}

【知识点】

1、HTTP 响应状态码

        HTTP 响应状态码是在服务器接收到 HTTP 请求之后，向客户端返回的一个三位数字的状态码。它表示了服务器处理请求的结果，以及客户端应该如何处理这个响应。

常见的 HTTP 响应状态码有以下几种：

1xx（信息性状态码）：表示服务器已接收到请求，正在处理中，需要一些时间来完成处理。

2xx（成功状态码）：表示服务器已成功处理请求，返回的数据正常。

3xx（重定向状态码）：表示需要客户端进一步处理，才能完成请求。

4xx（客户端错误状态码）：表示客户端请求有错误，服务器无法处理请求。

5xx（服务器错误状态码）：表示服务器在处理请求时发生了错误。

以下是常见的 HTTP 响应状态码及其含义：

200 OK：请求成功，服务器正常返回所需信息。

201 Created：请求成功，服务器已创建新资源。

204 No Content：请求成功，但服务器没有返回任何数据。

301 Moved Permanently：请求的资源已被永久移动到新的 URL，客户端应该使用新 URL 发起请求。

302 Found：请求的资源已被临时移动到新的 URL，客户端应该使用新 URL 发起请求。

304 Not Modified：客户端请求的资源未被修改，服务器返回该响应表示客户端可以使用缓存的版本。

400 Bad Request：请求出现语法错误。

401 Unauthorized：客户端未经过身份验证，无法访问该资源。

403 Forbidden：客户端已经经过身份验证，但是没有权限访问该资源。

404 Not Found：请求的资源不存在。

500 Internal Server Error：服务器在处理请求时发生了未知错误。

502 Bad Gateway：服务器作为网关或代理，从上游服务器收到无效响应。

503 Service Unavailable：服务器暂时无法处理请求，通常是由于服务器过载或停机维护。

504 Gateway Timeout：服务器作为网关或代理，无法从上游服务器收到及时响应。

2、当Spring Boot 2.6.x 和Swagger 3.0.0 整合的时候会报错

这是因为Springfox使用的路径匹配是基于AntPathMatcher的，而Spring Boot 2.6.X使用的是PathPatternMatcher。

解决：在application.properties里配置：

spring.mvc.pathmatch.matching-strategy=ANT_PATH_MATCHER

或yml配置：
spring:
  mvc:
    pathmatch:
      matching-strategy: ant_path_matcher