一文教你如何在项目开发中使用日志

SpringBoot日志

日志框架介绍

日志框架：

1. JUL：java原生日志框架
2. log4j：已终止
3. logback：原作者在log4j的基础上改进
4. log4j2：在logback基础上改进，，有自己独立的门面

日志门面：

slf4j：日志门面，日志的抽象层，一层规范，日志框架按照其规范实现具体细节即可，使用时，直接通过操作门面的方式去使用日志

阿里规范：

应用中不可直接使用日志系统（Log4j、Logback）中的API，而应依赖使用日志框架SLF4J中的API。使用门面模式的日志框架，有利于维护和各个类的日志处理方法统一。

实际使用：

实际项目开发中，遵循阿里规范，使用SLF4J和其他日志框架相结合的方式。

SLF4J绑定其他日志所需依赖：

绑定流程：

1. 添加slf4j-api的依赖

2. 使用slf4j的API在项目中进行统一的日志记录

3. 绑定具体的日志实现框架

   a. 绑定已经实现了slf4j的日志框架,直接添加对应依赖

   b. 绑定没有实现slf4j的日志框架,先添加日志的适配器,再添加实现类的依赖

4. slf4j有且仅有一个日志实现框架的绑定（如果出现多个默认使用第一个依赖日志实现）

绑定jul日志：

<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-api</artifactId>
    <version>1.7.27</version>
</dependency>
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-jdk14</artifactId>
    <version>1.7.25</version>
</dependency>

绑定log4j的实现：

<!--slf4j core 使用slf4j必須添加-->
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-api</artifactId>
    <version>1.7.27</version>
</dependency>
<!-- log4j-->
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-log4j12</artifactId>
    <version>1.7.27</version>
</dependency>
<dependency>
    <groupId>log4j</groupId>
    <artifactId>log4j</artifactId>
    <version>1.2.17</version>
</dependency>

绑定log4j2：

<!--使用slf4j作为日志的门面,使用log4j2来记录日志 -->
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-api</artifactId>
    <version>1.7.30</version>
</dependency>
<!--为slf4j绑定日志实现 log4j2的适配器 -->
<dependency>
    <groupId>org.apache.logging.log4j</groupId>
    <artifactId>log4j-slf4j-impl</artifactId>
    <version>2.12.1</version>
</dependency>

4. 绑定logback

   <!--使用slf4j作为日志的门面,使用log4j2来记录日志 -->
   <dependency>
       <groupId>org.slf4j</groupId>
       <artifactId>slf4j-api</artifactId>
       <version>1.7.30</version>
   </dependency>
   <!--为slf4j绑定日志实现 logback的适配器 -->
   <dependency>
       <groupId>ch.qos.logback</groupId>
       <artifactId>logback-classic</artifactId>
       <version>1.2.3</version>
   </dependency>
   

SLF4J原理解析

参考文章：Java日志框架：slf4j作用及其实现原理 - 五月的仓颉 - 博客园 (cnblogs.com)

SLF4J是一个日志规范，其他日志框架根据其规范具体实现即可，外部调用时，直接操作SLF4j。

一般的Java项目而言，日志框架 会选择slf4j-api作为门面，配上具体的实现框架（log4j、logback等），中间使用桥接器完成桥接。

具体桥接可以参考下方文章：文档合集 (ydlclass.com)

查看SpringBoot的默认实现：

SpringBoot的starter依赖中，包含了spring-boot-starter-logging依赖，该依赖中指定logback为默认的依赖。

依赖详情：

springboot默认以logback为依赖，logback-classic是log4j的一个改良版本，同时它完整实现了slf4j API，其余两个依赖为日志框架桥接，也就是说如果你的项目中或引的第三方jar包中有使用了log4j或者jul作为日志框架，则使用slf4j的实现。

原理解析：

1. SLF4J通过LoggerFactory加载日志具体的实现对象。
2. LoggerFactory在初始化的过程中，会通过performInitialization()方法绑定具体的日志实现。
3. 在绑定具体实现的时候，通过类加载器，加载org/slf4j/impl/StaticLoggerBinder.class
4. 所以，只要是一个日志实现框架，在org.slf4j.impl包中提供一个自己的StaticLoggerBinder类，在其中提供具体日志实现的LoggerFactory就可以被SLF4J所加载

进入 LoggerFactory

在slf4j中创建logger的方法是：

getIloggerFactory（）中的performInitialization方法绑定具体的日志

查看bing方法，在绑定具体实现的时候，通过类加载器，加载org/slf4j/impl/StaticLoggerBinder.class

查看具体实现：

所以，只要是一个日志实现框架，在org.slf4j.impl包中提供一个自己的StaticLoggerBinder类，在其中提供具体日志实现的LoggerFactory就可以被SLF4J所加载

切换SpringBoot默认依赖

SpringBoot默认的logback日志已经非常满足我们的使用了，我们在这里只介绍一下切换方法。

参考文章：(95条消息) spring boot 项目中使用log4j打印日志到Redis（详解）_至尊灬宝er的博客-CSDN博客_log4j redis

lomback日志的使用

基本使用

他是springboot的默认日志依赖，因此我们不需要再引入依赖，直接使用即可。

    private final static Logger logger = LoggerFactory.getLogger(AppController.class);
    logger.info("我是日志");

问题：需要打印日志的类，都需要添加该方法，麻烦，推荐使用Lombok的@SLF4J注解，来默认生成上方代码。

依赖：

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.16</version>
        </dependency>

使用方式：

效果：

此时，当我们查询mysql时，发现数据库没有打印日志，需要开启。

# 控制台打印sql日志
logging.level.com.cache.mycache.dao=debug

logging.level+mapper文件所在路径

效果：

logback的yaml配置详情：(93条消息) Spring Boot 默认日志使用__星辰夜风的博客-CSDN博客_spring 默认log

通过配置文件配置logback

yaml中配置logback的配置文件路径

logging:
  config: classpath:logback/logback-${spring.profiles.active}.xml

不同环境下，对日志的打印要求不一样，因此可以通过文件进行控制。

配置简单：logback的使用和logback.xml详解 - 行走在云端的愚公 - 博客园 (cnblogs.com)

详细配置：(92条消息) 使用logback输出日志总结_MrYuShiwen的博客-CSDN博客_logback打印日志

配置文件详情：

<?xml version="1.0" encoding="UTF-8"?>
<configuration scan="true" scanPeriod="30 seconds" debug="false">
    <contextName>SMPE-ADMIN</contextName>
    <property name="LOG_HOME" value="logs/%d{yyyy-MM,aux}/"/>
    <property name="LOG_" value="logs/"/>
    <property name="log.charset" value="utf-8"/>
    <property name="log.pattern"
              value="%black(%contextName-) %red(%d{yyyy-MM-dd HH:mm:ss}) %green([%thread]) %highlight(%-5level) %boldMagenta(%logger{36}) - %gray(%msg%n)"/>
    <!--输出到控制台-->
    <appender name="console" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>${log.pattern}</pattern>
            <charset>${log.charset}</charset>
        </encoder>
    </appender>

    <!-- 按照每天生成日志文件 -->
    <appender name="file" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <FileNamePattern>${LOG_HOME}/server.%d{yyyy-MM-dd-HH}.log</FileNamePattern>
            <MaxHistory>60</MaxHistory>
        </rollingPolicy>
        <encoder>
            <pattern>${log.pattern}</pattern>
            <charset>${log.charset}</charset>
        </encoder>
    </appender>

    <!--普通日志输出到控制台-->
    <root level="info">
        <!-- 开发环境日志只输出到控制台，不输出到文件 -->
        <appender-ref ref="console"/>
    </root>
</configuration>

效果：

Mysql日志

目的：进行数据库查询时，打印sql语句，并能打印sql操作结果。

sql日志

在控制台打印Mybatis日志

# 控制台打印sql日志
logging.level.com.cache.mycache.dao=debug

效果：

输出的是dao层的日志

log4jdbc

log4jdbc 是一个 Java JDBC Driver，可以记录 SQL 日志和 SQL 执行时间等信息

效果：

详细配置参考文章：(107条消息) Java - log4jdbc 使用与原理介绍（SQL/日志监控）_pan_mlpan的博客-CSDN博客_jdbc sql 监控

1. 安装依赖

<dependency>
      <groupId>org.bgee.log4jdbc-log4j2</groupId>
      <artifactId>log4jdbc-log4j2-jdbc4.1</artifactId>
      <version>1.16</version>
</dependency>

2. 配置

在使用 log4jdbc 时，需要进行三个配置：

• 更改数据库连接信息
• 编写 log4jdbc.log4j2.properties 文件
• 配置 logger

1. 更改数据库连接
   1. url 加上前缀 jdbc:log4jdbc
   2. driverClassName 改为 net.sf.log4jdbc.sql.jdbcapi.DriverSpy

# 修改前
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/ops_platform?characterEncoding=utf-8&useSSL=false

# 修改后
spring.datasource.driver-class-name=net.sf.log4jdbc.sql.jdbcapi.DriverSpy
spring.datasource.url=jdbc:log4jdbc:mysql://localhost:3306/ops_platform?characterEncoding=utf-8&useSSL=false

2. 编写 log4jdbc.log4j2.properties 文件

   1. 在resource目录下创建log4jdbc.log4j2.properties

   2. 内容

      # If you use SLF4J. First, you need to tell log4jdbc-log4j2 that you want to use the SLF4J logger
      log4jdbc.debug.stack.prefix=mycache
      log4jdbc.spylogdelegator.name=net.sf.log4jdbc.log.slf4j.Slf4jSpyLogDelegator
      log4jdbc.auto.load.popular.drivers=false
      log4jdbc.drivers=com.mysql.jdbc.Driver
      # 当该值为 false 时，boolean 值显示为 0 和 1 ，为 true 时 boolean 值显示为 true 和 false
      log4jdbc.dump.booleanastruefalse=true
      # 是否在 SQL 的行末添加一个分号
      log4jdbc.dump.sql.addsemicolon=true
      

3. 编写logback.xml文件

   1. 

   2. 在配置文件中执行logback.xml文件路径

      logging.config=classpath:logback.xml
      

   3. 在resource的相应目录下创建文件

      <?xml version="1.0" encoding="UTF-8"?>
      <configuration scan="true" scanPeriod="30 seconds" debug="false">
          <contextName>BLOG</contextName>
          <property name="LOG_HOME" value="logs/%d{yyyy-MM,aux}/"/>
          <property name="LOG_" value="logs/"/>
          <property name="log.charset" value="utf-8"/>
          <property name="log.pattern"
                    value="%black(%contextName-) %red(%d{yyyy-MM-dd HH:mm:ss}) %green([%thread]) %highlight(%-5level) %boldMagenta(%logger{36}) - %gray(%msg%n)"/>
          <!--输出到控制台-->
          <appender name="console" class="ch.qos.logback.core.ConsoleAppender">
              <encoder>
                  <pattern>${log.pattern}</pattern>
                  <charset>${log.charset}</charset>
              </encoder>
          </appender>
      
          <!-- 按照每天生成日志文件 -->
          <appender name="file" class="ch.qos.logback.core.rolling.RollingFileAppender">
              <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
                  <FileNamePattern>${LOG_HOME}/server.%d{yyyy-MM-dd-HH}.log</FileNamePattern>
                  <MaxHistory>60</MaxHistory>
              </rollingPolicy>
              <encoder>
                  <pattern>${log.pattern}</pattern>
                  <charset>${log.charset}</charset>
              </encoder>
          </appender>
      
          <!--    监控sql日志输出-->
          <!--  如想看到表格数据，将OFF改为INFO  -->
          <logger name="jdbc.resultsettable" level="INFO" additivity="false">
              <appender-ref ref="console"/>
          </logger>
          <!--    包含 SQL 语句实际的执行时间 及sql语句（与jdbc.sqlonly功能重复）   -->
          <logger name="jdbc.sqltiming" level="INFO" additivity="false">
              <appender-ref ref="console"/>
          </logger>
          <!--      仅仅记录 SQL 语句，会将占位符替换为实际的参数-->
          <logger name="jdbc.sqlonly" level="OFF" additivity="false">
              <appender-ref ref="console"/>
          </logger>
          <!--  包含 ResultSet 的信息，输出篇幅较长  -->
          <logger name="jdbc.resultset" level="ERROR" additivity="false">
              <appender-ref ref="console"/>
          </logger>
          <!-- 输出了 Connection 的 open、close 等信息  -->
          <logger name="jdbc.connection" level="OFF" additivity="false">
              <appender-ref ref="console"/>
          </logger>
          <!--    除了 ResultSet 之外的所有JDBC调用信息，篇幅较长 -->
          <logger name="jdbc.audit" level="OFF" additivity="false">
              <appender-ref ref="console"/>
          </logger>
      
          <!--普通日志输出到控制台-->
          <root level="info">
              <appender-ref ref="console"/>
              <appender-ref ref="file"/>
          </root>
      </configuration>
      
      

附：也可以根据不同的环境，配置日志不同的输出格式。

效果

有数据库的查询语句和结果。