log

最新推荐文章于 2022-02-11 17:05:43 发布

feiyuciuxun

最新推荐文章于 2022-02-11 17:05:43 发布

阅读量93

点赞数

分类专栏： java 日志

本文链接：https://blog.csdn.net/feiyuciuxun/article/details/105023302

版权

java 同时被 2 个专栏收录

15 篇文章 0 订阅

订阅专栏

日志

1 篇文章 0 订阅

订阅专栏

log4j.rootLogger = debug,stdout,D,E

### 输出信息到控制抬 ###
log4j.appender.stdout = org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target = System.out
log4j.appender.stdout.layout = org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern = [%-5p] %d{yyyy-MM-dd HH:mm:ss,SSS} method:%l%n%m%n

### 输出DEBUG 级别以上的日志到=E://logs/error.log ###
log4j.appender.D = org.apache.log4j.DailyRollingFileAppender
log4j.appender.D.File = E://logs/debug.log
log4j.appender.D.Append = true
log4j.appender.D.Threshold = DEBUG
log4j.appender.D.layout = org.apache.log4j.PatternLayout
log4j.appender.D.layout.ConversionPattern = %-d{yyyy-MM-dd HH:mm:ss}  [ %t:%r ] - [ %p ]  %m%n

### 输出ERROR 级别以上的日志到=E://logs/error.log ###
log4j.appender.E = org.apache.log4j.DailyRollingFileAppender
log4j.appender.E.File =E://logs/error.log
log4j.appender.E.Append = true
log4j.appender.E.Threshold = ERROR
log4j.appender.E.layout = org.apache.log4j.PatternLayout
log4j.appender.E.layout.ConversionPattern = %-d{yyyy-MM-dd HH:mm:ss}  [ %t:%r ] - [ %p ]

日志门面

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

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

常见的日志门面：

JCL 、 slf4j

常见的日志实现：

JUL、log4j、logback、log4j2

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

在没有日志门面时（日志接口），需要直接操作日志实现，但是当需要换一种日志实现时就需要把我们写的类中的代码进行修改，这样太麻烦。但是当有了日志接口后，我们只需要修改pom.xml里面的依赖就可以，不需要修改代码。这样实现用户和日志实现的解耦合。

日志框架出现顺序：

log4j -> JUL -> JCL -> slf4j -> logback -> log4j2

注：最早的时候是没有日志框架的，只能通过system.out...等方式输出。

SLF4J的使用

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

官网：http://slf4j.org/

注意：请注意，启用SLF4J的库意味着仅添加一个强制性依赖项，即slf4j-api.jar。如果在类路径上未找到绑定，则SLF4J将默认为无操作实现。

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

日志框架的绑定
日志框架的桥接

快速入门：（绑定slf4j-simple框架）

使用的依赖：

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

代码：

package com.Michael.slf4jTest;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class test01 {
    public static final Logger LOG = LoggerFactory.getLogger(test01.class);
    public static void main(String[] args) {
        LOG.error("error");
        LOG.warn("warn");
        LOG.info("info");
        LOG.debug("debug");
        LOG.trace("trace");
    }
}

输出结果：

使用占位符输出日志信息：

package com.Michael.slf4jTest;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class test01 {
    public static final Logger LOG = LoggerFactory.getLogger(test01.class);
    public static void main(String[] args) {
        LOG.error("error");
        LOG.warn("warn");
        LOG.info("info");     // 默认级别
        LOG.debug("debug");
        // 使用占位符输出日志信息
        String name = "haha";
        Integer age = 14;
        LOG.info("用户：{}，{}",name,age);
    }
}

结果：

将系统的异常信息输出

package com.Michael.slf4jTest;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class test01 {
    public static final Logger LOG = LoggerFactory.getLogger(test01.class);
    public static void main(String[] args) {
        try {
            int i = 1/0;
        }catch (Exception e){
            // 原理为 LOG.error可以传入一个Throwable参数
            LOG.error("出现异常：",e);
        }
    }
}

结果：

绑定日志的实现（Binding）

先看官网的一张图片：

可以看到一共有六列，表示slf4j共绑定了六种日志框架，

第一列，也就是第一种情况，项目中仅仅引入slf4j的门面，不引入具体实现，其功能是默认关闭的
第二种情况，也就是蓝颜色部分，分别为：logback、slf4j-simple、slf4j-nop。这三个框架比slf4j出来晚，所以设计的时候就默认遵循slf4j的API规范了，所以直接导入实现就可以了。
中间那两个，一个是log4j、一个是jdk14（jul），出现的比slf4j早，设计时无法默认绑定slf4jAPI规范（肯定的啊），所以不能直接绑定slf4j。中间需要加适配层，adaptation layer，简介遵循slf4j规范。

绑定logback框架

需要引入的依赖：

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

代码：

package com.Michael.slf4jTest;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class test01 {
    public static final Logger LOG = LoggerFactory.getLogger(test01.class);
    public static void main(String[] args) {
        LOG.info("info");
        LOG.warn("warn");
        LOG.error("error");
        try {
            int i = 1/0;
        }catch (Exception e){
            LOG.error("出现异常：",e);
        }
    }
}

结果：

注意：可以看到实际形式还是simple格式，那是因为我们依赖中导入了两个实现框架，一个是本身的simple，另一个是logback，这时候他会默认使用第一个日志框架来解析，

若把simple框架的依赖删掉或者放到logback依赖的后面，则结果如下：

绑定slf4j-nop：实际作用是关闭日志的输出

引入的依赖为：

    <!--slf4j 日志门面-->
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-api</artifactId>
        <version>1.7.26</version>
    </dependency>
    <!--nop 日志开关-->
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-nop</artifactId>
        <version>1.7.25</version>
    </dependency>

代码：还是上一个代码

结果：

没有日志输出了！

绑定log4j

    <!--slf4j 日志门面-->
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-api</artifactId>
        <version>1.7.26</version>
    </dependency>
    <!--绑定 log4j 日志实现，需要导入适配器-->
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-log4j12</artifactId>
        <version>1.7.12</version>
    </dependency>
    <!--再导入log4j-->
    <dependency>
        <groupId>log4j</groupId>
        <artifactId>log4j</artifactId>
        <version>1.2.17</version>
    </dependency>

代码：不变

结果：

此时类路径下缺少一个log4j.properties文件，其内容如下：

log4j.rootLogger=debug, A

log4j.appender.A=org.apache.log4j.ConsoleAppender
log4j.appender.A.layout=org.apache.log4j.PatternLayout
log4j.appender.A.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} [%c]-[%p] %m%n

结果：

绑定JUL

使用的依赖：

<!--slf4j 日志门面-->
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-api</artifactId>
        <version>1.7.26</version>
    </dependency>
<!--绑定 jul 日志实现，需要导入适配器-->
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-jdk14</artifactId>
        <version>1.7.25</version>
    </dependency>

代码：不变

结果：

总结：

添加slf4j-api的依赖
使用slf4j的API在项目中进行统一的日志记录
绑定具体的日志实现框架

绑定已经实现slf4j的日志框架，直接添加对应依赖
绑定没有实现slf4j的日志框架，先添加日志的适配器，再添加实现类的依赖

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

桥接旧的日志框架（Bridging）

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

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

先去除之前老的日志框架的依赖
添加SLF4J提供的桥接组件
为项目添加SLF4J具体实现

案例1：项目最开始使用的是log4j

依赖：

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

代码：

package com.Michael.slf4jTest;

import org.apache.log4j.Logger;

public class Log4jTest {
    public static final Logger LOG = Logger.getLogger(Log4jTest.class);

    public static void main(String[] args) {
        LOG.info("info");
    }
}

结果：

此时呢，我想讲log4j日志框架替换成slf4j 和 logback的组合，怎么办呢：

第一步，删掉log4j的依赖

第二步，引入以下依赖

<!--slf4j 日志门面-->
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-api</artifactId>
        <version>1.7.26</version>
    </dependency>
    <!--logback 日志实现-->
    <dependency>
        <groupId>ch.qos.logback</groupId>
        <artifactId>logback-classic</artifactId>
        <version>1.2.3</version>
    </dependency>

这就成功了，但是，代码报错了。不信你试试，因为引入的log4j的依赖删掉了。别慌，这是slf4j提供了桥接器，那怎么使用这个桥接器呢，先看一幅图：（图片网站：http://slf4j.org/images/legacy.png）

在原来的依赖中加入以下依赖

<!--配置 log4j 的桥接器-->
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>log4j-over-slf4j</artifactId>
        <version>1.7.25</version>
    </dependency>

此时代码不再报错

运行代码结果如下：

说明具体执行时使用了logback的日志格式。这就是桥接器的基本使用。

注意：使用桥接器时不能和适配器一起出现，否则会出现栈溢出

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

Logback

官网如下：http://logback.qos.ch/index.html。Logback是log4j创始人设计的另一个开源日志组件，性能比log4j要好。

Logback主要分为三个模块

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

Logback快速入门

依赖如下：

 <!--slf4j 日志门面-->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.26</version>
        </dependency>
        <!--logback 日志实现-->
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>1.2.3</version>
        </dependency>

代码：

package com.Michael;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class LogbackTest {
    public static final Logger LOG = LoggerFactory.getLogger(LogbackTest.class);

    public static void main(String[] args) {
        LOG.debug("debug");   //默认输出级别
        LOG.info("info");
        LOG.warn("warn");
        LOG.error("error");
    }
}

结果：

Logback配置

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

logback.groovy
logback-test.xml（一般开发环境测试时使用）
logback.xml 如果均不存在会采用默认配置

logback组件之间的关系：

Logger：日志的记录器，把它关联到应用的对应的context上后，主要用于存放日志的对象，也可以定义日志类型、级别
Appender：用于指定日志输出的目的地，目的地可以是控制台、文件、数据库等等
Layout：负责把事件转换成字符串，格式化的日志信息的输出。在logback中layout对象被封装在encoder中。

logback.xml内容如下：

<?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"/>  
  <!--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.err</target>  
    <!--日志格式配置-->  
    <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder"> 
      <pattern>${pattern}</pattern> 
    </encoder> 
  </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>元素，但是它是根logger。默认debug level:用来设置打印级别，大小写无关：TRACE, DEBUG, INFO, WARN, ERROR, ALL 和 OFF， <root>可以包含零个或多个<appender-ref>元素，标识这个appender将会添加到这个 logger。 -->  
  <root level="ALL"> 
    <appender-ref ref="console"/> 
  </root> 
</configuration>

代码如下：

package com.Michael;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class LogbackTest {
    public static final Logger LOG = LoggerFactory.getLogger(LogbackTest.class);

    public static void main(String[] args) {
        LOG.trace("trace");
        LOG.debug("debug");
        LOG.info("info");
        LOG.warn("warn");
        LOG.error("error");
    }
}

结果如下：

案例二：同时指定file和console输出

logback.xml文件如下：

<?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="log_dir" value="/log"></property>
    <!--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.err</target>
        <!--日志格式配置-->
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <pattern>${pattern}</pattern>
        </encoder>
    </appender>

    <!--日志文件输出的appender-->
    <appender name="file" class="ch.qos.logback.core.FileAppender">
        <!--日志文件保存路径-->
        <file>${log_dir}logback.log</file>
        <!--日志消息格式配置-->
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <pattern>${pattern}</pattern>
        </encoder>
    </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>元素，但是它是根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"/>
    </root>
</configuration>

代码：不变

结果：

1、控制台：

2、文件

案例三：HTML格式日志文件输出

logback.xml文件如下：

<?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="log_dir" value="/log"></property>
    <!--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.err</target>
        <!--日志格式配置-->
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <pattern>${pattern}</pattern>
        </encoder>
    </appender>

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

    <!--html 格式日志文件输出 appender-->
    <appender name="htmlFile" class="ch.qos.logback.core.FileAppender">
        <!--日志文件保存路径-->
        <file>${log_dir}/logback.html</file>
        <!--html 消息格式配置-->
        <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>
    </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>元素，但是它是根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"/>
    </root>
</configuration>

代码：不变

结果：仅仅列出htmlFile

logback.xml增加如下配置

 <!--日志才分和归档压缩的 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>
        <!--指定拆分规则-->
        <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
            <!--按照事件和压缩格式声明拆分的文件名-->
            <fileNamePattern>${log_dir}/rolling.%d{yyyy-MM-dd}.log%i.gz</fileNamePattern>
            <!--按照文件大小拆分-->
            <maxFileSize>1MB</maxFileSize>
        </rollingPolicy>
    </appender>

修改root为：

<root level="ALL">
        <appender-ref ref="console"/>
        <appender-ref ref="file"/>
        <appender-ref ref="htmlFile"/>
        <appender-ref ref="rollFile"/>
    </root>

结果增加如下：

案例：设置日志输出级别

logback.xml更新内容如下，其他内容不变

<!--日志才分和归档压缩的 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>
        <!--指定拆分规则-->
        <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
            <!--按照事件和压缩格式声明拆分的文件名-->
            <fileNamePattern>${log_dir}/rolling.%d{yyyy-MM-dd}.log%i.gz</fileNamePattern>
            <!--按照文件大小拆分-->
            <maxFileSize>1MB</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>元素，但是它是根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"/>
    </root>

结果：

1、控制台会打印所有级别的日志

2、文件内的日志如下

异步日志：默认的同步日志是和主线程同步执行的，也就是说日志记录完毕后代码才会往下执行，为了解决性能问题，就要学习异步日志了

logback.xml内容如下：

<?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="log_dir" value="/log"></property>
    <!--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.err</target>
        <!--日志格式配置-->
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <pattern>${pattern}</pattern>
        </encoder>
    </appender>

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

    <!--html 格式日志文件输出 appender-->
    <appender name="htmlFile" class="ch.qos.logback.core.FileAppender">
        <!--日志文件保存路径-->
        <file>${log_dir}/logback.html</file>
        <!--html 消息格式配置-->
        <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>
    </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>
        <!--指定拆分规则-->
        <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
            <!--按照事件和压缩格式声明拆分的文件名-->
            <fileNamePattern>${log_dir}/rolling.%d{yyyy-MM-dd}.log%i.gz</fileNamePattern>
            <!--按照文件大小拆分-->
            <maxFileSize>1MB</maxFileSize>
        </rollingPolicy>
        <!--日志级别过滤器-->
        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <!--日志过滤规则-->
            <level>ERROR</level>
            <onMatch>ACCEPT</onMatch>
            <onMismatch>DENY</onMismatch>
        </filter>
    </appender>

    <!--异步日志-->
    <appender name="async" class="ch.qos.logback.classic.AsyncAppender">
        <!--指定某个具体的 appender-->
        <appender-ref ref="rollFile"/>
    </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>元素，但是它是根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="async"/>
    </root>
</configuration>

自定义 logger 对象

logback.xml变化部分如下：

<!--用来设置某一个包或者具体的某一个类的日志打印级别、以及指定<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>元素，但是它是根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="async"/>
    </root>

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

此时只有控制台有输出，虽然文件会生成，但文件里面内容为空

Log4j2

简介：

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

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

Log4j2入门案例（无xml配置文件）

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

添加依赖如下：

<!--log4j2的日志门面-->
        <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.12.1</version>
        </dependency>

代码如下：

package com.Michael;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

public class Log4j2Test {
    public static final Logger LOG = LogManager.getLogger(Log4j2Test.class);

    public static void main(String[] args) {
        // 日志消息输出
        LOG.fatal("fatal");
        LOG.error("error");
        LOG.warn("warn");
        LOG.info("info");
        LOG.debug("debug");
        LOG.trace("trace");
    }

}

结果：

ERROR StatusLogger No Log4j 2 configuration file found. Using default configuration (logging only errors to the console), or user programmatically provided configurations. Set system property 'log4j2.debug' to show Log4j 2 internal initialization logging. See https://logging.apache.org/log4j/2.x/manual/configuration.html for instructions on how to configure Log4j 2
23:55:18.068 [main] FATAL com.Michael.Log4j2Test - fatal
23:55:18.071 [main] ERROR com.Michael.Log4j2Test - error

案例二：有xml配置文件

xml文件如下：

<?xml version="1.0" encoding="utf-8"?>

<Configuration status="warn" monitorInterval="5">
    <properties>
        <property name="LOG_HOME">D:/logs</property>
    </properties> 4.3 Log4j2异步日志 异步日志 log4j2最大的特点就是异步日志，其性能的提升主要也是从异步日志中受益，我们来看看如何使用 log4j2的异步日志。 同步日志
    <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>

代码：不变

结果：

案例三：使用slf4j充当门面

依赖如下：

<!--使用slf4j 作为日志门面-->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.26</version>
        </dependency>
        <!--使用 log4j2 的适配器进行绑定-->
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-slf4j-impl</artifactId>
            <version>2.9.1</version>
        </dependency>

        <!--log4j2的日志门面-->
        <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>

代码如下：

package com.Michael;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class slf4jTest {
    public static final Logger LOG = LoggerFactory.getLogger(slf4jTest.class);
    public static void main(String[] args) {
        LOG.error("error");
        LOG.warn("warn");
        LOG.info("info");
        LOG.warn("warn");
        LOG.error("error");

    }
}

结果：

log4j2配置文件讲解

<?xml version="1.0" encoding="utf-8"?>
<!--
status="warn" 日志框架本身的输出日志级别
monitorInterval=5 自动加载配置文件的间隔时间 不低于5秒
-->
<Configuration status="debug" monitorInterval="5">
    <!--
    集中配置属性进行管理
    使用时通过：${name}
    -->
    <properties>
        <property name="LOG_HOME">D:/logs</property>
    </properties>
    <!--日志处理-->
    <Appenders>
        <!--控制台输出 appender-->
        <Console name="Console" target="SYSTEM_OUT">
            <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>

        <!--使用随机读写流的日志文件输出 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="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/>
                <!--按照文件大小进行拆分，此处为10MB-->
                <SizeBasedTriggeringPolicy size="10 MB"/>
                <!--按照时间节点拆分，规则根据fileParttern定义的-->
                <TimeBasedTriggeringPolicy/>
            </Policies>
            <!--在同一个目录下，文件的个数限定为30个，超过进行覆盖-->
            <DefaultRolloverStrategy max="30"/>
        </RollingFile>
    </Appenders>
    <Loggers>
        <!--使用 rootlogger 配置 日志级别 level=trace-->
        <Root level="trace">
            <AppenderRef ref="Console"/>
        </Root>
    </Loggers>
</Configuration>

Log4j2异步日志

feiyuciuxun

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
log

log4j.rootLogger = debug,stdout,D,E### 输出信息到控制抬 ###log4j.appender.stdout = org.apache.log4j.ConsoleAppenderlog4j.appender.stdout.Target = System.outlog4j.appender.stdout.layout = org.apache.log4...
复制链接

扫一扫

专栏目录