SpringBoot+Mybatis+Swagger2环境搭建+logback-spring日志打印及入库

本文简介

本文将基于Spring官方提供的快速启动项目模板集成Mybatis、Swagger2框架，并讲解mybatis generator一键生成代码插件、logback、一键生成文档以及多环境的配置方法，最后再介绍一下自定义配置的注解获取、全局异常处理等经常用到的东西。

为什么使用SpringBoot

相对于传统的SSM框架，SpringBoot提供了默认的样板化配置，简化了Spring应用的初始搭建过程，如果你不想被众多xml配置困扰，就可以用SpringBoot来代替。

开发环境

开发工具：IDEA。IDEA默认集成了SpringBoot的快速启动项目。

PS：SpringBoot2.0以上要求JDK8.0及以上

创建项目

使用IDEA，在新建项目时选择Spring Initializr，主要配置如图：


创建完成，结构目录如下：

集成所需的配置

1.修改.properties为.yml

yml相对于properties更加精简而且很多官方给出的Demo都是yml的配置形式，在这里我们采用yml的形式代替properties，相对于properties形式主要有以下两点不同：

1. 对于键的描述由原有的 “.” 分割变成了树的形状；
2. 对于所有的键的后面一个要跟一个空格，不然启动项目会报配置解析错误。

spring:
  datasource:
    # 如果存在多个数据源，监控的时候可以通过名字来区分开来
    name: mysql
    # 连接数据库的url
    url: jdbc:mysql://localhost:3306/springdemo?characterEncoding=UTF8&serverTimezone=Asia/Shanghai
    # 连接数据库的账号
    username: root
    # 连接数据库的密码
    password: root
    # 使用druid数据源
    type: com.alibaba.druid.pool.DruidDataSource
    # 扩展插件
    # 监控统计用的filter:stat 日志用的filter:log4j 防御sql注入的filter:wall
    filters: stat
    # 最大连接池数量
    maxActive: 20
    # 初始化时建立物理连接的个数。初始化发生在显示调用init方法，或者第一次getConnection时
    initialSize: 1
    # 获取连接时最大等待时间，单位毫秒
    maxWait: 60000
    # 最小连接池数量
    minIdle: 1
    timeBetweenEvictionRunsMillis: 60000
    # 连接保持空闲而不被驱逐的最长时间
    minEvictableIdleTimeMillis: 300000
    # 用来检测连接是否有效的sql，要求是一个查询语句
    # 如果validationQuery为null，testOnBorrow、testOnReturn、testWhileIdle都不会其作用
    validationQuery: select count(1) from 'table'
    # 申请连接的时候检测，如果空闲时间大于timeBetweenEvictionRunsMillis，执行validationQuery检测连接是否有效
    testWhileIdle: true
    # 申请连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能
    testOnBorrow: false
    # 归还连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能
    testOnReturn: false
    # 是否缓存preparedStatement，即PSCache
    poolPreparedStatements: false
    # 要启用PSCache，必须配置大于0，当大于0时，poolPreparedStatements自动触发修改为true
    maxOpenPreparedStatements: -1

# pagehelper分页插件
pagehelper:
  # 数据库的方言
  helperDialect: mysql
  # 启用合理化，如果pageNum < 1会查询第一页，如果pageNum > pages会查询最后一页
  reasonable: true

2.配置所需依赖

快速启动项目创建成功后我们观察其pom.xml文件中的依赖如下图，包含了我们选择的Web、Mybatis以及Mysql

<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.1.1</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

除此之外，使用ORM框架一般还会配合数据库连接池以及分页插件来使用，阿里的druid、pagehelper分页插件，整合swagger2文档自动化构建框架，生成逆向代码的mybatis-generator-core，所以增加了以下五个依赖项：

<!-- 分页插件 -->
        <dependency>
            <groupId>com.github.pagehelper</groupId>
            <artifactId>pagehelper-spring-boot-starter</artifactId>
            <version>1.2.3</version>
        </dependency>
        <!-- alibaba的druid数据库连接池 -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.1</version>
        </dependency>
        <!-- alibaba的json格式化对象 -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.31</version>
        </dependency>
        <!-- 自动生成API文档 -->
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger2</artifactId>
            <version>2.5.0</version>
        </dependency>
        <!--官方给出的ui界面-->
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger-ui</artifactId>
            <version>2.6.1</version>
        </dependency>
        <!-- mybatis-generator-core 反向生成java代码-->
        <dependency>
            <groupId>org.mybatis.generator</groupId>
            <artifactId>mybatis-generator-core</artifactId>
            <version>1.3.5</version>
        </dependency>
        <!-- Lombok插件 -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.8</version>
        </dependency>

PS：配合pagehelper使用的配置项，在前面的yml配置中已经配了

3.集成Mybatis

Mybatis的配置主要包括了druid数据库连接池、pagehelper分页插件、mybatis-generator代码逆向生成插件以及mapper、pojo扫描配置
前两项已经在yml配置文件中配置好了。

mybatis-generator插件的使用主要分为以下三步

1. pom.xml中添加mybatis-generator插件

			<!-- 将Spring Boot应用打包为可执行的jar或war文件 -->
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
            <!-- mybatis generator 自动生成代码插件 -->
            <plugin>
                <groupId>org.mybatis.generator</groupId>
                <artifactId>mybatis-generator-maven-plugin</artifactId>
                <version>1.3.2</version>
                <configuration>
                    <!-- 扫描resources/generator目录下的generatorConfig.xml配置 -->
                    <configurationFile>
                        ${basedir}/src/main/resources/generator/generatorConfig.xml
                    </configurationFile>
                    <overwrite>true</overwrite>
                    <verbose>true</verbose>
                </configuration>
            </plugin>

2. 创建逆向代码生成配置文件generatorConfig.xml
   参照pom.xml插件配置中的扫描位置，在resources目录下创建generator文件夹，在新建的文件夹中创建generatorConfig.xml配置文件，文件的详细配置信息如下：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE generatorConfiguration
        PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
        "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">
<generatorConfiguration>
    <!-- 运行方式:mvaen运行命令 mybatis-generator:generate -e -->
    <!-- 数据库驱动:选择你的本地硬盘上面的数据库驱动包-->
    <properties resource="generator/generator.properties"/>
    <classPathEntry location="${classPathEntry}"/>
    <context id="DB2Tables" targetRuntime="MyBatis3">
        <!--数据库链接URL，用户名、密码 -->
        <jdbcConnection
                driverClass="com.mysql.jdbc.Driver"
                connectionURL="jdbc:mysql://localhost:3306/${db}?characterEncoding=UTF8&amp;serverTimezone=Asia/Shanghai"
                userId="${userId}"
                password="${password}">
        </jdbcConnection>
        <javaTypeResolver>
            <property name="forceBigDecimals" value="false"/>
        </javaTypeResolver>
        <javaModelGenerator targetPackage="${pojoTargetPackage}" targetProject="src/main/java">
            <property name="enableSubPackages" value="true"/>
            <property name="trimStrings" value="true"/>
        </javaModelGenerator>
        <!-- 生成映射文件的包名和位置-->
        <sqlMapGenerator targetPackage="${mapperTargetPackage}" targetProject="src/main/resources">
            <property name="enableSubPackages" value="true"/>
        </sqlMapGenerator>
        <!-- 生成DAO的包名和位置-->
        <javaClientGenerator type="XMLMAPPER" targetPackage="${daoTargetPackage}" targetProject="src/main/java">
            <property name="enableSubPackages" value="true"/>
        </javaClientGenerator>
        <!-- 要生成的表 tableName是数据库中的表名或视图名，%表示数据库下的所有表  schema是数据库名称-->
        <table tableName="%" schema="${db}"/>
    </context>
</generatorConfiguration>

为了将generatorConfig.xml配置模板化，在这里将变动性较大的配置项单独提取出来作为一个generatorConfig.xml的配置文件，然后通过properties标签读取此文件的配置，这样做的好处是当需要多处复用此xml时只需要关注少量的配置项。
做法如下：在generatorConfig.xml同级创建generator.properties文件，只需要配置generator.properties文件即可，配置内容如下：

# 请手动配置以下选项
# 数据库驱动:选择数据库驱动包，版本对应你连接的mysql版本
classPathEntry = D:/Java/mysql-connector-java-5.1.47.jar
# 数据库名称、用户名、密码
db = springdemo
userId = root
password = root
# 生成pojo的包名位置 在src/main/java目录下
pojoTargetPackage = com.spring.demo.springbootexample.mybatis.po
# 生成DAO的包名位置 在src/main/java目录下
daoTargetPackage = com.spring.demo.springbootexample.mybatis.mapper
# 生成Mapper的包名位置 位于src/main/resources目录下
mapperTargetPackage = mapper

3. 运行mybatis-generator插件生成dao、pojo、mapper

打开命令行cd到项目pom.xml同级目录运行以下命令，
或者在pom.xml文件夹处按住Shift并右键，选择“在此处打开PowerShell窗口”执行以下命令

执行：mvn mybatis-generator:generate -e


以上，在项目工程中即可自动生成逆向代码：

继续配置Mybatis，

4. mybatis扫描包配置

4.1、在application.yml配置mapper.xml以及pojo的包地址

mybatis:
  # mapper.xml包地址
  mapper-locations: classpath:mapper/*.xml
  # pojo生成包地址
  type-aliases-package: com.spring.demo.springbootexample.mybatis.po

4.2、在SpringBootExampleApplication.java中开启Mapper扫描注解

package com.spring.demo.springbootexample;

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

@SpringBootApplication
@MapperScan("com.spring.demo.springbootexample.mybatis.mapper")
public class SpringBootExampleApplication {

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

}

至此，Springboot+Mybatis+逆向代码已经集成完毕。

集成Swagger2

Swagger2是一个文档快速构建工具，能够通过注解自动生成一个Restful风格json形式的接口文档，并可以通过如swagger-ui等工具生成html网页形式的接口文档，swagger2的集成比较简单，集成、注解与使用分为四步

1、配置SwaggerConfig文件

package com.spring.demo.springbootexample.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import springfox.documentation.builders.ApiInfoBuilder;
import springfox.documentation.service.ApiInfo;
import springfox.documentation.service.Contact;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;

/**
 * 集成Swagger2配置
 * @author: chengsw
 * @date: 2019/11/26
 */
@Configuration
public class SwaggerConfig {
    // 接口版本号
    private final String version = "1.0";
    // 接口大标题
    private final String title = "SpringBoot示例工程";
    // 具体的描述
    private final String description = "API文档自动生成示例";
    // 服务说明url
    private final String termsOfServiceUrl = "http://www.chengsw.top";
    // licence
    private final String license = "CSW";
    // licnce url
    private final String licenseUrl = "https://csw-license.org/";
    // 接口作者联系方式
    private final Contact contact = new Contact("chengsw", "https://www.baidu.com", "[email protected]");

    @Bean
    public Docket buildDocket() {
        return new Docket(DocumentationType.SWAGGER_2).apiInfo(buildApiInf())
                .select()
   .apis(RequestHandlerSelectors.basePackage("com.spring.demo.springbootexample.controller"))
                .paths(PathSelectors.any())//配置需要解析的请求位置
                .build();
    }

    private ApiInfo buildApiInf() {
        return new ApiInfoBuilder().title(title).termsOfServiceUrl(termsOfServiceUrl).description(description)
                .version(version).license(license).licenseUrl(licenseUrl).contact(contact).build();
    }

}

2、在SpringBoot项目启动类加入@EnableSwagger2注解

3、常用注解使用示例

/**
 * Swagger在Contorller中的注解示例
 * @author: chengsw
 * @date: 2019/11/26
 */
@RestController
@RequestMapping("/v1/com")
@Api(value = "SwaggerTestController", tags = {"restful api示例"}) // 表示标识这个类是swagger的资源
public class SwaggerTestController {

    Logger logger = LoggerFactory.getLogger(SwaggerTestController.class);

    @Autowired
    private SwaggerTestService swaggerTestService;

    @GetMapping("/{id}")
    //表示一个http请求的操作
    @ApiOperation(value = "根据id查询企业信息", httpMethod = "GET")
    //@ApiImplicitParams用于方法，包含多个@ApiImplicitParam表示单独的请求参数
    @ApiImplicitParams({@ApiImplicitParam(name = "id", value = "企业id", required = true, paramType = "path"),
            @ApiImplicitParam(name = "id2", value = "测试参数", required = false, paramType = "path")})
    public BaseResponse selectComInfoById(@PathVariable("id") String id) {
        if (StringHelper.isNullOrEmptyString(id)) {
            logger.error(">> 根据id查询企业信息-请求参数异常 id->{}", id);
            return BaseResponse.error();
        }
        ComBasicInfo basicInfo = swaggerTestService.selectComInfoById(id);
        logger.info(">> 根据id查询企业信息完成 id->{}", id);
        return BaseResponse.success(basicInfo);
    }
    
}

4、启动项目，进入页面查看

http://localhost:8080/swagger-ui.html#/

logback-spring日志配置

在application.yml的同级目录创建logback-spring.xml，springboot推荐使用logback-spring.xml，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="60 seconds">
    <contextName>logback</contextName>

    <!-- name的值是变量的名称，value的值时变量定义的值。通过定义的值会被插入到logger上下文中。定义后，可以使“${}”来使用变量。 -->
    <property name="log.path" value="./logs" />

    <!--0. 日志格式和颜色渲染 -->
    <!-- 彩色日志依赖的渲染类 -->
    <conversionRule conversionWord="clr" converterClass="org.springframework.boot.logging.logback.ColorConverter" />
    <conversionRule conversionWord="wex" converterClass="org.springframework.boot.logging.logback.WhitespaceThrowableProxyConverter" />
    <conversionRule conversionWord="wEx" converterClass="org.springframework.boot.logging.logback.ExtendedWhitespaceThrowableProxyConverter" />
    <!-- 彩色日志格式 -->
    <property name="CONSOLE_LOG_PATTERN" value="${CONSOLE_LOG_PATTERN:-%clr(%d{yyyy-MM-dd HH:mm:ss.SSS}){faint} %clr(${LOG_LEVEL_PATTERN:-%5p}) %clr(${PID:- }){magenta} %clr(---){faint} %clr([%15.15t]){faint} %clr(%-40.40logger{39}){cyan} %clr(:){faint} %m%n${LOG_EXCEPTION_CONVERSION_WORD:-%wEx}}"/>

    <!--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>

    <!--2. 输出到文档-->
    <!-- 2.1 level为 DEBUG 日志，时间滚动输出  -->
    <appender name="DEBUG_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <!-- 正在记录的日志文档的路径及文档名 -->
        <file>${log.path}/web_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}/web-debug-%d{yyyy-MM-dd}.%i.log</fileNamePattern>
            <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                <maxFileSize>100MB</maxFileSize>
            </timeBasedFileNamingAndTriggeringPolicy>
            <!--日志文档保留天数-->
            <maxHistory>30</maxHistory>
        </rollingPolicy>
        <!-- 此日志文档只记录debug级别的 -->
        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <level>debug</level>
            <onMatch>ACCEPT</onMatch>
            <onMismatch>DENY</onMismatch>
        </filter>
    </appender>

    <!-- 2.2 level为 INFO 日志，时间滚动输出  -->
    <appender name="INFO_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <!-- 正在记录的日志文档的路径及文档名 -->
        <file>${log.path}/web_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>30</maxHistory>
        </rollingPolicy>
        <!-- 此日志文档只记录info级别的 -->
        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <level>info</level>
            <onMatch>ACCEPT</onMatch>
            <onMismatch>DENY</onMismatch>
        </filter>
    </appender>

    <!-- 2.3 level为 WARN 日志，时间滚动输出  -->
    <appender name="WARN_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <!-- 追加方式记录日志 -->
        <append>true</append>
        <!-- 正在记录的日志文档的路径及文档名 -->
        <file>${log.path}/web_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}/web-warn-%d{yyyy-MM-dd}.%i.log</fileNamePattern>
            <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                <maxFileSize>100MB</maxFileSize>
            </timeBasedFileNamingAndTriggeringPolicy>
            <!--日志文档保留天数-->
            <maxHistory>30</maxHistory>
        </rollingPolicy>
        <!-- 此日志文档只记录warn级别的 -->
        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <level>warn</level>
            <onMatch>ACCEPT</onMatch>
            <onMismatch>DENY</onMismatch>
        </filter>
    </appender>

    <!-- 2.4 level为 ERROR 日志，时间滚动输出  -->
    <appender name="ERROR_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <!-- 追加方式记录日志 -->
        <append>true</append>
        <!-- 正在记录的日志文档的路径及文档名 -->
        <file>${log.path}/web_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}/web-error-%d{yyyy-MM-dd}.%i.log</fileNamePattern>
            <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                <maxFileSize>100MB</maxFileSize>
            </timeBasedFileNamingAndTriggeringPolicy>
            <!--日志文档保留天数-->
            <maxHistory>30</maxHistory>
        </rollingPolicy>
        <!-- 此日志文档只记录ERROR级别的 -->
        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <level>ERROR</level>
            <onMatch>ACCEPT</onMatch>
            <onMismatch>DENY</onMismatch>
        </filter>
    </appender>

    <!--
        <logger>用来设置某一个包或者具体的某一个类的日志打印级别、以及指定<appender>。
        <logger>仅有一个name属性，一个可选的level和一个可选的addtivity属性。
        name:用来指定受此logger约束的某一个包或者具体的某一个类。
        level:用来设置打印级别，大小写无关：TRACE, DEBUG, INFO, WARN, ERROR, ALL 和 OFF，
              还有一个特俗值INHERITED或者同义词NULL，代表强制执行上级的级别。
              如果未设置此属性，那么当前logger将会继承上级的级别。
        addtivity:是否向上级logger传递打印信息。默认是true。
        <logger name="org.springframework.web" level="info"/>
        <logger name="org.springframework.scheduling.annotation.ScheduledAnnotationBeanPostProcessor" level="INFO"/>
    -->

    <!--
        使用mybatis的时候，sql语句是debug下才会打印，而这里我们只配置了info，所以想要查看sql语句的话，有以下两种操作：
        第一种把<root level="info">改成<root level="DEBUG">这样就会打印sql，不过这样日志那边会出现很多其他消息
        第二种就是单独给dao下目录配置debug模式，代码如下，这样配置sql语句会打印，其他还是正常info级别：
        【logging.level.org.mybatis=debug logging.level.dao=debug】
     -->

    <!--
        root节点是必选节点，用来指定最基础的日志输出级别，只有一个level属性
        level:用来设置打印级别，大小写无关：TRACE, DEBUG, INFO, WARN, ERROR, ALL 和 OFF，
        不能设置为INHERITED或者同义词NULL。默认是DEBUG
        可以包含零个或多个元素，标识这个appender将会添加到这个logger。
    -->

    <!-- 4. 最终的策略 -->
    <!-- 4.1 开发环境:打印控制台-->
    <springProfile name="dev">
        <logger name="com.spring.demo.springbootexample" level="warn"/><!--console控制台日志级别-->
        <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>


    <!-- 4.2 生产环境:输出到文档
    <springProfile name="prod">
        <logger name="com.spring.demo.springbootexample" level="error"/>
        <root level="info">
            <appender-ref ref="CONSOLE" />
            <appender-ref ref="DEBUG_FILE" />
            <appender-ref ref="INFO_FILE" />
            <appender-ref ref="ERROR_FILE" />
            <appender-ref ref="WARN_FILE" />
        </root>
    </springProfile> -->

    <!-- 5. 将日志写入数据库 -->
    <appender name="DB" class="ch.qos.logback.classic.db.DBAppender">
        <!--日志异步到数据库-->
        <connectionSource class="ch.qos.logback.core.db.DriverManagerConnectionSource">
            <driverClass>com.mysql.cj.jdbc.Driver</driverClass>
            <url>jdbc:mysql://localhost:3306/springdemo?useSSL=false&amp;useUnicode=true&amp;characterEncoding=UTF8&amp;serverTimezone=Asia/Shanghai</url>
            <user>root</user>
            <password>root</password>
        </connectionSource>
        <!--这里设置日志级别过滤器-->
        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <level>error</level>
            <onMatch>ACCEPT</onMatch><!--匹配时的操作：接收（记录）-->
            <onMismatch>DENY</onMismatch><!--不匹配时的操作：拒绝（不记录）-->
        </filter>
    </appender>

    <!-- 记录日志扫描的包，console打印的日志级别 -->
    <logger name="com.spring.demo.springbootexample" level="info">
        <appender-ref ref="DB"/>
    </logger>
    <!-- 基于info处理日志：具体控制台或者文件对日志级别的处理还要看所在appender配置的filter，如果没有配置filter，则使用root配置 -->
    <root level="error">
        <appender-ref ref="DB"/>
    </root>

</configuration>

补充

• @Api(value = “SwaggerTestController”, tags = {“restful api示例”})
  该注解tags如果存在中文，会导致swagger2 UI界面接口点击无法展开问题，可以通过去掉中文解决，或者页面点击Expand Operations（不足：该类下所有接口同时展开或收缩）。
• Java驱动包下载地址：

https://mvnrepository.com/artifact/mysql/mysql-connector-java
下载对应版本，不对应可能会出现报错或者数据库连接下所有表执行逆向代码（>8.0）。

• 说一下日志打印和存储数据库的配置关系
  
  根据上图：

1. console控制台打印的日志为logger设置的，打印范围为name属性的包范围；
2. 如果1配置了onMatch、onMismatch配置如图，则打印日志最多只可能打印warn，如果2的配置级别高于1，则日志数据库不保存数据；如果1没有配置onMatch、onMismatch配置如图（注释掉），则数据库日志和2级别一致；
3. 3不论是否存在时，都不影响上面的结论，看了一下资料，root也是logger，是根logger。意义可能是在配置多个logger是，使用< appender-ref ref=“DB”/>来标记这些日志保存的位置是DB所指向的数据库。
4. 这种配置数据库是默认的，数据库sql见附件。

欢迎补充和指出错误~

代码链接

链接：https://pan.baidu.com/s/1K1JBsFBhfpHwFZM9IUqG7g
提取码：yfr5