Java 项目创建 -- 统一结果处理、统一异常处理、统一日志处理

一、IDEA 插件使用

1、说明

　　此处使用 SpringBoot 2.2.6 、JDK 1.8 、mysql 8.0.18 作为演示。

　　使用 IDEA 作为开发工具。

2、IDEA 插件 -- Lombok

（1）简介
　　Lombok 能通过注解的方式，在编译时自动为属性生成构造器、getter/setter、equals、hashcode、toString 等方法。
　　比如在实体类上使用 @Data 注解，就可以省去 getter、 setter 等方法的编写，但是在编译生成的字节码文件中有getter和setter方法。

（2）安装

　　Settings -> Plugins，搜索 Lombok。点击 install 安装后重启 IDEA 即可。

（3）使用

Step1：
　　使用 maven 添加依赖，引入对应的 jar 包。

<!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.18.12</version>
</dependency>

Step2：
　　使用各种注解，简化代码编写。比如 @Data。

3、IDEA 插件 -- Easy Code

（1）简介
　　Easy Code 是 IDEA 的一个插件，可以直接对数据的表生成 entity, controller, service, dao, mapper 等代码，无需任何编码，简单而强大。

（2）安装

　　Settings -> Plugins，搜索 EasyCode。点击 install 安装后重启 IDEA 即可。

（3）使用
Step1：
　　创建一个 SpringBoot 项目。

Step2：
　　连接数据库，并创建一个 数据表，用于测试。

DROP DATABASE IF EXISTS test;

CREATE DATABASE test;

USE test;

CREATE TABLE emp(
    id int PRIMARY KEY auto_increment,
    name varchar(50),
    salary decimal(10, 2),
    age int,
    email varchar(50)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

INSERT INTO emp VALUES(null, "tom", 6000, 20, "tom@163.com");

Step3：
　　右键表名，选择 EasyCode -> Generate Code，生成代码。

选择代码生成的路径 以及 包名。

自动创建需要的文件。

Step4：
　　当然这样并不能直接使用，还得添加相关依赖、注解、以及数据库连接信息才能使用。
添加依赖：
　　比如： lombok、mybatis-plus、mysql-connector-java 以及 web 启动类。

<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.18.12</version>
    <scope>provided</scope>
</dependency>

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

<!-- https://mvnrepository.com/artifact/com.baomidou/mybatis-plus-boot-starter -->
<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-boot-starter</artifactId>
    <version>3.3.1</version>
</dependency>

<!-- mysql -->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.18</version>
</dependency>

添加注解：
　　dao 层添加 @Mapper 注解，或者在启动类上添加 @MapperScan 注解扫描 dao 层。
　　entity 上可以添加 @Data 注解，用于简化 getter、setter 方法。

配置 yml 文件:

# 配置数据源
spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    username: root
    password: 123456
    url: jdbc:mysql://localhost:3306/test

# 配置 mybatis-plus
mybatis-plus:
  mapper-location: classpath:/mapper/**/*.xml
  global-config:
    db-config:
      id-type: auto

Step5：启动项目，并访问 controller

4、使用 mybatis-plus 代码生成器生成代码

mybatis-plus 代码生成器：
    https://www.cnblogs.com/l-y-h/p/12859477.html#_label1_2

二、Java 项目构建 -- 统一结果处理

1、为什么使用统一结果？

　　大部分前后端项目采用 JSON 格式进行数据交互，定义一个统一的数据规范，有利于前后台的交互、以及信息处理。

2、数据格式？如何处理？代码实现？

（1）数据格式？
　　是否响应成功（success： true / false）
　　响应状态码（code：200 / 400 / 500 等）
　　状态码描述（message：访问成功 / 系统异常等）
　　响应数据（data：处理的数据）

【输出格式如下所示：】

{
  "success": true,
  "code": 200,
  "message": "查询用户列表",
  "data": {
    "itms": [
      {
        "id": "1",
        "username": "admin",
        "role": "ADMIN",
        "createTime": "2020-4-24T15:32:29",
        "modifiedTime": "2020-4-24T15:41:40"
      },{
        "id": "2",
        "username": "zhangsan",
        "role": "USER",
        "createTime": "2020-4-24T15:32:29",
        "modifiedTime": "2020-4-24T15:41:40"
      }
    ]
  }
}

（2）如何处理？
　　success 设置成 Boolean 类型。
　　code 设置成 Integer 类型。　　
　　message 设置成 String 类型。
　　data 设置成 HashMap 类型。
　　构造器私有，且使用静态方法返回类对象。
　　采用链式调用（即方法返回对象为其本身，return this）。

（3）代码实现？
　　Step1：创建一个 统一结果处理类 Result 。

【代码实现如下：】

package com.lyh.common.util;

import lombok.Data;
import org.apache.http.HttpStatus;

import java.util.HashMap;
import java.util.Map;

/**
 * 统一结果返回类。方法采用链式调用的写法（即返回类本身 return this）。
 * 构造器私有，不允许进行实例化，但提供静态方法 ok、error 返回一个实例。
 * 静态方法说明：
 *      ok     返回一个 成功操作 的结果（实例对象）。
 *      error  返回一个 失败操作 的结果（实例对象）。
 *
 * 普通方法说明：
 *      success      用于自定义响应是否成功
 *      code         用于自定义响应状态码
 *      message      用于自定义响应消息
 *      data         用于自定义响应数据
 *
 * 依赖信息说明：
 *      此处使用 @Data 注解，需导入 lombok 相关依赖文件。
 *      使用 HttpStatus 的常量表示 响应状态码，需导入 httpcore 相关依赖文件。
 */
@Data
public class Result {
    /**
     * 响应是否成功，true 为成功，false 为失败
     */
    private Boolean success;

    /**
     * 响应状态码， 200 成功，500 系统异常
     */
    private Integer code;

    /**
     * 响应消息
     */
    private String message;

    /**
     * 响应数据
     */
    private Map<String, Object> data = new HashMap<>();

    /**
     * 默认私有构造器
     */
    private Result(){}

    /**
     * 私有自定义构造器
     * @param success 响应是否成功
     * @param code 响应状态码
     * @param message 响应消息
     */
    private Result(Boolean success, Integer code, String message){
        this.success = success;
        this.code = code;
        this.message = message;
    }

    /**
     * 返回一个默认的 成功操作 的结果，默认响应状态码 200
     * @return 成功操作的实例对象
     */
    public static Result ok() {
        return new Result(true, HttpStatus.SC_OK, "success");
    }

    /**
     * 返回一个自定义 成功操作 的结果
     * @param success 响应是否成功
     * @param code 响应状态码
     * @param message 响应消息
     * @return 成功操作的实例对象
     */
    public static Result ok(Boolean success, Integer code, String message) {
        return new Result(success, code, message);
    }

    /**
     * 返回一个默认的 失败操作 的结果，默认响应状态码为 500
     * @return 失败操作的实例对象
     */
    public static Result error() {
        return new Result(false, HttpStatus.SC_INTERNAL_SERVER_ERROR, "error");
    }

    /**
     * 返回一个自定义 失败操作 的结果
     * @param success 响应是否成功
     * @param code 响应状态码
     * @param message 相应消息
     * @return 失败操作的实例对象
     */
    public static Result error(Boolean success, Integer code, String message) {
        return new Result(success, code, message);
    }

    /**
     * 自定义响应是否成功
     * @param success 响应是否成功
     * @return 当前实例对象
     */
    public Result success(Boolean success) {
        this.setSuccess(success);
        return this;
    }

    /**
     * 自定义响应状态码
     * @param code 响应状态码
     * @return 当前实例对象
     */
    public Result code(Integer code) {
        this.setCode(code);
        return this;
    }

    /**
     * 自定义响应消息
     * @param message 响应消息
     * @return 当前实例对象
     */
    public Result message(String message) {
        this.setMessage(message);
        return this;
    }

    /**
     * 自定义响应数据，一次设置一个 map 集合
     * @param map 响应数据
     * @return 当前实例对象
     */
    public Result data(Map<String, Object> map) {
        this.data.putAll(map);
        return this;
    }

    /**
     * 通用设置响应数据，一次设置一个 key - value 键值对
     * @param key 键
     * @param value 数据
     * @return 当前实例对象
     */
    public Result data(String key, Object value) {
        this.data.put(key, value);
        return this;
    }
}

Step2：依赖信息

<dependency>
    <groupId>org.apache.httpcomponents</groupId>
    <artifactId>httpcore</artifactId>
    <version>4.4.13</version>
</dependency>

<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.18.12</version>
    <scope>provided</scope>
</dependency>

Step3：HttpStatus 状态码参考地址

http://hc.apache.org/httpcomponents-core-ga/httpcore/apidocs/org/apache/http/HttpStatus.html

（4）使用：
　　修改某个 controller 如下所示：
　　若查询用户成功，调用 ok 返回查询到的结果。
　　若查询用户失败，调用 error 返回查询失败信息。

@GetMapping("selectOne")
public Result selectOne(Integer id) {
    Emp emp = this.empService.queryById(id);
    if (emp == null) {
        return Result.error().message("用户不存在");
    }
    return Result.ok().data("items", emp).message("查询成功");
}

启动服务并访问：
　　测试查询用户不成功的返回结果：

{
    "success": false,
    "code": 500,
    "message": "用户不存在",
    "data": {}
}

　　测试查询用户成功的返回结果：

{
    "success": true,
    "code": 200,
    "message": "查询成功",
    "data": {
        "items": {
            "id": 1,
            "name": "tom",
            "salary": 6000.0,
            "age": 20,
            "email": "tom@163.com"
        }
    }
}

三、Java 项目构建 -- 统一异常处理

1、为什么使用统一异常处理？

　　使用统一结果处理时，有些异常我们可以提前预知并处理，但是一个运行时异常，我们不一定能预知并处理，这时可以使用统一异常处理，当异常发生时，触发该处理操作，从而保证程序的健壮性。

2、怎么做？如何处理？代码实现？

（1）怎么做？
　　使用 @ControllerAdvice 或者 @RestControllerAdvice 注解作为统一异常处理的核心。
　　这两个注解都是 Spring MVC 提供的。作用于 控制层 的一种切面通知。
功能：
　　全局异常处理。
　　全局数据绑定。
　　全局数据预处理。

【@ControllerAdvice 与 @RestControllerAdvice 区别：】
    @RestControllerAdvice 注解包含了 @ControllerAdvice 与 @ResponseBody 注解。
    类似于 @Controller 与 @RestController 的区别。
    @RestControllerAdvice 返回 json 数据时不需要添加 @ResponseBody 注解。

（2）如何处理？
　　使用 @ControllerAdvice 或者 @RestControllerAdvice 注解标记一个 全局异常处理类。
　　全局异常处理类内部使用 @ExceptionHandler 注解去捕获异常。
　　可以自定义一个异常信息收集类，用于处理项目中的异常，并收集异常信息。

（3）代码实现？
　　Step1（可选操作）：
　　　　自定义一个异常类，用于处理项目中的异常，并收集异常信息。

【代码实现：】

package com.lyh.common.exception;

import lombok.Data;
import org.apache.http.HttpStatus;

/**
 * 自定义异常，
 * 可以自定义 异常信息 message 以及 响应状态码 code（默认为 500）。
 *
 * 依赖信息说明：
 *      此处使用 @Data 注解，需导入 lombok 相关依赖文件。
 *      使用 HttpStatus 的常量表示 响应状态码，需导入 httpcore 相关依赖文件。
 */
@Data
public class GlobalException extends RuntimeException {
    /**
     * 保存异常信息
     */
    private String message;

    /**
     * 保存响应状态码
     */
    private Integer code = HttpStatus.SC_INTERNAL_SERVER_ERROR;

    /**
     * 默认构造方法，根据异常信息 构建一个异常实例对象
     * @param message 异常信息
     */
    public GlobalException(String message) {
        super(message);
        this.message = message;
    }

    /**
     * 根据异常信息、响应状态码构建 一个异常实例对象
     * @param message 异常信息
     * @param code 响应状态码
     */
    public GlobalException(String message, Integer code) {
        super(message);
        this.message = message;
        this.code = code;
    }

    /**
     * 根据异常信息，异常对象构建 一个异常实例对象
     * @param message 异常信息
     * @param e 异常对象
     */
    public GlobalException(String message, Throwable e) {
        super(message, e);
        this.message = message;
    }

    /**
     * 根据异常信息，响应状态码，异常对象构建 一个异常实例对象
     * @param message 异常信息
     * @param code 响应状态码
     * @param e 异常对象
     */
    public GlobalException(String message, Integer code, Throwable e) {
        super(message, e);
        this.message = message;
        this.code = code;
    }
}

Step2：
　　定义一个全局的异常处理类 GlobalExceptionHandler。
　　使用 @RestControllerAdvice 注解标记这个类。
　　内部使用 @ExceptionHandler 注解去捕获异常。

【代码实现：】

package com.lyh.common.exception;

import com.lyh.common.util.Result;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;

/**
 * 全局异常处理类。
 * 使用 slf4j 保存日志信息。
 * 此处使用了 统一结果处理 类 Result 用于包装异常信息。
 */
@RestControllerAdvice
public class GlobalExceptionHandler {
    private Logger logger = LoggerFactory.getLogger(getClass());

    /**
     * 处理 Exception 异常
     * @param e 异常
     * @return 处理结果
     */
    @ExceptionHandler(Exception.class)
    public Result handlerException(Exception e) {
        logger.error(e.getMessage(), e);
        return Result.error().message("系统异常");
    }

    /**
     * 处理空指针异常
     * @param e 异常
     * @return 处理结果
     */
    @ExceptionHandler(NullPointerException.class)
    public Result handlerNullPointerException(NullPointerException e) {
        logger.error(e.getMessage(), e);
        return Result.error().message("空指针异常");
    }

    /**
     * 处理自定义异常
     * @param e 异常
     * @return 处理结果
     */
    @ExceptionHandler(GlobalException.class)
    public Result handlerGlobalException(GlobalException e) {
        logger.error(e.getMessage(), e);
        return Result.error().message(e.getMessage()).code(e.getCode());
    }
}

（4）使用？
　　修改某个 controller 如下所示：
　　参数不存在时，抛出 空指针异常。
　　参数为 -1 时，抛出自定义异常并处理。
　　查询结果为 null 时，抛出自定义异常并处理。
　　查询成功时，正确处理并返回。

@GetMapping("selectOne")
public Result selectOne(Integer id) {
    Emp emp = this.empService.queryById(id);
    if (id == null) {
        throw new NullPointerException();
    }
    if (id == -1) {
        throw new GlobalException("参数异常", 400);
    }
    if (emp == null) {
        throw new GlobalException("未查询到结果，请确认输入是否正确");
    }
    return Result.ok().data("items", emp).message("查询成功");
}

启动服务并访问：
　　参数不存在时：

{
    "success": false,
    "code": 500,
    "message": "空指针异常",
    "data": {}
}

　　参数存在，但为 -1 时：

{
    "success": false,
    "code": 400,
    "message": "参数异常",
    "data": {}
}

　　参数存在，但查询结果为 null 时：

{
    "success": false,
    "code": 500,
    "message": "未查询到结果，请确认输入是否正确",
    "data": {}
}

　　参数存在，查询结果存在时：

{
    "success": true,
    "code": 200,
    "message": "查询成功",
    "data": {
        "items": {
            "id": 1,
            "name": "tom",
            "salary": 6000.0,
            "age": 20,
            "email": "tom@163.com"
        }
    }
}

四、Java 项目构建 -- 统一日志处理

1、为什么使用统一日志处理？

　　实际开发中，经常遇到各种各样的问题，使用日志可以方便、快速定位到错误处，便于程序调试。

2、简单介绍？如何处理？实现？

（1）简单介绍
　　此处使用 logback 进行日志处理（是 SpringBoot 内置日志框架）。其与 log4j 类似。
　　日志级别从低到高分为TRACE < DEBUG < INFO < WARN < ERROR < FATAL，如果设置为WARN，则低于WARN的信息都不会输出

（2）如何处理？
　　一般通过 logback-spring.xml （放在 resources 目录下）作为 日志的配置文件。
　　默认情况下，日志输出到控制台，若想输出到文件中，可以简单的配置一下。

简单了解一下 logback-spring.xml 的常用标签信息。

【configuration】
    <configuration> </configuration> 是 logback-spring.xml 最外层标签（基本结构），
    其内部包含
         <contextName></contextName> 用于定义 logger 上下文名称，
         <property></property> 用于定义变量值，通过 ${} 引用变量，
         <appender></appender> 用于格式化日志并指定输出位置（控制台、文件），
         <springProfile></springProfile> 用于定义不同环境的日志（test、dev、prod），
         <root></root> 用于定义基本的日志输出级别。
         <logger></logger> 用于定义某个包、或类具体的日志输出级别。
         等标签。

Step1：了解一下 <property></property> 标签
　　property 用于定义变量值，可以通过 ${} 引用变量。
其中：
　　name 用于定义变量名。
　　value 用于定义变量值。
如下例：
　　log.path 用于定义文件输出路径。
　　CONSOLE_LOG_PATTERN 用于定义文件输出格式。
　　使用 ${log.path }、${CONSOLE_LOG_PATTERN} 即可获取到变量值。

<property name="log.path" value="E:/myProject/log" />
<property name="CONSOLE_LOG_PATTERN" value="%yellow(%date{yyyy-MM-dd HH:mm:ss}) |%highlight(%-5level) |%blue(%thread) |%blue(%file:%line) |%green(%logger) |%cyan(%msg%n)"/>

Step2：了解一下 <appender></appender> 标签
　　appender 用于格式化日志并指定输出位置（控制台、文件）。
其中：
　　ConsoleAppender 用于输出到控制台。
　　RollingFileAppender 用于输出到文件。
如下例：
　　日志输出到控制台，
　　name 属性用于指定 appender 名，后续可以通过 <appender-ref> 引用。
　　class 属性用于指定日志生成策略， ConsoleAppender 为控制台输出策略。
　　filter 标签用于过滤日志输出，如下，过滤掉低于 debug 级别的日志。
　　encoder 用于定义日志的编码格式，可以设置输出样式、字符集等。

<!--1. 输出到控制台-->
<appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
    <!--此日志appender是为开发使用，只配置最底级别，控制台输出的日志级别是大于或等于此级别的日志信息-->
    <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
        <level>debug</level>
    </filter>
    <encoder>
        <Pattern>${CONSOLE_LOG_PATTERN}</Pattern>
        <!-- 设置字符集 -->
        <charset>UTF-8</charset>
    </encoder>
</appender>

如下例：
　　日志输出到文件。
　　RollingFileAppender 为文件输出策略。
　　file 标签用于指定文件输出路径。
　　rollingPolicy 标签用于日志的处理（归档、切割、过期时间等）。

<!-- 2.2 level为 INFO 日志，时间滚动输出  -->
<appender name="INFO_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
    <!-- 正在记录的日志文档的路径及文档名 -->
    <file>${log.path}/info.log</file>
    <!--日志文档输出格式-->
    <encoder>
        <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
        <charset>UTF-8</charset>
    </encoder>
    <!-- 日志记录器的滚动策略，按日期，按大小记录 -->
    <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
        <!-- 每天日志归档路径以及格式 -->
        <fileNamePattern>${log.path}/web-info-%d{yyyy-MM-dd}.%i.log</fileNamePattern>
        <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
            <maxFileSize>100MB</maxFileSize>
        </timeBasedFileNamingAndTriggeringPolicy>
        <!--日志文档保留天数-->
        <maxHistory>15</maxHistory>
    </rollingPolicy>
    <!-- 此日志文档只记录info级别的 -->
    <filter class="ch.qos.logback.classic.filter.LevelFilter">
        <level>info</level>
        <onMatch>ACCEPT</onMatch>
        <onMismatch>DENY</onMismatch>
    </filter>
</appender>

Step3：了解一下 <root></root> 标签
　　root 用于定义基本的日志输出级别。
其中：
　　level 属性用于指定日志输出级别。
　　appender-ref 用于引用 <appender> 标签定义的内容。

<root level="INFO">
    <appender-ref ref="CONSOLE" />
    <appender-ref ref="INFO_FILE" />
</root>

Step4：了解一下 <logger></logger> 标签
　　用于定义某个包、或类具体的日志输出级别。
其中：
　　name 属性用于指定 某个包或者具体的某个类。
　　level 属性用于定义日志输出级别。

<logger name="com.lyh.test" level="INFO" />

Step5：了解一下 <springProfile></springProfile> 标签
　　用于定义不同环境下的日志输出。
其中：
　　name 属性用于指定环境（test、dev、prod）。
　　SpringBoot 中可以通过 yml 或者 properties 指定环境：

spring:
  profiles:
    active: dev

如下例：
　　为开发环境以及生产环境的不同日志输出处理方式。
　　开发环境（dev）下，可以在控制台输出。
　　生产环境（prod）下，只能输出到文件。

 <!--开发环境:打印控制台-->
<springProfile name="dev">
    <logger name="com.lyh.test" level="INFO" />
    <root level="INFO">
        <appender-ref ref="CONSOLE" />
        <appender-ref ref="INFO_FILE" />
        <appender-ref ref="WARN_FILE" />
        <appender-ref ref="ERROR_FILE" />
    </root>
</springProfile>

<!--生产环境:输出到文件-->
<springProfile name="prod">
    <root level="INFO">
        <appender-ref ref="ERROR_FILE" />
        <appender-ref ref="WARN_FILE" />
    </root>
</springProfile>

（3）实现？
Step1:
　　logback-spring.xml 完整配置如下（需要做些适当修改）。

<?xml version="1.0" encoding="UTF-8"?>
<!-- 日志级别从低到高分为TRACE < DEBUG < INFO < WARN < ERROR < FATAL，如果设置为WARN，则低于WARN的信息都不会输出 -->
<!-- scan:当此属性设置为true时，配置文档如果发生改变，将会被重新加载，默认值为true -->
<!-- scanPeriod:设置监测配置文档是否有修改的时间间隔，如果没有给出时间单位，默认单位是毫秒。
                 当scan为true时，此属性生效。默认的时间间隔为1分钟。-->
<!-- debug:当此属性设置为true时，将打印出logback内部日志信息，实时查看logback运行状态。默认值为false。-->
<configuration scan="true" scanPeriod="10 seconds">
    <!-- Step1（可选）：定义 logger 上下文名称 -->
    <contextName>logback</contextName>

    <!-- Step2（可选）：定义变量 -->
    <!-- name的值是变量的名称，value的值时变量定义的值。通过定义的值会被插入到logger上下文中。
         定义变量后，可以使 "${}" 来使用变量。 -->
    <!-- Step2.1 定义文件输出路径 -->
    <!-- 若项目部署到 linux 服务器上，此处路径必须得改 -->
    <!-- <property name="log.path" value="E:/myProject/log"/> -->
    <!-- 将日志文件输出到 当前目录下的 log 文件夹 -->
    <property name="log.path" value="src/log"/>

    <!-- Step2.2 定义彩色日志以及日志输出格式 -->
    <!-- 配置格式变量：CONSOLE_LOG_PATTERN 彩色日志格式 -->
    <property name="CONSOLE_LOG_PATTERN"
              value="%yellow(%date{yyyy-MM-dd HH:mm:ss}) |%highlight(%-5level) |%blue(%thread) |%blue(%file:%line) |%green(%logger) |%cyan(%msg%n)"/>

    <!-- Step3：定义日志输出位置 -->
    <!-- Step3.1 定义日志输出：输出到控制台 -->
    <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
        <!--此日志 appender 是为开发使用，只配置最底级别，控制台输出的日志级别是大于或等于此级别的日志信息-->
        <!-- 例如：如果此处配置了 INFO 级别，则后面其他位置即使配置了 DEBUG 级别的日志，也不会被输出 -->
        <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
            <level>DEBUG</level>
        </filter>
        <encoder>
            <Pattern>${CONSOLE_LOG_PATTERN}</Pattern>
            <!-- 设置字符集 -->
            <charset>UTF-8</charset>
        </encoder>
    </appender>

    <!-- Step3.2 定义日志输出：输出到文件 -->
    <!-- Step3.2.1 level为 DEBUG 日志，时间滚动输出  -->
    <appender name="DEBUG_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <!-- 正在记录的日志文档的路径及文档名 -->
        <file>${log.path}/debug.log</file>
        <!--日志文档输出格式-->
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
            <charset>UTF-8</charset> <!-- 设置字符集 -->
        </encoder>
        <!-- 日志记录器的滚动策略，按日期，按大小记录 -->
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <!-- 日志归档 -->
            <fileNamePattern>${log.path}/debug-%d{yyyy-MM-dd}.%i.log</fileNamePattern>
            <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                <maxFileSize>100MB</maxFileSize>
            </timeBasedFileNamingAndTriggeringPolicy>
            <!--日志文档保留天数-->
            <maxHistory>15</maxHistory>
        </rollingPolicy>
        <!-- 此日志文档只记录debug级别的 -->
        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <level>debug</level>
            <onMatch>ACCEPT</onMatch>
            <onMismatch>DENY</onMismatch>
        </filter>
    </appender>

    <!-- Step3.2.2 level为 INFO 日志，时间滚动输出  -->
    <appender name="INFO_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <!-- 正在记录的日志文档的路径及文档名 -->
        <file>${log.path}/info.log</file>
        <!--日志文档输出格式-->
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
            <charset>UTF-8</charset>
        </encoder>
        <!-- 日志记录器的滚动策略，按日期，按大小记录 -->
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <!-- 每天日志归档路径以及格式 -->
            <fileNamePattern>${log.path}/info-%d{yyyy-MM-dd}.%i.log</fileNamePattern>
            <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                <maxFileSize>100MB</maxFileSize>
            </timeBasedFileNamingAndTriggeringPolicy>
            <!--日志文档保留天数-->
            <maxHistory>15</maxHistory>
        </rollingPolicy>
        <!-- 此日志文档只记录info级别的 -->
        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <level>info</level>
            <onMatch>ACCEPT</onMatch>
            <onMismatch>DENY</onMismatch>
        </filter>
    </appender>

    <!-- Step3.2.3 level为 WARN 日志，时间滚动输出  -->
    <appender name="WARN_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <!-- 正在记录的日志文档的路径及文档名 -->
        <file>${log.path}/warn.log</file>
        <!--日志文档输出格式-->
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
            <charset>UTF-8</charset> <!-- 此处设置字符集 -->
        </encoder>
        <!-- 日志记录器的滚动策略，按日期，按大小记录 -->
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <fileNamePattern>${log.path}/warn-%d{yyyy-MM-dd}.%i.log</fileNamePattern>
            <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                <maxFileSize>100MB</maxFileSize>
            </timeBasedFileNamingAndTriggeringPolicy>
            <!--日志文档保留天数-->
            <maxHistory>15</maxHistory>
        </rollingPolicy>
        <!-- 此日志文档只记录warn级别的 -->
        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <level>warn</level>
            <onMatch>ACCEPT</onMatch>
            <onMismatch>DENY</onMismatch>
        </filter>
    </appender>

    <!-- Step3.2.4 level为 ERROR 日志，时间滚动输出  -->
    <appender name="ERROR_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <!-- 正在记录的日志文档的路径及文档名 -->
        <file>${log.path}/error.log</file>
        <!--日志文档输出格式-->
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
            <charset>UTF-8</charset> <!-- 此处设置字符集 -->
        </encoder>
        <!-- 日志记录器的滚动策略，按日期，按大小记录 -->
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <fileNamePattern>${log.path}/error-%d{yyyy-MM-dd}.%i.log</fileNamePattern>
            <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                <maxFileSize>100MB</maxFileSize>
            </timeBasedFileNamingAndTriggeringPolicy>
            <!--日志文档保留天数-->
            <maxHistory>15</maxHistory>
        </rollingPolicy>
        <!-- 此日志文档只记录ERROR级别的 -->
        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <level>ERROR</level>
            <onMatch>ACCEPT</onMatch>
            <onMismatch>DENY</onMismatch>
        </filter>
    </appender>

    <!-- Step4：配置不同环境下的日志输出 -->
    <!-- Step4.1 开发环境:打印到控制台-->
    <springProfile name="dev">
        <!-- <logger> 用来设置某一个包或者具体的某一个类的日志打印级别
            <logger name="com.lyh" level="INFO"/>
         -->
        <!-- 若想打印 sql 语句，可以指定包，并指定日志级别为 debug -->
        <logger name="com.lyh.test.test_mybatis_plus" level="DEBUG"/>

        <!-- root 用来指定最基础的日志输出级别 -->
        <root level="INFO">
            <appender-ref ref="CONSOLE"/>
            <appender-ref ref="DEBUG_FILE"/>
            <appender-ref ref="INFO_FILE"/>
            <appender-ref ref="WARN_FILE"/>
            <appender-ref ref="ERROR_FILE"/>
        </root>
    </springProfile>

    <!-- Step4.2 生产环境:输出到文档-->
    <springProfile name="prod">
        <logger name="com.lyh" level="WARN"/>
        <root level="INFO">
            <appender-ref ref="ERROR_FILE"/>
            <appender-ref ref="WARN_FILE"/>
        </root>
    </springProfile>
</configuration>

需要修改的地方如下，其余的根据项目情况进行修改。

【修改一：】
// 指定日志输出路径（log.path 相关的地方都可以视情况修改）
<property name="log.path" value="E:/myProject/log"/> <!-- 输出到指定的文件夹下 -->
<property name="log.path" value="src/log"/> <!-- 输出到当前项目下 -->

【修改二：】
// 使用 logger 指定包的地方，根据项目实际的包名进行修改
<logger name="com.lyh.test.test_mybatis_plus" level="DEBUG"/>

Step2：
　　一般日志会与异常处理相结合。
　　前面已经介绍了全局异常处理，在异常处理类中进行相关日志处理，即可。

【全局异常处理：】
    https://www.cnblogs.com/l-y-h/p/12781586.html#_label2

　　可以自定义一个异常信息处理工具类（可选操作），将堆栈信息转为 String 类型。

【可以自定义一个异常信息处理工具类：（可选操作，ExceptionUtil）】

import lombok.extern.slf4j.Slf4j;

import java.io.IOException;
import java.io.PrintWriter;
import java.io.StringWriter;

/**
 * 异常处理工具类，将异常堆栈信息转为 String 类型
 */
@Slf4j
public class ExceptionUtil {
    public static String getMessage(Exception e) {
        String message = null;
        try(StringWriter sw = new StringWriter(); PrintWriter pw = new PrintWriter(sw)) {
            e.printStackTrace(pw);
            pw.flush();
            sw.flush();
            message = sw.toString();
        }catch (IOException io) {
            io.printStackTrace();
            log.error(io.getMessage());
        }
        return message;
    }
}

修改统一异常处理工具类（GlobalExceptionHandler）。
使用 @Slf4j 标注类。
使用 log.error() 打印日志信息。

import com.lyh.test.test_mybatis_plus.util.Result;
import lombok.extern.slf4j.Slf4j;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;

/**
 * 全局异常处理类。
 * 使用 slf4j 保存日志信息。
 * 此处使用了 统一结果处理 类 Result 用于包装异常信息。
 */
@RestControllerAdvice
@Slf4j
public class GlobalExceptionHandler {
    /**
     * 处理 Exception 异常
     * @param e 异常
     * @return 处理结果
     */
    @ExceptionHandler(Exception.class)
    public Result handlerException(Exception e) {
        log.error(e.getMessage());
        return Result.error().message("系统异常");
    }

    /**
     * 处理空指针异常
     * @param e 异常
     * @return 处理结果
     */
    @ExceptionHandler(NullPointerException.class)
    public Result handlerNullPointerException(NullPointerException e) {
        log.error(e.getMessage());
        return Result.error().message("空指针异常");
    }

    /**
     * 处理自定义异常
     * @param e 异常
     * @return 处理结果
     */
    @ExceptionHandler(GlobalException.class)
    public Result handlerGlobalException(GlobalException e) {
        log.error(e.getMessage());
        return Result.error().message(e.getMessage()).code(e.getCode());
    }
}

简单测试一下：
　　如下，抛出自定义异常时，会被 GlobalExceptionHandler 捕获并处理。

@GetMapping("/test")
public Result test() {
    try{
        System.out.println(1/0);
    } catch (Exception e) {
        throw new GlobalException(ExceptionUtil.getMessage(e));
    }
    return Result.ok().data("items", userService.list());
}