Log4j2不同级别的日志写入到不同文件+扩展日志级别实现业务日志分类

最新推荐文章于 2023-03-30 14:30:13 发布
最新推荐文章于 2023-03-30 14:30:13 发布
阅读量3.7k 收藏 9
点赞数
分类专栏： 日志 文章标签： java log4j2 spring boot log4j spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gxdogjava/article/details/110163547
版权

目录

前言

1.不同级别的日志输出到不同的文件

1.1    自定义RollingFile配置

1.2    自定义Console

1.3    Async异步输出

1.4    自定义Logger配置

1.5    自定义统一日志类LogUtil.java

1.6    使用说明

1.6.1.1 通过LogUtil创建业务类日志对象

1.6.1.2 使用业务类日志对象

1.7    日志输出样式

2.扩展日志级别

2.1    自定义日志级别

2.2    自定义RollingFile配置

2.3    Async异步输出

2.4    root引入扩展日志级别

2.5    自定义统一日志类LogUtil.java

2.6    StandardLevel

2.7    使用说明

2.7.1 通过LogUtil创建业务类日志对象

2.7.2 使用业务类日志对象

 

2.8    日志输出样式

3.动态Appender

4.扩展log4j2自定义Appender

前言

该篇适合于工程项目已有对info、warn、error等不同级别日志的统一拦截，仍需要根据业务将不同业务的日志分级别输出到不同的文件中，这些日志文件只有该业务的日志，不含有系统其它业务、框架等的日志；网上很多都是千篇一律的东西，内容老旧，错误百出，不能解决问题，该篇文章是将实际的集成过程整理，并将遇到的问题进行了说明，另外java代码实现动态日志附加器是根据log4j2的新方法实现，不是网上都在转的log4j（很多方法会显示已启用），可供大家参考。

设计思路：

  • 首先定义业务名称，日志输出的时候带有该业务的名称（日志格式可以灵活设置）
  • 其次通过统一的LogUtil工具类进行输出，并将logger标签配置到LogUtil，这样做的目的是避免系统已存在的日志附加器RollingFile配置输出的日志写入到业务日志文件，造成日志混乱，
  • 统一的LogUtil类，通过集成原生的ExtendedLoggerWrapper既实现了日志级别的扩展，也可以在业务类使用LogUtil的时候通过工厂模式获取到当前业务类的日志对象，从而通过该对象获取到业务类的全路径，方便日志输出的灵活改造。
  • 最后扩展日志级别，扩展的日志级别主要用于补充业务场景，更多的用在公共组件、中间件内部进行输出（根据实际情况和要求设计）。

这里再说一下，如果对整个系统实现不同级别的日志写入到不同的文件，以下的配置修改一下即可，而且不需要创建LogUtil，也不需要扩展日志级别，配置好RollingFile，Console，直接引入到root（实际上是使用了默认的日志检测路径）就可以实现。

1.不同级别的日志输出到不同的文件

1.1    自定义RollingFile配置

自定义Customer类型、INFO级别日志输出

名称：CustomerInfoLog

存储路径：项目配置路径+ /logs/Customer/CustomerInfo.log

日志输出格式：%d{yyyy-MM-dd HH:mm:ss.SSS} |-%-5level [%thread] Customer [%L] %msg%n"

其他内容参考以下配置：LOG_HOME是自己配置的项目日志路径property；FILE_DEADLINE是自己配置的保存时间property。

 

 

<!-- 自定义Customer类型INFO级别日志附加器 -->
<!-- 滚动文件生成 fileName日志文件名称，filePattern压缩文件路径 -->
<RollingFile name="CustomerInfoLog" fileName="${LOG_HOME}/logs/Customer/CustomerInfo.log"
filePattern="${LOG_HOME}/logs/Customer/CustomerInfo/CustomerInfo-%d{MM-dd-yyyy}-%i.log.gz">
    <!-- 过滤日志级别 info及以上 -->
    <Filters>
        <ThresholdFilter onMismatch="NEUTRAL" onMatch="DENY" level="WARN"/>
        <ThresholdFilter level="INFO" onMatch="ACCEPT" onMismatch="DENY" />
    </Filters>
    <!-- 指定日志输出格式 -->
    <PatternLayout pattern="%d{yyyy-MM-dd HH:mm:ss.SSS} |-%-5level [%thread] Customer [%L] %msg%n" />
    <!-- 新文件生成策略，每100M生成一个新文件 -->
    <Policies>
        <TimeBasedTriggeringPolicy />
        <SizeBasedTriggeringPolicy size="100 MB" />
    </Policies>
    <!-- 默认过度策略，不设置，则默认为最多同一文件夹下7个文件 大于此值会删除旧的日志文件 -->
    <DefaultRolloverStrategy>
        <!-- 文件删除策略，basePath扫描路径，maxDepth目录的最大级别数，IfFileName文件名称，IfLastModified指定持续时间（7天前）-->
        <Delete basePath="${LOG_HOME}" maxDepth="4">
            <IfFileName glob="*/Customer/CustomerInfo/CustomerInfo-*.log.gz" />
            <IfLastModified age="${FILE_DEADLINE}" />
        </Delete>
    </DefaultRolloverStrategy>
</RollingFile>

自定义Customer类型、WARN级别日志输出

名称：CustomerWarnLog

存储路径：项目配置路径+ /logs/Customer/CustomerWarn.log

日志输出格式：%d{yyyy-MM-dd HH:mm:ss.SSS} |-%-5level [%thread] Customer [%L] %msg%n"

其他内容参考以下配置：LOG_HOME是自己配置的项目日志路径property；FILE_DEADLINE是自己配置的保存时间property。

<!-- 自定义WARN级别日志附加器 -->
<!-- 滚动文件生成 fileName日志文件名称，filePattern压缩文件路径 -->
<RollingFile name="CustomerWarnLog" fileName="${LOG_HOME}/logs/Customer/CustomerWarn.log"
filePattern="${LOG_HOME}/logs/Customer/CustomerWarn/CustomerWarn-%d{MM-dd-yyyy}-%i.log.gz">
    <!-- 过滤日志级别 info及以上 -->
    <Filters>
        <ThresholdFilter onMismatch="NEUTRAL" onMatch="DENY" level="ERROR"/>
        <ThresholdFilter level="WARN" onMatch="ACCEPT" onMismatch="DENY" />
    </Filters>
    <!-- 指定日志输出格式 -->
    <PatternLayout pattern="%d{yyyy-MM-dd HH:mm:ss.SSS} |-%-5level [%thread] Customer [%L] %msg%n" />
     <!-- 新文件生成策略，每100M生成一个新文件 -->
     <Policies>
        <TimeBasedTriggeringPolicy />
        <SizeBasedTriggeringPolicy size="100 MB" />
    </Policies>
    <!-- 默认过度策略，不设置，则默认为最多同一文件夹下7个文件 大于此值会删除旧的日志文件 -->
    <DefaultRolloverStrategy>
        <!-- 文件删除策略，basePath扫描路径，maxDepth目录的最大级别数，IfFileName文件名称，IfLastModified指定持续时间（7天前）-->
        <Delete basePath="${LOG_HOME}" maxDepth="4">
            <IfFileName glob="*/Customer/CustomerWarn/CustomerWarn-*.log.gz" />
            <IfLastModified age="${FILE_DEADLINE}" />
        </Delete>
    </DefaultRolloverStrategy>
</RollingFile>

自定义Customer类型、ERROR级别日志输出

名称：CustomerErrorLog

存储路径：项目配置路径+ /logs/Customer/CustomerError.log

日志输出格式：%d{yyyy-MM-dd HH:mm:ss.SSS} |-%-5level [%thread] Customer [%L] %msg%n"

其他内容参考以下配置：LOG_HOME是自己配置的项目日志路径property；FILE_DEADLINE是自己配置的保存时间property。

<!-- 自定义ERROR级别日志附加器 -->
<!-- 滚动文件生成 fileName日志文件名称，filePattern压缩文件路径 -->
<RollingFile name="CustomerErrorLog" fileName="${LOG_HOME}/logs/Customer/CustomerError.log"
filePattern="${LOG_HOME}/logs/Customer/CustomerError/CustomerError-%d{MM-dd-yyyy}-%i.log.gz">
    <!-- 过滤日志级别 info及以上 -->
    <Filters>
        <ThresholdFilter level="ERROR" onMatch="ACCEPT" onMismatch="DENY" />
    </Filters>
    <!-- 指定日志输出格式 -->
    <PatternLayout pattern="%d{yyyy-MM-dd HH:mm:ss.SSS} |-%-5level [%thread] Customer [%L] %msg%n" />
    <!-- 新文件生成策略，每100M生成一个新文件 -->
    <Policies>
        <TimeBasedTriggeringPolicy />
        <SizeBasedTriggeringPolicy size="100 MB" />
    </Policies>
    <!-- 默认过度策略，不设置，则默认为最多同一文件夹下7个文件 大于此值会删除旧的日志文件 -->
    <DefaultRolloverStrategy>
        <!-- 文件删除策略，basePath扫描路径，maxDepth目录的最大级别数，IfFileName文件名称，   IfLastModified指定持续时间（7天前）-->
        <Delete basePath="${LOG_HOME}" maxDepth="4">
            <IfFileName glob="*/Customer/CustomerError/CustomerError-*.log.gz" />
            <IfLastModified age="${FILE_DEADLINE}" />
        </Delete>
    </DefaultRolloverStrategy>
</RollingFile>

1.2    自定义Console

自定义Customer类型、CONSOLE（控制台）日志输出

名称：CustomerCONSOLE

日志输出格式：%d{yyyy-MM-dd HH:mm:ss.SSS} |-%-5level [%thread] Customer [%L] %msg%n"

<Console name="CustomerCONSOLE" target="system_out">
    <PatternLayout pattern="%d{yyyy-MM-dd HH:mm:ss.SSS} |-%-5level [%thread] Customer [%L] %msg%n" />
</Console>

日志输出格式如下：

2020-11-22 20:07:06.927 |-INFO  [http-nio-9991-exec-1] Customer [] com.xxx.controller.TestController -|  xxxxxxxxx

1.3    Async异步输出

将Customer日志类型的INFO、WARN、ERROR的RollingFile以及自定义的CONSOLE引入

<Async name="AsyncCustomerInfoLog">
    <AppenderRef ref="CustomerInfoLog"/>
</Async>
<Async name="AsyncCustomerWarnLog">
    <AppenderRef ref="CustomerWarnLog"/>
</Async>
<Async name="AsyncCustomerErrorLog">
    <AppenderRef ref="CustomerErrorLog"/>
</Async>
<Async name="AsyncCustomerCONSOLE">
	<AppenderRef ref="CustomerCONSOLE"/>
</Async>

1.4    自定义Logger配置

name：com.xxx.util.LogUtil     指向统一日志类，由该类统一输出日志

level：info   级别不能高于引入的附加器（appender）的最低等级

<!-- 使用LogUtil输出日志的，写入到指定的文件 -->
<Logger name="com.xxx.util.LogUtil" level="info" additivity="false">
    <AppenderRef ref="AsyncCustomerCONSOLE" />
    <AppenderRef ref="AsyncCustomerInfoLog"/>
    <AppenderRef ref="AsyncCustomerWarnLog"/>
    <AppenderRef ref="AsyncCustomerErrorLog"/>
</Logger>

注意：自定义的异步RollingFile和Console不能引入到root中，否则，导致其他路径下的同级别日志也会写入到自定义的文件中。

loggers配置说明

  • name：用来指定该Logger所适用的类或者类所在的包全路径，继承自Root节点。一般是项目包名或者框架的包名
  • level：日志输出级别，未指定级别，则默认为 ERROR
  • AppenderRef：Logger的子节点，用来指定该日志输出到哪个Appender，如果没有指定，就会默认继承自Root。如果指定了，那么会在指定的这个Appender和Root的Appender中都会输出，此时我们可以设置Logger的additivity="false"只在自定义的Appender中进行输出

1.5    自定义统一日志类LogUtil.java

关键代码：

import org.apache.logging.log4j.Level;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.Marker;
import org.apache.logging.log4j.message.Message;
import org.apache.logging.log4j.message.MessageFactory;
import org.apache.logging.log4j.spi.AbstractLogger;
import org.apache.logging.log4j.spi.ExtendedLoggerWrapper;
import org.apache.logging.log4j.util.MessageSupplier;
import org.apache.logging.log4j.util.Supplier;

/**
 * 自定义日志工具类.
 *
 * @Author: gaoxd
 * @Date: 2020/11/11 15:17
 * @Version: 1.0
 **/

public class LogUtil extends ExtendedLoggerWrapper {
    private final Logger log = LogManager.getLogger(LogUtil.class);
    private final ExtendedLoggerWrapper logger;
    private static final String FQCN = LogUtil.class.getName();
    private LogUtil(final Logger logger) {
        super((AbstractLogger) logger, logger.getName(), logger.getMessageFactory());
        this.logger = this;
    }

    public static LogUtil getLogger() {
        final Logger wrapped = LogManager.getLogger();
        return new LogUtil(wrapped);
    }

    public static LogUtil getLogger(final Class<?> loggerName) {
        final Logger wrapped = LogManager.getLogger(loggerName);
        return new LogUtil(wrapped);
    }

    public static LogUtil getLogger(final Class<?> loggerName, final MessageFactory factory) {
        final Logger wrapped = LogManager.getLogger(loggerName, factory);
        return new LogUtil(wrapped);
    }

    public static LogUtil getLogger(final Object value) {
        final Logger wrapped = LogManager.getLogger(value);
        return new LogUtil(wrapped);
    }

    public static LogUtil getLogger(final Object value, final MessageFactory factory) {
        final Logger wrapped = LogManager.getLogger(value, factory);
        return new LogUtil(wrapped);
    }

    public static LogUtil getLogger(final String name) {
        final Logger wrapped = LogManager.getLogger(name);
        return new LogUtil(wrapped);
    }

    public static LogUtil getLogger(final String name, final MessageFactory factory) {
        final Logger wrapped = LogManager.getLogger(name, factory);
        return new LogUtil(wrapped);
    }

    /**
     * 改写slf4j2 info级别部分方法
     * 可以自行添加
     * 为了防止调用超出该类实现的info方法，名字后加了Util跟原info方法区分，
     * 如果将slf4j2的info方法全部重写，可以在该类中将方法命名为info.
     */
    public void infoUtil(final String message) {
        log.info(logger.getName() + " -| " + message);
    }

    public void infoUtil(final String message, final Object... params) {
        log.info(logger.getName() + " -| " + message, params);
    }

    public void infoUtil(final String message, final Throwable t) {
        log.info(logger.getName() + " -| " + message, t);
    }

    public void infoUtil(final String message, final Supplier<?>... paramSuppliers) {
        log.info(logger.getName() + " -| " + message, paramSuppliers);
    }

    /**
     * 改写slf4j2 warn级别部分方法
     * 可以自行添加
     * 为了防止调用超出该类实现的warn方法，名字后加了Util跟原warn方法区分，
     * 如果将slf4j2的warn方法全部重写，可以在该类中将方法命名为warn.
     */
    public void warnUtil(final String message) {
        log.warn(logger.getName() + " -| " + message);
    }

    public void warnUtil(final String message, final Object... params) {
        log.warn(logger.getName() + " -| " + message, params);
    }

    public void warnUtil(final String message, final Throwable t) {
        log.warn(logger.getName() + " -| " + message, t);
    }

    public void warnUtil(final String message, final Supplier<?>... paramSuppliers) {
        log.warn(logger.getName() + " -| " + message, paramSuppliers);
    }

    /**
     * 改写slf4j2 error级别部分方法
     * 可以自行添加
     * 为了防止调用超出该类实现的error方法，名字后加了Util跟原error方法区分，
     * 如果将slf4j2的error方法全部重写，可以在该类中将方法命名为error.
     */

    public void errorUtil(final String message) {
        log.error(logger.getName() + " -| " + message);
    }

    public void errorUtil(final String message, final Object... params) {
        log.error(logger.getName() + " -| " + message, params);
    }

    public void errorUtil(final String message, final Throwable t) {
        log.error(logger.getName() + " -| " + message, t);
    }

    public void errorUtil(final String message, final Supplier<?>... paramSuppliers) {
        log.error(logger.getName() + " -| " + message, paramSuppliers);
    }
}

特殊说明：

1. 继承ExtendedLoggerWrapper类是为了使用log4j2的原生获取logger对象的方式，从而通过logger.getName获取使用LogUtil的业务类的class全路径，方便对日志输入改写；应该还有其他的方式，比如：动态代理的方式，这里没有采用，有兴趣可以尝试。

2. 2020-11-22 20:07:06.927 |-INFO  [http-nio-9991-exec-1] Customer [] com.xxx.controller.TestController -| xxxx  日志中的com.xxx.controller.TestController（调用LogUtil的业务类的全路径）并非通过配置文件加进去，而是跟msg拼接加入进去。

3. private final Logger log = LogManager.getLogger(LogUtil.class);     使用log4j2原生方式创建LogUtil类自己的日志对象，以使用对象的原生方法info/warn/error，从而与Logger配置的name对应。当前只扩展了部分方法，而且为了跟原生方法区分，防止调用到原生方法，方法名称定义为infoUtil/warnUtil/errorUtil。

1.6    使用说明

1.6.1.1 通过LogUtil创建业务类日志对象

private final LogUtil LOGGER = LogUtil.getLogger(TestController.class);

1.6.1.2 使用业务类日志对象

LOGGER.infoUtil("TestController:infoUtil");

LOGGER.warnUtil("TestController:warnUtil");

LOGGER.errorUtil("TestController:errorUtil");

关键代码：

import com.xxx.util.LogUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * 文件描述
 * @Author: gaoxd
 * @Date: 2020/11/11 18:43
 * @Version: 1.0
 **/
@RestController
@Slf4j
public class TestController {
    private final LogUtil LOGGER = LogUtil.getLogger(TestController.class);

    @GetMapping("test1")
    public Object test1() {
        LOGGER.infoUtil("TestController:infoUtil");
        LOGGER.info("TestController:info");
        LOGGER.warnUtil("TestController:warnUtil");
        LOGGER.warn("TestController:warn");
        LOGGER.errorUtil("TestController:errorUtil");
        LOGGER.error("TestController:error");
        return "test1";
    }
}

特殊说明：用LogUtil对象调用原生的info/warn/error方法会在控制台输出，不能输出到指定的业务日志文件中；如果我们在LogUtil中将方法名称定义跟log4j2原生的方法一样并且全部覆盖，那么LOGGER.info()的调用方式既可以输出到控制台，也可以输出到指定文件。

1.7    日志输出样式

  • 2020-11-22 20:07:06.927 |-INFO  [http-nio-9991-exec-1] Customer [] com.xxx.controller.TestController -| TestController:infoUtil
  • 2020-11-22 20:07:06.927 |-WARN [http-nio-9991-exec-1] Customer [] com.xxx.controller.TestController -| TestController:warnUtil
  • 2020-11-22 20:07:06.927 |-ERROR [http-nio-9991-exec-1] Customer [] com.xxx.controller.TestController -| TestController:errorUtil

2.扩展日志级别

2.1    自定义日志级别

<!-- 自定义日志级别 -->
<CustomLevels>
    <CustomLevel name="EXCEPTION" intLevel="70" />
    <CustomLevel name="BUSINESS" intLevel="80" />
    <CustomLevel name="MIDDLE" intLevel="90" />
</CustomLevels>

特说说明：该处可以不配置，不影响使用，只是服务启动的时候会报错误日志，没有默认值；

2.2    自定义RollingFile配置

自定义BUSINESS级别日志输出

名称：BusinessLog

存储路径：项目配置路径+ /logs/ business.log

其他内容参考以下配置

<!-- 滚动文件生成 fileName日志文件名称，filePattern压缩文件路径 -->
<RollingFile name="BusinessLog" fileName="${LOG_HOME}/logs/business.log"
filePattern="${LOG_HOME}/logs/business/business-%d{MM-dd-yyyy}-%i.log.gz">
<!-- 过滤日志级别 info及以上 -->
    <Filters>
        <ThresholdFilter onMismatch="NEUTRAL" onMatch="DENY" level="EXCEPTION"/>
        <ThresholdFilter level="BUSINESS" onMatch="ACCEPT" onMismatch="DENY" />
    </Filters>
    <!-- 指定日志输出格式 -->
    <PatternLayout pattern="${LOG_PATTERN}" />
    <!-- 新文件生成策略，每100M生成一个新文件 -->
    <Policies>
        <TimeBasedTriggeringPolicy />
        <SizeBasedTriggeringPolicy size="100 MB" />
    </Policies>
    <!-- 默认过度策略，不设置，则默认为最多同一文件夹下7个文件 大于此值会删除旧的日志文件 -->
    <DefaultRolloverStrategy>
        <!-- 文件删除策略，basePath扫描路径，maxDepth目录的最大级别数，IfFileName文件名称，   IfLastModified指定持续时间（7天前）-->
        <Delete basePath="${LOG_HOME}" maxDepth="4">
            <IfFileName glob="*/business/business-*.log.gz" />
            <IfLastModified age="${FILE_DEADLINE}" />
        </Delete>
    </DefaultRolloverStrategy>
</RollingFile>

自定义MIDDLE级别日志输出

名称：MiddleLog

存储路径：项目配置路径+ /logs/middle.log

其他内容参考以下配置

<!-- 滚动文件生成 fileName日志文件名称，filePattern压缩文件路径 -->
<RollingFile name="MiddleLog" fileName="${LOG_HOME}/logs/middle.log"
filePattern="${LOG_HOME}/logs/middle/middle-%d{MM-dd-yyyy}-%i.log.gz">
    <!-- 过滤日志级别 info及以上 -->
    <Filters>
        <ThresholdFilter onMismatch="NEUTRAL" onMatch="DENY" level="BUSINESS"/>
        <ThresholdFilter level="MIDDLE" onMatch="ACCEPT" onMismatch="DENY" />
    </Filters>
    <!-- 指定日志输出格式 -->
    <PatternLayout pattern="${LOG_PATTERN}" />
    <!-- 新文件生成策略，每100M生成一个新文件 -->
    <Policies>
        <TimeBasedTriggeringPolicy />
        <SizeBasedTriggeringPolicy size="100 MB" />
    </Policies>
    <!-- 默认过度策略，不设置，则默认为最多同一文件夹下7个文件 大于此值会删除旧的日志文件 -->
    <DefaultRolloverStrategy>
        <!-- 文件删除策略，basePath扫描路径，maxDepth目录的最大级别数，IfFileName文件名称，IfLastModified指定持续时间（7天前）-->
        <Delete basePath="${LOG_HOME}" maxDepth="4">
            <IfFileName glob="*/middle/middle-*.log.gz" />
            <IfLastModified age="${FILE_DEADLINE}" />
        </Delete>
    </DefaultRolloverStrategy>
</RollingFile>

自定义EXCEPTION级别日志输出

名称：ExceptionLog

存储路径：项目配置路径+ /logs/exception.log

其他内容参考以下配置

<!-- 滚动文件生成 fileName日志文件名称，filePattern压缩文件路径 -->
<RollingFile name="ExceptionLog" fileName="${LOG_HOME}/logs/exception.log"
filePattern="${LOG_HOME}/logs/exception/exception-%d{MM-dd-yyyy}-%i.log.gz">
    <!-- 过滤日志级别 info及以上 -->
    <Filters>
        <ThresholdFilter level="EXCEPTION" onMatch="ACCEPT" onMismatch="DENY" />
    </Filters>
    <!-- 指定日志输出格式 -->
    <PatternLayout pattern="${LOG_PATTERN}" />
    <!-- 新文件生成策略，每100M生成一个新文件 -->
    <Policies>
        <TimeBasedTriggeringPolicy />
        <SizeBasedTriggeringPolicy size="100 MB" />
    </Policies>
    <!-- 默认过度策略，不设置，则默认为最多同一文件夹下7个文件 大于此值会删除旧的日志文件 -->
    <DefaultRolloverStrategy>
        <!-- 文件删除策略，basePath扫描路径，maxDepth目录的最大级别数，IfFileName文件名称，IfLastModified指定持续时间（7天前）-->
        <Delete basePath="${LOG_HOME}" maxDepth="4">
            <IfFileName glob="*/exception/exception-*.log.gz" />
            <IfLastModified age="${FILE_DEADLINE}" />
        </Delete>
    </DefaultRolloverStrategy>
</RollingFile>

2.3    Async异步输出

<Async name="AsyncBusinessLog">
    <AppenderRef ref="BusinessLog"/>
</Async>
<Async name="AsyncExceptionLog">
    <AppenderRef ref="ExceptionLog"/>
</Async>
<Async name="AsyncMiddleLog">
    <AppenderRef ref="MiddleLog"/>
</Async>

2.4    root引入扩展日志级别

特殊说明：对项目路径中使用到的扩展日志输出进行写入到文件；如需配置到指定路径下，需要配置logger。

<loggers>
    <root level="${LOG_LEVEL}">
        <!-- 引入扩展日志级别的Appender，对项目路径中使用到的扩展日志输出进行写入到文件 -->
        <AppenderRef ref="AsyncBusinessLog"/>
        <AppenderRef ref="AsyncExceptionLog"/>
        <AppenderRef ref="AsyncMiddleLog"/>
    </root>
</loggers>

2.5    自定义统一日志类LogUtil.java

关键代码：只实现的部分日志输出的方法，可以自行扩展
 

import org.apache.logging.log4j.Level;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.Marker;
import org.apache.logging.log4j.message.Message;
import org.apache.logging.log4j.message.MessageFactory;
import org.apache.logging.log4j.spi.AbstractLogger;
import org.apache.logging.log4j.spi.ExtendedLoggerWrapper;
import org.apache.logging.log4j.util.MessageSupplier;
import org.apache.logging.log4j.util.Supplier;

public class LogUtil extends ExtendedLoggerWrapper {
    private final ExtendedLoggerWrapper logger;
    private static final String FQCN = LogUtil.class.getName();

    /**
     * 异常日志级别.
     */
    private static final Level EXCEPTION = Level.forName("EXCEPTION", 70);

    /**
     * 业务日志级别.
     */
    private static final Level BUSINESS = Level.forName("BUSINESS", 80);

    /**
     * 中间结果级别.
     */
    private static final Level MIDDLE = Level.forName("MIDDLE", 90);

    private LogUtil(final Logger logger) {
        super((AbstractLogger) logger, logger.getName(), logger.getMessageFactory());
        this.logger = this;
    }

    public static LogUtil getLogger() {
        final Logger wrapped = LogManager.getLogger();
        return new LogUtil(wrapped);
    }

    public static LogUtil getLogger(final Class<?> loggerName) {
        final Logger wrapped = LogManager.getLogger(loggerName);
        return new LogUtil(wrapped);
    }

    public static LogUtil getLogger(final Class<?> loggerName, final MessageFactory factory) {
        final Logger wrapped = LogManager.getLogger(loggerName, factory);
        return new LogUtil(wrapped);
    }

    public static LogUtil getLogger(final Object value) {
        final Logger wrapped = LogManager.getLogger(value);
        return new LogUtil(wrapped);
    }

    public static LogUtil getLogger(final Object value, final MessageFactory factory) {
        final Logger wrapped = LogManager.getLogger(value, factory);
        return new LogUtil(wrapped);
    }

    public static LogUtil getLogger(final String name) {
        final Logger wrapped = LogManager.getLogger(name);
        return new LogUtil(wrapped);
    }

    public static LogUtil getLogger(final String name, final MessageFactory factory) {
        final Logger wrapped = LogManager.getLogger(name, factory);
        return new LogUtil(wrapped);
    }

    /**自定义级别：business*/
    public void business(final Marker marker, final Message msg) {
        logger.logIfEnabled(FQCN, BUSINESS, marker, msg, (Throwable) null);
    }

    public void business(final Marker marker, final Message msg, final Throwable t) {
        logger.logIfEnabled(FQCN, BUSINESS, marker, msg, t);
    }

    public void business(final Marker marker, final Object message) {
        logger.logIfEnabled(FQCN, BUSINESS, marker, message, (Throwable) null);
    }

    /**自定义级别：exception*/
    public void exception(final Marker marker, final Message msg) {
        logger.logIfEnabled(FQCN, EXCEPTION, marker, msg, (Throwable) null);
    }

    public void exception(final Marker marker, final Message msg, final Throwable t) {
        logger.logIfEnabled(FQCN, EXCEPTION, marker, msg, t);
    }

    public void exception(final Marker marker, final Object message) {
        logger.logIfEnabled(FQCN, EXCEPTION, marker, message, (Throwable) null);
    }

    /**自定义级别：middle*/
    public void middle(final Marker marker, final Message msg) {
        logger.logIfEnabled(FQCN, MIDDLE, marker, msg, (Throwable) null);
    }

    public void middle(final Marker marker, final Message msg, final Throwable t) {
        logger.logIfEnabled(FQCN, MIDDLE, marker, msg, t);
    }

    public void middle(final Marker marker, final Object message) {
        logger.logIfEnabled(FQCN, MIDDLE, marker, message, (Throwable) null);
    }

}

特殊说明：目前参考示例扩展了3个日志级别BUSINESS/MIDDLE/EXCEPTION，对应的int值分别是80/70/90，数字越小日志级别越高

2.6    StandardLevel

org.apache.logging.log4j.spi. StandardLevel    log4j2原生的日志级别类

数字越小级别越高

    /**
     * No events will be logged.
     */
    OFF(0),
    /**
     * A severe error that will prevent the application from continuing.
     */
    FATAL(100),
    /**
     * An error in the application, possibly recoverable.
     */
    ERROR(200),
    /**
     * An event that might possible lead to an error.
     */
    WARN(300),
    /**
     * An event for informational purposes.
     */
    INFO(400),
    /**
     * A general debugging event.
     */
    DEBUG(500),
    /**
     * A fine-grained debug message, typically capturing the flow through the application.
     */
    TRACE(600),
    /**
     * All events should be logged.
     */
    ALL(Integer.MAX_VALUE);

2.7    使用说明

2.7.1 通过LogUtil创建业务类日志对象

 

private final LogUtil LOGGER = LogUtil.getLogger(TestController.class);

2.7.2 使用业务类日志对象

 

LOGGER.middle("middle");

LOGGER.business("business");

LOGGER.exception("exception");

关键代码

import com.xxx.util.LogUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@Slf4j
public class TestController {
    private final LogUtil LOGGER = LogUtil.getLogger(TestController.class);

    @GetMapping("test1")
    public Object test1() {
        LOGGER.middle("middle");
        LOGGER.business("business");   
        LOGGER.exception("exception");
        return "test1";
    }
}

2.8    日志输出样式

2020-11-22 20:07:43.000 |-BUSINESS [http-nio-9991-exec-1] com.xxx.controller.TestController [] -| business

2020-11-22 20:07:43.000 |-MIDDLE [http-nio-9991-exec-1] com.xxx.controller.TestController [] -| middle

2020-11-22 20:07:43.000 |-EXCEPTION [http-nio-9991-exec-1] com.xxx.controller.TestController [] -| exception

3.动态Appender

主要代码是start方法中的，采用log4j2的新方法，个人任务这种方式不如直接配置了

import org.apache.logging.log4j.Level;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.core.Filter;
import org.apache.logging.log4j.core.LoggerContext;
import org.apache.logging.log4j.core.appender.RollingFileAppender;
import org.apache.logging.log4j.core.appender.rolling.CompositeTriggeringPolicy;
import org.apache.logging.log4j.core.appender.rolling.DefaultRolloverStrategy;
import org.apache.logging.log4j.core.appender.rolling.SizeBasedTriggeringPolicy;
import org.apache.logging.log4j.core.appender.rolling.TimeBasedTriggeringPolicy;
import org.apache.logging.log4j.core.appender.rolling.action.*;
import org.apache.logging.log4j.core.config.AppenderRef;
import org.apache.logging.log4j.core.config.Configuration;
import org.apache.logging.log4j.core.config.LoggerConfig;
import org.apache.logging.log4j.core.filter.ThresholdFilter;
import org.apache.logging.log4j.core.layout.PatternLayout;

import java.io.File;

import static org.apache.logging.log4j.core.Filter.Result.DENY;

/**
 * 自定义日志类.
 *
 * @Author: gaoxd
 * @Date: 2020/11/10 20:09
 * @Version: 1.0
 **/
public class LogUtilTest {
    private final static Logger logger = LogManager.getLogger(LogUtilTest.class);
    public static void info (String msg) {
        logger.info(msg);
    }

    // todo:实现info的多个方法

    /**
     * 日志打印的目录
     */
    private static final String DARALOGDIR = "log" + File.separator + "logs";
    private static final LoggerContext CTX = (LoggerContext) LogManager.getContext(false);
    private static final Configuration CONFIG = CTX.getConfiguration();
    private static final String INFO = "info";
    private static final String ERROR = "error";

    private LogUtilTest() {
    }

    /**
     * 启动一个动态的logger
     */
    private static void start(String loggerName) {
        // 日志展示的样式：PatternLayout
        PatternLayout patternLayout = PatternLayout.newBuilder()
                .withConfiguration(CONFIG).withPattern("%d{yyyy-MM-dd HH:mm:ss.SSS} |-%-5level [%thread] %c [%L] -| %msg%n").build();
        // 根据时间滚动文件策略 默认interval是1 每一个时间粒度生成一个新文件，modulate默认false 不以0点为偏移
        TimeBasedTriggeringPolicy timeBasedTriggeringPolicy = TimeBasedTriggeringPolicy.newBuilder().build();
        // 根据文件大小滚动策略 每100M生成一个新文件
        SizeBasedTriggeringPolicy sizeBasedTriggeringPolicy = SizeBasedTriggeringPolicy.createPolicy("100 MB");
        // 包含其他触发策略的触发策略
        CompositeTriggeringPolicy compositeTriggeringPolicy =
                CompositeTriggeringPolicy.createPolicy(timeBasedTriggeringPolicy, sizeBasedTriggeringPolicy);
        // log文件名称
        String loggerDir = DARALOGDIR + File.separator + loggerName;
        // todo:删除日志的策略
        IfFileName ifFileName = IfFileName.createNameCondition("*/customize/customize-*.log.gz", null);
        // 日志保留7天
        IfLastModified ifLastModified = IfLastModified.createAgeCondition(Duration.parse("7d"));
        DeleteAction deleteAction = DeleteAction.createDeleteAction(
                loggerDir, false, 4, false, null,
                new PathCondition[]{ifLastModified, ifFileName}, null, CONFIG);
        Action[] actions = new Action[]{deleteAction};
        DefaultRolloverStrategy defaultRolloverStrategy =
                DefaultRolloverStrategy.newBuilder().withConfig(CONFIG).withCustomActions(actions).build();
        ThresholdFilter filter = ThresholdFilter.createFilter(Level.INFO, Filter.Result.ACCEPT, DENY);
        RollingFileAppender appender = RollingFileAppender.newBuilder()
                .setFilter(filter)
                .withFileName(loggerDir + ".log")
                // todo:
                .withFilePattern(DARALOGDIR + File.separator + loggerName + "-%d{yyyy-MM-dd}-.%i.log")
                .withAppend(true)
                .withStrategy(defaultRolloverStrategy)
                // todo:
                .setName(loggerName + INFO)
                .withPolicy(compositeTriggeringPolicy)
                .setLayout(patternLayout)
                .setConfiguration(CONFIG)
                .build();
        appender.start();
        CONFIG.addAppender(appender);
        // todo:
        AppenderRef refInfo = AppenderRef.createAppenderRef(loggerName + INFO, null, null);
        AppenderRef[] refs = new AppenderRef[]{refInfo};
        LoggerConfig loggerConfig = LoggerConfig.createLogger(false,
                Level.INFO, loggerName, "true", refs, null, CONFIG, null);
        loggerConfig.addAppender(appender, Level.INFO, null);
        CONFIG.addLogger(loggerName, loggerConfig);
        LoggerConfig rootLogger = CONFIG.getRootLogger();
        rootLogger.addAppender(appender, Level.INFO, null);
        CTX.updateLoggers();
    }

    public void stop(String loggerName) {
        synchronized (CONFIG) {
            CONFIG.getAppender(loggerName + INFO).stop();
            CONFIG.getAppender(loggerName + ERROR).stop();
            CONFIG.getLoggerConfig(loggerName).removeAppender(loggerName + INFO);
            CONFIG.getLoggerConfig(loggerName).removeAppender(loggerName + ERROR);
            CONFIG.removeLogger(loggerName);
            CTX.updateLoggers();
        }
    }

    /**
     * 获取Logger
     */
    public static Logger getCustomizeLogger(final Class<?> clazz) {
        synchronized
        (CONFIG) {
            if (!CONFIG.getLoggers().containsKey(CONFIG)) {
                start("customize");
            }
        }
        return LogManager.getLogger(clazz);
    }
}

4.扩展log4j2自定义Appender

写在这篇底部内容会很长，所以新写了一篇，请参考：

https://blog.csdn.net/gxdogjava/article/details/110749120

 

Dame Time
关注
  • 0
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java程序员修炼之道 之 Logging(2/3) - 怎么写Log
紫风乱写
08-13 3722
本文介绍了在代码中应该在什么时候需要Log什么信息；使用何种级别的Log；如何Log异常信息；Log中的一些要点。另外也分析了静态Logger变量和对象Logger变量的优劣。
Log4j2实现不同线程不同级别日志输出到不同的文件中
06-04
Log4j2实现不同线程不同级别日志输出到不同的文件中 源码+log4j jar包
log4j2 不同级别的log输出到不同的文件
weixin_34162228的博客
04-30 924
2019独角兽企业重金招聘Python工程师标准>>> ...
slf4j 日志使用
Janet的博客
10-22 1524
使用log4j
LOG4J2指定不同类型的日志输出到不同的文件
P19777的博客
11-01 4882
在项目中，可能会产生非常多的日志记录，为了方便日志分析，一般可以将日志按级别输出到指定文件,本次就先说说log4j2的实现吧。 我们配置的Appender默认情况下是可以输出任何类型的日志的，只要某个Logger引用了Appender，那么这个Logger中输出的任何日志信息都能输出到该Appender中，当前了Logger中是可以设置日志级别的，高于设置的级别才能输出，但是也不能达到我们想要的...
使用Log4j为项目配置日志输出应用详解以及示例演示的实现分析
09-05
此外，Log4j2引入了更多的改进，如异步日志记录，提高了性能，以及更高级别的配置模型。 总之，Log4j是一个强大的日志工具，能够帮助开发者有效地管理和监控应用程序的日志输出。正确配置Log4j，不仅有助于调试和...
C#实现将日志写入文本文件的方法
09-03
这个简单的日志写入方法可以作为基础，根据实际需求进行扩展，例如添加错误处理、支持多线程写入、自定义日志级别、文件大小限制等特性。通过理解和掌握这些基本概念，你可以构建出更复杂且适应性强的日志记录系统。
LOG4CPP多个日志文件
04-07
在“LOG4CPP 多个日志文件”的场景下，我们主要关注如何配置LOG4CPP以将日志输出到不同的文件，如DEBUG、NOTICE、WARNING、ERROR和CRITICAL级别分别对应不同的文件。 首先，理解LOG4CPP的基本架构至关重要。LOG4CPP...
C# 利用log4net 把日志写入到数据库
10-23
通过log4net，C#开发者可以轻松地将日志信息写入到数据库，便于后期的数据分析和问题排查。合理配置和使用log4net，不仅能提高开发效率，还能确保系统的稳定性和可靠性。在实际项目中，可以根据具体需求调整log4net...
log4j日志写入数据库实例
08-23
总之，Log4j将日志写入数据库的能力极大地扩展了日志管理的功能，使得日志数据可以用于长期存储、报表生成和复杂查询。通过调整配置和使用不同的Appender，我们可以根据具体需求定制日志处理策略，从而提升系统的可...
Log4j2 自定义appender
宇哥996的博客
12-26 2518
Log4j 2介绍: Log4j 2是Java的流行日志记录程序包,几乎每个大型应用程序都包含其自己的日志记录或跟踪API,将日志语句插入代码是调试它的低技术方法。这也可能是唯一的方法，因为调试器并不总是可用或不适用。对于多线程应用程序和整个分布式应用程序通常是这种情况。 经验表明，日志记录是开发周期的重要组成部分。它具有几个优点。它提供有关应用程序运行的精确上下文。一旦插入到代码中，就无需人工干预即可生成日志输出。此外，日志输出可以保存在永久性介质中，以便以后进行研究。除了在开发周...
log4j2 概述、配置详情、日志八种输出级别讲解
weixin_46122692的博客
10-20 1843
Log4j：专门为我们的javat程序记录日志使用的;就是jar包+配置文件 那么没有使用log4j的时候,如何打印信息呢? System.out.println(“====”); log4j2官网:http://logging.apache.org/log4j/2.x/ 文件目录介绍： 项目中部署： 配置文件log4j2.xml <?xml version="1.0" encoding="UTF-8"?> <!-- status=debug 可以查看log4j的装配过程 --&g
log4j如何定义多个日志输出文件
雪落南城的博客
10-10 832
背景 起因于一个线上问题的数据修复，需要通过批量跑大量数据，同时对数据处理结果进行记录，最快捷的方式就是直接将处理结果落到日志文件中去，然后线下统一处理； 但是，如果直接使用代码中log会把信息都落到一个日志文件中，没有办法分离； 所以，需要对数据修复的程序单独走一个日志文件； 做法 首先在log4j2.xml中定义新的appender 然后再定义新的logger 在代码中引入新的logger使用即可： private static final Logger fixLogger = LoggerFa
【log4j2】将info和error级别的日志分别输出到不同的appender中
kanbe_kotori的专栏
11-10 3006
目的：将我的应用输出的info消息放到一个info.log文件，将所有error消息输出到logs.log文件。 需要注意的是，info消息是限制在我自己的应用下的，也就是其他框架输出的info不保存。 <?xml version="1.0" encoding="UTF-8"?> <Configuration> <Properties> ...
loguru将不同级别的日志分别写入不同文件
最新发布
qq_25894535的博客
03-30 1129
loguru不同级别日志分文件写入
SpringBoot之Slf4j日志实现根据业务不同将日志写进不同的文件
gcglhd的博客
02-25 4096
背景： 最近遇到一个工作业务需求：简单地将就是一个服务里面包含HTTP的入口服务，还包含TCP入口服务，这个时候正常情况下，我们使用@Slf4j的日志方式，会自动的将所有的日志写进一个文件，因为@Slf4j默认是按照系统日志进行写入， 这个时候就增加了我们后期的排查工作，因为如果出问题，或者有需求将所有的TCP入口的日志全部拉取出来这个时候，就会很麻烦，根据这个需求，我们采用Slf4可自定义的特性进行相关的配置，具体的配置使用如下： 1. 首先就是要写一个logback.xml...
log4j2自定义appender插件源码、配置及采坑说明
三生三石光润木子
12-06 4115
本篇为扩展appender标签，如果需要扩展filer、marker等其他的log4j2提供的扩展方式，可以查看相关的文档： 中文文档：https://www.docs4dev.com/docs/zh/log4j2/2.x/all/javadoc.html 英文文档：http://logging.apache.org/log4j/2.x/ api：http://logging.apache.org/log4j/2.x/log4j-api/apidocs/index.html 通过本篇，你可以看到我在扩展插件
Springboot学习：整合log4j2打印System.out日志
谦竹墨客
09-08 2503
Springboot整合log4j2打印System.out日志 记一次开发踩坑，springboot整合log4j2的过程中，try catch 捕获异常后，Exception.printStackTrace()方法却没有将错误日志打印到日志文件中，通过阅读源码发现，printStackTrace使用的是System.err进行日志打印，所以采用下面的办法进行处理，自定义PrintStream 1、继承PrintStream父类，并重写print这一类方法，使用log输出。 public class Lo
java log4j扩展_log4j2动态修改日志级别及拓展性使用详解
weixin_35690449的博客
02-24 922
一、供参考的完整日志配置${sys:vmparam}${basePath}/app.logfilePattern="logs/$${date:yyyy-MM}/app-%d{yyyy-MM-dd-HH}-%i.log.gz">二、动态修改日志级别Collection current = LoggerContext.getContext(false).getLoggers();Collecti...
Log4j详解：强大的日志管理工具与配置
Log4j的强大之处在于它的配置能力，允许通过XML或Java属性文件来配置logging策略，从而实现统一的日志管理，减少了代码中的硬编码，提高了代码的可维护性和扩展性。在大型项目或企业级应用中，Log4j能够提高开发效率...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值