全栈架构师之路

Appearance

Log ​

timeline

日志的概念 ​

日志文件 ​

日志文件是用于记录系统操作事件的文件集合，可分为事件日志和消息日志。具有处理历史数据、诊断 问题的追踪以及理解系统的活动等重要作用。 在计算机中，日志文件是记录在操作系统或其他软件运行中发生的事件或在通信软件的不同用户之间的 消息的文件。记录是保持日志的行为。在最简单的情况下，消息被写入单个日志文件。 许多操作系统，软件框架和程序包括日志系统。广泛使用的日志记录标准是在因特网工程任务组 (IETF)RFC5424 中定义的 syslog。 syslog 标准使专用的标准化子系统能够生成，过滤，记录和分析日 志消息。

调试日志 ​

软件开发中，我们经常需要去调试程序，做一些信息，状态的输出便于我们查询程序的运行状况。为了 让我们能够更加灵活和方便的控制这些调试的信息，所有我们需要专业的日志技术。java 中寻找 bug 会 需要重现。调试也就是 debug 可以在程序运行中暂停程序运行，可以查看程序在运行中的情况。日志主 要是为了更方便的去重现问题。

系统日志 ​

系统日志是记录系统中硬件、软件和系统问题的信息，同时还可以监视系统中发生的事件。用户可以通 过它来检查错误发生的原因，或者寻找受到攻击时攻击者留下的痕迹。系统日志包括系统日志、应用程 序日志和安全日志。

系统日志的价值 系统日志策略可以在故障刚刚发生时就向你发送警告信息，系统日志帮助你在最短的时间内发现问题。 系统日志是一种非常关键的组件，因为系统日志可以让你充分了解自己的环境。这种系统日志信息对于 决定故障的根本原因或者缩小系统攻击范围来说是非常关键的，因为系统日志可以让你了解故障或者袭 击发生之前的所有事件。为虚拟化环境制定一套良好的系统日志策略也是至关重要的，因为系统日志需 要和许多不同的外部组件进行关联。良好的系统日志可以防止你从错误的角度分析问题，避免浪费宝贵 的排错时间。另外一种原因是借助于系统日志，管理员很有可能会发现一些之前从未意识到的问题，在 几乎所有刚刚部署系统日志的环境当中。

JAVA日志框架 ​

问题:

  1. 控制日志输出的内容和格式
  2. 控制日志输出的位置
  3. 日志优化:异步日志，日志文件的归档和压缩
  4. 日志系统的维护
  5. 面向接口开发 -- 日志的门面

为什么要用日志框架 ​

因为软件系统发展到今天已经很复杂了，特别是服务器端软件，涉及到的知识，内容，问题太多。在某 些方面使用别人成熟的框架，就相当于让别人帮你完成一些基础工作，你只需要集中精力完成系统的业 务逻辑设计。而且框架一般是成熟，稳健的，他可以处理系统很多细节问题，比如，事务处理，安全 性，数据流控制等问题。还有框架一般都经过很多人使用，所以结构很好，所以扩展性也很好，而且它 是不断升级的，你可以直接享受别人升级代码带来的好处。

现有的日志框架 ​

JUL(java util logging)、logback、log4j、log4j2 JCL(Jakarta Commons Logging)、slf4j( Simple Logging Facade for Java) 日志门面 JCL、slf4j 日志实现 JUL、logback、log4j、log4j2

JUL ​

https://docs.oracle.com/javase/10/core/java-logging-overview.htm

JUL 全称 Java util Logging 是 java 原生的日志框架，使用时不需要另外引用第三方类库，相对其他日志框架使用方便，学习简单，能够在小型应用中灵活使用。

JUL入门 ​

架构介绍 ​

Java_Logging_Control_Flow

  • Loggers:被称为记录器，应用程序通过获取 Logger 对象，调用其 API 来来发布日志信息。Logger 通常时应用程序访问日志系统的入口程序。
  • Appenders:也被称为 Handlers，每个 Logger 都会关联一组 Handlers，Logger 会将日志交给关联 Handlers 处理，由 Handlers 负责将日志做记录。Handlers 在此是一个抽象，其具体的实现决定了 日志记录的位置可以是控制台、文件、网络上的其他日志服务或操作系统日志等。
  • Layouts:也被称为 Formatters，它负责对日志事件中的数据进行转换和格式化。Layouts 决定了 数据在一条日志记录中的最终形式。
  • Level:每条日志消息都有一个关联的日志级别。该级别粗略指导了日志消息的重要性和紧迫，我 可以将 Level 和 Loggers，Appenders 做关联以便于我们过滤消息。
  • Filters:过滤器，根据需要定制哪些信息会被记录，哪些信息会被放过。

总结一下就是:

用户使用 Logger 来进行日志记录，Logger 持有若干个 Handler，日志的输出操作是由 Handler 完成的。 在 Handler 在输出日志前，会经过 Filter 的过滤，判断哪些日志级别过滤放行哪些拦截，Handler 会将日 志内容输出到指定位置(日志文件、控制台等)。Handler 在输出日志时会使用 Layout，将输出内容进 行排版。

入门案例 ​

java
public class JULTest {
    // 1.创建日志记录器对象
    private final static Logger logger = Logger.getLogger("com.futureweaver.log.JULTest");

    @Test
    public void testQuick() throws Exception {
        // 2.日志记录输出
        logger.info("hello jul");

        logger.log(Level.INFO, "info msg");
        String name = "jack";
        Integer age = 18;
        logger.log(Level.INFO, "用户信息:{0},{1}", new Object[]{name, age});
    }
}

日志级别 ​

jul 中定义的日志级别:

  • java.util.logging.Level 中定义了日志的级别:

  • SEVERE(最高值)

  • WARNING

  • INFO (默认级别)

  • CONFIG

  • FINE

  • FINER

  • FINEST(最低值)

  • 还有两个特殊的级别:

  • OFF，可用来关闭日志记录。

  • ALL，启用所有消息的日志记录。

虽然我们测试了 7 个日志级别但是默认只实现 info 以上的级别

java
@Test
public void testLogLevel() throws Exception {
    // 1.获取日志对象
    Logger logger = Logger.getLogger("com.futureweaver.log.QuickTest");

    // 2.日志记录输出
    logger.severe("severe");
    logger.warning("warning");
    logger.info("info");
    logger.config("cofnig");
    logger.fine("fine");
    logger.finer("finer");
    logger.finest("finest");
}

自定义日志级别配置

java
@Test
public void testLogConfig() throws Exception {
    // 1.创建日志记录器对象
    Logger logger = Logger.getLogger("com.futureweaver.log.JULTest");

    // 一、自定义日志级别
    // a.关闭系统默认配置
    logger.setUseParentHandlers(false);

    // b.创建handler对象
    ConsoleHandler consoleHandler = new ConsoleHandler();

    // c.创建formatter对象
    SimpleFormatter simpleFormatter = new SimpleFormatter();

    // d.进行关联
    consoleHandler.setFormatter(simpleFormatter);
    logger.addHandler(consoleHandler);

    // e.设置日志级别
    logger.setLevel(Level.ALL);
    consoleHandler.setLevel(Level.ALL);

    // 二、输出到日志文件
    FileHandler fileHandler = new FileHandler("d:/logs/jul.log");
    fileHandler.setFormatter(simpleFormatter);
    logger.addHandler(fileHandler);

    // 2.日志记录输出
    logger.severe("severe");
    logger.warning("warning");
    logger.info("info");
    logger.config("config");
    logger.fine("fine");
    logger.finer("finer");
    logger.finest("finest");
}

Logger之间的父子关系 ​

JUL 中 Logger 之间存在父子关系，这种父子关系通过树状结构存储，JUL 在初始化时会创建一个顶层 RootLogger 作为所有 Logger 父 Logger，存储上作为树状结构的根节点。并父子关系通过路径来关联。

java
@Test
public void testLogParent() throws Exception {
    // 日志记录器对象父子关系
    Logger logger1 = Logger.getLogger("com.futureweaver.log");
    Logger logger2 = Logger.getLogger("com.futureweaver");

    System.out.println(logger1.getParent() == logger2);
    // 所有日志记录器对象的顶级父元素 class为java.util.logging.LogManager$RootLogger name为""
    System.out.println("logger2 parent:" + logger2.getParent() + "，name:" + logger2.getParent().getName());

    // 一、自定义日志级别
    // a.关闭系统默认配置
    logger2.setUseParentHandlers(false);
    // b.创建handler对象
    ConsoleHandler consoleHandler = new ConsoleHandler();
    // c.创建formatter对象
    SimpleFormatter simpleFormatter = new SimpleFormatter();
    // d.进行关联
    consoleHandler.setFormatter(simpleFormatter);
    logger2.addHandler(consoleHandler);
    // e.设置日志级别
    logger2.setLevel(Level.ALL);
    consoleHandler.setLevel(Level.ALL);

    // 测试日志记录器对象父子关系
    logger1.severe("severe");
    logger1.warning("warning");
    logger1.info("info");
    logger1.config("config");
    logger1.fine("fine");
    logger1.finer("finer");
    logger1.finest("finest");
}

日志的配置文件 ​

默认配置文件路径$JAVAHOME\jre\lib\logging.properties

java
@Test
public void testProperties() throws Exception {
    // 读取自定义配置文件
    InputStream in = JULTest.class.getClassLoader().getResourceAsStream("logging.properties");
    // 获取日志管理器对象
    LogManager logManager = LogManager.getLogManager();
    // 通过日志管理器加载配置文件
    logManager.readConfiguration(in);

    Logger logger = Logger.getLogger("com.futureweaver.log.JULTest");
    logger.severe("severe");
    logger.warning("warning");
    logger.info("info");
    logger.config("config");
    logger.fine("fine");
    logger.finer("finer");
    logger.finest("finest");
}

配置文件:

properties
### RootLogger使用的处理器(获取时设置)
handlers= java.util.logging.ConsoleHandler
## RootLogger日志等级
.level= INFO

### 自定义Logger
com.futureweaver.handlers= java.util.logging.FileHandler
## 自定义Logger日志等级
com.futureweaver.level= INFO
## 忽略父日志设置
com.futureweaver.useParentHandlers=false

### 控制台处理器
## 输出日志级别
java.util.logging.ConsoleHandler.level = INFO
## 输出日志格式
java.util.logging.ConsoleHandler.formatter = java.util.logging.SimpleFormatter

### 文件处理器
## 输出日志级别
java.util.logging.FileHandler.level=INFO
## 输出日志格式
java.util.logging.FileHandler.formatter = java.util.logging.SimpleFormatter
## 输出日志文件路径
java.util.logging.FileHandler.pattern = /java%u.log
## 输出日志文件限制大小(50000字节)
java.util.logging.FileHandler.limit = 50000
## 输出日志文件限制个数
java.util.logging.FileHandler.count = 10
## 输出日志文件 是否是追加
java.util.logging.FileHandler.append=true

日志原理解析 ​

  1. 初始化 LogManager
  2. LogManager 加载 logging.properties 配置
  3. 添加 Logger 到 LogManager
  4. 从单例 LogManager 获取 Logger
  5. 设置级别 Level，并指定日志记录 LogRecord
  6. Filter 提供了日志级别之外更细粒度的控制
  7. Handler 是用来处理日志输出位置
  8. Formatter 是用来格式化 LogRecord 的

jul_procedure

LOG4J ​

http://logging.apache.org/log4j/1.2/

Log4j 是 Apache 下的一款开源的日志框架，通过在项目中使用 Log4J，我们可以控制日志信息输出到控 制台、文件、甚至是数据库中。我们可以控制每一条日志的输出格式，通过定义日志的输出级别，可以 更灵活的控制日志的输出过程。方便项目的调试。

Log4j入门 ​

  1. 建立 maven 工程

  2. 添加依赖

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

    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
        <scope>test</scope>
    </dependency>
</dependencies>
  1. java 代码
java
public class Log4jTest {
    // 创建日志记录器对象
    private final static Logger logger = Logger.getLogger(Log4jTest.class);

    @Test
    public void testQuick() throws Exception {
        // 初始化系统配置，不需要配置文件
        BasicConfigurator.configure();

        // 日志级别
        logger.fatal("fatal"); // 严重错误，一般会造成系统崩溃和终止运行
        logger.error("error"); // 错误信息，但不会影响系统运行
        logger.warn("warn"); // 警告信息，可能会发生问题
        logger.info("info"); // 程序运行信息，数据库的连接、网络、IO操作等
        logger.debug("debug");// 调试信息，一般在开发阶段使用，记录程序的变量、参数等
        logger.trace("trace");// 追踪信息，记录程序的所有流程信息
    }
}
  1. 日志的级别

  • 每个 Logger 都被了一个日志级别(log level)，用来控制日志信息的输出。日志级别从高到低分为:

  • fatal 指出每个严重的错误事件将会导致应用程序的退出。

  • error 指出虽然发生错误事件，但仍然不影响系统的继续运行。

  • warn 表明会出现潜在的错误情形。

  • info 一般和在粗粒度级别上，强调应用程序的运行全程。

  • debug 一般用于细粒度级别上，对调试应用程序非常有帮助。

  • trace 是程序追踪，可以用于输出程序运行中的变量，显示执行的流程。

  • 还有两个特殊的级别:

  • OFF，可用来关闭日志记录。

  • ALL，启用所有消息的日志记录。

注:一般只使用 4 个级别，优先级从高到低为 ERROR > WARN > INFO > DEBUG

Log4j组件 ​

Log4J 主要由 Loggers (日志记录器)、Appenders(输出端)和 Layout(日志格式化器)组成。其中 Loggers 控制日志的输出级别与日志是否输出;Appenders 指定日志的输出方式(输出到控制台、文件 等);Layout 控制日志信息的输出格式。

Loggers ​

日志记录器，负责收集处理日志记录，实例的命名就是类“XX”的 full quailied name(类的全限定名)， Logger 的名字大小写敏感，其命名有继承机制:例如:name 为 org.apache.commons 的 logger 会继承 name 为 org.apache 的 logger。

Log4J 中有一个特殊的 logger 叫做“root”，他是所有 logger 的根，也就意味着其他所有的 logger 都会直接 或者间接地继承自 root。root logger 可以用 Logger.getRootLogger()方法获取。

但是，自 log4j 1.2 版以来， Logger 类已经取代了 Category 类。对于熟悉早期版本的 log4j 的人来说， Logger 类可以被视为 Category 类的别名。

log4j_procedure

Appenders ​

Appender 用来指定日志输出到哪个地方，可以同时指定日志的输出目的地。Log4j 常用的输出目的地有以下几种:

输出端类型作用
ConsoleAppender将日志输出到控制台
FileAppender将日志输出到文件中
DailyRollingFileAppender将日志输出到一个日志文件，并且每天输出到一个新的文件
RollingFileAppender将日志信息输出到一个日志文件，并且指定文件的尺寸，当文件大小达到指定尺寸时，会自动把文件改名，同时产生一个新的文件
JDBCAppender把日志信息保存到数据库中

Layouts ​

布局器 Layouts 用于控制日志输出内容的格式，让我们可以使用各种需要的格式输出日志。Log4j 常用的 Layouts:

格式化器类型作用
HTMLLayout格式化日志输出为HTML表格形式
SimpleLayout简单的日志输出格式化，打印的日志格式为(info - message)
PatternLayout最强大的格式化期，可以根据自定义格式输出日志，如果没有指定转换格式，就是用默认的转换格式

Layout的格式 ​

在 log4j.properties 配置文件中，我们定义了日志输出级别与输出端，在输出端中分别配置日志的输出 格式。

tex
## log4j 采用类似 C 语言的 printf 函数的打印格式格式化日志信息，具体的占位符及其含义如下:
%m 输出代码中指定的日志信息
%p 输出优先级，及 DEBUG、INFO 等
%n 换行符(Windows平台的换行符为 "\n"，Unix 平台为 "\n")
%r 输出自应用启动到输出该 log 信息耗费的毫秒数
%c 输出打印语句所属的类的全名
%t 输出产生该日志的线程全名
%d 输出服务器当前时间，默认为 ISO8601，也可以指定格式，如:%d{yyyy年MM月dd日HH:mm:ss}
%l 输出日志时间发生的位置，包括类名、线程、及在代码中的行数。如:Test.main(Test.java:10)
%F 输出日志消息产生时所在的文件名称
%L 输出代码中的行号
%% 输出一个 "%" 字符

## 可以在 % 与字符之间加上修饰符来控制最小宽度、最大宽度和文本的对其方式。如:

%5c 输出category名称，最小宽度是5，category<5，默认的情况下右对齐
%-5c 输出category名称，最小宽度是5，category<5，"-"号指定左对齐,会有空格
%.5c 输出category名称，最大宽度是5，category>5，就会将左边多出的字符截掉，<5不会有空格
%20.30c category名称<20补空格，并且右对齐，>30字符，就从左边交远销出的字符截掉

Appender的输出 ​

控制台，文件，数据库

properties
global.conversion.pattern=[%-5p] [%d] [%l] %n%m%n%n

## root
log4j.rootLogger=ALL,stdout

## ConsoleAppender
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Threshold=DEBUG
log4j.appender.stdout.Encoding=utf-8
log4j.appender.stdout.Target=System.out
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=${global.conversion.pattern}

## DailyRollingFileAppender
##log4j.appender.rolling=org.apache.log4j.DailyRollingFileAppender
##log4j.appender.rolling.File=/Users/LEAF/log4j.log
##log4j.appender.rolling.Append=true
##log4j.appender.rolling.layout=org.apache.log4j.PatternLayout
##log4j.appender.rolling.layout.ConversionPattern=${global.conversion.pattern}
##log4j.appender.rolling.encoding=UTF-8

## JDBCAppender
##log4j.appender.db=org.apache.log4j.jdbc.JDBCAppender
##log4j.appender.db.layout=org.apache.log4j.PatternLayout
##log4j.appender.db.Driver=com.mysql.jdbc.Driver
##log4j.appender.db.URL=jdbc:mysql://localhost:3306/log?useUnicode=true&characterEncoding=utf8&useSSL=false&serverTimezone=UTC
##log4j.appender.db.User=root
##log4j.appender.db.Password=root
##log4j.appender.db.Sql=INSERT INTO log(project_name,create_date,level,category,file_name,thread_name,line,all_category,message) values('futureweaver','%d{yyyy-MM-ddHH:mm:ss}','%p','%c','%F','%t','%L','%l','%m')
sql
CREATE TABLE `log` (
    `log_id` int(11) NOT NULL AUTO_INCREMENT,
    `project_name` varchar(255) DEFAULT NULL COMMENT '目项名',
    `create_date` varchar(255) DEFAULT NULL COMMENT '创建时间',
    `level` varchar(255) DEFAULT NULL COMMENT '优先级',
    `category` varchar(255) DEFAULT NULL COMMENT '所在类的全名',
    `file_name` varchar(255) DEFAULT NULL COMMENT '输出日志消息产生时所在的文件名称 ', `thread_name` varchar(255) DEFAULT NULL COMMENT '日志事件的线程名',
    `line` varchar(255) DEFAULT NULL COMMENT '号行',
    `all_category` varchar(255) DEFAULT NULL COMMENT '日志事件的发生位置',
    `message` varchar(4000) DEFAULT NULL COMMENT '输出代码中指定的消息',
    PRIMARY KEY (`log_id`)
);

自定义Logger ​

properties
## RootLogger配置
log4j.rootLogger = trace,console
## 自定义Logger
log4j.logger.com.futureweaver = info,file
log4j.logger.org.apache = error
java
@Test
public void testCustomLogger() throws Exception {
    // 自定义 com.futureweaver
    Logger logger1 = Logger.getLogger(Log4jTest.class);
    logger1.fatal("fatal"); // 严重错误，一般会造成系统崩溃和终止运行
    logger1.error("error"); // 错误信息，但不会影响系统运行
    logger1.warn("warn"); // 警告信息，可能会发生问题
    logger1.info("info"); // 程序运行信息，数据库的连接、网络、IO操作等
    logger1.debug("debug"); // 调试信息，一般在开发阶段使用，记录程序的变量、参数等
    logger1.trace("trace");// 追踪信息，记录程序的所有流程信息

    // 自定义 org.apache
    Logger logger2 = Logger.getLogger(Logger.class);
    logger2.fatal("fatal logger2");// 严重错误，一般会造成系统崩溃和终止运行
    logger2.error("error logger2");// 错误信息，但不会影响系统运行
    logger2.warn("warn logger2");// 警告信息，可能会发生问题
    logger2.info("info logger2");// 程序运行信息，数据库的连接、网络、IO操作等
    logger2.debug("debug logger2");// 调试信息，一般在开发阶段使用，记录程序的变量、参数等
    logger2.trace("trace logger2");/ 追踪信息，记录程序的所有流程信息
}

JCL ​

http://commons.apache.org/proper/commons-logging/

全称为 Jakarta Commons Logging，是 Apache 提供的一个通用日志 API。

它是为 "所有的 Java 日志实现"提供一个统一的接口，它自身也提供一个日志的实现，但是功能非常常弱 (SimpleLog)。所以一般不会单独使用它。他允许开发人员使用不同的具体日志实现工具: Log4j, Jdk 自带的日志(JUL)

JCL 有两个基本的抽象类:Log(基本记录器)和 LogFactory(负责创建 Log 实例)。

JCL入门 ​

  1. 建立 maven 工程

  2. 添加依赖

xml
<dependency>
    <groupId>commons-logging</groupId>
    <artifactId>commons-logging</artifactId>
    <version>1.2</version>
</dependency>
  1. 入门代码
java
public class JCLTest {
    // 创建日志对象
    private final static Log log = LogFactory.getLog(JCLTest.class);

    @Test
    public void testQuick() throws Exception {
        // 日志记录输出
        log.fatal("fatal");
        log.error("error");
        log.warn("warn");
        log.info("info");
        log.debug("debug");
    }
}

我们为什么要使用日志门面:

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

JCL原理 ​

JCL_Type_Hierarchy

  1. 通过 LogFactory 动态加载 Log 实现类

  2. 日志门面支持的日志实现数组

java
private static final String[] classesToDiscover =
    new String[]{"org.apache.commons.logging.impl.Log4JLogger",
                 "org.apache.commons.logging.impl.Jdk14Logger",
                 "org.apache.commons.logging.impl.Jdk13LumberjackLogger",
                 "org.apache.commons.logging.impl.SimpleLog"};
  1. 获取具体的日志实现
java
for(int i = 0; i < classesToDiscover.length && result == null; ++i) {
    result = this.createLogFromClass(classesToDiscover[i], logCategory, true);
}

日志门面 ​

当我们的系统变的更加复杂的时候，我们的日志就容易发生混乱。随着系统开发的进行，可能会更新不 同的日志框架，造成当前系统中存在不同的日志依赖，让我们难以统一的管理和控制。就算我们强制要 求所有的模块使用相同的日志框架，系统中也难以避免使用其他类似 spring,mybatis 等其他的第三方框 架，它们依赖于我们规定不同的日志框架，而且他们自身的日志系统就有着不一致性，依然会出来日志 体系的混乱。

所以我们需要借鉴 JDBC 的思想，为日志系统也提供一套门面，那么我们就可以面向这些接口规范来开 发，避免了直接依赖具体的日志框架。这样我们的系统在日志中，就存在了日志的门面和日志的实现。

常见的日志门面 : JCL、slf4j

常见的日志实现: JUL、log4j、logback、log4j2

日志门面和日志实现的关系:

log_facade

日志框架的发展历史:

  • System.out 和 System.err

这应该是最早的日志记录方式吧，但是不灵活也不可配置，要么就是全部打印，要么就是全部不打印，没有一个统一的日志级别

  • Log4j

在1996年初，E.U.SEMPER（欧洲安全电子市场）项目决定编写自己的跟踪API，最后该API演变为Log4j，Log4j日志软件包一经推出就备受欢迎。 当然这里必须要提到一个人，就是Log4j的主要贡献者，这个大佬： Ceki Gülcü

  • JUL(Java Util Logging)

果然Sun有自己的考虑，2002年2月Java1.4发布，Sun竟然推出了自己的日志库Java Util Logging，其实很多日志的实现思想也都是仿照Log4j，毕竟Log4j先出来很多年了，已经很成熟了此时，这两个日志工具打架，显然Log4j是更胜一筹

  • JCL（Jakarta Commons Logging）

2002年8月，Apache推出了日志接口Jakarta Commons Logging，也就是日志抽象层，当然也提供了一个默认实现Simple Log，这野心很大，想一统日志抽象（就像以前的JDBC一统数据库访问层），让日志产品去实现它的抽象，这样只要你的日志代码依赖的是JCL的接口，你就可以很方便的在Log4j和JUL之间做切换，当时日志领域大概是这样的结构，当然也还是方便理解的，也很优雅。 但是好景不长，在使用过程中，虽然现在日志系统在JCL的统一下很优雅，很美好，但大家发现了JCL还不够好，有些人甚至认为JCL造成的问题比解决的问题还多

http://tapestryjava.blogspot.com/2007/08/so-long-commons-logging-hello-slf4j.html

2470668837-5ddce0a421ac2

  • Slf4j（Simple Logging Facade for Java）

所以大佬粗线，Ceki Gülcü（也就是Log4j的作者）由于一些原因离开了Apache，之后觉得JCL不好，于是于2005年自己撸出一个新工程，也就是一套新日志接口（有得也叫日志门面）：Slf4j（Simple Logging Facade for Java），感觉粗来了么。。。这战争的硝烟，明显这个Slf4j是直指JCL啊，但是后面确实也证明了Slf4j是要比JCL在很多地方更优秀。

  • logback

由于使用slf4j，需要一次桥接包，也就是之前的日志产品都不是正统的Slf4j的实现，因此，2006年，出自Ceki Gülcü之手的日志产品Logback应运而生，而且大佬还专门写了一篇文章

http://logback.qos.ch/reasonsToSwitch.html

  • log4j2

在2012年，Apache直接推出新项目，不是Log4j1.x升级，而是新项目Log4j2，因为Log4j2是完全不兼容Log4j1.x的 并且很微妙的，Log4j2几乎涵盖Logback所有的特性（这不是对着干是啥~而且还有抄袭的嫌疑。。。哈哈哈），更甚者的Log4j2也搞了分离的设计，分化成log4j-api和log4j-core，这个log4j-api也是日志接口，log4j-core才是日志产品。。。

SLF4J ​

https://www.slf4j.org/

简单日志门面(Simple Logging Facade For Java) SLF4J主要是为了给Java日志访问提供一套标准、规范 的API框架，其主要意义在于提供接口，具体的实现可以交由其他日志框架，例如log4j和logback等。 当然slf4j自己也提供了功能较为简单的实现，但是一般很少用到。对于一般的Java项目而言，日志框架 会选择slf4j-api作为门面，配上具体的实现框架(log4j、logback等)，中间使用桥接器完成桥接。

SLF4J是目前市面上最流行的日志门面。现在的项目中，基本上都是使用SLF4J作为我们的日志系统。

SLF4J 日志门面主要提供两大功能:

  1. 日志框架的绑定
  2. 日志框架的桥接

SLF4J入门 ​

  1. 添加依赖
xml
<!--slf4j core 使用slf4j必須添加-->
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-api</artifactId>
    <version>1.7.30</version>
</dependency>

<!--slf4j 自带的简单日志实现 -->
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-simple</artifactId>
    <version>1.7.30</version>
</dependency>
  1. 编写代码
java
public class Slf4jTest {
    // 声明日志对象
    public final static Logger LOGGER = LoggerFactory.getLogger(Slf4jTest.class);

    @Test
    public void testQuick() throws Exception {
        //打印日志信息
        LOGGER.error("error");
        LOGGER.warn("warn");
        LOGGER.info("info");
        LOGGER.debug("debug");
        LOGGER.trace("trace");

        // 使用占位符输出日志信息
        String name = "jack";
        Integer age = 18;
        LOGGER.info("用户:{},{}", name, age);

        // 将系统异常信息写入日志
        try {
            int i = 1 / 0;
        } catch (Exception e) {
            // e.printStackTrace();
            LOGGER.info("出现异常:", e);
        }
    }
}

为什么要使用 SLF4J 作为日志门面?

    1. 使用 SLF4J 框架，可以在部署时迁移到所需的日志记录框架。
    1. SLF4J 提供了对所有流行的日志框架的绑定，例如 log4j，JUL，Simple logging 和 NOP。因此可以在部署时切换到任何这些流行的框架。
    1. 无论使用哪种绑定，SLF4J 都支持参数化日志记录消息。由于 SLF4J 将应用程序和日志记录框架分离， 因此可以轻松编写独立于日志记录框架的应用程序。而无需担心用于编写应用程序的日志记录框架。
    1. SLF4J 提供了一个简单的 Java 工具，称为迁移器。使用此工具，可以迁移现有项目，这些项目使用日志 框架(如 Jakarta Commons Logging(JCL)或 log4j 或 Java.util.logging(JUL))到 SLF4J。

绑定日志的实现(Binding) ​

https://www.slf4j.org/manual.html#swapping

以下列出了slf4j的一部分日志实现

  • slf4j-log4j12
  • slf4j-reload4j
  • slf4j-jdk14
  • slf4j-nop
  • slf4j-simple
  • slf4j-jcl
  • logback-classic

注意

在构建时(build time)，slf4j-log4j12模块，会自动重定向到slf4j-reload4j模块

如前所述，SLF4J 支持各种日志框架。SLF4J 发行版附带了几个称为“SLF4J 绑定”的 jar 文件，每个绑定对应一个受支持的框架。

使用 slf4j 的日志绑定流程:

  1. 添加 slf4j-api 的依赖
  2. 使用 slf4j 的 API 在项目中进行统一的日志记录
  3. 绑定具体的日志实现框架
    1. 绑定已经实现了 slf4j 的日志框架,直接添加对应依赖
    2. 绑定没有实现 slf4j 的日志框架,先添加日志的适配器,再添加实现类的依赖
  4. slf4j 有且仅有一个日志实现框架的绑定(如果出现多个默认使用第一个依赖日志实现)

要切换日志框架，只需替换类路径上的 slf4j 绑定。例如，要从 java.util.logging 切换到 log4j，只需将 slf4j-jdk14-1.7.27.jar 替换为 slf4j-log4j12-1.7.27.jar 即可。

SLF4J 不依赖于任何特殊的类装载。实际上，每个 SLF4J 绑定 都是硬连线的 以使用一个且只有 一个特定的日志记录框架。例如，slf4j-log4j12-1.7.27.jar 绑定在编译时绑定以使用 log4j。在您的代码 中，除了 slf4j-api-1.7.27.jar ，您只需将您选择的一个且只有一个绑定放到相应的类路径位置。不要 在类路径上放置多个绑定。以下是一般概念的图解说明。

concrete-bindings

桥接旧的日志框架(Bridging) ​

通常，您依赖的某些组件依赖于 SLF4J 以外的日志记录 API。您也可以假设这些组件在不久的将来不会切 换到 SLF4J。为了解决这种情况，SLF4J 附带了几个桥接模块，这些模块将对 log4j，JCL 和 java.util.logging API 的调用重定向，就好像它们是对 SLF4J API 一样。

桥接解决的是项目中日志的遗留问题，当系统中存在之前的日志 API，可以通过桥接转换到 slf4j 的实现

注意

要使得jul-to-slf4j生效，需要利用jdk-logging的Handler机制，在root logger上install一个handler，将所有日志劫持到slf4j上。

java
SLF4JBridgeHandler.removeHandlersForRootLogger();
SLF4JBridgeHandler.install();

spring boot中的日志初始化模块已经包括了该逻辑，故无需手动调用。在使用其他框架时，建议在入口类处的static{ }区执行，确保尽早初始化。

注意

  1. jcl-over-slf4j.jar 和 slf4j-jcl.jar 不能同时出现
  2. log4j-over-slf4j.jar 和 slf4j-log4j12.jar 不能同时出现
  3. jul-to-slf4j.jar 和 slf4j-jdk14.jar 不能同时出现

legacy

迁移的方式:

如果我们要使用 SLF4J 的桥接器，替换原有的日志框架，那么我们需要做的第一件事情，就是删除掉原有项目中的日志框架的依赖。然后替换成 SLF4J 提供的桥接器。

xml
<!-- log4j-->
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>log4j-over-slf4j</artifactId>
    <version>1.7.27</version>
</dependency>

<!-- jul -->
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>jul-to-slf4j</artifactId>
    <version>1.7.27</version>
</dependency>

<!--jcl -->
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>jcl-over-slf4j</artifactId>
    <version>1.7.27</version>
</dependency>

SLF4J原理解析 ​

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

Logback ​

https://logback.qos.ch/index.html

Logback 是由 log4j 创始人设计的另一个开源日志组件，性能比 log4j 要好。

Logback 主要分为三个模块:

  • logback-core:其它两个模块的基础模块
  • logback-classic:它是 log4j 的一个改良版本，同时它完整实现了 slf4j API
  • logback-access:访问模块与 Servlet 容器集成提供通过 Http 来访问日志的功能

后续的日志代码都是通过 SLF4J 日志门面搭建日志系统，所以在代码是没有区别，主要是通过修改配置 文件和 pom.xml 依赖

logback入门 ​

  1. 添加依赖
xml
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-api</artifactId>
    <version>1.7.30</version>
</dependency>

<dependency>
    <groupId>ch.qos.logback</groupId>
    <artifactId>logback-classic</artifactId>
    <version>1.2.3</version>
</dependency>
  1. java 代码
java
//定义日志对象
public final static Logger LOGGER = LoggerFactory.getLogger(LogBackTest.class);

@Test
public void testSlf4j(){
    //打印日志信息
    LOGGER.error("error");
    LOGGER.warn("warn");
    LOGGER.info("info");
    LOGGER.debug("debug");
    LOGGER.trace("trace");
}

logback配置 ​

https://logback.qos.ch/manual/layouts.html

logback 会依次读取以下类型配置文件: logback.groovy logback-test.xml logback.xml 如果均不存在会采用默认配置

  1. logback 组件之间的关系
    1. Logger:日志的记录器，把它关联到应用的对应的 context 上后，主要用于存放日志对象，也 可以定义日志类型、级别。
    2. Appender:用于指定日志输出的目的地，目的地可以是控制台、文件、数据库等等。
    3. Layout:负责把事件转换成字符串，格式化的日志信息的输出。在 logback 中 Layout 对象被封装在 encoder 中。
  2. 基本配置信息
xml
<?xml version="1.0" encoding="UTF-8"?>
<configuration>
<!--
    日志输出格式(更多格式参考官方文档 https://logback.qos.ch/manual/layouts.html ):
    %-5level
    %d{yyyy-MM-dd HH:mm:ss.SSS}日期
    %c类的完整名称
    %M为method
    %L为行号
    %thread线程名称
    %m或者%msg为信息
    %n换行
 -->
    <property name="LOG_PATTERN" value="[%-5p] [%d] [%caller] %n%m%n%n"/>
    <property name="CONSOLE_LOG_PATTERN"
              value="%highlight([%-5p] [%d] [%class.%method %file:%line]) %n%m%n%n"/>
    <property name="CONSOLE_LOG_PATTERN_CALLER"
            value="%highlight([%-5p] [%d] [%caller]) %n%m%n%n"/>
    <property name="LOG_FOLDER" value="${file_appender_location}"/>

<!--
    Appender: 设置日志信息的去向,常用的有以下几个
    - ch.qos.logback.core.ConsoleAppender (控制台)
    - ch.qos.logback.core.rolling.RollingFileAppender (文件大小到达指定尺 寸的时候产生一个新文件)
    - ch.qos.logback.core.FileAppender (文件)
 -->
    <appender name="console" class="ch.qos.logback.core.ConsoleAppender">

        <!--输出流对象 默认 System.out 改为 System.err-->
        <target>System.out</target>
      
        <!--日志格式配置-->
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <pattern>#[[${CONSOLE_LOG_PATTERN}]]#</pattern>
        </encoder>
    </appender>

<!--
    <!--日志文件输出appender对象-->  
    <appender name="file" class="ch.qos.logback.core.FileAppender">

        <!--日志格式配置-->
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <pattern>#[[${LOG_PATTERN}]]#</pattern>
        </encoder>

        <!--日志输出路径-->
        <file>#[[${LOG_FOLDER}]]#/logback.log</file>
    </appender>
 -->

<!--
    <!-- 生成html格式appender对象 -->
    <appender name="htmlFile" class="ch.qos.logback.core.FileAppender">
        <!--日志格式配置-->
        <encoder class="ch.qos.logback.core.encoder.LayoutWrappingEncoder">
            <layout class="ch.qos.logback.classic.html.HTMLLayout">
                <pattern>%level%d{yyyy-MM-dd HH:mm:ss}%c%M%L%thread%m</pattern>
            </layout>
        </encoder>
        <!--日志输出路径-->
        <file>#[[${LOG_FOLDER}]]#/logback.html</file>
    </appender>
 -->

<!--
    <!-- 日志文件拆分和归档的appender对象-->  
    <appender name="rollFile" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <!--日志格式配置-->
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <pattern>#[[${LOG_PATTERN}]]#</pattern>
        </encoder>

        <!--日志输出路径-->
        <file>#[[${LOG_FOLDER}]]#/roll_logback.log</file>

        <!--指定日志文件拆分和压缩规则-->
        <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">

            <!--通过指定压缩文件名称，来确定分割文件方式-->
            <fileNamePattern>#[[${log_dir}]]#/rolling.%d{yyyy-MM-dd}.log%i.gz</fileNamePattern>

            <!--文件拆分大小-->
            <maxFileSize>10MB</maxFileSize>
        </rollingPolicy>

        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <!--设置拦截日志级别-->
            <level>error</level>
            <onMatch>ACCEPT</onMatch>
            <onMismatch>DENY</onMismatch>
        </filter>
    </appender>
 -->

<!--
    用来设置某一个包或者具体的某一个类的日志打印级别、以及指定<appender>。
    <loger>仅有一个name属性，一个可选的level和一个可选的addtivity属性
    name:
    用来指定受此logger约束的某一个包或者具体的某一个类。
    level:
    用来设置打印级别，大小写无关:TRACE, DEBUG, INFO, WARN, ERROR, ALL 和OFF

    如果未设置此属性，那么当前logger将会继承上级的级别。
    additivity:
    是否向上级loger传递打印信息。默认是true。

    <logger>可以包含零个或多个<appender-ref>元素，标识这个appender将会添加到这个logger
  自定义logger additivity表示是否从 rootLogger继承配置 
 -->
<!--
    <logger name="com.futureweaver" level="debug" additivity="false">
        <appender-ref ref="console"/>
    </logger>        
 -->

<!--
    异步日志
 -->
<!--
    <appender name="async" class="ch.qos.logback.classic.AsyncAppender">
        <appender-ref ref="rollFile"/>
    </appender>
 -->

<!--
    也是<logger>元素，但是它是根logger。默认debug
    level:用来设置打印级别，大小写无关:TRACE, DEBUG, INFO, WARN, ERROR, ALL和 OFF，
    <root>可以包含零个或多个<appender-ref>元素，标识这个appender将会添加到这个logger。
 -->
    <root level="ALL">
        <appender-ref ref="console"/>
    </root>
</configuration>
  1. 官方提供的 log4j.properties 转换成 logback.xml

https://logback.qos.ch/translator/

logback-access的使用 ​

logback-access 模块与 Servlet 容器(如 Tomcat 和 Jetty)集成，以提供 HTTP 访问日志功能。我们可以使用 logback-access 模块来替换 tomcat 的访问日志。

  1. 将 logback-access.jar 与 logback-core.jar 复制到$TOMCAT_HOME/lib/目录下

  2. 修改$TOMCAT_HOME/conf/server.xml 中的 Host 元素中添加:

xml
<Valve className="ch.qos.logback.access.tomcat.LogbackValve" />
  1. logback 默认会在$TOMCAT_HOME/conf 下查找文件 logback-access.xml
xml
<?xml version="1.0" encoding="UTF-8"?>
<configuration>
    <!-- always a good activate OnConsoleStatusListener -->
    <statusListener class="ch.qos.logback.core.status.OnConsoleStatusListener"/>
    <property name="LOG_DIR" value="${catalina.base}/logs"/>
    <appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <file>${LOG_DIR}/access.log</file>
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <fileNamePattern>access.%d{yyyy-MM-dd}.log.zip</fileNamePattern>
        </rollingPolicy>
        <encoder>
            <!-- 访问日志的格式 -->
            <pattern>combined</pattern>
        </encoder>
    </appender>

    <appender-ref ref="FILE"/>

</configuration>
  1. 官方配置

https://logback.qos.ch/access.html#configuration

log4j2 ​

https://logging.apache.org/log4j/2.x/

Apache Log4j 2 是对 Log4j 的升级版，参考了 logback 的一些优秀的设计，并且修复了一些问题，因此带来了一些重大的提升，主要有:

  • 异常处理，在 logback 中，Appender 中的异常不会被应用感知到，但是在 log4j2 中，提供了一些异 常处理机制。
  • 性能提升， log4j2 相较于 log4j 和 logback 都具有很明显的性能提升，后面会有官方测试的数据。
  • 自动重载配置，参考了 logback 的设计，当然会提供自动刷新参数配置，最实用的就是我们在生产上可以动态的修改日志的级别而不需要重启应用。
  • 无垃圾机制，log4j2 在大部分情况下，都可以使用其设计的一套无垃圾机制，避免频繁的日志收集 导致的 jvm gc。

Log4j2入门 ​

目前市面上最主流的日志门面就是 SLF4J，虽然 Log4j2 也是日志门面，因为它的日志实现功能非常强大，性能优越。所以大家一般还是将 Log4j2 看作是日志的实现，Slf4j + Log4j2 应该是未来的大势所趋。

  1. 添加依赖
xml
<!-- Log4j2 门面API-->
<dependency>
    <groupId>org.apache.logging.log4j</groupId>
    <artifactId>log4j-api</artifactId>
    <version>2.11.1</version>
</dependency>

<!-- Log4j2 日志实现 -->
<dependency>
    <groupId>org.apache.logging.log4j</groupId>
    <artifactId>log4j-core</artifactId>
    <version>2.11.1</version>
</dependency>
  1. JAVA 代码
java
public class Log4j2Test {
    // 定义日志记录器对象
    public static final Logger LOGGER = LogManager.getLogger(Log4j2Test.class);

    @Test
    public void testQuick() throws Exception {
        LOGGER.fatal("fatal");
        LOGGER.error("error");
        LOGGER.warn("warn");
        LOGGER.info("info");
        LOGGER.debug("debug");
        LOGGER.trace("trace");
    }
}
  1. 使用 slf4j 作为日志的门面,使用 log4j2 作为日志的实现
java
<!-- Log4j2 门面API-->
<dependency>
    <groupId>org.apache.logging.log4j</groupId>
    <artifactId>log4j-api</artifactId>
    <version>2.11.1</version>
</dependency>

<!-- Log4j2 日志实现 -->
<dependency>
    <groupId>org.apache.logging.log4j</groupId>
    <artifactId>log4j-core</artifactId>
    <version>2.11.1</version>
</dependency>

<!--使用slf4j作为日志的门面,使用log4j2来记录日志 -->
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-api</artifactId>
    <version>1.7.25</version>
</dependency>

<!--为slf4j绑定日志实现 log4j2的适配器 -->
<dependency>
    <groupId>org.apache.logging.log4j</groupId>
    <artifactId>log4j-slf4j-impl</artifactId>
    <version>2.10.0</version>
</dependency>

Log4j2配置 ​

log4j2 默认加载 classpath 下的 log4j2.xml 文件中的配置。

xml
<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="warn" monitorInterval="5">
    <properties>
        <property name="LOG_HOME">D:/logs</property>
    </properties>

    <Appenders>
        <Console name="Console" target="SYSTEM_OUT">
            <PatternLayout pattern="%d{HH:mm:ss.SSS} [%t] [%-5level] %c{36}:%L - -- %m%n" />
        </Console>

        <File name="file" fileName="${LOG_HOME}/myfile.log">
            <PatternLayout pattern="[%d{yyyy-MM-dd HH:mm:ss.SSS}] [%-5level] %l %c{36} - %m%n" />
        </File>

        <RandomAccessFile name="accessFile" fileName="${LOG_HOME}/myAcclog.log">
            <PatternLayout pattern="[%d{yyyy-MM-dd HH:mm:ss.SSS}] [%-5level] %l %c{36} - %m%n" />
        </RandomAccessFile>

        <RollingFile name="rollingFile"
                     fileName="${LOG_HOME}/myrollog.log"
                     filePattern="D:/logs/$${date:yyyy-MM-dd}/myrollog-%d{yyyy-MM-dd-HH-mm}-%i.log">
            <ThresholdFilter level="debug" onMatch="ACCEPT" onMismatch="DENY" />
            <PatternLayout pattern="[%d{yyyy-MM-dd HH:mm:ss.SSS}] [%-5level] %l %c{36} - %msg%n" />
            <Policies>
                <OnStartupTriggeringPolicy />
                <SizeBasedTriggeringPolicy size="10 MB" />
                <TimeBasedTriggeringPolicy />
            </Policies>
            <DefaultRolloverStrategy max="30" />
        </RollingFile>
    </Appenders>

    <Loggers>
        <Root level="trace">
            <AppenderRef ref="Console" />
        </Root>
    </Loggers>
</Configuration>

Log4j2异步日志 ​

异步日志

log4j2 最大的特点就是异步日志，其性能的提升主要也是从异步日志中受益，我们来看看如何使用 log4j2 的异步日志。

  • 同步日志

log4j2-sync

  • 异步日志

logj2-async

Log4j2 提供了两种实现日志的方式，一个是通过 AsyncAppender，一个是通过 AsyncLogger，分别对应前面我们说的 Appender 组件和 Logger 组件。

注意:配置异步日志需要添加依赖

xml
<!--异步日志依赖-->
<dependency>
    <groupId>com.lmax</groupId>
    <artifactId>disruptor</artifactId>
    <version>3.3.4</version>
</dependency>
  1. AsyncAppender 方式
xml
<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="warn">
    <properties>
        <property name="LOG_HOME">D:/logs</property>
    </properties>

    <Appenders>
        <File name="file" fileName="${LOG_HOME}/myfile.log">
            <PatternLayout>
                <Pattern>%d %p %c{1.} [%t] %m%n</Pattern>
            </PatternLayout>
        </File>
        <Async name="Async">
            <AppenderRef ref="file"/>
        </Async>
    </Appenders>

    <Loggers>
        <Root level="error">
            <AppenderRef ref="Async"/>
        </Root>
    </Loggers>
</Configuration>
  1. AsyncLogger 方式

AsyncLogger 才是 log4j2 的重头戏，也是官方推荐的异步方式。它可以使得调用 Logger.log 返回的更快。你可以有两种选择:全局异步和混合异步。

全局异步就是，所有的日志都异步的记录，在配置文件上不用做任何改动，只需要添加一个 log4j2.component.properties 配置;

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

混合异步就是，你可以在应用中同时使用同步日志和异步日志，这使得日志的配置方式更加灵活。

xml
<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="WARN">
    <properties>
      <property name="LOG_HOME">D:/logs</property>
    </properties>
    <Appenders>
        <File name="file" fileName="${LOG_HOME}/myfile.log">
            <PatternLayout>
                <Pattern>%d %p %c{1.} [%t] %m%n</Pattern>
            </PatternLayout>
        </File>
        <Async name="Async">
            <AppenderRef ref="file"/>
        </Async>
    </Appenders>

    <Loggers>
        <AsyncLogger name="com.futureweaver" level="trace" includeLocation="false" additivity="false">
            <AppenderRef ref="file"/>
        </AsyncLogger>
        <Root level="info" includeLocation="true">
          <AppenderRef ref="file"/>
        </Root>
    </Loggers>
</Configuration>

如上配置: com.futureweaver 日志是异步的，root 日志是同步的。

使用异步日志需要注意的问题:

  1. 如果使用异步日志，AsyncAppender、AsyncLogger 和全局日志，不要同时出现。性能会和 AsyncAppender 一致，降至最低。
  2. 设置 includeLocation=false ，打印位置信息会急剧降低异步日志的性能，比同步日志还要慢。

Log4j2的性能 ​

Log4j2 最牛的地方在于异步输出日志时的性能表现，Log4j2 在多线程的环境下吞吐量与 Log4j 和 Logback 的比较如下图。下图比较中 Log4j2 有三种模式:1)全局使用异步模式;2)部分 Logger 采用异步模式;3)异步 Appender。可以看出在前两种模式下，Log4j2 的性能较之 Log4j 和 Logback 有很大的优势。

log4j2-throughput

无垃圾记录

垃圾收集暂停是延迟峰值的常见原因，并且对于许多系统而言，花费大量精力来控制这些暂停。

许多日志库(包括以前版本的 Log4j)在稳态日志记录期间分配临时对象，如日志事件对象，字符串，字符数组，字节数组等。这会对垃圾收集器造成压力并增加 GC 暂停发生的频率。

从版本 2.6 开始，默认情况下 Log4j 以“无垃圾”模式运行，其中重用对象和缓冲区，并且尽可能不分配临时对象。还有一个“低垃圾”模式，它不是完全无垃圾，但不使用 ThreadLocal 字段。

Log4j 2.6 中的无垃圾日志记录部分通过重用 ThreadLocal 字段中的对象来实现，部分通过在将文本转换为字节时重用缓冲区来实现。

使用 Log4j 2.5:内存分配速率 809 MB /秒，141 个无效集合。

1829785-20200224215456996-630669001

Log4j 2.6 没有分配临时对象：0（零）垃圾回收。

1829785-20200224215800892-1432858172

有两个单独的系统属性可用于手动控制 Log4j 用于避免创建临时对象的机制：

  • log4j2.enableThreadlocals - 如果“true”（非 Web 应用程序的默认值）对象存储在 ThreadLocal 字段中并重新使用，否则将为每个日志事件创建新对象。

  • log4j2.enableDirectEncoders - 如果将“true”（默认）日志事件转换为文本，则将此文本转换为字节而不创建临时对象。注意： 由于共享缓冲区上的同步，在此模式下多线程应用程序的同步日志记录性能可能更差。如果您的应用程序是多线程的并且日志记录性能很重要，请考虑使用异步记录器

SpringBoot中的日志使用 ​

springboot 框架在企业中的使用越来越普遍，springboot 日志也是开发中常用的日志系统。springboot 默认就是使用 SLF4J 作为日志门面，logback 作为日志实现来记录日志。

SpringBoot中的日志设计 ​

springboot 中的日志

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

依赖关系图:

f7121ec7d9d38496e827bdf25165c6b1

总结：

  1. springboot 底层默认使用 logback 作为日志实现。

  2. 使用了 SLF4J 作为日志门面

  3. 将 JUL 也转换成 slf4j

  4. 也可以使用 log4j2 作为日志门面，但是最终也是通过 slf4j 调用 logback

SpringBoot日志使用 ​

  1. 在 springboot 中测试打印日志
java
@SpringBootTest
class SpringbootLogApplicationTests {
    //记录器
    public static final Logger LOGGER = LoggerFactory.getLogger(SpringbootLogApplicationTests.class);

    @Test
    public void contextLoads() {
        // 打印日志信息
        LOGGER.error("error");
        LOGGER.warn("warn");
        LOGGER.info("info"); // 默认日志级别
        LOGGER.debug("debug");
        LOGGER.trace("trace");
    }
}
  1. 修改默认日志配置
properties
logging.level.root=off
logging.level.com.futureweaver=trace

## 在控制台输出的日志的格式 同logback
logging.pattern.console=%clr(%d{yyyy-MM-dd HH:mm:ss.SSS}){faint} %clr(%5p) %clr(${PID}){magenta} %clr(---){faint} %clr([%15.15t]){faint} %clr(%-40.40logger{39}){cyan} %clr(:){faint} %m%n%wEx

## 指定文件中日志输出的格式
logging.file.name=D:/logs/springboot.log
logging.pattern.file=%d{yyyy-MM-dd HH:mm:ss.SSS} %5p ${PID} --- [%t] %-40.40logger{39} : %m%n%wEx
  1. 指定配置

给类路径下放上每个日志框架自己的配置文件;SpringBoot 就不使用默认配置的了

日志框架配置文件
logbacklogback-spring.xml, logback.xml
log4j2log4j2-spring.xml, log4j2.xml
JULlogging.properties
  1. 使用 SpringBoot 解析日志配置

logback-spring.xml:由 SpringBoot 解析日志配置

xml
<encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
    <springProfile name="dev">
        <pattern>${pattern}</pattern>
    </springProfile>
    <springProfile name="pro">
        <pattern>%d{yyyyMMdd:HH:mm:ss.SSS} [%thread] %-5level %msg%n</pattern>
    </springProfile>
</encoder>
  • application.properties
properties
spring.profiles.active=dev
  1. 将日志切换为 log4j2
xml
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <exclusions>
        <!--排除logback-->
        <exclusion>
            <artifactId>spring-boot-starter-logging</artifactId>
            <groupId>org.springframework.boot</groupId>
        </exclusion>
    </exclusions>
</dependency>

<!-- 添加log4j2 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-log4j2</artifactId>
</dependency>

Idea模板 ​

  1. 进入 Idea 欢迎页面(如果已开启某个项目，点击菜单栏-File-Close Project)
  2. 左侧导航栏，选择Customize，选择All Settings...
  3. 左侧导航栏，选择Editor->File And Code Templates

pom.xml ​

  1. 右侧视图，选择Other选项卡
  2. 右侧窗口中的左侧导航栏，选择Maven->Maven Project.xml(如果已修改，先撤销，后修改)
  3. 下拉到底部，将以下文本，CV到</project>上侧
xml
    <dependencies>
        <!-- spring-boot-starter -->
        <!-- spring-boot-starter-web -->
        <!-- spring-boot-devtools -->
        <!-- spring-boot-starter-test -->
        <!-- tomcat-embed-jasper -->
        <!-- mybatis-spring-boot-starter -->
        <!-- druid-spring-boot-starter -->
        <!-- pagehelper-spring-boot-starter -->

        <!-- javax.servlet-api -->
        <!-- spring-context -->
        <!-- spring-aspect -->
        <!-- spring-web -->
        <!-- spring-webmvc -->
        <!-- spring-jdbc -->
        <!-- jackson-databind -->
        <!-- hibernate-validator -->
        <!-- taglibs-standard-impl -->
        <!-- taglibs-standard-spec -->
        <!-- mysql-connector-j -->
        <!-- druid -->
        <!-- mybatis -->
        <!-- mybatis-spring -->
        <!-- pagehelper -->

        <!-- slf4j-api -->
        <!-- slf4j-simple/logback-classic -->
        <!-- log4j -->
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>

        <resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>*.xml</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>true</filtering>
            </resource>

            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>*</include>
                </includes>
                <filtering>true</filtering>
            </resource>
        </resources>
    </build>

log4j.properties ​

  1. 右侧视图，选择Files选项卡
  2. 点击+(如果已存在，先删除，后添加)
  3. Name -> log4j-properties
  4. Extention -> properties
  5. File Name -> log4j.properties
  6. 将以下内容，粘贴到模板内部
properties
global.conversion.pattern=[%-5p] [%d] [%l] %n%m%n%n

## root
log4j.rootLogger=ALL,stdout
log4j.logger.${debug_level_package} = DEBUG,stdout

## ConsoleAppender
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Threshold=DEBUG
log4j.appender.stdout.Encoding=utf-8
log4j.appender.stdout.Target=System.out
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=${global.conversion.pattern}

## DailyRollingFileAppender
##log4j.appender.rolling=org.apache.log4j.DailyRollingFileAppender
##log4j.appender.rolling.Threshold=DEBUG
##log4j.appender.rolling.File=${file_appender-location}
##log4j.appender.rolling.Append=true
##log4j.appender.rolling.layout=org.apache.log4j.PatternLayout
##log4j.appender.rolling.layout.ConversionPattern=${global.conversion.pattern}
##log4j.appender.rolling.encoding=UTF-8

logback.xml ​

  1. 右侧视图，选择Files选项卡
  2. 点击+(如果已存在，先删除，后添加)
  3. Name -> logback-xml
  4. Extention -> xml
  5. File Name -> logback.xml
  6. 将以下内容，粘贴到模板内部
xml
<?xml version="1.0" encoding="UTF-8"?>
<configuration>
    <property name="LOG_PATTERN" 
              value="[%-5p] [%d] [%caller] %n%m%n%n"/>
    <property name="CONSOLE_LOG_PATTERN"
              value="%highlight([%-5p] [%d] [%class.%method %file:%line]) %n%m%n%n"/>
    <property name="CONSOLE_LOG_PATTERN_CALLER"
              value="%highlight([%-5p] [%d] [%caller]) %n%m%n%n"/>
    <property name="LOG_FOLDER" 
              value="${file_appender_location}"/>

    <appender name="console" class="ch.qos.logback.core.ConsoleAppender">
        <target>System.out</target>
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <pattern>#[[${CONSOLE_LOG_PATTERN}]]#</pattern>
        </encoder>
    </appender>

    <!--
    <appender name="file" class="ch.qos.logback.core.FileAppender">
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <pattern>#[[${LOG_PATTERN}]]#</pattern>
        </encoder>
        <file>#[[${LOG_FOLDER}]]#/logback.log</file>
    </appender>
     -->

    <!--
    <appender name="htmlFile" class="ch.qos.logback.core.FileAppender">
        <encoder class="ch.qos.logback.core.encoder.LayoutWrappingEncoder">
            <layout class="ch.qos.logback.classic.html.HTMLLayout">
                <pattern>%level%d{yyyy-MM-dd HH:mm:ss}%c%M%L%thread%m</pattern>
            </layout>
        </encoder>
        <file>#[[${LOG_FOLDER}]]#/logback.html</file>
    </appender>
     -->

    <!--
    <appender name="rollFile" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <pattern>#[[${LOG_PATTERN}]]#</pattern>
        </encoder>
        <file>#[[${LOG_FOLDER}]]#/roll_logback.log</file>
        <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
            <fileNamePattern>#[[${log_dir}]]#/rolling.%d{yyyy-MM-dd}.log%i.gz</fileNamePattern>
            <maxFileSize>10MB</maxFileSize>
        </rollingPolicy>
    </appender>
     -->

    <logger name="${debug_level_package}" level="DEBUG"/>

    <root level="ALL">
        <appender-ref ref="console"/>
    </root>
</configuration>

学习目标总结 ​

  • 日志的作用和目的
  • 日志的框架
  • JUL 的使用
  • LOG4J 的使用
  • JCL 的使用
  • 日志门面和日志体系
  • SLF4J
  • logback 的使用
  • log4j2 的使用
  • SpringBoot 中的日志使用

参考资料 ​

https://www.logicbig.com/tutorials/spring-framework/spring-boot/logging-console-pattern.html