为什么程序需要记录日志

我们不可能实时的24小时对系统进行人工监控，那么如果程序出现异常错误时要如何排查呢？并且系统在运行时做了哪些事情我们又从何得知呢？这个时候日志这个概念就出现了，日志的出现对系统监控和异常分析起着至关重要的作用；

就拿java来说，在早期的日志都是通过System.out.println()进行记录的，但是这种方式不便于管理，所以apache最先开发了首个日志框架：log4j; 为日志框架奠定了基础；

日志框架出现的历史顺序为 ： log4j → JUL → JCL → SLF4J → logback → log4j2

java日志框架分类

日志实现

1. JUL（java.util.logging）：java自带的日志框架，适合小型项目
2. logback：目前比较火的框架，spring2.0默认使用logback日志
3. log4j：老牌日志框架，apache 旗下
4. log4j2：log4j升级版，目前最好的日志实现技术

日志门面接口

1. JCL（jakarta commons Logging）：apache旗下
2. slf4j (simple logging facade for java)：目前比较火的

JUL java.util.logging）-- java自带的日志框架

JUL日志级别

JUL一共有7个日志级别，用法如下：

logger.(Level.INFO,"info");

1. Level.SEVERE：最高级别的日志，主要记录错误信息
2. Level.WARNING：级别排行第二，记录警告信息
3. Level.INFO：级别排行第三，最常用的日志级别，记录普通消息，比如请求信息、连接信息、参数信息等等
4. Level.CONFIG：级别排行第四，记录配置信息，加载配置文件、读取配置参数都可以使用CONFIG记录
5. Level.FINE ：debug 时记录的 日志消息，记录运行时的状态、传递的参数等等
6. Level.FINER：debug 时记录的 日志消息，记录运行时的状态、传递的参数等等
7. Level.FINEST：debug 时记录的 日志消息，记录运行时的状态、传递的参数等等
8. Level.ALL：所有记录都开启
9. Level.OFF： 关闭日志记录

其中，FINE、FINER、FINEST都是记录debug信息的，三者取其一即可；

JUL原理

1. Logger是用来记录日志的，
2. LogRecord是用来传递日志的，
3. Handler是用来导出（处理）日志的，
4. Level是用来定义日志级别的（控制日志输出），
5. Filter提供了日志级别之外更细粒度的控制，
6. Formatter是用来格式化LogRecord的，
7. 此外还有一个单一的全局的LogManager维护Logger和管理日志。JUL主要由这七个核心类或接口组成，再有就是一些子类或者实现类。API中关于这几个类或接口的类和方法的详细介绍这里不再复述。现在我们已经对JUL有了一个整体的了解，并且对核心类或接口的功能职责也有了初步了解，接下就该结合代码看看JUL的真面目。

JUL配置文件详解

新建一个文件名为：logging.properties，内容如下，以下配置可以同时输出到控制台和文件中

#为顶级父元素RootLogger指定默认的处理器:ConsoleHandler,即若是你没有自定义Logger,就用这个Logger
handlers=java.util.logging.ConsoleHandler
#顶级父元素默认的日志级别为INFO,即此Logger的日志级别是INFO
.level=INFO 
#自定义Logger,即该Logger的name为com.yexindong,调用时这样即可 Logger logger = Logger.getLogger("com.yexindong");
#指定了自定义Logger的handlers，ConsoleHandler是输出到控制台，FileHandler是输出到文件中，两个都指定就可以同时输出；
com.yexindong.handlers=java.util.logging.ConsoleHandler, java.util.logging.FileHandler
#指定了自定义Logger的日志级别
com.yexindong.level=INFO
#关闭默认配置
com.yexindong.useParentHandlers=false

#*******************向文件输出的handler对象 start*******************
#指定日志文件输出的路径
java.util.logging.FileHandler.pattern=D:\\ying.log
#指定文件内容的大小(单位：字节(b))
java.util.logging.FileHandler.limit=50000
#指定日志文件的个数
java.util.logging.FileHandler.count=10
#指定日志文件的格式,
java.util.logging.FileHandler.formatter=java.util.logging.SimpleFormatter
#指定以追加的方式添加日志内容
java.util.logging.FileHandler.append=true
#*******************向文件输出的handler对象 end*******************

#*******************向控制台输出的handler对象 start*****************
#指定日志级别 ,尽量和自定义的级别相同，否则会有些日志无法打印处理
java.util.logging.ConsoleHandler.level=INFO
#指定日志的格式
java.util.logging.ConsoleHandler.formatter=java.util.logging.SimpleFormatter
#指定日志的编码
java.util.logging.ConsoleHandler.encoding=UTF-8
#*******************向控制台输出的handler对象 end*****************
#指定日志消息的格式
java.util.logging.SimpleFormatter.format=%1$tY-%1$tm-%1$td %1$tH:%1$tM:%1$tS %4$s %2$s %5$s%6$s%n

log4j

log4j 很重要的一个缺陷是不支持占位符，但是用户可自己定义实现占位符的功能，

log4j日志级别

log4j的默认日志级别 是debug；

1. logger.fatal(info)：记录严重的错误信息，一般会造成系统崩溃并终止运行
2. logger.error(info)：记录错误信息，不会影响系统运行
3. logger.warn(info)：记录警告信息
4. logger.info(info)：记录运行信息，
5. logger.debug(info)：（默认）记录调式信息，一般在开发中使用
6. logger.trace(info)：记录追踪信息，记录程序的流程信息；

Appenders

Appenders ·是用来指定将日志输出到哪个地方，可以同时指定日志的输出目的地，log4j常用的Appenders有以下几种

layouts

布局器，用于控制日志输出的格式，让我么可以自定义日志格式，log4j常用的layouts有以下几种

PatternLayout 格式语法

log4j2

apache log4j2是对log4j的升级班，参考了logback的一些优秀设计，并且修复了logback体系中的一些问题，因此带来了一些重大的提升，主要有以下几点

1. 异常处理，在logback中，appender中的异常不会被应用感知到，但是log4j2中，提供了一些异常处理机制
2. 性能提升，log2j 比log4j和logback都具有明显的性能提升，官方数据是提升了18倍
3. 自动重载配置，参考了logback的设计，提供了自动刷新参数的配置，在生产上可以动态修改日志级别，而不需要重启应用；
4. 无垃圾机制，（默认开启）log4j2在大部分情况下， 都可以使用无垃圾机制，避免频繁的日志收集导致触发jvm的垃圾回收机制；

log4j2 异步日志原理

1. 应用程序的主线程调用打印记录日志的方法后，传递到logEvent对象
2. event将对象加入到一个阻塞队列（ArrayBlockingQueue）中
3. 此时，主线程的工作就已经完成了，其余工作交给log异步线程就可以了
4. 阻塞队列（ArrayBlockingQueue）收到日志消息后，立马将消息发给appender对象
5. appender收到消息后开始打输出消息；

搭建 log4j2门面 + log4j2实现

添加依赖

<!-- log4j门面-->
<dependency>
    <groupId>org.apache.logging.log4j</groupId>
    <artifactId>log4j-api</artifactId>
    <version>2.15.0</version>
</dependency>
<!-- log4j2依赖-->
<dependency>
    <groupId>org.apache.logging.log4j</groupId>
    <artifactId>log4j-core</artifactId>
    <version>2.15.0</version>
</dependency>

java代码

package com;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
//使用log4j作为门面
public class Log4j2App {
    public static void main(String[] args) {
        Logger logger = LogManager.getLogger(Log4j2App.class);
        logger.fatal("max error");
        logger.error("error");
        logger.warn("warn");
        logger.info("info");
        logger.debug("debug");
        logger.trace("trace");
        
    }
}

配置文件log4j2.xml

<?xml version="1.0" encoding="UTF-8"?>
<!--日志级别以及优先级排序: OFF > FATAL > ERROR > WARN > INFO > DEBUG > TRACE > ALL -->
<!--Configuration后面的status，这个用于设置log4j2自身内部的信息输出，可以不设置，当设置成trace时，你会看到log4j2内部各种详细输出-->
<!--monitorInterval：Log4j能够自动检测修改配置 文件和重新配置本身，设置间隔秒数-->
<configuration status="WARN" monitorInterval="30">

    <properties>
        <!-- 配置全局变量，使用时通过：${name} 获取-->
        <property name="LOG_PATH">D:\\log\\</property>
        <property name="pattern_format">[%d{HH:mm:ss:SSS}] [%-5p] - %l -- %m%n</property>
    </properties>
    <!--先定义所有的appender-->
    <appenders>
        <!--控制台的输出配置-->
        <console name="Console" target="SYSTEM_OUT">
            <!--输出日志的格式-->
            <PatternLayout pattern="${pattern_format}"/>
        </console>

        <!--文件会打印出所有信息，这个log每次运行程序会自动清空，由append属性决定，这个也挺有用的，适合临时测试用-->
        <File name="log" fileName="${LOG_PATH}/log4j2_all.log" append="false">
            <PatternLayout pattern="${pattern_format}"/>
        </File>
        <!-- RandomAccessFile 使用随机读写流输出日志到文件，性能较高 -->
        <RandomAccessFile name="file" fileName="${LOG_PATH}/randomAccessFile.log">
            <PatternLayout pattern="${pattern_format}"/>
        </RandomAccessFile>
        <!-- RollingFile 按照一定的规则进行拆分文件-->
        <!-- 这个会打印出所有的info及以下级别的信息，每次大小超过size，则这size大小的日志会自动存入按年份-月份建立的文件夹下面并进行压缩，作为存档-->
        <RollingFile name="RollingFileInfo" fileName="${LOG_PATH}/info_low.log" filePattern="${LOG_PATH}/$${date:yyyy-MM}/info-%d{yyyy-MM-dd}-%i.log">
            <!--控制台只输出level及以上级别的信息（onMatch），其他的直接拒绝（onMismatch）-->
            <ThresholdFilter level="info" onMatch="ACCEPT" onMismatch="DENY"/>
            <PatternLayout pattern="${pattern_format}"/>
            <Policies>
                <!-- 系统启动或重启时就触发拆分规则，生成一个新的日志文件-->
                <OnStartupTriggeringPolicy/>
                <!-- 按照时间的节点进行拆分 ，根据filePattern定义的规则拆分-->
                <TimeBasedTriggeringPolicy/>
                <!-- 按文件大小进行拆分-->
                <SizeBasedTriggeringPolicy size="100 KB"/>
            </Policies>
            <!-- 在同一目录下，日志文件的个数限定为30个，超过30个则会覆盖，这个配置可以有效防止日志文件过大导致磁盘空间不足； -->
            <DefaultRolloverStrategy max="30"/>
        </RollingFile>
        <!-- 只打印 info级别的信息-->
        <RollingFile name="RollingFileInfo" fileName="${LOG_PATH}/info.log" filePattern="${LOG_PATH}/$${date:yyyy-MM}/info-%d{yyyy-MM-dd}-%i.log">
            <!--控制台只输出 info 级别的信息-->
            <filters>
                <!-- onMismatch="NEUTRAL" 表示该级别及以下的，由下一个filter处理，如果当前是最后一个，则不匹配该级别以下的 onMatch="DENY" 表示不匹配该级别及以上 -->
                <ThresholdFilter level="warn" onMatch="DENY" onMismatch="NEUTRAL"/>
                <!-- onMatch="ACCEPT" 表示匹配该级别及以上 onMismatch="DENY" 表示不匹配该级别以下的 -->
                <ThresholdFilter level="info" onMatch="ACCEPT" onMismatch="DENY"/>
            </filters>

            <PatternLayout pattern="${pattern_format}"/>
            <Policies>
                <TimeBasedTriggeringPolicy/>
                <SizeBasedTriggeringPolicy size="100 KB"/>
            </Policies>
        </RollingFile>
        <!-- 只打印warn级别的信息，并自动存档-->
        <RollingFile name="RollingFileWarn" fileName="${LOG_PATH}/warn.log" filePattern="${LOG_PATH}/$${date:yyyy-MM}/warn-%d{yyyy-MM-dd}-%i.log">
            <!-- 只打印warn级别的日志-->
            <filters>
                <ThresholdFilter level="error" onMatch="DENY" onMismatch="NEUTRAL"/>
                <ThresholdFilter level="warn" onMatch="ACCEPT" onMismatch="DENY"/>
            </filters>
            <PatternLayout pattern="${pattern_format}"/>
            <Policies>
                <TimeBasedTriggeringPolicy/>
                <SizeBasedTriggeringPolicy size="100 KB"/>
            </Policies>
            <!-- DefaultRolloverStrategy属性如不设置，则默认为最多同一文件夹下7个文件，这里设置了20 -->
            <DefaultRolloverStrategy max="20"/>
        </RollingFile>
        <!-- 打印error级别以上的信息-->
        <RollingFile name="RollingFileError" fileName="${LOG_PATH}/error.log" filePattern="${LOG_PATH}/$${date:yyyy-MM}/error-%d{yyyy-MM-dd}-%i.log">
            <!-- 只打印error级别的日志-->
            <filters>
                <ThresholdFilter level="error" onMatch="ACCEPT" onMismatch="DENY"/>
            </filters>
            <PatternLayout pattern="${pattern_format}"/>
            <Policies>
                <TimeBasedTriggeringPolicy/>
                <SizeBasedTriggeringPolicy size="100 KB"/>
            </Policies>
        </RollingFile>

<!-- 每天进行归档，自动压缩日志文件 -->
        <RollingRandomAccessFile name="applicationAppender" fileName="${LOG_PATH}/rollingRandomAccessFile.log" filePattern="${LOG_PATH}/$${date:yyyy-MM}/common-%d{yyyy-MM-dd}.log.gz" append="true">
            <PatternLayout pattern="${pattern_format}"/>
            <Policies>
                <TimeBasedTriggeringPolicy/>
            </Policies>
        </RollingRandomAccessFile>
    </appenders>
    <!--然后定义logger，只有定义了logger并引入的appender，appender才会生效-->
    <loggers>
        <!--过滤掉spring和mybatis的一些无用的DEBUG信息-->
        <logger name="org.springframework" level="INFO"></logger>
        <logger name="org.mybatis" level="INFO"></logger>
        <root level="all">
            <!-- appender引用-->
            <appender-ref ref="Console"/>
            <appender-ref ref="log"/>
            <appender-ref ref="RollingFileInfo"/>
            <appender-ref ref="RollingFileWarn"/>
            <appender-ref ref="RollingFileError"/>
        </root>
    </loggers>
</configuration>

运行上面的java代码，打印的日志如下

[21:10:17:717] [FATAL] - com.Log4j2App.main(Log4j2App.java:15) -- max error
[21:10:17:717] [ERROR] - com.Log4j2App.main(Log4j2App.java:16) -- error
[21:10:17:717] [WARN ] - com.Log4j2App.main(Log4j2App.java:17) -- warn
[21:10:17:717] [INFO ] - com.Log4j2App.main(Log4j2App.java:18) -- info
[21:10:17:717] [DEBUG] - com.Log4j2App.main(Log4j2App.java:19) -- debug
[21:10:17:717] [TRACE] - com.Log4j2App.main(Log4j2App.java:20) -- trace

搭建slf4j门面 + log4j2 实现

加入pom依赖

<!-- slf4j门面-->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.30</version>
        </dependency>
<!-- slf4j与log4j2的桥接包：log4j-slf4j-impl-2.9.0.jar，这个包的作用就是使用slf4j的api，但是底层实现是基于log4j2.-->
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-slf4j-impl</artifactId>
            <version>2.9.0</version>
        </dependency>

        <!-- log4j门面 ，这个也是需要的-->
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-api</artifactId>
            <version>2.15.0</version>
        </dependency>
        <!-- log4j2依赖-->
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-core</artifactId>
            <version>2.15.0</version>
        </dependency>
        <!-- log4j2异步日志依赖 ，不用异步功能的话，这个包可以不要-->
        <dependency>
            <groupId>com.lmax</groupId>
            <artifactId>disruptor</artifactId>
            <version>3.3.4</version>
        </dependency>

java代码

package com;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/** * 使用Slf4j作为门面 */
public class Log4j2_Slf4j_App {
    public static void main(String[] args) {
        Logger logger = LoggerFactory.getLogger(Log4j2_Slf4j_App.class);
        logger.error("error");
        logger.warn("warn");
        logger.info("info");
        logger.debug("debug");
        logger.trace("trace");
    }
}

配置文件还是使用原来 log4j2.xml 即可，

执行代码后打印结果如下

[11:20:56:866] [ERROR] - com.Log4j2_Slf4j_App.main(Log4j2_Slf4j_App.java:15) -- error
[11:20:56:866] [WARN ] - com.Log4j2_Slf4j_App.main(Log4j2_Slf4j_App.java:16) -- warn
[11:20:56:866] [INFO ] - com.Log4j2_Slf4j_App.main(Log4j2_Slf4j_App.java:17) -- info
[11:20:56:867] [DEBUG] - com.Log4j2_Slf4j_App.main(Log4j2_Slf4j_App.java:18) -- debug
[11:20:56:867] [TRACE] - com.Log4j2_Slf4j_App.main(Log4j2_Slf4j_App.java:19) -- trace

异步日志

异步分为全局异步和混合异步2种方式

• 全局异步：所有日志都异步记录
• 混合异步：在应用种同时使用同步日志和异步日志，这样的日志配置更加灵活

添加maven依赖

<!-- log4j2异步日志依赖-->
<dependency>
    <groupId>com.lmax</groupId>
    <artifactId>disruptor</artifactId>
    <version>3.3.4</version>
</dependency>

全局异步

1. 全局启用异步Logger方案一 ：JVM启动参数加上-DLog4jContextSelector=org.apache.logging.log4j.core.async.AsyncLoggerContextSelector
2. 全局启用异步Logger方案二：classpath中添加文件log4j2.component.properties，文件增加以下内容：

Log4jContextSelector=org.apache.logging.log4j.core.async.AsyncLoggerContextSelector

混合异步

log4j2提供2种异步日志的实现方式

• AsyncAppender ：性能提升较小
• AsyncLogger：性能提升较大，推荐使用

AsyncAppender配置方式

<?xml version="1.0" encoding="UTF-8"?>
<configuration status="WARN" monitorInterval="30">
  <appender name="xindong_file" class="ch.qos.logback.core.FileAppender">
    <file>myapp.log</file>
    <encoder>
      <pattern>[%d{yyyy-MM-dd HH:mm:ss.SSS}] [%level] [%thread] [%logger{50}] >>> %msg%n</pattern>
    </encoder>
  </appender>
 
  <appender name="xindong_async" class="ch.qos.logback.classic.AsyncAppender">
    <appender-ref ref="xindong_file" />
  </appender>
 
  <root level="DEBUG">
    <appender-ref ref="xindong_async" />
  </root>
</configuration>

AsyncLogger配置方式

<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="WARN" monitorInterval="30">
    <Appenders>
        <RollingRandomAccessFile name="applicationAppender" fileName="./log/application.log" filePattern="./log/$${date:yyyy-MM}/common-%d{yyyy-MM-dd}.log.gz" append="false">
            <PatternLayout pattern="[%d{yyyy-MM-dd HH:mm:ss.SSS}] [%p] - %l - %m%n"/>
            <Policies>
                <TimeBasedTriggeringPolicy/>
            </Policies>
        </RollingRandomAccessFile>

        <Console name="CONSOLE" target="SYSTEM_OUT">
            <PatternLayout pattern="[%d{yyyy-MM-dd HH:mm:ss.SSS}] [%p] %t - %l - %m%n"/>
        </Console>

    </Appenders>

    <Loggers>
        <!-- AsyncLogger配置 -->
        <AsyncLogger name="log4j2" >
            <AppenderRef ref="applicationAppender"/>
        </AsyncLogger>

        <Root level="info">
            <!--<AppenderRef ref="CONSOLE"/>-->
            <AppenderRef ref="applicationAppender"/>
        </Root>

        <!--<Logger name="log4j2" level="debug" additivity="false" >-->
            <!--<AppenderRef ref="CONSOLE"/>-->
            <!--<AppenderRef ref="applicationAppender"/>-->
        <!--</Logger>-->

    </Loggers>
</Configuration>

logback

logback是由log4j的创始人设计的另一个开源日志组件，性能比log4j更好；
logback主要分为三个模块

1. logback-core：其他2个模块的基础模块，也是最核心的模块
2. logback-classic：它是log4j的一个改良版本，同时它完整实现了slf4j API
3. logback-access：访问模块与servlet容器集成通过http来访问日志的功能；

logback默认日志级别

logback的默认日志级别是debug；

logback配置文件

logback 支持以下几种方式的配置文件，如果以下文件都不存在的话则会采用默认的配置文件；

• logback.groovy
• logback-test.xml
• logback.xml

logback使用

先导入maven依赖,这里使用slf4j来管理logback

<!-- 使用日志门面管理logback-->
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-api</artifactId>
    <version>1.7.30</version>
</dependency>
<dependency>
    <groupId>ch.qos.logback</groupId>
    <artifactId>logback-core</artifactId>
    <version>1.2.3</version>
</dependency>
<dependency>
    <groupId>ch.qos.logback</groupId>
    <artifactId>logback-classic</artifactId>
    <version>1.2.3</version>
</dependency>

java代码

package com.log;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class LogbackApp {
    public static void main(String[] args) {
        Logger logger = LoggerFactory.getLogger(LogbackApp.class);
        logger.error("error");
        logger.info("123445");
        logger.debug("debug");
        logger.trace("trace");
        
    }
}

logback的配置文件,这里的配置比较全，童鞋们按需配置即可

<?xml version="1.0" encoding="UTF-8" ?>
<configuration>

    <!-- 配置变量，和 maven 的 properties标签的功能医院-->
    <property name="pattern" value="%d{yyyy-MM-dd HH:mm:ss} [%t] [%-5level] %c %M %L %m %n"></property>
    <property name="html_pattern" value="%d{yyyy-MM-dd HH:mm:ss}%t%-5level%c%M%L%m%n"></property>

    <!-- 输出到控制台-->
    <appender name="yexindong_console_appender" class="ch.qos.logback.core.ConsoleAppender">
        <!-- 控制输出流对象，默认为System.out（黑色字体） ，System.err 是红色字体 -->
        <!-- <target>System.err</target>-->
        <!-- 输出的日志消息格式配置-->
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <!-- 日志输出格式 %-5level ： 日志级别，占用5个字符的位置 %d{yyyy-MM-dd HH:mm:ss,SSS} ：日期并指定格式 %c ：类的完整名称 %M ： 方法名称 %L : 代码所在行号 %t ： 调用logger打印方法的thread线程名称 %m ： 打印的日志内容 %n ： 换行 -->
            <pattern>${pattern}</pattern>
        </encoder>
    </appender>

    <!-- 输出到文件-->
    <!-- <appender name="yexindong_file_appender" class="ch.qos.logback.core.FileAppender">-->
            <!-- 日志文件保存路径-->
    <!-- <file>D:\\log\\logback.log</file>-->
            <!-- 输出的日志消息格式配置-->
    <!-- <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">-->
    <!-- <pattern>${pattern}</pattern>-->
    <!-- </encoder>-->
    <!-- </appender>-->

    <!-- 输出到html格式的日志文件-->
    <!-- <appender name="yexindong_html_appender" class="ch.qos.logback.core.FileAppender">-->
            <!-- 日志文件保存路径-->
    <!-- <file>D:\\log\\logback_html.html</file>-->
            <!-- html 消息格式配置-->
    <!-- <encoder class="ch.qos.logback.core.encoder.LayoutWrappingEncoder">-->
    <!-- <layout class="ch.qos.logback.classic.html.HTMLLayout">-->
    <!-- <pattern>${html_pattern}</pattern>-->
    <!-- </layout>-->
    <!-- </encoder>-->
    <!-- </appender>-->

    <!-- 日志拆分、自动归档压缩-->
    <appender name="yexindong_roll_file_appender" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <!-- 日志文件保存路径-->
        <file>D:\\log\\logback_rolling.log</file>
        <!-- 输出的日志消息格式配置-->
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <pattern>${pattern}</pattern>
        </encoder>

        <!-- 指定文件拆分规则-->
        <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
            <!-- 按照时间为节点进行拆分，自动压缩的文件名称-->
            <fileNamePattern>D:\\log\\logback_rolling.%d{yyyy-MM-dd HH_mm_ss}.log%i.gz</fileNamePattern>
            <!-- 按照文件大小进行拆分，当文件大小达到1MB时就会将日志进行压缩 -->
            <maxFileSize>1MB</maxFileSize>
        </rollingPolicy>
        <!-- 日志级别过滤器-->
        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <!-- 设置日志级别，-->
            <level>ERROR</level>
            <!-- 超过这个级别的日志才会打印-->
            <onMatch>ACCEPT</onMatch>
            <!-- 小于这个级别的日志不会打印-->
            <onMismatch>DENY</onMismatch>
        </filter>
    </appender>

    <!-- 异步日志，因为之前每次打印日志都是在主线程进行输出的，这样对响应速度会有所影响，配置成异步日志会提升响应速度-->
    <appender name="yexindong_async_appender" class="ch.qos.logback.classic.AsyncAppender">
        <!-- 这里将自动归档的appender设为异步的-->
        <appender-ref ref="yexindong_roll_file_appender"></appender-ref>
    </appender>

    <!--根logger配置-->
    <root level="All">
        <!-- appender引用-->
        <appender-ref ref="yexindong_console_appender"></appender-ref>
        <!-- <appender-ref ref="yexindong_file_appender"></appender-ref>-->
        <!-- <appender-ref ref="yexindong_html_appender"></appender-ref>-->
        <appender-ref ref="yexindong_async_appender"></appender-ref>
    </root>
    <!-- 自定义logger对象 name="com" ： 这里是com是包名，表示com包下所有子包的类都使用自定义logger level="info" ：自定义logger的日志级别 additivity="false" ：表示自定义的logger对象是否继承 rootLogger（根logger） -->
    <logger name="com" level="all" additivity="false">
        <appender-ref ref="yexindong_console_appender"></appender-ref>
    </logger>

</configuration>

运行后即可看到打印的日志内容

2021-12-17 19:55:38 [main] [ERROR] com.log.LogbackApp main 13 error 
2021-12-17 19:55:38 [main] [INFO ] com.log.LogbackApp main 14 123445 
2021-12-17 19:55:38 [main] [DEBUG] com.log.LogbackApp main 15 debug 
2021-12-17 19:55:38 [main] [TRACE] com.log.LogbackApp main 16 trace

日志门面技术

什么是日志门面技术

日志门面技术借鉴了 JDBC 的思想，为日志系统也提供了一套门面，开发者就可以面向这些接口规范来开发，避免了直接依赖具体日志框架，因为不同的日志框架有不同的用法，所以导致在更换日志框架时就需要改动大量的代码，所以为了减少开发量，就有了日志门面技术，门面技术简单地理解就是说你的日志框架变了，但是不需要改代码，只修改依赖和配置文件即可，提高了开发效率;

目前主流的日志门面技术有2种

• JCL
• SLF4J

因为JCL支持的日志技术比较少，只支持目前比较主流的日志框架，且不支持扩展，需要扩展其他的日志实现技术的话需要用户自己修改源代码，但是随着技术的发展，以后肯定会发展出更多更好的日志框架，但是jcl却不支持这些新出的框架，因此jcl在在2014年就已经被 apache 给淘汰了，目前使用最广泛的是slf4j；

为什么要用门面技术？

1. 面向接口开发，不在依赖具体的实现类，减少代码的耦合
2. 项目通过导入不同的日志实现类，可以灵活的切换日志框架
3. 统一API，方便开发者学习和使用
4. 统一配置便于项目日志的管理

日志门面技术 - JCL

日志实现优先级排列

jcl门面技术在获取log实现时会按照以下顺序依次获取logger的实现，我们可以看到它是优先使用log4j的，如果找到了log4j的实现，就不会在往下找其他实现了

1. log4j ： 优先使用log4j
2. jdk14Logger：jdk自带logger
3. jdk13LumberjackLogger ：也是jdk自带logger
4. SimpleLog ： jcl自带的日志框架，功能比较简单

JCL使用

1. 先添加apache门面的pom依赖

<dependency>
    <groupId>commons-logging</groupId>
    <artifactId>commons-logging</artifactId>
    <version>1.2</version>
</dependency>

1. 打印日志

package com.log;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
public class App {
    public static void main(String[] args) {
        Log log = LogFactory.getLog(App.class);
        // jcl优先使用 log4j 日志，如果未添加log4j依赖，默认会使用java自带的日志框架：java.util.logging
        log.info("hello world");
    }
}

1. 打印结果如下，发现默认情况下使用的是jdk自带的日志框架

十二月 17, 2021 11:34:22 上午 com.log.App main
信息: hello world

1. 接下来我们加上 log4j的依赖

<dependency>
    <groupId>log4j</groupId>
    <artifactId>log4j</artifactId>
    <version>1.2.17</version>
</dependency>

1. 再加上log4j的配置文件 log4j.properties，放在resources目录下

# 配置log4j的顶级父元素，指定日志级别为 trace，使用appender为yexindong, 这个yexindong  是用户自定义的
log4j.rootLogger=trace,yexindong
# ***********************输出到控制台 start****************
# 指定控制台日志输出的 appender
log4j.appender.yexindong=org.apache.log4j.ConsoleAppender
# 指定消息layout布局器
log4j.appender.yexindong.layout=org.apache.log4j.PatternLayout
# 指定消息输出格式
log4j.appender.yexindong.layout.conversionPattern=%t %d [%t] %-5p %l -- %m %n

1. 其他代码不变，再次运行main方法后打印结果如下 ，会发现自动使用了log4j进行输出日志；

main 2021-12-17 11:36:06,642 [main] INFO  com.log.App.main(App.java:17) -- hello world

日志门面技术 - SLF4J

SLF4J的由来

在log4j开发出来出来之后，log4j就受到了广大开发者的爱好，纷纷开始使用log4j，但是后来 log4j的创始人跟apache因为一些矛盾从apache辞职自己去创业了，创始人为了给自己的公司打出一点名声，所以就基于log4j又开发出了一个新的日志框架 logback，logback不管是性能还是功能都比log4j强，但是却很少人使用， 因为jcl门面不支持logback，所以这个创世人又设计出了slf4j，slf4j支持市面上所有主流的日志框架；所以目前为止，使用最多的就是slf4j了； 后来 apache又基于 logback 的源码 设计出了 log4j2 日志，性能上log4j2比logback更胜一筹，并且log4j2既是日志框架，也是门面技术，但是log4j2的门面技术很少人使用，大多还是使用slf4j；

注意事项

=maven依赖中，尽量保证只有一个日志实现，如果由多个日志实现的话默认使用第一个（maven依赖靠前的那个），并且在控制台会显示以下警告信息

# 提示有多个日志实现
SLF4J: Class path contains multiple SLF4J bindings.
# 第一个日志实现
SLF4J: Found binding in [jar:file:/D:/repository/org/slf4j/slf4j-simple/1.7.25/ slf4j-simple-1.7.25.jar!/org/slf4j/impl/StaticLoggerBin
# 第二个日志实现
SLF4J: Found binding in [jar:file:/D:/repository/org/slf4j/slf4j-log4j12/1.7.12/slf4j-log4j12-1.7.12.jar!/org/slf4j/impl/StaticLoggerBinder.class]
# 默认绑定第一个
SLF4J: Actual binding is of type [org.slf4j.impl.SimpleLoggerFactory]

准备java打印日志代码

首先加入slf4j的依赖

<!-- 日志门面依赖-->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.26</version>
        </dependency>

log打印代码如下

package com.log;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class App {
    public static void main(String[] args) {
        Logger logger = LoggerFactory.getLogger(App.class);
        logger.error("12322");
        logger.warn("warn");
        logger.info("info {}", "yexindong");
        logger.debug("debug");
        logger.trace("trace");
    }
}

此时还不会打印内容，因为目前只有接口，还没有具体的实现

1、slf4j绑定默认日志

slf4j-simple是slf4j内置的简单日志实现框架，功能比较简单；

<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-simple</artifactId>
    <version>1.7.25</version>
</dependency>

运行上述java代码后，控制台打印的结果如下

[main] ERROR com.log.App - 12322
[main] WARN com.log.App - warn
[main] INFO com.log.App - info yexindong

2、绑定 java自带日志框架 jul

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

运行上述java代码后，控制台打印的结果如下

十二月 17, 2021 5:03:58 下午 com.log.App main
严重: 12322
十二月 17, 2021 5:03:58 下午 com.log.App main
警告: warn
十二月 17, 2021 5:03:58 下午 com.log.App main
信息: info yexindong

3、绑定log4j日志框架

其中 slf4j-log4j12 是适配器，必须要一个适配器，否则log4j不生效

<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-log4j12</artifactId>
    <version>1.7.12</version>
</dependency>
<dependency>
    <groupId>log4j</groupId>
    <artifactId>log4j</artifactId>
    <version>1.2.17</version>
</dependency>

除此之外，还需要加上log4j的配置文件：log4j.properties

# 配置log4j的顶级父元素，指定日志级别为 trace，使用appender为yexindong, 这个yexindong  是用户自定义的
log4j.rootLogger=trace,yexindong
# ***********************输出到控制台 start****************
# 指定控制台日志输出的 appender
log4j.appender.yexindong=org.apache.log4j.ConsoleAppender
# 指定消息layout布局器
log4j.appender.yexindong.layout=org.apache.log4j.PatternLayout
# 指定消息输出格式
log4j.appender.yexindong.layout.conversionPattern=%t %d [%t] %-5p %l -- %m %n
# ***********************输出到控制台 end****************

运行上述java代码后，控制台打印的结果如下

main 2021-12-17 17:22:03,345 [main] ERROR com.log.App.main(App.java:11) -- 12322 
main 2021-12-17 17:22:03,350 [main] WARN  com.log.App.main(App.java:12) -- warn 
main 2021-12-17 17:22:03,351 [main] INFO  com.log.App.main(App.java:13) -- info yexindong 
main 2021-12-17 17:22:03,351 [main] DEBUG com.log.App.main(App.java:14) -- debug 
main 2021-12-17 17:22:03,351 [main] TRACE com.log.App.main(App.java:15) -- trace

4、绑定logback日志框架

<dependency>
    <groupId>ch.qos.logback</groupId>
    <artifactId>logback-classic</artifactId>
    <version>1.2.3</version>
</dependency>
<dependency>
    <groupId>ch.qos.logback</groupId>
    <artifactId>logback-core</artifactId>
    <version>1.2.3</version>
</dependency>

运行上述java代码后，控制台打印的结果如下

17:14:23.500 [main] ERROR com.log.App - 12322
17:14:23.508 [main] WARN com.log.App - warn
17:14:23.508 [main] INFO com.log.App - info yexindong
17:14:23.510 [main] DEBUG com.log.App - debug

slf4j 日志桥接器

使用场景

老项目使用的日志框架是log4j，现在想要使用logback， 但是一大堆的java文件中都有log4j的导入

import org.apache.log4j.Logger;

因为使用了logback，就一定要将log4j相关的maven依赖删除，依赖删除后，这个import导入就一定会报错，一个个去改把，太麻烦了，搞不好改错了，更麻烦，于是就有了 日志桥接器，只需要加上桥接器的maven依赖即可，代码一行都不需要改，依赖如下

<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>log4j-over-slf4j</artifactId>
    <version>1.7.25</version>
</dependency>

加上这个依赖后，虽然import上是log4j，但是底层调用的其实是logback的日志实现；

注意问题

1. log4j-over-slf4j 和 slf4j-jcl.jar 不能同时部署，否则会导致无限循环
2. log4j-over-slf4j桥接器 和 slf4j-log4j 适配器不能同时出现
3. jul-to-slf4j.jar 和 slf4j-jdk14.jar 不能同时出现
4. 所有的桥接器都只对Logger日志记录器对象有效，如果程序中调用了内部的配置类或者是Appender、Filter等对象，将无法产生效果；

完