SpringBoot + Vue + ElementUI 实现后台管理系统…

2020-06-10 16:04:00来源:博客园 阅读 ()

新老客户大回馈,云服务器低至5折

SpringBoot + Vue + ElementUI 实现后台管理系统模板 -- 后端篇(一): 搭建基本环境、整合 Swagger、MyBatisPlus、JSR303 以及国际化操作

相关

(1) 相关博文地址:

SpringBoot + Vue + ElementUI 实现后台管理系统模板 -- 前端篇(一):搭建基本环境:https://www.cnblogs.com/l-y-h/p/12930895.html
SpringBoot + Vue + ElementUI 实现后台管理系统模板 -- 前端篇(二):引入 element-ui 定义基本页面显示:https://www.cnblogs.com/l-y-h/p/12935300.html
SpringBoot + Vue + ElementUI 实现后台管理系统模板 -- 前端篇(三):引入 js-cookie、axios、mock 封装请求处理以及返回结果:https://www.cnblogs.com/l-y-h/p/12955001.html
SpringBoot + Vue + ElementUI 实现后台管理系统模板 -- 前端篇(四):引入 vuex 进行状态管理、引入 vue-i18n 进行国际化管理:https://www.cnblogs.com/l-y-h/p/12963576.html
SpringBoot + Vue + ElementUI 实现后台管理系统模板 -- 前端篇(五):引入 vue-router 进行路由管理、模块化封装 axios 请求、使用 iframe 标签嵌套页面:https://www.cnblogs.com/l-y-h/p/12973364.html
SpringBoot + Vue + ElementUI 实现后台管理系统模板 -- 前端篇(六):使用 vue-router 进行动态加载菜单:https://www.cnblogs.com/l-y-h/p/13052196.html

(2)代码地址:

https://github.com/lyh-man/admin-vue-template.git

 

一、简介

1、项目介绍

(1)基本介绍
  使用 SpringBoot + MyBatisPlus + MySQL 搭建一个后台管理系统的模板(后台代码)。
  当然这类模板在网上有很多,可以直接下载、修改使用。
  写这个项目目的,纯属练手(有不对的地方,还望不吝指教)。

【layuiAdmin 后台管理模板:(付费)】
    https://www.layui.com/admin/
    
【renren-fast:(开源)】
    https://gitee.com/renrenio/renren-fast

 

(2)软件使用
开发工具(随意选择,能提高开发效率即可):
  IntelliJ IDEA + Navicat

【Win10 下载、安装 Navicat 15 并激活 参考:】
    https://www.cnblogs.com/l-y-h/p/12746596.html

 

环境、依赖:
  JDK 1.8                        开发环境
  SpringBoot 2.3             核心框架
  SpringMVC                  视图框架
  MyBatisPlus                持久层框架
  swagger2                     生成在线的接口文档
  JSR303                        数据校验
  SLF4J、Logback         日志管理
  MySQL 8.0.18              数据库

【mysql安装、使用 -- windows 参考:】
    https://www.cnblogs.com/l-y-h/p/11700113.html

【mysql安装、使用 -- Linux 参考:】
    https://www.cnblogs.com/l-y-h/p/12576633.html

【docker 安装 mysql 8.0.18 -- Linux 参考:】
    https://www.cnblogs.com/l-y-h/p/12622730.html#_label5

 

(3)基本目录介绍

back
|--- src
|   |--- main         保存源代码
|   |   |--- java                     代码目录
|   |   |   |--- common               保存公共操作
|   |   |   |   |--- config           保存配置类
|   |   |   |   |--- exception        保存异常处理操作
|   |   |   |   |--- utils            保存工具类
|   |   |   |   |--- validator        保存 JSR303 校验相关操作
|   |   |   |--- controller          保存控制层代码
|   |   |   |--- entity              保存实体类代码
|   |   |   |--- handler             保存数据处理相关操作
|   |   |   |--- mapper              保存 sql 相关映射操作
|   |   |   |--- service             保存业务层代码
|
|   |   |--- resources                 资源目录
|   |   |   |--- static                用于保存项目静态文件
|   |   |   |--- application.yml       用于保存项目的配置信息
|   |   |   |--- logback-spring.xml    用于保存日志的配置信息
|
|   |--- test         保存测试代码
|   |   |--- java
|
|--- pom.xml    用于保存项目依赖信息

 

二、基本环境搭建

1、创建一个 SpringBoot 项目

Step1:
  File -》 New -》Project

 

 

 

Step2:
  Spring Initializr -》 选择合适的 JDK -》next

 

 

 

Step3:
  填写相关信息。

 

 

 

Step4:
  选择相应的 SpringBoot 版本,以及相关依赖(可以在项目中手动添加)。
如下,选择一个 web 依赖(自动集成SpringMVC 相关依赖)。

 

 

 

Step5:
  选择项目保存的路径。点击 next 后等待软件下载项目相关依赖即可。

 

 

 

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

(1)简介
  定义统一数据规范,返回一个固定格式的 JSON 结果。

【格式:】
    是否响应成功(success: true / false)
  响应状态码(code:200 / 400 / 500 等)
  状态码描述(message:访问成功 / 系统异常等)
  响应数据(data:处理的数据)

【类似如下:】
{
    "success": true,
    "code": 200,
    "message": "success",
    "data": {}
}

 

可以参考:
  https://www.cnblogs.com/l-y-h/p/12781586.html#_label1

 

(2)代码实现
Step1:
  添加依赖信息。
  httpcore 用于状态码的获取。
  lombok 用于简化代码的编写。

<!-- 状态码参考地址:http://hc.apache.org/httpcomponents-core-ga/httpcore/apidocs/org/apache/http/HttpStatus.html -->
<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>

 

 

 

 

Step2:
  在 common.utils 目录下新建一个 Result.java 工具类,用于封装返回结果。

package com.lyh.admin_template.back.common.utils;

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;
    }
}

 

 

 

(3)编写一个 TestController.java 用于测试一下。
代码:

package com.lyh.admin_template.back.controller;

import com.lyh.admin_template.back.common.utils.Result;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * 用于测试环境搭建各个功能是否成功
 */
@RestController
@RequestMapping("/test")
public class TestController {
    /**
     * 用于测试 Result 是否能够正常返回指定格式的数据
     * @return
     */
    @GetMapping("/testResult")
    public Result testResult() {
        return Result.ok();
    }
}

 

 

 

启动服务并访问接口,返回结果如下:(返回指定的 JSON 格式)

 

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

(1)简介
  程序运行时可能会遇到各种错误,使用统一的异常处理规范,可以方便的排查错误。
可以参考:
  https://www.cnblogs.com/l-y-h/p/12781586.html#_label2

 

(2)代码实现
Step1:
  添加依赖信息。
  此处需要使用 @RestControllerAdvice、@ExceptionHandler 两个注解,需要 Spring MVC 相关依赖,若之前创建项目时,未选择 Spring Web,此处需要手动添加。

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

 

Step2:
  在 common.exception 目录下自定义一个异常类 GlobalException,用于自定义异常信息。

package com.lyh.admin_template.back.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;
    }
}

 

 

 

Step3:
  在 common.exception 目录下定义一个全局异常处理类 GlobalExceptionHandler,用于处理异常。
  异常一般都与日志一起操作,此处演示不使用注解 @Slf4j 时的日志处理。

package com.lyh.admin_template.back.common.exception;

import com.lyh.admin_template.back.common.utils.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());
    }
}

 

 

 

Step4:
  在 TestController.java 添加一个接口,用于测试。

package com.lyh.admin_template.back.controller;

import com.lyh.admin_template.back.common.exception.GlobalException;
import com.lyh.admin_template.back.common.utils.Result;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * 用于测试环境搭建各个功能是否成功
 */
@RestController
@RequestMapping("/test")
public class TestController {

    /**
     * 用于测试 异常 是否能被统一处理,并返回指定格式的数据
     * @return
     */
    @GetMapping("/testGlobalException")
    public Result testGlobalException() {
        try {
            int test = 10 / 0;
        } catch (Exception e) {
            throw new GlobalException(e.getMessage());
        }
        return Result.ok();
    }
}

 

 

 

启动服务并访问接口,返回结果如下:(捕获到异常信息并返回)

 

 

 

日志也能正常输出:

 

 

 

Step5:(可选操作)
  若想在返回结果中输出 堆栈 信息,可以定义如下工具类,将堆栈信息转为 String 类型,然后再添加到返回的 message 中即可。
如下,新建一个工具类,用于装换堆栈信息为 String 类型,使用 @Slf4j 注解形式操作日志。

package com.lyh.admin_template.back.common.utils;

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;
    }
}

 

 

 

修改 TestController.java,简单测试一下:

package com.lyh.admin_template.back.controller;

import com.lyh.admin_template.back.common.exception.GlobalException;
import com.lyh.admin_template.back.common.utils.ExceptionUtil;
import com.lyh.admin_template.back.common.utils.Result;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * 用于测试环境搭建各个功能是否成功
 */
@RestController
@RequestMapping("/test")
public class TestController {

    /**
     * 用于测试 异常 是否能被统一处理,并返回指定格式的数据
     * @return
     */
    @GetMapping("/testGlobalException")
    public Result testGlobalException() {
        try {
            int test = 10 / 0;
        } catch (Exception e) {
            throw new GlobalException(ExceptionUtil.getMessage(e));
        }
        return Result.ok();
    }
}

 

 

 

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

(1)简介
  使用日志可以方便、快速定位到错误所在处。统一日志格式可以更方便日志的查看、管理。
可以参考:
  https://www.cnblogs.com/l-y-h/p/12781586.html#_label3

 

(2)代码实现:
  在 resources 目录下新建一个 logback-spring.xml 文件,其会在项目启动时被加载。
Step1:
  基本代码如下:(需要适当修改)

<?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.admin_template.back" 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>

 

Step2:
  按照项目需要对该文件进行修改。
一般只需要修改两处地方即可。

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

【修改二:】
// 使用 logger 指定包日志级别管理,根据项目实际的包名进行修改(如下,用于输出 sql 语句)
<logger name="com.lyh.admin_template.back" level="DEBUG"/>

 

Step3:
  在 application.yml 或者 application.properties 中指定环境(dev、prod)可以打印不同的日志。

spring:
  profiles:
    active: prod

 

三、集成一些常用功能

1、SpringBoot 整合 Swagger

(1)简介
  使用 Swagger 生成一个在线的接口文档,前后端可以根据此接口文档对接口进行测试、调用。
Swagger 使用可以参考:
  https://www.cnblogs.com/l-y-h/p/12872748.html

 

(2)SpringBoot 整合 Swagger
Step1:
  添加依赖信息。

<!-- https://mvnrepository.com/artifact/io.springfox/springfox-swagger2 -->
<dependency>
    <groupId>io.springfox</groupId>
    <artifactId>springfox-swagger2</artifactId>
    <version>2.9.2</version>
</dependency>
<!-- https://mvnrepository.com/artifact/io.springfox/springfox-swagger-ui -->
<dependency>
    <groupId>io.springfox</groupId>
    <artifactId>springfox-swagger-ui</artifactId>
    <version>2.9.2</version>
</dependency>

 

 

 

 

Step2:
  在 common.config 目录下编写一个配置类 SwaggerConfig.java,用于配置 Swagger 相关信息。
  @Configuration 注解用于标注一个配置类
  @EnableSwagger2 注解用于开启 Swagger。
  @Profile({"dev","test"}) 注解用于表示 dev、test 环境下可以使用 Swagger,prod 环境下不行。
如下:
  指定了 com.lyh.admin_template.back.controller 包下标注了 @ApiOperation 注解的接口才会生成接口文档。

package com.lyh.admin_template.back.common.config;

import io.swagger.annotations.ApiOperation;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Profile;
import springfox.documentation.builders.ApiInfoBuilder;
import springfox.documentation.builders.PathSelectors;
import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.service.ApiInfo;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.swagger2.annotations.EnableSwagger2;

@Configuration
@EnableSwagger2
@Profile({"dev","test"})
public class SwaggerConfig {

    @Bean
    public Docket createRestApi() {
        return new Docket(DocumentationType.SWAGGER_2)
                .apiInfo(apiInfo())
                .select()
                // 加了ApiOperation注解的类,才会生成接口文档
                .apis(RequestHandlerSelectors.withMethodAnnotation(ApiOperation.class))
                // 指定包下的类,才生成接口文档
                .apis(RequestHandlerSelectors.basePackage("com.lyh.admin_template.back.controller"))
                .paths(PathSelectors.any())
                .build();
    }

    private ApiInfo apiInfo() {
        return new ApiInfoBuilder()
                .title("Swagger 测试")
                .description("Swagger 测试文档")
                .termsOfServiceUrl("https://www.cnblogs.com/l-y-h/")
                .version("1.0.0")
                .build();
    }
}

 

 

 

Step3:
  编写 TestController.java 用于测试一下 Swagger 是否整合成功。

package com.lyh.admin_template.back.controller;

import com.lyh.admin_template.back.common.utils.Result;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * 用于测试环境搭建各个功能是否成功
 */
@RestController
@RequestMapping("/test")
@Api(tags = "测试页面")
public class TestController {

    /**
     * 用于测试 Swagger 是否整合成功
     * @return
     */
    @ApiOperation(value = "测试 Swagger")
    @GetMapping("/testSwagger")
    public Result testSwagger() {
        return Result.ok();
    }
}

 

Step4:
  访问项目的 swagger-ui.html 页面,即可访问到 Swagger 页面。
比如:http://localhost:8080/swagger-ui.html,
如下,三个接口,只有标注了 @ApiOperation 注解的接口才会被显示在 接口文档中。

 

 

 

2、SpringBoot 整合 MyBatis-Plus

(1)简介
  MyBatisPlus 是 MyBatis 增强版(持久层框架),其内置了一些 sql 增删改查的操作,可以免去 xml 文件的编写工作(当然复杂的 sql 逻辑还是得用 xml 编写)。
  当然还有其他一些功能,总体使用起来比 MyBatis 更加方便。

使用 MyBatisPlus,可参考:
  https://www.cnblogs.com/l-y-h/p/12859477.html

 

(2)SpringBoot 整合 MyBatisPlus
Step1:
  添加相关依赖信息。
  涉及数据库操作,此处使用 mysql,所以需要 mysql-connector 相关依赖。
  当然还得有 MyBatisPlus 相关操作的依赖。
    mybatis-plus-boot-starter 是最基本的依赖。
    mybatis-plus-generator、velocity-engine-core 是MyBatisPlus 代码生成器所需依赖。

<!-- mybatis-plus -->
<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-boot-starter</artifactId>
    <version>3.3.1</version>
</dependency>
<!-- mybatis-plus-generator -->
<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-generator</artifactId>
    <version>3.3.1.tmp</version>
</dependency>
<!-- mybatis-plus engine -->
<dependency>
    <groupId>org.apache.velocity</groupId>
    <artifactId>velocity-engine-core</artifactId>
    <version>2.2</version>
</dependency>
<!-- mysql-connector -->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.18</version>
</dependency>

 

 

 

Step2:
  在本地数据库新建一个 admin_template 数据库,并建立一个 back_user 表用于测试一下 MyBatisPlus 是否能使用。
back_user 建表 SQL 语句如下:

DROP DATABASE IF EXISTS admin_template;

CREATE DATABASE admin_template;

USE admin_template;

CREATE TABLE back_user (
    id bigint NOT NULL COMMENT '用户 ID',
    name varchar(50) NOT NULL COMMENT '用户名',
    mobile varchar(20) NOT NULL COMMENT '用户手机号',
    password varchar(64) NOT NULL COMMENT '用户密码',
    create_time datetime COMMENT '创建时间',
    update_time datetime COMMENT '修改时间',
    delete_flag tinyint COMMENT '逻辑删除标志,0 表示未删除, 1 表示删除',
    version tinyint COMMENT '版本号',
    PRIMARY KEY(id),
    UNIQUE INDEX(name)
) ENGINE=InnoDB DEFAULT CHARACTER SET utf8mb4 COMMENT='用户表';

 

 

 

Step3:
  在配置文件中配置 数据源信息。
  根据项目自行配置 mysql 数据源信息。

spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    username: root
    password: 123456
    url: jdbc:mysql://localhost:3306/admin_template?useUnicode=true&characterEncoding=utf8

 

 

 

Step4:
  在项目启动类上,需要标注 @MapperScan 注解用于指明需要被扫描的 mapper 的路径。

package com.lyh.admin_template.back;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
@MapperScan("com.lyh.admin_template.back.mapper")
public class BackApplication {

    public static void main(String[] args) {
        SpringApplication.run(BackApplication.class, args);
    }

}

 

 

 

(3)使用代码生成器
  使用 MyBatisPlus 代码生成器 AutoGenerator 根据 back_user 表逆向生成基本代码。
Step1:
  添加依赖。
  mybatis-plus-generator、velocity-engine-core 是MyBatisPlus 代码生成器所需依赖。

<!-- mybatis-plus-generator -->
<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-generator</artifactId>
    <version>3.3.1.tmp</version>
</dependency>
<!-- mybatis-plus engine -->
<dependency>
    <groupId>org.apache.velocity</groupId>
    <artifactId>velocity-engine-core</artifactId>
    <version>2.2</version>
</dependency>

 

Step2:
  编写一个测试类,用于测试 代码生成器 功能。
  需要修改的地方,下面注释中已标明。

package com.lyh.admin_template.back;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.generator.AutoGenerator;
import com.baomidou.mybatisplus.generator.config.DataSourceConfig;
import com.baomidou.mybatisplus.generator.config.GlobalConfig;
import com.baomidou.mybatisplus.generator.config.PackageConfig;
import com.baomidou.mybatisplus.generator.config.StrategyConfig;
import com.baomidou.mybatisplus.generator.config.rules.DateType;
import com.baomidou.mybatisplus.generator.config.rules.NamingStrategy;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
public class TestAutoGenerator {
    @Test
    public void autoGenerate() {
        // Step1:代码生成器
        AutoGenerator mpg = new AutoGenerator();

        // Step2:全局配置
        GlobalConfig gc = new GlobalConfig();
        // 填写代码生成的目录(需要修改)
        String projectPath = "E:\\myProject\\myGit\\admin-vue-template\\back";
        // 拼接出代码最终输出的目录
        gc.setOutputDir(projectPath + "/src/main/java");
        // 配置开发者信息(可选)(需要修改)
        gc.setAuthor("lyh");
        // 配置是否打开目录,false 为不打开(可选)
        gc.setOpen(false);
        // 实体属性 Swagger2 注解,添加 Swagger 依赖,开启 Swagger2 模式(可选)
        gc.setSwagger2(true);
        // 重新生成文件时是否覆盖,false 表示不覆盖(可选)
        gc.setFileOverride(false);
        // 配置主键生成策略,此处为 ASSIGN_ID(可选)
        gc.setIdType(IdType.ASSIGN_ID);
        // 配置日期类型,此处为 ONLY_DATE(可选)
        gc.setDateType(DateType.ONLY_DATE);
        // 默认生成的 service 会有 I 前缀
        gc.setServiceName("%sService");
        mpg.setGlobalConfig(gc);

        // Step3:数据源配置(需要修改)
        DataSourceConfig dsc = new DataSourceConfig();
        // 配置数据库 url 地址
        dsc.setUrl("jdbc:mysql://localhost:3306/admin_template?useUnicode=true&characterEncoding=utf8");
        // dsc.setSchemaName("testMyBatisPlus"); // 可以直接在 url 中指定数据库名
        // 配置数据库驱动
        dsc.setDriverName("com.mysql.cj.jdbc.Driver");
        // 配置数据库连接用户名
        dsc.setUsername("root");
        // 配置数据库连接密码
        dsc.setPassword("123456");
        mpg.setDataSource(dsc);

        // Step:4:包配置
        PackageConfig pc = new PackageConfig();
        // 配置父包名(需要修改)
        pc.setParent("com.lyh.admin_template");
        // 配置模块名(需要修改)
        pc.setModuleName("back");
        // 配置 entity 包名
        pc.setEntity("entity");
        // 配置 mapper 包名
        pc.setMapper("mapper");
        // 配置 service 包名
        pc.setService("service");
        // 配置 controller 包名
        pc.setController("controller");
        mpg.setPackageInfo(pc);

        // Step5:策略配置(数据库表配置)
        StrategyConfig strategy = new StrategyConfig();
        // 指定表名(可以同时操作多个表,使用 , 隔开)(需要修改)
        strategy.setInclude("back_user");
        // 配置数据表与实体类名之间映射的策略
        strategy.setNaming(NamingStrategy.underline_to_camel);
        // 配置数据表的字段与实体类的属性名之间映射的策略
        strategy.setColumnNaming(NamingStrategy.underline_to_camel);
        // 配置 lombok 模式
        strategy.setEntityLombokModel(true);
        // 配置 rest 风格的控制器(@RestController)
        strategy.setRestControllerStyle(true);
        // 配置驼峰转连字符
        strategy.setControllerMappingHyphenStyle(true);
        // 配置表前缀,生成实体时去除表前缀
        // 此处的表名为 test_mybatis_plus_user,模块名为 test_mybatis_plus,去除前缀后剩下为 user。
        strategy.setTablePrefix(pc.getModuleName() + "_");
        mpg.setStrategy(strategy);

        // Step6:执行代码生成操作
        mpg.execute();
    }
}

 

 

 

执行后,根据 back_user 表结构生成 controller、entity、mapper、service 等相关代码。

 

 

 

(4)使用自动填充数据
  添加数据时,按照某种规则自动给字段添加相关数据。
比如:
  back_user 中 create_time、update_time、delete_flag、version 等字段,在插入、修改时都是按照某种数据填充规则进行数据填充,这些数据就可以使用 MyBatisPlus 的自动填充数据功能来完成。
可以参考:
 https://www.cnblogs.com/l-y-h/p/12859477.html#_label1_3

Step1:
  在 handler 目录下新建一个自动填充处理类 MyMetaObjectHandler.java,实现 MetaObjectHandler 接口,并重写方法以实现自动填充功能。
  @Component 表示将此类交给 Spring 去管理。

package com.lyh.admin_template.back.handler;

import com.baomidou.mybatisplus.core.handlers.MetaObjectHandler;
import org.apache.ibatis.reflection.MetaObject;
import org.springframework.stereotype.Component;

import java.util.Date;

/**
 * 自动填充处理类,
 * insertFill() 表示插入时的填充规则,
 * updateFill() 表示更新时的填充规则。
 */
@Component
public class MyMetaObjectHandler implements MetaObjectHandler {

    /**
     * 插入时的填充规则
     * @param metaObject
     */
    @Override
    public void insertFill(MetaObject metaObject) {
        this.strictInsertFill(metaObject, "createTime", Date.class, new Date());
        this.strictInsertFill(metaObject, "updateTime", Date.class, new Date());
        this.strictInsertFill(metaObject, "deleteFlag", Integer.class, 0);
        this.strictInsertFill(metaObject, "version", Integer.class, 1);
    }

    /**
     * 更新时的填充规则
     * @param metaObject
     */
    @Override
    public void updateFill(MetaObject metaObject) {
        this.strictUpdateFill(metaObject, "updateTime", Date.class, new Date());
    }
}

 

 

 

Step2:
  给实体类需要填充的数据上添加 @TableField 注解,并指明填充规则。

package com.lyh.admin_template.back.entity;

import com.baomidou.mybatisplus.annotation.*;

import java.util.Date;
import java.io.Serializable;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;

/**
 * <p>
 * 用户表
 * </p>
 *
 * @author lyh
 * @since 2020-06-08
 */
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@TableName("back_user")
@ApiModel(value="User对象", description="用户表")
public class User implements Serializable {

    private static final long serialVersionUID=1L;

    @ApiModelProperty(value = "用户 ID")
    @TableId(value = "id", type = IdType.ASSIGN_ID)
    private Long id;

    @ApiModelProperty(value = "用户名")
    private String name;

    @ApiModelProperty(value = "用户手机号")
    private String mobile;

    @ApiModelProperty(value = "用户密码")
    private String password;

    @TableField(fill = FieldFill.INSERT)
    @ApiModelProperty(value = "创建时间")
    private Date createTime;

    @TableField(fill = FieldFill.INSERT_UPDATE)
    @ApiModelProperty(value = "修改时间")
    private Date updateTime;

    @TableField(fill = FieldFill.INSERT)
    @ApiModelProperty(value = "逻辑删除标志,0 表示未删除, 1 表示删除")
    private Integer deleteFlag;

    @TableField(fill = FieldFill.INSERT)
    @ApiModelProperty(value = "版本号")
    private Integer version;

}

 

 

 

Step3:
  在 TestController.java 中添加测试代码:

package com.lyh.admin_template.back.controller;

import com.lyh.admin_template.back.common.utils.Result;
import com.lyh.admin_template.back.entity.User;
import com.lyh.admin_template.back.service.UserService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

/**
 * 用于测试环境搭建各个功能是否成功
 */
@RestController
@RequestMapping("/test")
@Api(tags = "测试页面")
public class TestController {

    @Autowired
    private UserService userService;

    @ApiOperation(value = "获取所有用户信息")
    @GetMapping("/getListOfUser")
    public Result testGetListOfUser() {
        return Result.ok().data("user", userService.list());
    }

    @ApiOperation(value = "测试 MyBatis Plus 自动填充数据功能")
    @PostMapping("/testMyBatisPlus/AutoFill")
    public Result testMyBatisPlusAutoFill(@RequestBody User user) {
        if(userService.save(user)) {
            return Result.ok().message("数据添加成功");
        }
        return Result.error().message("数据添加失败");
    }
   
}

 

 

 

Step4:
  使用 Swagger,并输入以下数据进行测试:
  由于 id 采用 IdType.ASSIGN_ID 类型,其也是自动生成的。
  所以只需要添加 mobile、name、password 三个值即可。
  且 name 在 back_user 表中是唯一的,所以重复添加时会添加失败。

{
  "mobile": "13865561381",
  "name": "lyh",
  "password": "123456"
}

 

 

 

(5)实现逻辑删除
  删除数据时,有物理删除(直接从数据表中删除)、逻辑删除(修改表中某字段,该字段表示该行数据已被删除,但仍留在数据表中,查询数据时此数据不可见)。
可以参考:
  https://www.cnblogs.com/l-y-h/p/12859477.html#_label1_4

Step1:
  在实体类上使用 @TableLogic 注解标注逻辑删除字段,并指定字段变化规则。
  指定 back_user 表中的 delete_flag 字段,0 表示未删除, 1 表示删除。

package com.lyh.admin_template.back.entity;

import com.baomidou.mybatisplus.annotation.*;

import java.util.Date;
import java.io.Serializable;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;

/**
 * <p>
 * 用户表
 * </p>
 *
 * @author lyh
 * @since 2020-06-08
 */
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@TableName("back_user")
@ApiModel(value="User对象", description="用户表")
public class User implements Serializable {

    private static final long serialVersionUID=1L;

    @ApiModelProperty(value = "用户 ID")
    @TableId(value = "id", type = IdType.ASSIGN_ID)
    private Long id;

    @ApiModelProperty(value = "用户名")
    private String name;

    @ApiModelProperty(value = "用户手机号")
    private String mobile;

    @ApiModelProperty(value = "用户密码")
    private String password;

    @TableField(fill = FieldFill.INSERT)
    @ApiModelProperty(value = "创建时间")
    private Date createTime;

    @TableField(fill = FieldFill.INSERT_UPDATE)
    @ApiModelProperty(value = "修改时间")
    private Date updateTime;

    @TableField(fill = FieldFill.INSERT)
    @TableLogic(value = "0", delval = "1")
    @ApiModelProperty(value = "逻辑删除标志,0 表示未删除, 1 表示删除")
    private Integer deleteFlag;

    @TableField(fill = FieldFill.INSERT)
    @ApiModelProperty(value = "版本号")
    private Integer version;

}

 

 

 

Step2:
  编写 TestController.java 进行测试。

package com.lyh.admin_template.back.controller;

import com.lyh.admin_template.back.common.utils.Result;
import com.lyh.admin_template.back.entity.User;
import com.lyh.admin_template.back.service.UserService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.HashMap;

/**
 * 用于测试环境搭建各个功能是否成功
 */
@RestController
@RequestMapping("/test")
@Api(tags = "测试页面")
public class TestController {

    @Autowired
    private UserService userService;

    @ApiOperation(value = "获取所有用户信息")
    @GetMapping("/getListOfUser")
    public Result testGetListOfUser() {
        return Result.ok().data("user", userService.list());
    }

    @ApiOperation(value = "删除指定姓名的用户")
    @DeleteMapping("/testMyBatisPlus/LogicDel")
    public Result testMyBatisPlusLogicDel(@RequestParam String name) {
        HashMap<String, Object> hashMap = new HashMap<>();
        hashMap.put("name", name);
        userService.removeByMap(hashMap);
        return Result.ok();
    }

    @ApiOperation(value = "测试 MyBatis Plus 自动填充数据功能")
    @PostMapping("/testMyBatisPlus/AutoFill")
    public Result testMyBatisPlusAutoFill(@RequestBody User user) {
        if(userService.save(user)) {
            return Result.ok().message("数据添加成功");
        }
        return Result.error().message("数据添加失败");
    }
}

 

 

 

Step3:
  测试逻辑删除。
  逻辑删除后,数据仍存于表中,但查询不可见。

 

 

 

(6)分页、乐观锁实现
  分页、乐观锁实现需要借助插件来完成了,需要进行额外的配置。
可以参考:
  https://www.cnblogs.com/l-y-h/p/12859477.html#_label1_5
  https://www.cnblogs.com/l-y-h/p/12859477.html#_label1_6
此处直接写实现逻辑,不详细解释。

Step1:
  在 common.config 目录下编写一个配置类 MyBatisPlusConfig.java。
  此时可以将 启动类上的 @MapperScan 移到此处。

package com.lyh.admin_template.back.common.config;

import com.baomidou.mybatisplus.extension.plugins.OptimisticLockerInterceptor;
import com.baomidou.mybatisplus.extension.plugins.PaginationInterceptor;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * 自定义一个 MybatisPlus 配置类,配置分页插件、乐观锁插件
 * mapper 扫描也可在此写上
 */
@Configuration
@MapperScan("com.lyh.admin_template.back.mapper")
public class MyBatisPlusConfig {
    /**
     * 分页插件
     * @return 分页插件的实例
     */
    @Bean
    public PaginationInterceptor paginationInterceptor() {
        return new PaginationInterceptor();
    }

    /**
     * 乐观锁插件
     * @return 乐观锁插件的实例
     */
    @Bean
    public OptimisticLockerInterceptor optimisticLockerInterceptor() {
        return new OptimisticLockerInterceptor();
    }
}

 

Step2:
  对于实现乐观锁,只需在 实体类字段上标注 @Version 注解即可。
如下,给 User.java 的 version 字段添加 @Version 注解。

package com.lyh.admin_template.back.entity;

import com.baomidou.mybatisplus.annotation.*;

import java.util.Date;
import java.io.Serializable;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;

/**
 * <p>
 * 用户表
 * </p>
 *
 * @author lyh
 * @since 2020-06-08
 */
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@TableName("back_user")
@ApiModel(value="User对象", description="用户表")
public class User implements Serializable {

    private static final long serialVersionUID=1L;

    @ApiModelProperty(value = "用户 ID")
    @TableId(value = "id", type = IdType.ASSIGN_ID)
    private Long id;

    @ApiModelProperty(value = "用户名")
    private String name;

    @ApiModelProperty(value = "用户手机号")
    private String mobile;

    @ApiModelProperty(value = "用户密码")
    private String password;

    @TableField(fill = FieldFill.INSERT)
    @ApiModelProperty(value = "创建时间")
    private Date createTime;

    @TableField(fill = FieldFill.INSERT_UPDATE)
    @ApiModelProperty(value = "修改时间")
    private Date updateTime;

    @TableField(fill = FieldFill.INSERT)
    @TableLogic(value = "0", delval = "1")
    @ApiModelProperty(value = "逻辑删除标志,0 表示未删除, 1 表示删除")
    private Integer deleteFlag;

    @Version
    @TableField(fill = FieldFill.INSERT)
    @ApiModelProperty(value = "版本号")
    private Integer version;

}

 

Step3:
  对于实现分页,首先声明一个 Page 对象,并指定查询的当前页以及每页的大小,然后直接调用 MyBatisPlus 提供的 page 方法即可,page 方法中可以添加过滤条件。
如下,编写 TestController.java 用于测试

package com.lyh.admin_template.back.controller;

import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.lyh.admin_template.back.common.utils.Result;
import com.lyh.admin_template.back.entity.User;
import com.lyh.admin_template.back.service.UserService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * 用于测试环境搭建各个功能是否成功
 */
@RestController
@RequestMapping("/test")
@Api(tags = "测试页面")
public class TestController {

    @Autowired
    private UserService userService;

    @ApiOperation(value = "测试分页插件")
    @GetMapping("/testMyBatisPlus/page/{current}/{size}")
    public Result testPage(@PathVariable("current") Long current, @PathVariable("size") Long size) {
        Page<User> page = new Page(current, size);
        return Result.ok().data("page", userService.page(page, null));
    }
}

 

 

 

3、SpringBoot 整合 JSR303

(1)简介
  使用 JSR303,采用注解的方式,对传入接口的数据进行数据校验,减少额外的校验代码。
可以参考:
  https://www.cnblogs.com/l-y-h/p/12797809.html

(2)代码实现:
Step1:
  添加相关依赖信息。

<!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-validation -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-validation</artifactId>
</dependency>

 

Step2:
  定义两个接口,AddGroup.java、UpdateGroup.java,用于分组校验。

【AddGroup.java】
package com.lyh.admin_template.back.common.validator.group;

/**
 * 新增数据的 Group 校验规则
 */
public interface AddGroup {
}

【UpdateGroup.java】
package com.lyh.admin_template.back.common.validator.group;

/**
 * 更新数据时的 Group 校验规则
 */
public interface UpdateGroup {
}

 

 

 

Step3:
  在全局异常处理中,处理检验失败所抛出的异常。

package com.lyh.admin_template.back.common.exception;

import com.lyh.admin_template.back.common.utils.Result;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.MethodArgumentNotValidException;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;

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

/**
 * 全局异常处理类。
 * 使用 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());
    }

    /**
     * 处理 JSR303 校验的异常
     * @param e 异常
     * @return 处理结果
     */
    @ExceptionHandler(MethodArgumentNotValidException.class)
    public Result handlerValidException(MethodArgumentNotValidException e) {
        logger.error(e.getMessage(), e);
        BindingResult result = e.getBindingResult();
        Map<String, String> map = new HashMap<>();
        // 获取校验结果,遍历获取捕获到的每个校验结果
        result.getFieldErrors().forEach(item ->{
            // 存储得到的校验结果
            map.put(item.getField(), item.getDefaultMessage());
        });
        return Result.error().message("数据校验不合法").data("items", map);
    }
}

 

 

 

Step4:
  在实体类上添加相关 JSR 303 注解即可使用。
如下,在 name、mobile、password 字段上添加 注解并指定 分组校验规则。

package com.lyh.admin_template.back.entity;

import com.baomidou.mybatisplus.annotation.*;
import com.lyh.admin_template.back.common.validator.group.AddGroup;
import com.lyh.admin_template.back.common.validator.group.UpdateGroup;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;

import javax.validation.constraints.NotEmpty;
import javax.validation.constraints.Pattern;
import java.io.Serializable;
import java.util.Date;

/**
 * <p>
 * 用户表
 * </p>
 *
 * @author lyh
 * @since 2020-06-08
 */
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@TableName("back_user")
@ApiModel(value="User对象", description="用户表")
public class User implements Serializable {

    private static final long serialVersionUID=1L;

    @ApiModelProperty(value = "用户 ID")
    @TableId(value = "id", type = IdType.ASSIGN_ID)
    private Long id;

    @NotEmpty(message = "用户名不能为空", groups = {AddGroup.class, UpdateGroup.class})
    @ApiModelProperty(value = "用户名")
    private String name;

    @NotEmpty(message = "手机号不能为空", groups = {AddGroup.class, UpdateGroup.class})
    @Pattern(message = "手机号格式不合法", regexp = "^[1-9]{1}\\d{10}$", groups = {AddGroup.class, UpdateGroup.class})
    @ApiModelProperty(value = "用户手机号")
    private String mobile;

    @NotEmpty(message = "用户密码不能为空", groups = {AddGroup.class, UpdateGroup.class})
    @ApiModelProperty(value = "用户密码")
    private String password;

    @TableField(fill = FieldFill.INSERT)
    @ApiModelProperty(value = "创建时间")
    private Date createTime;

    @TableField(fill = FieldFill.INSERT_UPDATE)
    @ApiModelProperty(value = "修改时间")
    private Date updateTime;

    @TableField(fill = FieldFill.INSERT)
    @TableLogic(value = "0", delval = "1")
    @ApiModelProperty(value = "逻辑删除标志,0 表示未删除, 1 表示删除")
    private Integer deleteFlag;

    @Version
    @TableField(fill = FieldFill.INSERT)
    @ApiModelProperty(value = "版本号")
    private Integer version;

}

 

 

 

Step4:
  编写 TestController.java 用于测试 JSR303 校验 。

package com.lyh.admin_template.back.controller;

import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.lyh.admin_template.back.common.utils.Result;
import com.lyh.admin_template.back.common.validator.group.AddGroup;
import com.lyh.admin_template.back.common.validator.group.UpdateGroup;
import com.lyh.admin_template.back.entity.User;
import com.lyh.admin_template.back.service.UserService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * 用于测试环境搭建各个功能是否成功
 */
@RestController
@RequestMapping("/test")
@Api(tags = "测试页面")
public class TestController {

    @Autowired
    private UserService userService;

    @ApiOperation(value = "测试 JSR 303 添加时的校验规则")
    @PostMapping("testValidator/save")
    public Result testValidatorSave(@Validated({AddGroup.class}) @RequestBody User user) {
        if(userService.save(user)) {
            return Result.ok().message("数据添加成功");
        }
        return Result.error().message("数据添加失败");
    }

    @ApiOperation(value = "测试 JSR 303 更新时的校验规则")
    @PostMapping("testValidator/update")
    public Result testValidatorUpdate(@Validated({UpdateGroup.class}) @RequestBody User user) {
        UpdateWrapper<User> updateWrapper = new UpdateWrapper<>();
        updateWrapper.eq("name", user.getName());
        if(userService.update(user, updateWrapper)) {
            return Result.ok().message("数据更新成功");
        }
        return Result.error().message("数据更新失败");
    }
}

 

 

 

Step5:
  使用 Swagger 进行测试。
  由于添加、修改在此处指定的规则均相同,当数据为空或者手机号不合法时,会校验失败,不会进入接口。数据校验通过后,才会执行接口中逻辑。

 

 

4、SpringBoot 实现热部署(可选操作)

(1)简介
  每次修改代码,都需要重新启动项目,随着项目内容增大,启动耗时会很长,严重影响开发效率。实现热部署,即在项目运行时修改 Java 文件,最后项目内容会随之修改,不用重启项目(当然热部署也会出现一些问题)。

(2)实现
  此处采用 spring-boot-devtools 提供的开发者工具实现热部署。
  其基于类加载机制来实现热部署,即修改完代码后,需要重新编译当前代码才能触发热部署。IDEA 中默认关闭自动编译,需要按下面步骤将其开启。


Step1:
  添加依赖信息。

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

 

Step2:
  在 idea 中开启项目自动编译。
  打开设置窗口,找到 Build, Execution, Deployment -> Compiler
  然后勾选 Build project automatically 。

 

 

Step3:
  在 idea 中开启项目运行时自动 make。
  按快捷键 ctrl + alt + shift + /,可以弹出一个框,选择 Registry.

 

 

进入 Registry 窗口后,找到 compiler.automake.allow.when.app.running 并勾选。

 

 

Step4:
  开启项目的热部署策略。

 

 

 

 

Step5:
  修改完后,记得重启项目。然后修改代码,查看是否生效(可能需要等待几秒)。
  快捷键 Ctrl + Shift + F9 可以重新编译项目(有时候热部署可能会删除一些文件,若显示异常,可以手动编译一下)。

 

 

5、SpringBoot 实现国际化操作

(1)简介
  代码中,需要进行语言切换(比如中英文切换),前端做了相关国际化处理,后端也需要进行类似的处理。否则中文系统下返回英文数据,英文系统下返回中文数据,看起来就很诡异。

(2)实现步骤:
  SpringBoot 内置了国际化处理,可以直接使用,当然也可以自定义使用。
如下为自定义使用步骤。
Step1:在 resources 目录下定义好相关的资源文件,并填入相应的中英文数据信息。
Step2:在项目配置文件中 定义 spring.messages.basename,用于指定资源文件。
Step3:添加一个 国际化的配置文件,用于拦截并处理转换语言。
Step4:添加一个工具类,用于获取国际化的数据。

【自定义国际化操作 参考:】
    https://www.jianshu.com/p/a354d3f849ec

【LocaleResolver 使用参考】
    https://ethendev.github.io/2017/10/15/SpringBoot-internationalization/

【WebMvcConfigurer 使用参考:】
     https://blog.csdn.net/zhangpower1993/article/details/89016503

 

(3)代码实现:
Step1:
  在 resources/static 目录下,新建一个 i18n 目录,用于存放国际化资源文件。
  在该目录下新建两个文件:messages_zh_CN.properties、messages_en_US.properties。
  SpringBoot 中配置类 MessageSourceAutoConfiguration.java 源码中默认配置文件前缀为 messages。可以在 SpringBoot 的配置文件中指定 spring.messages.basename,从而自定义文件路径。

 

 

定义国际化资源文件内容:

【messages_en_US.properties】
    test=test I18n
    
【messages_en_US.properties】
    test=测试 I18n

 

 

Step2:
  在 application.yml 中定义 spring.messages.basename,用于指定 Step1 中定义的国际化资源文件路径。也可指定 编码字符集。

  有时候会出现中文乱码情况,请自行检查国际化资源文件是否为 UTF-8 编码格式的。

spring:
  # 配置国际化,basename 指定国际化文件前缀
  messages:
    basename: static/i18n/messages
    encoding: UTF-8

 

 

Step3:
  新建一个国际化配置文件 LocaleConfig.java,用于处理 国际化相关逻辑。
其中:
  LocaleResolver 用于解析当前语言环境。
  LocaleChangeInterceptor 用于获取请求中的语言环境。
  ResourceBundleMessageSource 用于加载国际资源文件位置。

方式一:
  使用 LocaleResolver 并根据 session 去解析当前语言环境。

package com.lyh.admin_template.back.common.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.LocaleResolver;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
import org.springframework.web.servlet.i18n.LocaleChangeInterceptor;
import org.springframework.web.servlet.i18n.SessionLocaleResolver;

import java.util.Locale;

/**
 * 配置国际化语言
 */
@Configuration
public class LocaleConfig {

    /**
     * 默认解析器
     */
    @Bean
    public LocaleResolver localeResolver() {
        SessionLocaleResolver localeResolver = new SessionLocaleResolver();
        localeResolver.setDefaultLocale(Locale.SIMPLIFIED_CHINESE);
        return localeResolver;
    }

    /**
     * 定义拦截器,其中 language 表示切换语言的参数名。
     */
    @Bean
    public WebMvcConfigurer localeInterceptor() {
        return new WebMvcConfigurer() {
            @Override
            public void addInterceptors(InterceptorRegistry registry) {
                LocaleChangeInterceptor localeInterceptor = new LocaleChangeInterceptor();
                localeInterceptor.setParamName("language");
                registry.addInterceptor(localeInterceptor);
            }
        };
    }
    
    /**
     * 由于返回类型不是 MessageSource 类型,所以需要在 @Bean 注解中指明 name 参数,用于自动装配到 MessageSource 中。
     * 使用时 通过 @Autowired 注入 MessageSource 即可。
     * setBasenames 用于指定国际化资源文件前缀
     * setDefaultEncoding 用于指定编码字符集
     */
    @Bean(name = "messageSource")
    public ResourceBundleMessageSource getMessageSource() throws Exception {
        ResourceBundleMessageSource resourceBundleMessageSource = new ResourceBundleMessageSource();
        resourceBundleMessageSource.setDefaultEncoding("UTF-8");
        resourceBundleMessageSource.setBasenames("static/i18n/messages");
        return resourceBundleMessageSource;
    }
}

 

 

方式二(此项目中使用):
  使用 LocaleResolver 并根据 cookie 去解析当前语言环境。

package com.lyh.admin_template.back.common.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.LocaleResolver;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
import org.springframework.web.servlet.i18n.CookieLocaleResolver;
import org.springframework.web.servlet.i18n.LocaleChangeInterceptor;

import java.util.Locale;

/**
 * 配置国际化语言
 */
@Configuration
public class LocaleConfig {

    /**
     * 默认解析器
     */
    @Bean
    public LocaleResolver localeResolver() {
        CookieLocaleResolver cookieLocaleResolver = new CookieLocaleResolver();
        cookieLocaleResolver.setDefaultLocale(Locale.SIMPLIFIED_CHINESE);
        cookieLocaleResolver.setCookieName("language");
        cookieLocaleResolver.setCookieMaxAge(-1);
        return cookieLocaleResolver;
    }

    /**
     * 定义拦截器,其中 language 表示切换语言的参数名。
     * 拦截请求后,根据请求中的 language 参数去设置语言。
     */
    @Bean
    public WebMvcConfigurer localeInterceptor() {
        return new WebMvcConfigurer() {
            @Override
            public void addInterceptors(InterceptorRegistry registry) {
                LocaleChangeInterceptor localeInterceptor = new LocaleChangeInterceptor();
                localeInterceptor.setParamName("language");
                registry.addInterceptor(localeInterceptor);
            }
        };
    }
    
    /**
     * 由于返回类型不是 MessageSource 类型,所以需要在 @Bean 注解中指明 name 参数,用于自动装配到 MessageSource 中。
     * 使用时 通过 @Autowired 注入 MessageSource 即可。
     * setBasenames 用于指定国际化资源文件前缀
     * setDefaultEncoding 用于指定编码字符集
     */
    @Bean(name = "messageSource")
    public ResourceBundleMessageSource getMessageSource() throws Exception {
        ResourceBundleMessageSource resourceBundleMessageSource = new ResourceBundleMessageSource();
        resourceBundleMessageSource.setDefaultEncoding("UTF-8");
        resourceBundleMessageSource.setBasenames("static/i18n/messages");
        return resourceBundleMessageSource;
    }
}

 

 

Step4:
  在 common.utils 目录下定义一个国际化工具类,用于获取国际化文件中的数据。

package com.lyh.admin_template.back.common.utils;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.MessageSource;
import org.springframework.context.i18n.LocaleContextHolder;
import org.springframework.stereotype.Component;

import java.util.Locale;

/**
 * 国际化工具类,用于获取国际化文件中的数据
 */
@Component
public class MessageSourceUtil {

    @Autowired
    private MessageSource messageSource;

    public String getMessage(String code) {
        return getMessage(code, null);
    }

    public String getMessage(String code, Object[] args) {
        return getMessage(code, args, "");
    }

    public String getMessage(String code, Object[] args, String defaultMsg) {
        // 获取当前语言信息
        Locale locale = LocaleContextHolder.getLocale();
        // 根据 code 从国际化资源文件中查找相关信息
        return messageSource.getMessage(code, args, defaultMsg, locale);
    }

}

 

 

Step5:
  编写 TestController.java 进行测试。

package com.lyh.admin_template.back.controller;

import com.lyh.admin_template.back.common.utils.MessageSourceUtil;
import com.lyh.admin_template.back.common.utils.Result;
import com.lyh.admin_template.back.service.UserService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * 用于测试环境搭建各个功能是否成功
 */
@RestController
@RequestMapping("/test")
@Api(tags = "测试页面")
public class TestController {

    @Autowired
    private UserService userService;
    @Autowired
    private MessageSourceUtil messageSourceUtil;

    @ApiOperation(value = "测试国际化返回数据")
    @GetMapping("/testLocale")
    public Result testI18n() {
        return Result.ok().data("test", messageSourceUtil.getMessage("test"));
    }
}

 

 

如下图所示,
  当 cookie 中不存在 language 时,默认返回中文数据。
  当 cookie 中存在 language = zh_CH 时,返回中文数据。
  当 cookie 中存在 language = en_US 时,返回英文数据。

 

 

(4)整合 JSR303 进行国际化处理

【JSR303 国际化问题 参考:】
    https://blog.csdn.net/jin861625788/article/details/73181075

对于 JSR303 国际化问题,只需要让其也加载 国际化资源文件即可。

Step1:
  可以手动配置 Validator 实例对象。
  引入 import javax.validation.Validator; 不要导错包了。

package com.lyh.admin_template.back.common.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.support.ResourceBundleMessageSource;
import org.springframework.validation.beanvalidation.LocalValidatorFactoryBean;
import org.springframework.web.servlet.LocaleResolver;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
import org.springframework.web.servlet.i18n.CookieLocaleResolver;
import org.springframework.web.servlet.i18n.LocaleChangeInterceptor;

import javax.validation.Validator;
import java.util.Locale;

/**
 * 配置国际化语言
 */
@Configuration
public class LocaleConfig {

    /**
     * 默认解析器
     */
    @Bean
    public LocaleResolver localeResolver() {
        CookieLocaleResolver cookieLocaleResolver = new CookieLocaleResolver();
        cookieLocaleResolver.setDefaultLocale(Locale.SIMPLIFIED_CHINESE);
        cookieLocaleResolver.setCookieName("language");
        cookieLocaleResolver.setCookieMaxAge(-1);
        return cookieLocaleResolver;
    }

    /**
     * 定义拦截器,其中 language 表示切换语言的参数名。
     * 拦截请求后,根据请求中的 language 参数去设置语言。
     */
    @Bean
    public WebMvcConfigurer localeInterceptor() {
        return new WebMvcConfigurer() {
            @Override
            public void addInterceptors(InterceptorRegistry registry) {
                LocaleChangeInterceptor localeInterceptor = new LocaleChangeInterceptor();
                localeInterceptor.setParamName("language");
                registry.addInterceptor(localeInterceptor);
            }
        };
    }

    /**
     * 由于返回类型不是 MessageSource 类型,所以需要在 @Bean 注解中指明 name 参数,用于自动装配到 MessageSource 中。
     * 使用时 通过 @Autowired 注入 MessageSource 即可。
     * setBasenames 用于指定国际化资源文件前缀
     * setDefaultEncoding 用于指定编码字符集
     */
    @Bean(name = "messageSource")
    public ResourceBundleMessageSource getMessageSource() throws Exception {
        ResourceBundleMessageSource resourceBundleMessageSource = new ResourceBundleMessageSource();
        resourceBundleMessageSource.setDefaultEncoding("UTF-8");
        resourceBundleMessageSource.setBasenames("static/i18n/messages");
        return resourceBundleMessageSource;
    }

    /**
     * 配置 JSR303 国际化问题,让其加载国际化资源文件
     * @return
     * @throws Exception
     */
    @Bean
    public Validator getValidator() throws Exception {
        LocalValidatorFactoryBean validator = new LocalValidatorFactoryBean();
        validator.setValidationMessageSource(getMessageSource());
        return validator;
    }

}

 

 

Step2:
  修改相关实体类,使用 {} 获取配置文件中的值。

package com.lyh.admin_template.back.entity;

import com.baomidou.mybatisplus.annotation.*;
import com.lyh.admin_template.back.common.validator.group.AddGroup;
import com.lyh.admin_template.back.common.validator.group.UpdateGroup;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;

import javax.validation.constraints.NotEmpty;
import javax.validation.constraints.Pattern;
import java.io.Serializable;
import java.util.Date;

/**
 * <p>
 * 用户表
 * </p>
 *
 * @author lyh
 * @since 2020-06-08
 */
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@TableName("back_user")
@ApiModel(value="User对象", description="用户表")
public class User implements Serializable {

    private static final long serialVersionUID=1L;

    @ApiModelProperty(value = "用户 ID")
    @TableId(value = "id", type = IdType.ASSIGN_ID)
    private Long id;

    @NotEmpty(message = "{user.name.empty}", groups = {AddGroup.class, UpdateGroup.class})
    @ApiModelProperty(value = "用户名")
    private String name;

    @NotEmpty(message = "{user.mobile.empty}", groups = {AddGroup.class, UpdateGroup.class})
    @Pattern(message = "手机号格式不合法", regexp = "^[1-9]{1}\\d{10}$", groups = {AddGroup.class, UpdateGroup.class})
    @ApiModelProperty(value = "用户手机号")
    private String mobile;

    @NotEmpty(message = "{user.password.empty}", groups = {AddGroup.class, UpdateGroup.class})
    @ApiModelProperty(value = "用户密码")
    private String password;

    @TableField(fill = FieldFill.INSERT)
    @ApiModelProperty(value = "创建时间")
    private Date createTime;

    @TableField(fill = FieldFill.INSERT_UPDATE)
    @ApiModelProperty(value = "修改时间")
    private Date updateTime;

    @TableField(fill = FieldFill.INSERT)
    @TableLogic(value = "0", delval = "1")
    @ApiModelProperty(value = "逻辑删除标志,0 表示未删除, 1 表示删除")
    private Integer deleteFlag;

    @Version
    @TableField(fill = FieldFill.INSERT)
    @ApiModelProperty(value = "版本号")
    private Integer version;

}

 

 

Step3:
  修改对应的资源文件。

【messages_en_US.properties】
    user.name.empty=User name cannot be null
    user.mobile.empty=User mobile cannot be null
    user.password.empty=User password cannot be null

【messages_zh_CH.properties】
    user.name.empty=用户名不能为空
    user.mobile.empty=用户手机号不能为空
    user.password.empty=用户密码不能为空

 

 

Step4:
  简单测试一下。
  使用之前写好的 “测试 JSR 303 添加时的校验规则” 接口用于测试。

 


原文链接:https://www.cnblogs.com/l-y-h/p/13083375.html
如有疑问请与原作者联系

标签:PSword文件数据服务器开发

版权申明:本站文章部分自网络,如有侵权,请联系:west999com@outlook.com
特别注意:本站所有转载文章言论不代表本站观点,本站所提供的摄影照片,插画,设计作品,如需使用,请与原作者联系,版权归原作者所有

上一篇:java8 stream的分组功能,具体时候是真的好用

下一篇:类的继承,方法重新中修饰符如何定义