Logback和Log4j详解

最新推荐文章于 2024-10-04 18:41:44 发布
最新推荐文章于 2024-10-04 18:41:44 发布
阅读量7.6k 收藏 34
点赞数 7
分类专栏： Java工具 文章标签： java 编程语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/smilekutper/article/details/109303276
版权

文章目录

日志框架

前言

​ 在程序中写日志是一件非常重要，但是很容易被开发人员忽视的事情。程序中好的日志可以帮助我们大大减轻后期维护压力。在实际的工作中，开发人员往往迫于巨大时间压力，而写日志又是一个非常繁琐的事情，往往没有引起足够的重视。开发人员应在一开始就养成良好的日志撰写习惯，并且应在实际的开发工作中为写日志预留足够的时间。

一、日志简介

1、什么是日志？

简单的说，日志就是记录程序的运行轨迹，方便查找关键信息，也方便快速定位解决问题。

2、日志的用途？

  1. 记录用户操作的审计日志，甚至有的时候就是监管部门的要求

  2. 快速定位问题的根源

  3. 追踪程序执行的过程

  4. 追踪数据的变化

  5. 数据统计和性能分析

  6. 采集运行环境数据

    一般在程序上线之后，一旦发生异常，第一件事就是要弄清楚当时发生了什么。用户当时做了什么操作，环境有无影响，数据有什么变化，是不是反复发生等，然后再进一步的确定大致是哪个方面的问题。确定是程序的问题之后再交由开发人员去重现、研究、提出解决方案。这时，日志就给我们提供了第一手的资料。

二、常用的日志框架

1、日志门面

日志门面其实就是日志框架的接口，不同的日志框架可以实现同一个框架接口，在我们更换日志框架的时候只要换了jar包就行。遵循了设计原则中的依赖倒置原则。

常见的日志门面：slf4j（主流）、commons-logging

slf4j的实现框架：log4j和logback

日志级别：TRACE, DEBUG, INFO, WARN, ERROR，遵循就近原则。

  • 注：我们在项目中导入包的时候一定要导入日志门面对应的接口类，不要使用实现类。[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0nCr01BZ-1603758455711)(C:\Users\smilevers\AppData\Roaming\Typora\typora-user-images\image-20201009095946899.png)]

2、logback（更快的执行速度使其成为主流）

推荐阅读官方文档：[](http://www.logback.cn/02%E7%AC%AC%E4%BA%8C%E7%AB%A0%E6%9E%B6%E6%9E%84.html

2.1 引入依赖
 		<!--slf4j统一日志接口依赖包-->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.5</version>
        </dependency>
            
        <!--logback依赖包-->
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-core</artifactId>
            <version>1.1.7</version>
        </dependency>
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>1.1.7</version>
        </dependency>
2.2 编写xml文件
  • logback的xml文件初始化过程（寻找顺序吧）
  1. logback 会在类路径下寻找名为 logback-test.xml 的文件。
  2. 如果没有找到，logback 会继续寻找名为 logback.groovy 的文件。
  3. 如果没有找到，logback 会继续寻找名为 logback.xml 的文件。
  4. 如果没有找到，将会通过 JDK 提供的 ServiceLoader 工具在类路径下寻找文件 META-INFO/services/ch.qos.logback.classic.spi.Configurator，该文件的内容为实现了 Configurator 接口的实现类的全限定类名。
  5. 如果以上都没有成功，logback 会通过 BasicConfigurator 为自己进行配置，并且日志将会全部在控制台打印出来。

我们一般会命名为logback.xml

<configuration debug="false">
    <!--appender必须定义在logger的前面-->
    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">　　　　　
        <encoder>　　　　　　　　　
            <pattern>IM ROOT [%p]%d %c: %m%n</pattern>
            <!--            <outputPatternAsHeader>true</outputPatternAsHeader>-->
        </encoder>
    </appender>

    <appender name="my_info" class="ch.qos.logback.core.ConsoleAppender">　　　　　
        <encoder>　　　　　　　　　
            <pattern>IM INFO [%p]%d %c: %m%n</pattern>
        </encoder>
    </appender>

    <!--输出到指定文件-->
    <appender name="FILE" class="ch.qos.logback.core.FileAppender">
        <file>test.log</file>
        <immediateFlush>true</immediateFlush>
        <encoder>　　　　　　　　　
            <pattern>IM ROOT [%p]%d %c: %m%n</pattern>
        </encoder>
    </appender>

    <!--按日期输出到指定文件(基于时间的轮转策略)-->
    <!--    <appender name="ROLL" class="ch.qos.logback.core.rolling.RollingFileAppender">-->
    <!--        &lt;!&ndash;        <file>testROll.log</file>&ndash;&gt;-->
    <!--        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">-->
    <!--            <fileNamePattern>log/logFile.%d{yyyy-MM-dd}.log</fileNamePattern>-->
    <!--保存30填记录，最大保存日志为3G-->
    <!--            <maxHistory>30</maxHistory>-->
    <!--            <totalSizeCap>3GB</totalSizeCap>-->
    <!--        </rollingPolicy>-->
    <!--        <encoder>　　　　　　　　　-->
    <!--            <pattern>IM ROLL [%p]%d %c: %m%n</pattern>-->
    <!--        </encoder>-->
    <!--    </appender>-->

    <!--按日期输出到指定文件(基于时间及大小的轮转策略)-->
    <!--    <appender name="ROLL_SIZEANDTIME" class="ch.qos.logback.core.rolling.RollingFileAppender">-->
    <!--        <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">-->
    <!--            <fileNamePattern>mylog-%d{yyyy-MM-dd}.%i.txt</fileNamePattern>-->
    <!--每个文件最大100M-->
    <!--            <maxFileSize>100MB</maxFileSize>-->
    <!--            <maxHistory>60</maxHistory>-->
    <!--            <totalSizeCap>20GB</totalSizeCap>-->
    <!--        </rollingPolicy>-->
    <!--        <encoder>　　　　　　　　　-->
    <!--            <pattern>IM ROLL_SIZEANDTIME [%p]%d %c: %m%n</pattern>-->
    <!--        </encoder>-->
    <!--    </appender>-->

    <!--输出到数据库-->
    <!--    <appender name="DB" class="ch.qos.logback.classic.db.DBAppender">-->
    <!--        <connectionSource class="ch.qos.logback.core.db.DataSourceConnectionSource">-->
    <!--            <dataSource class="com.mysql.jdbc.jdbc2.optional.MysqlDataSource">-->
    <!--                <serverName>cdb-6j6jktxk.bj.tencentcdb.com</serverName>-->
    <!--                <port>10175</port>-->
    <!--                <databaseName>logging</databaseName>-->
    <!--                <user>root</user>-->
    <!--                <password>@bai880607</password>-->
    <!--            </dataSource>-->
    <!--        </connectionSource>-->
    <!--    </appender>-->

    <!--帅选策略-->
    <!--    <appender name="SIFT" class="ch.qos.logback.classic.sift.SiftingAppender">-->
    <!-- 在缺少 class 属性的情况下，默认的 discriminator 类型为ch.qos.logback.classic.sift.MDCBasedDiscriminator -->
    <!--        <discriminator>-->
    <!--            <key>userid</key>-->
    <!--            <defaultValue>unknown</defaultValue>-->
    <!--        </discriminator>-->
    <!--        <sift>-->
    <!--            <appender name="FILE-${userid}"-->
    <!--                      class="ch.qos.logback.core.FileAppender">-->
    <!--                <file>${userid}_${FILE_NAME}.log</file>-->
    <!--                <append>false</append>-->
    <!--                <layout class="ch.qos.logback.classic.PatternLayout">-->
    <!--                    <pattern>%d [%thread] %level %mdc %logger{35} - %msg%n</pattern>-->
    <!--                </layout>-->
    <!--            </appender>-->
    <!--        </sift>-->
    <!--    </appender>-->

    <!--ROOT顶级logger-->
    <root level="ERROR">　　　　　　
        <appender-ref ref="STDOUT"/>　　　
    </root>
    <!--自定义子logger-my_info-->
    <logger name="my_info" level="INFO" additivity="false">
        <appender-ref ref="my_info"/>　　
    </logger>
    <!--自定义子logger-my_info-->
    <logger name="my_warn" level="DEBUG">
        <appender-ref ref="FILE"/>　　
    </logger>
</configuration>
2.3 测试用例
public class Log4jTest{
    // 创建不同的logger
    private static final Logger logger = LoggerFactory.getLogger(Log4jTest.class);
    private static final Logger my_info = LoggerFactory.getLogger("my_info");
    private static final Logger my_warn = LoggerFactory.getLogger("my_warn");
    private static final Logger my_error = LoggerFactory.getLogger("my_error");
    java.util.logging.Logger log = java.util.logging.Logger.getLogger(this.getClass().getName());

    @Test
    public void test1() {
        int count = 10;
        // my_warn.info("日志输出次数：{}",count);
        my_warn.debug("日志输出次数：{}", count);
        // MDC.put("userid", "Alice");
        // logger.debug("Alice says hello");
        // 打印内部的状态
        // LoggerContext lc = (LoggerContext)LoggerFactory.getILoggerFactory();
        // StatusPrinter.print(lc);
    }
2.4组件详解

常用的2大组件looger和appender，

2.4.1 appender

appender可以控制日志输出的路径和输出格式。

日志输出路径：控制台、本地文件、远程文件、数据库。

encoder组件用来控制输出格式。（不建议使用layout）

这里只介绍3种：

1、ConsoleAppender：输出到控制台
<appender name="my_info" class="ch.qos.logback.core.ConsoleAppender">　　　　　
    <encoder>　　　　　　　　　
        <pattern>IM INFO [%p]%d %c: %m%n</pattern>
    </encoder>
</appender>
2、FileAppender：输出到文件
<!--输出到指定文件-->
<appender name="FILE" class="ch.qos.logback.core.FileAppender">
    <file>test.log</file>
    <immediateFlush>true</immediateFlush>
    <encoder>　　　　　　　　　
        <pattern>IM ROOT [%p]%d %c: %m%n</pattern>
    </encoder>
</appender>
3、RollingFileAppender：轮转输出到文件
  • 基于时间的轮转策略
   <!--按日期输出到指定文件(基于时间的轮转策略)-->
    <appender name="ROLL" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <!--指定当前活动的文件名称-->
        <file>testROll.log</file>
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <!--指定归档的文件名称-->
            <fileNamePattern>log/logFile.%d{yyyy-MM-dd}.log</fileNamePattern>
            <!--保存30天记录，最大保存日志为3G-->
            <maxHistory>30</maxHistory>
            <totalSizeCap>3GB</totalSizeCap>
        </rollingPolicy>
        <encoder>　　　　　　　　　
            <pattern>IM ROLL [%p]%d %c: %m%n</pattern>
        </encoder>
    </appender>
  • 基于时间和大小的轮转策略
<!--按日期输出到指定文件(基于时间及大小的轮转策略)-->
<appender name="ROLL_SIZEANDTIME" class="ch.qos.logback.core.rolling.RollingFileAppender">
    <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
        <fileNamePattern>mylog-%d{yyyy-MM-dd}.%i.txt</fileNamePattern>
        <!--每个文件最大100M-->
        <maxFileSize>100MB</maxFileSize>
        <maxHistory>60</maxHistory>
        <totalSizeCap>20GB</totalSizeCap>
    </rollingPolicy>
    <encoder>　　　　　　　　　
        <pattern>IM ROLL_SIZEANDTIME [%p]%d %c: %m%n</pattern>
    </encoder>
</appender>
4、DBAppender：输出到数据库
<!--输出到数据库-->
<appender name="DB" class="ch.qos.logback.classic.db.DBAppender">
    <connectionSource class="ch.qos.logback.core.db.DataSourceConnectionSource">
        <dataSource class="com.mysql.jdbc.jdbc2.optional.MysqlDataSource">
            <serverName>数据库url</serverName>
            <port>10175</port>
            <databaseName>logging</databaseName>
            <user>root</user>
            <password>********</password>
        </dataSource>
    </connectionSource>
</appender>
  • 需要建立的表及字段
BEGIN;
DROP TABLE IF EXISTS logging_event_property;
DROP TABLE IF EXISTS logging_event_exception;
DROP TABLE IF EXISTS logging_event;
COMMIT;
 
 
BEGIN;
CREATE TABLE logging_event 
  (
    timestmp         BIGINT NOT NULL,
    formatted_message  TEXT NOT NULL,
    logger_name       VARCHAR(254) NOT NULL,
    level_string      VARCHAR(254) NOT NULL,
    thread_name       VARCHAR(254),
    reference_flag    SMALLINT,
    arg0              VARCHAR(254),
    arg1              VARCHAR(254),
    arg2              VARCHAR(254),
    arg3              VARCHAR(254),
    caller_filename   VARCHAR(254) NOT NULL,
    caller_class      VARCHAR(254) NOT NULL,
    caller_method     VARCHAR(254) NOT NULL,
    caller_line       CHAR(4) NOT NULL,
    event_id          BIGINT NOT NULL AUTO_INCREMENT PRIMARY KEY
  );
COMMIT;
 
BEGIN;
CREATE TABLE logging_event_property
  (
    event_id          BIGINT NOT NULL,
    mapped_key        VARCHAR(254) NOT NULL,
    mapped_value      TEXT,
    PRIMARY KEY(event_id, mapped_key),
    FOREIGN KEY (event_id) REFERENCES logging_event(event_id)
  );
COMMIT;
 
BEGIN;
CREATE TABLE logging_event_exception
  (
    event_id         BIGINT NOT NULL,
    i                SMALLINT NOT NULL,
    trace_line       VARCHAR(254) NOT NULL,
    PRIMARY KEY(event_id, i),
    FOREIGN KEY (event_id) REFERENCES logging_event(event_id)
  );
COMMIT;
2.4.2 logger

1、logger就是我们代码中创建的logger对象，可以控制输出级别 、引用appender和是否继承父类logger的appender。

private static final Logger logger = LoggerFactory.getLogger(Log4jTest.class);
private static final Logger my_info = LoggerFactory.getLogger("my_info");
private static final Logger my_warn = LoggerFactory.getLogger("my_warn");
private static final Logger my_error = LoggerFactory.getLogger("my_error");

2、一个logger可以引用多个appender，通过符号 . 来区分

<!--自定义子logger-my_info.my_warn-->
<logger name="my_info.my_warn" level="DEBUG">
    <appender-ref ref="STDOUT"/>　　
</logger>

3、所有logger都默认继承root对象

<!--ROOT顶级logger-->
<root level="ERROR">　　　　　　
    <appender-ref ref="STDOUT"/>　　　
</root>

不设置也行，root对象有默认属性

4、logger的名字可以自定义，一般我们通过当前类来获取logger

5、可以通过包名或类名来指定输出级别

<!--通过包来控制输出级别-->
<logger name="com.smilevers" level="DEBUG">
</logger>

3、log4j

Log4j 是 Apache 的一个开源日志框架，也是市场占有率最多的一个框架。大多数没用过 Java Logging， 但没人敢说没用过 Log4j 吧，反正从我接触 Java 开始就是这种情况，做 Java 项目必有 Log4j 日志框架。

注意：log4j 在 2015/08/05 这一天被 Apache 宣布停止维护了，用户需要切换到 Log4j2上面去。

#ERROR To CONSOLE
log4j.rootLogger=ERROR,CONSOLE

###################
# Console Appender
###################
log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender
log4j.appender.CONSOLE.Target=System.out
log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout
log4j.appender.CONSOLE.layout.ConversionPattern=[%p] %d %c - %m%n


log4j.logger.mdp_root =INFO,CONSOLE
#log4j.logger.mdp_root =INFO,mdp_root
log4j.appender.mdp_root=org.apache.log4j.RollingFileAppender
log4j.appender.mdp_root.File=${catalina.base}/logs/mdp/mdp_root.log
log4j.appender.mdp_root.Append=true
log4j.appender.mdp_root.MaxFileSize=50000KB
log4j.appender.mdp_root.MaxBackupIndex=100
log4j.appender.mdp_root.layout=org.apache.log4j.PatternLayout
log4j.appender.mdp_root.layout.ConversionPattern=[%p] %d %c - %m%n

log4j.logger.mdp_system =INFO,CONSOLE
#log4j.logger.mdp_system =INFO,mdp_system
log4j.appender.mdp_system=org.apache.log4j.RollingFileAppender
log4j.appender.mdp_system.File=${catalina.base}/logs/mdp/mdp_system.log
log4j.appender.mdp_system.Append=true
log4j.appender.mdp_system.MaxFileSize=50000KB
log4j.appender.mdp_system.MaxBackupIndex=100
log4j.appender.mdp_system.layout=org.apache.log4j.PatternLayout
log4j.appender.mdp_system.layout.ConversionPattern=[%p] %d %c - %m%n

log4j.logger.mdp_exception =INFO,CONSOLE
#log4j.logger.mdp_exception =INFO,mdp_exception
log4j.appender.mdp_exception=org.apache.log4j.RollingFileAppender
log4j.appender.mdp_exception.File=${catalina.base}/logs/mdp/mdp_exception.log
log4j.appender.mdp_exception.Append=true
log4j.appender.mdp_exception.MaxFileSize=50000KB
log4j.appender.mdp_exception.MaxBackupIndex=100
log4j.appender.mdp_exception.layout=org.apache.log4j.PatternLayout
log4j.appender.mdp_exception.layout.ConversionPattern=[%p] %d %c - %m%n

log4j.logger.mdp_debug =INFO,CONSOLE
#log4j.logger.mdp_debug =INFO,mdp_debug
log4j.appender.mdp_debug=org.apache.log4j.RollingFileAppender
log4j.appender.mdp_debug.File=${catalina.base}/logs/mdp/mdp_debug.log
log4j.appender.mdp_debug.Append=true
log4j.appender.mdp_debug.MaxFileSize=50000KB
log4j.appender.mdp_debug.MaxBackupIndex=100
log4j.appender.mdp_debug.layout=org.apache.log4j.PatternLayout
log4j.appender.mdp_debug.layout.ConversionPattern=[%p] %d %c - %m%n

log4j.logger.mdp_handle =INFO,CONSOLE
#log4j.logger.mdp_handle =INFO,mdp_handle
log4j.appender.mdp_handle=org.apache.log4j.RollingFileAppender
log4j.appender.mdp_handle.File=${catalina.base}/logs/mdp/mdp_handle.log
log4j.appender.mdp_handle.Append=true
log4j.appender.mdp_handle.MaxFileSize=50000KB
log4j.appender.mdp_handle.MaxBackupIndex=100
log4j.appender.mdp_handle.layout=org.apache.log4j.PatternLayout
log4j.appender.mdp_handle.layout.ConversionPattern=[%p] %d %c - %m%n

log4j.logger.mdp_info =INFO,CONSOLE
#log4j.logger.mdp_info =INFO,mdp_info
log4j.additivity.mdp_info= false
log4j.appender.mdp_info=org.apache.log4j.RollingFileAppender
log4j.appender.mdp_info.File=${catalina.base}/logs/mdp/mdp_info.log
log4j.appender.mdp_info.Append=true
log4j.appender.mdp_info.MaxFileSize=50000KB
log4j.appender.mdp_info.MaxBackupIndex=100
log4j.appender.mdp_info.layout=org.apache.log4j.PatternLayout
log4j.appender.mdp_info.layout.ConversionPattern=[%p] %d %c - %m%n

#framework
log4j.logger.org.springframework=INFO
#log4j.logger.org.springframework.web=TRACE
log4j.logger.com.midea=DEBUG
log4j.logger.com.cttq=DEBUG
log4j.logger.org.apache.ibatis=DEBUG
log4j.logger.org.mybatis=DEBUG
log4j.logger.java.sql=DEBUG
log4j.logger.com.alibaba.dubbo=ERROR

三、项目实战

1、项目日志打印2次的问题

在使用项目工具LogUtils工具打印日志的时候，会出现控制台打印2次日志的问题。

分析：日志打印2次，应该是继承的父类的appender，那我们只要添加additivity属性，并将其值设置为false即可。

2、通过类创建的logger对象打印不出日志

分析：日志打印不出，一般是级别设置的不对，通过查看配置文件可以看到，配置中指定了具体包的日志级别为DEBUG，而我们打印日志的包并没有指定，就会继承root对象的级别为ERROR，因此我们使用logger.debbug或logger.info都不能打印输出日志。我们再将所在包添加即可。

3、按级别分文件输出

<configuration>
    <property name="APP_NAME" value="APPNAME"/>
    <property name="LOG_HOME" value="./log/APPNAME" />
    <contextName>${APP_NAME}</contextName>
    <!-- 控制台日志输出 -->
    <appender name="stdout" class="ch.qos.logback.core.ConsoleAppender">
        <encoder charset="UTF-8">
            <pattern>%d{yyyy-MM-dd HH:mm:ss} %5p %c:%L %m%n</pattern>
        </encoder>
    </appender>
    <!-- 滚动记录文件，先将日志记录到指定文件，当符合某个条件时，将日志记录到其他文件 -->
    <appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <!-- 指定日志文件的名称 -->
        <file>${LOG_HOME}/${APP_NAME}.log</file>
        <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
            <!--
            滚动时产生的文件的存放位置及文件名称 %d{yyyy-MM-dd}：按天进行日志滚动
            %i：当文件大小超过maxFileSize时，按照i进行文件滚动
            -->
            <fileNamePattern>${LOG_HOME}/logbacks/${APP_NAME}-%d{yyyy-MM-dd}-%i.log</fileNamePattern>
            <MaxHistory>180</MaxHistory>
            <!--
            当日志文件超过maxFileSize指定的大小是，根据上面提到的%i进行日志文件滚动 -->
            <maxFileSize>30MB</maxFileSize>
        </rollingPolicy>
        <!--
        日志输出格式：%d表示日期时间，%thread表示线程名，%-5level：级别从左显示5个字符宽度 %logger{50} 表示logger名字最长50个字符，否则按照句点分割。 %msg：日志消息，%n是换行符
        -->
        <layout class="ch.qos.logback.classic.PatternLayout">
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [ %thread ] - [ %-5level ] [ %logger{50} : %line ] - %msg%n</pattern>
        </layout>
    </appender>
 
    <!-- root是所有logger的父级，当logger的additivity=false时，logger管理的日志不再父级传递 -->
    <!--root的level尽量高一些，logger的级别必须低于root的级别才能输出-->
    <!--ALL > TRACE > FATAL > DEBUG > INFO > WARN > ERROR > OFF-->
    <root level="DEBUG">
        <appender-ref ref="stdout"/>
        <appender-ref ref="FILE"/>
    </root>
 
    <!--appender和logger一起使用-->
 
    <!--appender的name可以随意指定，被logger的appender-ref标签引用-->
    <appender name="errorAppender" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <!-- 指定日志文件的名称 -->
        <file>${LOG_HOME}/${APP_NAME}-error.log</file>
        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <!--只匹配ERROR级别日志-->-->
            <level>ERROR</level>
            <onMatch>ACCEPT</onMatch>
            <onMismatch>DENY</onMismatch>
        </filter>
        <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
            <!--
            滚动时产生的文件的存放位置及文件名称 %d{yyyy-MM-dd}：按天进行日志滚动
            %i：当文件大小超过maxFileSize时，按照i进行文件滚动
            -->
            <fileNamePattern>${LOG_HOME}/logbacks/${APP_NAME}-error-%d{yyyy-MM-dd}-%i.log</fileNamePattern>
            <MaxHistory>180</MaxHistory>
            <!-- 当日志文件超过maxFileSize指定的大小是，根据上面提到的%i进行日志文件滚动 -->
            <maxFileSize>30MB</maxFileSize>
        </rollingPolicy>
        <!--
        日志输出格式：%d表示日期时间，%thread表示线程名，%-5level：级别从左显示5个字符宽度 %logger{50} 表示logger名字最长50个字符，否则按照句点分割。 %msg：日志消息，%n是换行符
        -->
        <layout class="ch.qos.logback.classic.PatternLayout">
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [ %thread ] - [ %-5level ] [ %logger{50} : %line ] - %msg%n</pattern>
        </layout>
    </appender>
    <appender name="infoAppender" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <!-- 指定日志文件的名称 -->
        <file>${LOG_HOME}/${APP_NAME}-info.log</file>
        <!--只输出INFO-->
        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <!--只匹配INFO级别日志-->
            <level>INFO</level>
            <onMatch>ACCEPT</onMatch>
            <onMismatch>DENY</onMismatch>
        </filter>
        <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
            <!--
            滚动时产生的文件的存放位置及文件名称 %d{yyyy-MM-dd}：按天进行日志滚动
            %i：当文件大小超过maxFileSize时，按照i进行文件滚动
            -->
            <fileNamePattern>${LOG_HOME}/logbacks/${APP_NAME}-info-%d{yyyy-MM-dd}-%i.log</fileNamePattern>
            <MaxHistory>180</MaxHistory>
            <!-- 当日志文件超过maxFileSize指定的大小是，根据上面提到的%i进行日志文件滚动 -->
            <maxFileSize>30MB</maxFileSize>
        </rollingPolicy>
        <!--
        日志输出格式：%d表示日期时间，%thread表示线程名，%-5level：级别从左显示5个字符宽度 %logger{50} 表示logger名字最长50个字符，否则按照句点分割。 %msg：日志消息，%n是换行符
        -->
        <layout class="ch.qos.logback.classic.PatternLayout">
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [ %thread ] - [ %-5level ] [ %logger{50} : %line ] - %msg%n</pattern>
        </layout>
    </appender>
 
    <!--logger的name作为匹配包名的作用-->
    <!--当java代码中LoggerFactory.getLogger(XX.class);匹配该XX的类名-->
    <!--当java代码中LoggerFactory.getLogger("loggername");时，name属性直接写loggername-->
    <logger name="com.example" additivity="false">
        <appender-ref ref="infoAppender"/>
        <appender-ref ref="errorAppender"/>
    </logger>
     
</configuration>

4、 日志框架的迁移

log4j和logback可以无缝切换，不需要改变任何代码，只需要把对应的jar包换掉即可。

四、日志规范

1、Logger对象的声明和初始化

//推荐，注意导入的包一定是slf4j的
private static final Logger logger = LoggerFactory.getLogger(Xxx.class);

2、 不得使用System.out, System.err进行日志记录，请改使用logger.debug、logger.error

3、 使用参数化形式{}占位

LOG.debug("Save order with order no：{}, and order amount：{}");

为使用占位符的，必须使用isXxxEnabled() 判断

if (logger.isDebugEnabled()) {
    logger.debug(test());
}

4、 输出不同级别的日志

  • ERROR（错误）

    一般用来记录程序中发生的任何异常错误信息（Throwable），或者是记录业务逻辑出错。

  • WARN（警告）

    一般用来记录一些用户输入参数错误

  • INFO（信息）

    默认的日志级别，用来记录程序运行中的一些有用的信息。如程序运行开始、结束、耗时、重要参数等信息，需要注意有选择性的有意义的输出，到时候自己找问题看一堆日志却找不到关键日志就没意义了

  • DEBUG（调试）

    这个级别一般记录一些运行中的中间参数信息，只允许在测试环境开启，选择性在开发环境开启。

5、没有输出全部错误信息

看以下代码，这样不会记录详细的堆栈异常信息，只会记录错误基本描述信息，不利于排查问题。

try {
    // ...
} catch (Exception e) {
    // 错误
    LOG.error('XX 发生异常', e.getMessage());
 
    // 正确
    LOG.error('XX 发生异常', e);

6、不要在千层循环中打印日志

这个是什么意思，如果你的框架使用了性能不高的 Log4j 框架，那就不要在上千个 for循环中打印日志，这样可能会拖垮你的应用程序，如果你的程序响应时间变慢，那要考虑是不是日志打印的过多了

// 错误
for(int i=0; i<2000; i++){
    LOG.info("XX");
}

最好的办法是在循环中记录要点，在循环外面总结打印出来。

7、 什么时候输出日志

7.1 异常捕获处

在捕获异常处输出日志，大家在基本都能做到，唯一需要注意的是怎么输出一个简单明了的日志信息。这在后面的问题问题中有进一步说明。

7.2 调用外部接口处

在调用外部系统时，我们需要输出日志记录返回的结果。

7.3 关键操作

关键操作的日志一般是INFO级别，如果数量、频度很高，可以考虑使用DEBUG级别。以下是一些关键操作的举例，实际的关键操作肯定不止这么多。

n 删除：删除一个文件、删除一组重要数据库记录……

n 添加：和外系统交互时，收到了一个文件、收到了一个任务……

n 处理：开始、结束一条任务……

n ……

五、日志分析、存储、展示

1、ELK简介

ELK是一套完整的日志解决方案，由ElasticSearch、Logstash、 Kibana
这三款开源软件组成。

  • EastiSearch是基于Lucene开发的分布式存储检引擎，用来存储各类日志;
  • Logstash对日志进行收集、分析，并将其存储供以后使用:
  • Kibana 是基于Node.js开发的展示工具，为Logstah和ElasticSearch提供用于日志展示的Web界面，还用于帮助汇总、分析和搜索重要日志数据。

ELK官网https://www.elastic.co/products 分别提供包进行下载安装。

2、ELK工作原理

  • 在所有需要收集日志的服务上部署Logstash,作为署Logstash agent用于监控并过滤所收集的日志，将过滤后的内容整合在一起，最终全部交给EastiSearch检索引擎；
  • 用EastiSearch进行自定义检索;
  • 再通过Kibana通过结合自定义检索内容生成图表，进行日志数据展示。

详细参考：https://blog.51cto.com/11134648/2163789
logback官方文档

smilevers
关注
专栏目录
log4j转换到logback, log4j.properties直接转换成logback.xml，logback提供了官方配置详解和转换工具
Web3 & Basketball
01-11 4395
logback比log4j要快大约10倍，而且消耗更少的内存，那如果从log4j转换成logback，如果重新写logback.xml是一件很麻烦的事情，如何配置logback，请参照官方配置详解：https://logback.qos.ch/manual/configuration.html 现在Logback官方提供了直接把log4j.properties转换成logback.xml的工具：
Java日志框架：Slf4j、Log4J、Logback详解
BugTO的博客
10-06 198
Slf4j（Simple Logging Facade for Java）是一种日志框架的抽象层，它提供了一套简单易用的API，可以与不同的具体日志实现框架进行交互。Log4J和Logback则是具体的日志实现框架，它们提供了丰富的功能和灵活的配置选项，可以满足不同项目的需求。综上所述，Slf4j、Log4J和Logback是Java后端开发中常用的日志框架，它们提供了统一的日志API和丰富的功能，帮助开发人员记录和管理应用程序的日志信息。这些配置文件可以根据具体的框架进行自定义，以满足项目的需求。
logback和log4j配置
Thancks
09-22 1576
logback.xml配置： %d{yyyy-MM-dd HH:mm:ss.SSS} %level [%thread] %class:%line >> %msg%n /home/report/logs/opt/jfpay_task_bat_log/task.log /home/rep
log4j与logback（简介，配置项解释，配置示例，使用说明）
weixin_42100211的博客
06-26 2619
log4j与logback简介，配置示例，使用说明，配置项解释
SpringBoot基础(三)：Logback日志
最新发布
从基础到源码解析的学习记录
10-04 8166
SpringBoot基础系列文章SpringBoot基础(一)：快速入门SpringBoot基础(二)：配置文件详解SpringBoot基础(三)：Logback日志 默认使用作为，作为来记录日志 Logback是由设计的另一个开源日志组件，性能比log4j要好   适配器作用：以后想要换其他日志框架，只要排除掉logback日志实现，导入log4j2或jul的日志实现即可，代码中API还是slf4j不需要修改，。  注解的原理就是在编译后的Class文件的类名下生成，所以这两使用哪个都一样。 2、默
logback与Log4J的区别
热门推荐
Jenny的人生旅途
05-23 4万+
Logback和log4j是非常相似的，如果你对log4j很熟悉，那对logback很快就会得心应手。下面列了logback相对于log4j的一些优点： 更快的实现 Logback的内核重写了，在一些关键执行路径上性能提升10倍以上。而且logback不仅性能提升了，初始化内存加载也更小了。 非常充分的测试 Logback经过了几年，数不清小时的测试。Logback的测试完全不同级别的。在作者的观
logback的使用和logback.xml详解
相识的你的博客
03-30 2682
一、logback的介绍 　　Logback是由log4j创始人设计的另一个开源日志组件,官方网站： http://logback.qos.ch。它当前分为下面下个模块： 　　logback-core：其它两个模块的基础模块 　　logback-classic：它是log4j的一个改良版本，同时它完整实现了slf4j API使你可以很方便地更换成其它日志系统如log4j或JDK14 Logg
如何将应用的log4j替换成logback详解
08-31
2. 添加Logback依赖：在`pom.xml`中添加Logback的三个核心组件：`logback-core`、`logback-classic`和`log4j-over-slf4j`。`logback-classic`是Logback的用户接口，`logback-core`是其核心库，而`log4j-over-slf4j`...
妈妈再也不用担心我搞不懂——log4j/logback/log4j2原理了
Saintyyu的博客
12-02 764
本文深入浅出地介绍log4j、logback、log4j2的核心原理，通俗易懂。
SpringBoot框架配置log4j和log4j2的配置代码
11-29
Log4j和Log4j2是两种广泛使用的Java日志框架，它们提供了灵活的日志配置和高性能的日志处理能力。本文将详细介绍如何在SpringBoot项目中配置Log4j和Log4j2。 ### SpringBoot与Log4j Log4j是Apache的一个开源项目，...
日志框架Logback和Log4j2该如何选择？
fastboot
04-30 1583
1、Logback1.1、Logback简介Logback是由log4j创始人设计的又一个开源日志组件。Logback当前分成三个模块：logback-core，logback- classic和logback-accesslogback-core是其它两个模块的基础模块，类似与springframeworklogback-classic是log4j的一个改良版本。此外logback-classi...
logback和log4j比较，前者是后者改良，logback配置详解
弗思的博客
04-22 1667
logback和log4j比较，前者是后者改良，logback配置详解 深夜不说话原文链接 一、logback的介绍 　　Logback是由log4j创始人设计的另一个开源日志组件,官方网站： http://logback.qos.ch。它当前分为下面下个模块： 　　logback-core：其它两个模块的基础模块 　　logback-classic：它是log4j的一个改良版本，同时它完整实现了slf4j API使你可以很方便地更换成其它日志系统如log4j或JDK14 Logging 　　lo.
logback的使用和配置|logback比log4j的优点|logback是一个更好的log4j
小小鱼儿小小林的博客
01-22 1164
一、前言logback介绍 Logback是由log4j创始人设计的另一个开源日志组件, 官方文档（https://logback.qos.ch/documentation.html）和网站（https://logback.qos.ch/） 。 大家可以用谷歌浏览器访问，不喜欢英文文档的可以右键翻译成中文，觉得自己英文ok的，可以直接看英文文档 它当前分为下面几个模块： logb...
Mybatis日志Log4j与Logback
久绊A的博客
07-05 2621
它实现了日志事件的处理和分发，以及日志的格式化和输出等核心功能。Logback是由Log4j创始人Ceki Gülcü开发的后继项目，旨在解决Log4j的问题，并提供更好的性能和可靠性，因此Logback可以被视为Log4j的升级版。使用 Slf4j 可以让你的应用程序与具体的日志实现库解耦，从而可以灵活地切换和配置不同的日志库，例如 Log4j、Logback等。3、查看日志输出：在控制台窗口的选项卡中，您将看到应用程序的日志输出，您可以滚动查看日志消息，以及根据需要过滤和搜索特定的日志消息。
Logback和log4j
kalman2008的技术专栏
07-30 465
Logback和log4j是非常相似的，如果你对log4j很熟悉，那对logback很快就会得心应手。下面列了logback相对于log4j的一些优点：  更快的实现  Logback的内核重写了，在一些关键执行路径上性能提升10倍以上。而且logback不仅性能提升了，初始化内存加载也更小了。  非常充分的测试  Logback经过了几年，数不清小时的测试。Logback的测试完
logback与log4j
weixin_30624825的博客
08-21 125
logback和log4j是一个人写的， springboot默认使用的日志框架是logback。 logback主要由logback-core：是其它模块的基础设施、其他模块基于它构建、提供了关键性的通用机制、 logback-classic：是log4j的轻量级的实现，实现了简单日志门面slf4j、 ...
log4j和lockback的比较，二者可否同时使用
weixin_30726161的博客
07-10 597
一、log4j和logback的介绍 log4j： 可以控制日志信息输送的目的地是控制台、文件、GUI组件，甚至是套接口服务器、NT的事件记录器、UNIX Syslog守护进程等；可以控制每一条日志的输出格式；通过定义每一条日志信息的级别，能够更加细致地控制日志的生成过程。上述可以通过一个配置文件来灵活地进行配置，而不需要修改应用的代码。 logback： 是由log4j创始人设计的又...
logback VS log4j2 那些你注意不到的性能差距...
BASK2311的博客
01-25 2155
logback, log4j2 等都是非常优秀的日志框架， 在日常使用中，我们很少会关注去使用哪一个框架， 但其实这些日志框架在性能方面存在明显的差异。尤其在生产环境中， 有时候日志的性能高低，很可能影响到机器的成本， 像一些大企业，如阿里、腾讯、字节等，一点点的性能优化，就能节省数百万的支出。再次， 统一日志框架也是大厂常有的规范化的事情， 还可以便于后续的ETL流程， 因此，我们选一个日志框架，其实还是比较重要的。
Log4j详解：Java日志框架的优势与应用
"log4j是一个广泛使用的Java日志框架，起源于1996年的E.U.SEMPER项目，现属于Apache Public License下...此外，社区的活跃和众多的扩展库（如Logback、Log4j2等）确保了其持续的更新和支持，以满足不断发展的软件需求。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值