no17-日志框架学习

飞一样的编程
飞一样的编程
擅长邻域:Java,MySQL,Linux,nginx,springboot,mongodb,微信小程序,vue

分类: springboot 专栏: springboot学习 标签: 日志框架学习

2023-04-14 23:37:02 604浏览

日志框架学习

前言:常见的日志

  • nginx日志:
127.0.0.1 - - [28/Nov/2019:08:37:25 +0800] "GET /plugins/normalize-css/normalize.css HTTP/1.1" 200 8053 "http://www.xuecheng.com/" "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/68.0.3440.106 Safari/537.36"
127.0.0.1 - - [28/Nov/2019:08:37:25 +0800] "GET / HTTP/1.1" 200 57621 "-" "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/68.0.3440.106 Safari/537.36"
127.0.0.1 - - [28/Nov/2019:08:37:25 +0800] "GET /static/css/page-learing-article.css HTTP/1.1" 404 582 "http://www.xuecheng.com/" "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/68.0.3440.106 Safari/537.36"
127.0.0.1 - - [28/Nov/2019:08:37:25 +0800] "GET /static/plugins/bootstrap/dist/css/bootstrap.css HTTP/1.1" 404 582 "http://www.xuecheng.com/" "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/68.0.3440.106 Safari/537.36"
127.0.0.1 - - [28/Nov/2019:08:37:25 +0800] "GET /css/page-learing-index.css HTTP/1.1" 200 25403 "http://www.xuecheng.com/" "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/68.0.3440.106 Safari/537.36"
127.0.0.1 - - [28/Nov/2019:08:37:25 +0800] "GET /css/main.css HTTP/1.1" 200 39 "http://www.xuecheng.com/" "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/68.0.3440.106 Safari/537.36"
  • Tomcat日志:
01-Aug-2019 08:42:19.365 信息 [main] org.apache.catalina.startup.VersionLoggerListener.log Server version:        Apache Tomcat/8.5.31
01-Aug-2019 08:42:19.422 信息 [main] org.apache.catalina.startup.VersionLoggerListener.log Server built:          Apr 27 2018 20:24:25 UTC
01-Aug-2019 08:42:19.425 信息 [main] org.apache.catalina.startup.VersionLoggerListener.log Server number:         8.5.31.0
01-Aug-2019 08:42:19.427 信息 [main] org.apache.catalina.startup.VersionLoggerListener.log OS Name:               Windows 7
01-Aug-2019 08:42:19.428 信息 [main] org.apache.catalina.startup.VersionLoggerListener.log OS Version:            6.1
01-Aug-2019 08:42:19.429 信息 [main] org.apache.catalina.startup.VersionLoggerListener.log Architecture:          amd64
01-Aug-2019 08:42:19.430 信息 [main] org.apache.catalina.startup.VersionLoggerListener.log Java Home:             C:\Program Files\Java\jdk1.8.0_131\jre
01-Aug-2019 08:42:19.432 信息 [main] org.apache.catalina.startup.VersionLoggerListener.log JVM Version:           1.8.0_131-b11
01-Aug-2019 08:42:19.433 信息 [main] org.apache.catalina.startup.VersionLoggerListener.log JVM Vendor:            Oracle Corporation
01-Aug-2019 08:42:19.434 信息 [main] org.apache.catalina.startup.VersionLoggerListener.log CATALINA_BASE:         D:\Program Files\cas\apache-tomcat-8.5.31
01-Aug-2019 08:42:19.436 信息 [main] org.apache.catalina.startup.VersionLoggerListener.log CATALINA_HOME:         D:\Program Files\cas\apache-tomcat-8.5.31
01-Aug-2019 08:42:19.437 信息 [main] org.apache.catalina.startup.VersionLoggerListener.log Command line argument: -Djava.util.logging.config.file=D:\Program Files\cas\apache-tomcat-8.5.31\conf\logging.properties
01-Aug-2019 08:42:19.438 信息 [main] org.apache.catalina.startup.VersionLoggerListener.log Command line argument: -Djava.util.logging.manager=org.apache.juli.ClassLoaderLogManager
01-Aug-2019 08:42:19.440 信息 [main] org.apache.catalina.startup.VersionLoggerListener.log Command line argument: -Djdk.tls.ephemeralDHKeySize=2048

一、 从Tomcat的日志说起

Tomcat中的日志其实是对jul的一层封装

二、乱乱的日志体系

2.1 日志发展史

问题:

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

日志门面 JCL、slf4j

日志实现 JUL、logback、log4j、log4j2

jul

入门使用

Loggers:被称为记录器,调用其API来来发布日志信息。指定日志级别,日志内容 Handler:指定日志位置,格式化信息

package com.zs.blog;

import org.junit.jupiter.api.Test;

import java.util.logging.Level;
import java.util.logging.Logger;

public class JULTest {
    @Test
    public void testQuick() throws Exception {
        // 1.创建日志记录器对象
        Logger logger = Logger.getLogger("com.itheima.log.JULTest");
        // 2.日志记录输出
        logger.info("hello jul");
        // 3. 通用方法进行记录
        logger.log(Level.INFO, "info msg");
        // 4. 日志内容占位符的使用
        String name = "jack"; Integer age = 18; logger.log(Level.INFO, "用户信息:{0},{1}", new Object[]{name, age});
    }
}

日志级别

/**
     * 洋红色日志:System.err
     * 只输出info后面的日志信息:默认配置的日志级别是info
     */
    @Test
    public void test01(){
        Logger logger = Logger.getLogger("abc");
        // 2.日志记录输出 all < finest < finer < fine < config < info < warning < severe < off
        logger.severe("severe");
        logger.warning("warning");
        logger.info("info");
        logger.config("config");
        logger.fine("fine");
        logger.finer("finer");
        logger.finest("finest");
    }

父子关系

/**
 * LogManager$RootLogger 是 logger1 的父级
 * logger1 是 logger2 的父级
 * logger2 是 logger3 的父级
 */
@Test
public void test02(){
    //所有的logger默认的父级是java.util.loggering.LogManager$RootLogger
    Logger logger1 = Logger.getLogger("a");
    Logger logger2 = Logger.getLogger("a.b");
    Logger logger3 = Logger.getLogger("a.b.c");
}
将logger对象的日志级别,以及将父级的Handler的输出级别改为all 即可输出所有级别的日志了
@Test
public void test01(){
    Logger logger = Logger.getLogger("abc");
    //设置 logger的级别
    logger.setLevel(Level.ALL);

    //获取到父级并设置Handler(appender)的级别
    Handler[] handlers = logger.getParent().getHandlers();
    for (Handler handler : handlers) {
        handler.setLevel(Level.ALL);
    }

    logger.severe("severe");
    logger.warning("warning");
    logger.info("info");
    logger.config("config");
    logger.fine("fine");
    logger.finer("finer");
    logger.finest("finest");
}

使用自己的Handler

@Test
public void test03(){
    Logger logger = Logger.getLogger("a");

    ConsoleHandler selfHandler = new ConsoleHandler();
    //设置自己的Handler
    logger.addHandler(selfHandler);
    //不在使用父级的Handler,解决日志重复输出
    logger.setUseParentHandlers(false);

    logger.info("info");
}

自定义日志级别配置

  @Test
    public void testLogConfig() throws Exception {
        // 1.创建日志记录器对象
        Logger logger = Logger.getLogger("com.itheima.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("cofnig");
        logger.fine("fine");
        logger.finer("finer");
        logger.finest("finest");
    }

配置文件

jre文件夹中

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

handlers= java.util.logging.ConsoleHandler
# 配置全局的Logger的级别
.level= INFO

# 文件输出的规则
java.util.logging.FileHandler.pattern = %h/java%u.log
java.util.logging.FileHandler.limit = 50000
java.util.logging.FileHandler.count = 1
java.util.logging.FileHandler.formatter = java.util.logging.XMLFormatter

# 控制台输出规则
java.util.logging.ConsoleHandler.level = INFO
java.util.logging.ConsoleHandler.formatter = java.util.logging.SimpleFormatter

# 指定包的日志级别
com.xyz.foo.level = SEVERE

读取配置文件

static LogManager logManager = LogManager.getLogManager();
static {
    try {
        logManager.readConfiguration(JulService.class.getClassLoader()
        .getResourceAsStream("logging.properties"));
    } catch (IOException e) {
        e.printStackTrace();
    }
}

测试代码如下

@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.itheima.log.JULTest");
        logger.severe("severe");
        logger.warning("warning");
        logger.info("info");
        logger.config("config");
        logger.fine("fine");
        logger.finer("finer");
        logger.finest("finest");
    }
## RootLogger使用的处理器(获取时设置)
handlers= java.util.logging.ConsoleHandler
# RootLogger日志等级
.level= INFO


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



## 控制台处理器
# 输出日志级别
java.util.logging.ConsoleHandler.level = INFO
# 输出日志格式
java.util.logging.ConsoleHandler.formatter = java.util.logging.SimpleFormatter
# 指定handler对象的日志消息格式对象
java.util.logging.ConsoleHandler.encoding = UTF-8
# 指定日志输出的格式
java.util.logging.SimpleFormatter.format="%4$s: %5$s [%1$tc]%n"


## 文件处理器
# 输出日志级别
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
    1. LogManager加载logging.properties配置
    2. 添加Logger到LogManager
  1. 从单例LogManager获取Logger
  2. 设置级别Level,并指定日志记录LogRecord
  3. Filter提供了日志级别之外更细粒度的控制
  4. Handler是用来处理日志输出位置
  5. Formatter是用来格式化LogRecord的


log4j (最后更新2012年)

可以控制日志信息输出到控制台、文件、甚至是数据库中。我们可以控制每一条日志的输出格式,通过定义日志的输出级别,可以更灵活的控制日志的输出过程。 官方网站: http://logging.apache.org/log4j/1.2/

Log4j 只维护到 2012年的1.2.17版本

开创了日志的分级别输出思想

log4j入门

添加依赖

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

java代码

package com.zs.blog;

import org.apache.log4j.BasicConfigurator;
import org.apache.log4j.Logger;
import org.junit.jupiter.api.Test;

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


        // 创建日志记录器对象
        Logger logger = Logger.getLogger(Log4jTest.class);
        // 日志记录输出
        logger.info("hello log4j");


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

日志的级别

* 每个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 类的别名。

Appenders(输出位置)

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

输出端类型

作用

ConsoleAppender

将日志输出到控制台

FileAppender

将日志输出到文件中

DailyRollingFileAppender

将日志输出到一个日志文件,并且每天输出到一个新的文件

RollingFileAppender

将日志信息输出到一个日志文件,并且指定文件的尺寸,当文件大小达到指定尺寸时,会自动吧文改名,同时产生一个新的文件

JDBCAppender

把日志信息保存到数据库中

Layouts(输出格式)

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

格式化器类型

作用

HTMLLayout

格式化日志输出为HTML表格形式

SimpleLayout

简单的日志输出格式化,打印的日志格式为(info-message)

PatternLayout

最强大的格式化器,可以根据自定义格式输出日志,如果没有指定转换格式,就使用默认的转换格式

配置文件

日志配置文件

配置文件名称(源码位置)

log4j.properties或log4j.xml

.m2/repository/log4j/log4j/1.2.17/log4j-1.2.17.jar!/org/apache/log4j/LogManager.class:25

配置文件位置(源码位置)

类路径下

/Users/miyufeng/.m2/repository/log4j/log4j/1.2.17/log4j-1.2.17.jar!/org/apache/log4j/LogManager.class:115

读取配置文件内部信息(源码位置)

/Users/miyufeng/.m2/repository/log4j/log4j/1.2.17/log4j-1.2.17.jar!/org/apache/log4j/LogManager.class:132

/Users/miyufeng/.m2/repository/log4j/log4j/1.2.17/log4j-1.2.17.jar!/org/apache/log4j/helpers/OptionConverter.class:303

具体如何配置

rootLogger 顶层父级(源码位置)

/Users/miyufeng/.m2/repository/log4j/log4j/1.2.17/log4j-1.2.17.jar!/org/apache/log4j/PropertyConfigurator.class:44

/Users/miyufeng/.m2/repository/log4j/log4j/1.2.17/log4j-1.2.17.jar!/org/apache/log4j/PropertyConfigurator.class:232

/Users/miyufeng/.m2/repository/log4j/log4j/1.2.17/log4j-1.2.17.jar!/org/apache/log4j/PropertyConfigurator.class:295

appender 输出器配置、layout 格式化器(源码位置)

/Users/miyufeng/.m2/repository/log4j/log4j/1.2.17/log4j-1.2.17.jar!/org/apache/log4j/PropertyConfigurator.class:337

入门案例,使用配置文件

package com.zs.logger;

import org.apache.log4j.BasicConfigurator;
import org.apache.log4j.Logger;
import org.junit.Test;

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


        // 创建日志记录器对象
        Logger logger = Logger.getLogger(Log4jTest.class);
        // 日志记录输出
        logger.info("hello log4j");


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

配置示例1

log4j.properties

# rootLooger的日志级别,以及appenders
log4j.rootLogger = trace,stdout

# 配置简单控制台appender对象
# 使用控制台appender
log4j.appender.stdout = org.apache.log4j.ConsoleAppender
# 日志格式:简单格式
log4j.appender.stdout.layout = org.apache.log4j.SimpleLayout

配置示例2

# rootLooger的日志级别,以及appenders
log4j.rootLogger = trace,stdout

# 使用控制台appender,其中stdout是自定义的
log4j.appender.stdout = org.apache.log4j.ConsoleAppender
# 输出目的地
log4j.appender.stdout.Target = System.out
# appender的日志级别
log4j.appender.stdout.Threshold = info
# 日志格式:简单格式
#log4j.appender.stdout.layout = org.apache.log4j.SimpleLayout
log4j.appender.stdout.layout = org.apache.log4j.PatternLayout
# %d{yyyy-MM-dd HH:mm:ss}:指定日期格式
# %-5p:日志级别     %20c:全类名    %L:第几行      %m:自己打印的message     %n:换行
log4j.appender.stdout.layout.ConversionPattern = %d{yyyy-MM-dd HH:mm:ss} %-5p %20c %L:%m %n


# 配置文件appender,输出到文件,而且每天一个文件
log4j.appender.a1 = org.apache.log4j.DailyRollingFileAppender
# 这里的目录不需要提前创建
log4j.appender.a1.file = ${user.home}/log-demo/log4j/a1.log
log4j.appender.a1.threshold = info
log4j.appender.a1.layout = org.apache.log4j.PatternLayout
log4j.appender.a1.layout.ConversionPattern = %d{yyyy-MM-dd HH:mm:ss} %-5p %20c %L:%m %n



log4j.appender.a2 = org.apache.log4j.RollingFileAppender
log4j.appender.a2.file = ${user.home}/log-demo/log4j/a2.log
# 单个文件最大100MB
log4j.appender.a2.maxFileSize = 100MB
# 最多保留7个日志文件
log4j.appender.a2.maxBackupIndex = 7
log4j.appender.a2.threshold = info
log4j.appender.a2.layout = org.apache.log4j.PatternLayout
log4j.appender.a2.layout.ConversionPattern = %d{yyyy-MM-dd HH:mm:ss} %-5p %20c %L:%m %n

# 还可以保存7天的日志文件 crontab
# find /home/zhao/logs/ -type f -mtime +7 -exec rm -f {} \;

#mysql 将日志保存到数据库
log4j.appender.logDB=org.apache.log4j.jdbc.JDBCAppender
log4j.appender.logDB.layout=org.apache.log4j.PatternLayout
log4j.appender.logDB.Driver=com.mysql.jdbc.Driver
log4j.appender.logDB.URL=jdbc:mysql://localhost:3306/test
log4j.appender.logDB.User=root
log4j.appender.logDB.Password=root
log4j.appender.logDB.Sql=INSERT INTO
log(project_name,create_date,level,category,file_name,thread_name,line,all_categ
ory,message) values('itcast','%d{yyyy-MM-dd
HH:mm:ss}','%p','%c','%F','%t','%L','%l','%m')

# 注意:父子类都指定同一个appender时会出现日志重复问题
# 自定义logger对象设置
log4j.logger.com.zs.log.log4j = ERROR,a1
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`)
);

语法

说明

%c

a.b.c

%c{2}

b.c

%20c

(若名字空间长度小于20,则左边用空格填充)

%-20c

(若名字空间长度小于20,则右边用空格填充)

%.30c

(若名字空间长度超过30,截去多余字符)

%20.30c

(若名字空间长度小于20,则左边用空格填充;若名字空间长度超
过30,截去多余字符)

%-20.30c

(若名字空间长度⼩于20,则右边用空格填充;若名字空间长度超
过30,截去多余字符)

%C

org.apache.xyz.SomeClass

%C{1}

SomeClass

%d{yyyy/MM/dd
HH:mm:ss,SSS}

2000/10/12 11:22:33,117

%d{ABSOLUTE}

11:22:33,117

%d{DATE}

12 Oct 2000 11:22:33,117

%d{ISO8601}

2000-10-12 11:22:33,117

%F

MyClass.java

%l

MyClass.main(MyClass.java:123)

%L

123

%m

This is a message for debug.

%M

main

%n

Windows平台下表示rn,UNIX平台下表示n

%p

INFO

%r

1215

%t

MyClass

%%

%

日志门面

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

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

常见的日志门面 : JCL、slf4j 常见的日志实现: JUL、log4j、logback、log4j2

日志框架出现的历史顺序: log4j -->JUL-->JCL--> slf4j --> logback --> log4j2

jcl(了解,最后更新2014年)

Jakarta Commons Logging.commons-logging.jar 2014年 1.2

  • jakarta
  • 运行时获取具体日志:org.apache.commons.logging.LogFactoryImpl#discoverLogImplementation

默认使用的是jul的日志

<dependency> 
	<groupId>commons-logging</groupId> 
	<artifactId>commons-logging</artifactId> 
	<version>1.2</version> 
</dependency>
public class JULTest { 
	@Test 
	public void testQuick() throws Exception { 
		// 创建日志对象 
		Log log = LogFactory.getLog(JULTest.class); 
		// 日志记录输出 
		log.fatal("fatal"); 
		log.error("error"); 
		log.warn("warn"); 
		log.info("info"); 
		log.debug("debug"); 
	} 
}

如何切换成log4j

1、引入log4j

2、配置log4j.properties

原理

  1. 通过LogFactory动态加载Log实现类
  2. 日志门面支持的日志实现数组
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. 获取具体的日志实现
for(int i = 0; i < classesToDiscover.length && result == null; ++i) { 
	result = this.createLogFromClass(classesToDiscover[i], logCategory, true); 
}

SLF4j的使用

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

官方网站: https://www.slf4j.org/

SLF4J入门

  • 添加依赖
   <!--slf4j 门面:只要用slf4j做日志门面,这个就必须写!!!!-->
        <dependency>
            <groupId>org.slf4j</groupId>
              <artifactId>slf4j-api</artifactId>
          </dependency>
        <!--slf4j简单实现-->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-simple</artifactId>
        </dependency>

  • java代码
package com.zs.blog;
import org.junit.jupiter.api.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class Slf4jTest {

    public static final Logger LOGGER = LoggerFactory.getLogger(Slf4jTest.class);


    @Test
    public void testQuick() throws Exception {
        // 日志级别
        LOGGER.error("error 中文"); // 错误信息,但不会影响系统运行
        LOGGER.warn("warn 中文"); // 警告信息,可能会发生问题
        LOGGER.info("info 中文"); // 程序运行信息,数据库的连接、网络、IO操作等
        LOGGER.debug("debug 中文"); // 调试信息,一般在开发阶段使用,记录程序的变量、参 数等
        LOGGER.trace("trace 中文"); // 追踪信息,记录程序的所有流程信息

        LOGGER.info("用户:{},年龄 {}","zs",18);

        //将系统异常信息输出
        try {
            int i =1/0;
        } catch (Exception e) {
            LOGGER.error("出现异常",e);
        }
    }
}

日志的实现(Binding)


使用slf4j的日志绑定流程:

1. 添加slf4j-api的依赖

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

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

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

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

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

  • 绑定slf4j-simple 、logback 、nop这些遵循slf4j技术的(在slf4j火起来之后的技术)
<!--slf4j 门面-->
<dependency>
  <groupId>org.slf4j</groupId>
  <artifactId>slf4j-api</artifactId>
  <version>1.7.26</version>
</dependency> 
<!--以下三个日志实现任选一个-->
<!--以下三个日志实现任选一个-->
<!--以下三个日志实现任选一个-->


<!--slf4j简单实现-->
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-simple</artifactId>
    <version>1.7.21</version>
</dependency>
<!-- logback-->
<dependency>
    <groupId>ch.qos.logback</groupId>
    <artifactId>logback-classic</artifactId>
    <version>1.2.3</version>
</dependency>
<!-- nop 日志开关,加上这个就日志无效了-->
<dependency>
  <groupId>org.slf4j</groupId>
  <artifactId>slf4j-nop</artifactId>
  <version>1.7.27</version>
</dependency>

  • 绑定老牌的日志实现,需要导入适配器

log4j

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

jul

<!-- jul 导入适配器即可,因为这个是基于jdk的 -->
<dependency>
  <groupId>org.slf4j</groupId>
  <artifactId>slf4j-jdk14</artifactId>
  <version>1.7.27</version>
</dependency>

SLF4J桥接旧的日志框架

比如之前是用的log4j这种老的日志框架写的,现在想升级slf4j结合logback的形式.但又不想改代码,那就可以用slf4j的桥接功能(把旧的log4j的依赖去掉,logback依赖加入 ,slf4-api的依赖加入,再加一个log4j和slf4j之间的桥接器依赖即可)

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

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

注意问题:

  1. jcl-over-slf4j.jar和 slf4j-jcl.jar不能同时部署。前一个jar文件将导致JCL将日志系统的选择委托给 SLF4J,后一个jar文件将导致SLF4J将日志系统的选择委托给JCL,从而导致无限循环
  2. log4j-over-slf4j.jar和slf4j-log4j12.jar不能同时出现
  3. jul-to-slf4j.jar和slf4j-jdk14.jar不能同时出现
  4. 所有的桥接都只对Logger日志记录器对象有效,如果程序中调用了内部的配置类或者是 Appender,Filter等对象,将无法产生效果。

Logback的使用

Logback是由log4j创始人设计的另一个开源日志组件,性能比log4j要好。 官方网站:https://logback.qos.ch/index.html

Logback主要分为三个模块:

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

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

logback入门

  1. 添加依赖
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-api</artifactId>
    <version>1.7.25</version>
</dependency>
<dependency>
    <groupId>ch.qos.logback</groupId>
    <artifactId>logback-classic</artifactId>
    <version>1.2.3</version>
</dependency>
  1. java代码
package com.zs.blog;


import org.junit.jupiter.api.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class LogbackTest {


    //定义日志对象
    public final static Logger LOGGER = LoggerFactory.getLogger(LogbackTest.class);


    @Test
    public void testQuick() throws Exception {
        // 日志级别
        LOGGER.error("error 中文"); // 错误信息,但不会影响系统运行
        LOGGER.warn("warn 中文"); // 警告信息,可能会发生问题
        LOGGER.info("info 中文"); // 程序运行信息,数据库的连接、网络、IO操作等
        LOGGER.debug("debug 中文"); // 调试信息,一般在开发阶段使用,记录程序的变量、参 数等
        LOGGER.trace("trace 中文"); // 追踪信息,记录程序的所有流程信息

        LOGGER.info("用户:{},年龄 {}","zs",18);

        //将系统异常信息输出
        try {
            int i =1/0;
        } catch (Exception e) {
            LOGGER.error("出现异常",e);
        }
    }
}

logback配置

logback会依次读取以下类型配置文件:

  • logback.groovy
  • logback-test.xml
  • logback.xml 如果均不存在会采用默认配置
  1. logback组件之间的关系
    1. Logger:日志的记录器,把它关联到应用的对应的context上后,主要用于存放日志对象,也 可以定义日志类型、级别。
    2. Appender:用于指定日志输出的目的地,目的地可以是控制台、文件、数据库等等。
    3. Layout:负责把事件转换成字符串,格式化的日志信息的输出。在logback中Layout对象被封 装在encoder中。
  1. 配置
<?xml version="1.0" encoding="UTF-8"?>
<configuration>

    <!--##################################################配置集中管理属性##################################################-->
    <!--
        日志输出格式:
            %-5level
            %d  {yyyy-MM-dd HH:mm:ss.SSS}日期
            %c  类的完整名称
            %M  为method
            %L  为行号
            %thread 线程名称
            %m  或者 %msg 为信息
            %n  换行
     -->
    <!--格式化输出:%d表示日期,%thread表示线程名,%-5level:级别从左显示5个字符宽度 %msg:日志消息,%n是换行符-->
    <property name="pattern" value="%d{yyyy-MM-dd HH:mm:ss.SSS} %c [%thread] %-5level %msg%n"/>
    <property name="pattern2" value="%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} %line: %msg%n"/>

    <!-- 日志文件存放目录
            value="/logs" : 绝对路径
            value="logs" : 项目根路径
    -->
    <property name="log_dir" value="logs"></property>
    <!--###############################################################################################################-->


    <!--##############################################控制台日志输出appender##############################################-->
    <!--
        Appender: 设置日志信息的去向,常用的有以下几个
            ch.qos.logback.core.ConsoleAppender (控制台)
            ch.qos.logback.core.rolling.RollingFileAppender (文件大小到达指定尺 寸的时候产生一个新文件)
            ch.qos.logback.core.FileAppender (文件)
    -->
    <!--控制台appender-->
    <appender name="console" class="ch.qos.logback.core.ConsoleAppender">
        <!--输出流对象 默认 System.out 改为 System.err-->
        <target>System.err</target>
        <!--日志格式配置-->
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <pattern>${pattern}</pattern>
        </encoder>
    </appender>


    <!--fileappender-->
    <appender name="file" class="ch.qos.logback.core.FileAppender">
        <!--日志格式配置-->
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <pattern>${pattern}</pattern>
        </encoder>
        <!--日志输出路径-->
        <file>${log_dir}/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>
                <!--                <pattern>${pattern}</pattern>-->
            </layout>
            <!--日志输出路径-->
            <file>${log_dir}/logback.html</file>
        </encoder>
    </appender>

    <!-- 日志文件拆分和归档的appender对象-->
    <appender name="rollFile" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <!--日志输出路径-->
        <file>${log_dir}/roll_logback.log</file>

        <!--日志格式配置-->
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <pattern>${pattern}</pattern>
        </encoder>
<!--        <encoder>-->
<!--            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} %line: %msg%n</pattern>-->
<!--            <charset>UTF-8</charset>-->
<!--        </encoder>-->

        <!--指定日志文件拆分和压缩策略-->
        <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
            <!--通过指定压缩文件名称,来确定分割文件方式-->
<!--            <fileNamePattern>${log_dir}/rolling.%d{yyyy-MM-dd-HH-mm-ss}.log%i.gz</fileNamePattern>-->
<!--            <fileNamePattern>${log_dir}/rolling.%d{yyyy-MM-dd}.log%i</fileNamePattern>-->
            <fileNamePattern>${log_dir}/${appName}-%d{yyyy-MM-dd}-%i.log</fileNamePattern>
            <!--单个日志文件最大大小-->
            <maxFileSize>100MB</maxFileSize>
            <!--归档日志将保留过去30天-->
            <maxHistory>30</maxHistory>
            <!--归档日志总大小-->
            <totalSizeCap>1GB</totalSizeCap>
        </rollingPolicy>


        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <!--设置拦截日志级别-->
            <level>info</level> <!--error级别输出-->
            <onMatch>ACCEPT</onMatch><!--超过这个级别的就放行 -->
            <onMismatch>DENY</onMismatch><!--小于这个级别的就拦截 -->
        </filter>
    </appender>

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

    <!--################################################logger日志记录器################################################-->
    <!--日志记录器对象-->
    <!--
        用来设置某一个包或者具体的某一个类的日志打印级别、以及指定<appender>。
        <loger>仅有一个name属性,一个可选的level和一个可选的addtivity属性
        name:
            用来指定受此logger约束的某一个包或者具体的某一个类。
        level:
            用来设置打印级别,大小写无关:TRACE, DEBUG, INFO, WARN, ERROR, ALL 和 OFF,如果未设置此属性,那么当前logger将会继承上级的级别。
        additivity:
            是否向上级loger传递打印信息。默认是true。 false:表示不重复输出
        <logger>可以包含零个或多个<appender-ref>元素,标识这个appender将会添加到这个 logger
    -->
    <!--自定义logger
        additivity表示是否从 rootLogger继承配置
    -->
    <logger name="com.zs.blog" level="warn" additivity="false">
        <appender-ref ref="console"/>
    </logger>

    <!--
        也是<logger>元素,但是它是根logger。默认debug
        level:用来设置打印级别,大小写无关:TRACE, DEBUG, INFO, WARN, ERROR, ALL 和 OFF,
        <root>可以包含零个或多个<appender-ref>元素,标识这个appender将会添加到这个 logger。
    -->
    <root level="ALL">
        <appender-ref ref="console"/>
        <!--        <appender-ref ref="file"/>-->
        <!--        <appender-ref ref="htmlfile"/>-->
        <!--        <appender-ref ref="rollFile"/>-->
        <appender-ref ref="async"/>
    </root>
    <!--###############################################################################################################-->

</configuration>
  1. 官方提供的log4j.properties转换成logback.xml

https://logback.qos.ch/translator/services/propertiesTranslator.html 生成后的logback的内容中 的格式信息需要修改即可

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元素中添加:
<Valve className="ch.qos.logback.access.tomcat.LogbackValve" />
  1. logback默认会在$TOMCAT_HOME/conf下查找文件 logback-access.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

前面提到,log4j由apache宣布,2015年后,不再维护。推荐大家升级到log4j2,虽然log4j2沿袭了log4j的思想,然而log4j2和log4j完全是两码事,并不兼容。

log4j2以性能著称,它⽐其前身Log4j 1.x提供了重大改进,同时类⽐logback,它提供了Logback中可⽤的许多改进,同时修复了Logback架构中的一些固有问题。功能上,它有着和Logback相同的基本操作,同时又有自己独特的部分,⽐如:插件式结构、配置文件优化、异步日志等。

pom:

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

代码:

// 定义日志记录器对象
    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("inf");
        LOGGER.debug("debug");
        LOGGER.trace("trace");


    }

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

<?xml version="1.0" encoding="UTF-8"?>
<!--
    status="warn" 日志框架本身的输出日志级别
    monitorInterval="5" 自动加载配置文件的间隔时间,不低于 5 秒
-->
<Configuration status="debug" monitorInterval="5">

    <!--
        集中配置属性进行管理
        使用时通过:${name}
    -->
    <properties>
        <property name="LOG_HOME">/logs</property>
    </properties>

    <!--日志处理-->
    <Appenders>
        <!--控制台输出 appender-->
        <Console name="Console" target="SYSTEM_ERR">
            <PatternLayout pattern="%d{HH:mm:ss.SSS} [%t] [%-5level] %c{36}:%L --- %m%n" />
        </Console>

        <!--日志文件输出 appender-->
        <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>

        <!--<Async name="Async">-->
            <!--<AppenderRef ref="file"/>-->
        <!--</Async>-->

        <!--使用随机读写刘的日志文件输出 appender,性能提高-->
        <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>

        <!--按照一定规则拆分的日志文件的 appender-->
        <RollingFile name="rollingFile" fileName="${LOG_HOME}/myrollog.log"
                     filePattern="/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 />
                <!--按照文件大小拆分,10MB -->
                <SizeBasedTriggeringPolicy size="10 MB" />
                <!--按照时间节点拆分,规则根据filePattern定义的-->
                <TimeBasedTriggeringPolicy />
            </Policies>
            <!--在同一个目录下,文件的个数限定为 30 个,超过进行覆盖-->
            <DefaultRolloverStrategy max="30" />
        </RollingFile>

    </Appenders>

    <!--logger 定义-->
    <Loggers>


        <!--自定义异步 logger 对象
            includeLocation="false" 关闭日志记录的行号信息
            additivity="false" 不在继承 rootlogger 对象
        -->
        <AsyncLogger name="com.itheima" level="trace" includeLocation="false" additivity="false">
            <AppenderRef ref="Console"/>
        </AsyncLogger>


        <!--使用 rootLogger 配置 日志级别 level="trace"-->
        <Root level="trace">
            <!--指定日志使用的处理器-->
            <AppenderRef ref="Console" />

            <!--使用异步 appender-->
            <!--<AppenderRef ref="Async" />-->
        </Root>
    </Loggers>
</Configuration>

现在主流的是是用slf4j作为日志门面,而不是用log4j2自带的日志门面,所以要在前面的依赖基础上外加下面两个依赖

<!--使用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提供了两种实现日志的方式,一个是通过AsyncAppender,一个是通过AsyncLogger,分别对应

前面我们说的Appender组件和Logger组件。

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

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

1.AsyncAppender方式 (不推荐)

以下两处注释的地方放开即可

2. AsyncLogger方式 (推荐)

AsyncLogger才是log4j2 的重头戏,也是官方推荐的异步方式。它可以使得调用Logger.log返回的

更快。你可以有两种选择:全局异步和混合异步。

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

log4j2.component.properties 配置;

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

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

灵活。

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

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

1. 如果使用异步日志,AsyncAppender、AsyncLogger和全局日志,不要同时出现。性能会和

AsyncAppender一致,降至最低。

2. 设置includeLocation=false ,打印位置信息会急剧降低异步日志的性能,比同步日志还要

慢。

另一个亮点无垃圾记录

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

许多日志库(包括以前版本的Log4j)在稳态日志记录期间分配临时对象,如日志事件对象,字符串,

字符数组,字节数组等。这会对垃圾收集器造成压力并增加GC暂停发生的频率。

从版本2.6开始,默认情况下Log4j以“无垃圾”模式运行,其中重用对象和缓冲区,并且尽可能不分配临

时对象。还有一个“低垃圾”模式,它不是完全无垃圾,但不使用ThreadLocal字段。

Log4j 2.6中的无垃圾日志记录部分通过重用ThreadLocal字段中的对象来实现,部分通过在将文本转换

为字节时重用缓冲区来实现。

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

springboot项目

1.springboot 底层默认使用logback作为日志实现。
2.使用了SLF4]作为日志门面
3.将JUL也转换成sIf4j
4.也可以使用log4i2作为日志门面,但是最终也是通过sIf4i调用logback

使用默认的logback

测试类

@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");

        // 使用 log4j2 使用桥接器切换为 slf4j 门面和 logback 日志实现
        org.apache.logging.log4j.Logger logger = LogManager.getLogger(SpringbootLogApplicationTests.class);
        logger.info("log4j2 info");
    }

}

application.properties配置文件(后面切换成log4j2也照样用这个)

# 指定自定义 logger 对象日志级别
logging.level.com.itheima=trace

# 指定控制台输出消息格式
logging.pattern.console=[%-5level] %d{yyyy-MM-dd HH:mm:ss} %c [%thread]===== %msg %n

# 指定存放日志文件的具体路径
# logging.file=/logs/springboot.log
# 指定日志文件存放的目录,默认的文件名 spring.log
logging.file.path=/logs/springboot/
# 指定日志文件消息格式
logging.pattern.file=[%-5level] %d{yyyy-MM-dd HH:mm:ss} %c [%thread]===== %msg %n

# 指定项目使用的具体环境
spring.profiles.active=pro

logback-spring.xml配置文件

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


    <property name="pattern" value="[%-5level] %d{yyyy-MM-dd HH:mm:ss.SSS} %c %M %L [%thread] -------- %m %n"></property>



    <!--控制台日志输出的 appender-->
    <appender name="console" class="ch.qos.logback.core.ConsoleAppender">
        <!--控制输出流对象 默认 System.out 改为 System.err-->
        <target>System.err</target>
        <!--日志消息格式配置-->
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <springProfile name="dev">
                <pattern>${pattern}</pattern>
            </springProfile>
            <springProfile name="pro">
                <pattern>[%-5level] %d{yyyy-MM-dd HH:mm:ss.SSS} %c %M %L [%thread] xxxxxxxx %m %n</pattern>
            </springProfile>
        </encoder>
    </appender>



    <!--自定义 looger 对象
        additivity="false" 自定义 logger 对象是否继承 rootLogger
     -->
    <logger name="com.itheima" level="info" additivity="false">
        <appender-ref ref="console"/>
    </logger>
</configuration>

切换成log4j2

依赖

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

日志配置文件:log4j2.xml

<?xml version="1.0" encoding="UTF-8"?>
<!--
    status="warn" 日志框架本身的输出日志级别
    monitorInterval="5" 自动加载配置文件的间隔时间,不低于 5 秒
-->
<Configuration status="debug" monitorInterval="5">


    <!--日志处理-->
    <Appenders>
        <!--控制台输出 appender-->
        <Console name="Console" target="SYSTEM_ERR">
            <PatternLayout pattern="%d{HH:mm:ss.SSS} [%t] [%-5level] %c{36}:%L --- %m%n" />
        </Console>

    </Appenders>

    <!--logger 定义-->
    <Loggers>


        <!--使用 rootLogger 配置 日志级别 level="trace"-->
        <Root level="trace">
            <!--指定日志使用的处理器-->
            <AppenderRef ref="Console" />

        </Root>
    </Loggers>
</Configuration>

好博客就要一起分享哦!分享海报

此处可发布评论

评论(1展开评论

蓝色妖姬 能力:10

2023-04-18 10:49:55

学习中
点击查看更多评论

展开评论

您可能感兴趣的博客

客服QQ 1913284695