使用log4j MDC实现日志追踪

import java.io.Serializable;

import java.util.HashMap;

import java.util.Map;

import java.util.Optional;

/**

  * 线程上下文

  *

  * @date 2017年3月1日

  * @since 1.0.0

  */

public class ThreadContext {

     /**

      * 线程上下文变量的持有者

      */

     private final static ThreadLocal<Map<String, Object>> CTX_HOLDER = new ThreadLocal<Map<String, Object>>();

     static {

         CTX_HOLDER.set( new HashMap<String, Object>());

     }

     /**

      * traceID

      */

     private final static String TRACE_ID_KEY = "traceId" ;

     /**

      * 会话ID

      */

     private final static String SESSION_KEY = "token" ;

     /**

      * 操作用户ID

      */

     private final static String VISITOR_ID_KEY = "userId" ;

     /**

      * 操作用户名

      */

     private final static String VISITOR_NAME_KEY = "userName" ;

     /**

      * 客户端IP

      */

     private static final String CLIENT_IP_KEY = "clientIp" ;

     /**

      * 添加内容到线程上下文中

      *

      * @param key

      * @param value

      */

     public final static void putContext(String key, Object value) {

         Map<String, Object> ctx = CTX_HOLDER.get();

         if (ctx == null ) {

             return ;

         }

         ctx.put(key, value);

     }

     /**

      * 从线程上下文中获取内容

      *

      * @param key

      */

     @SuppressWarnings ( "unchecked" )

     public final static <T extends Object> T getContext(String key) {

         Map<String, Object> ctx = CTX_HOLDER.get();

         if (ctx == null ) {

             return null ;

         }

         return (T) ctx.get(key);

     }

     /**

      * 获取线程上下文

      */

     public final static Map<String, Object> getContext() {

         Map<String, Object> ctx = CTX_HOLDER.get();

         if (ctx == null ) {

             return null ;

         }

         return ctx;

     }

     /**

      * 删除上下文中的key

      *

      * @param key

      */

     public final static void remove(String key) {

         Map<String, Object> ctx = CTX_HOLDER.get();

         if (ctx != null ) {

             ctx.remove(key);

         }

     }

     /**

      * 上下文中是否包含此key

      *

      * @param key

      * @return

      */

     public final static boolean contains(String key) {

         Map<String, Object> ctx = CTX_HOLDER.get();

         if (ctx != null ) {

             return ctx.containsKey(key);

         }

         return false ;

     }

     /**

      * 清空线程上下文

      */

     public final static void clean() {

         CTX_HOLDER.remove();

     }

     /**

      * 初始化线程上下文

      */

     public final static void init() {

         CTX_HOLDER.set( new HashMap<String, Object>());

     }

     /**

      * 设置traceID数据

      */

     public final static void putTraceId(String traceId) {

         putContext(TRACE_ID_KEY, traceId);

     }

     /**

      * 获取traceID数据

      */

     public final static String getTraceId() {

         return getContext(TRACE_ID_KEY);

     }

     /**

      * 设置会话的用户ID

      */

     public final static void putUserId(Integer userId) {

         putContext(VISITOR_ID_KEY, userId);

     }

     /**

      * 设置会话的用户ID

      */

     public final static int getUserId() {

         Integer val = getContext(VISITOR_ID_KEY);

         return val == null ? 0 : val;

     }

     /**

      * 设置会话的用户名

      */

     public final static void putUserName(String userName) {

         putContext(VISITOR_NAME_KEY, userName);

     }

     /**

      * 获取会话的用户名称

      */

     public final static String getUserName() {

         return Optional.ofNullable(getContext(VISITOR_NAME_KEY))

                 .map(name -> String.valueOf(name))

                 .orElse( "" );

     }

     /**

      * 取出IP

      *

      * @return

      */

     public static final String getClientIp() {

         return getContext(CLIENT_IP_KEY);

     }

     /**

      * 设置IP

      *

      * @param ip

      */

     public static final void putClientIp(String ip) {

         putContext(CLIENT_IP_KEY, ip);

     }

     /**

      * 设置会话ID

      *

      * @param token

      */

     public static void putSessionId(String token) {

         putContext(SESSION_KEY, token);

     }

     /**

      * 获取会话ID

      *

      * @param token

      */

     public static String getSessionId(String token) {

         return getContext(SESSION_KEY);

     }

     /**

      * 清空会话数据

      */

     public final static void removeSessionId() {

         remove(SESSION_KEY);

     }

}

import java.util.UUID;

import org.slf4j.MDC;

import ThreadContext;

/**

  * trace工具

  *

  * @date 2017年3月10日

  * @since 1.0.0

  */

public class TraceUtil {

     public static void traceStart() {

         ThreadContext.init();

         String traceId = generateTraceId();

         MDC.put( 'traceId' , traceId);

         ThreadContext.putTraceId(traceId);

     }

     public static void traceEnd() {

         MDC.clear();

         ThreadContext.clean();

     }

     /**

      * 生成跟踪ID

      *

      * @return

      */

     private static String generateTraceId() {

         return UUID.randomUUID().toString();

     }

}

import java.io.IOException;

import javax.servlet.FilterChain;

import javax.servlet.ServletException;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import org.springframework.core.Ordered;

import org.springframework.core.annotation.Order;

import org.springframework.web.filter.OncePerRequestFilter;

import com.pingan.manpan测试数据mon.util.TraceUtil;

import com.pingan.manpan.user.dto.ThreadContext;

import com.pingan.manpan.web测试数据mon.surpport.IpUtils;

/**

  * 上下文Filter

  *

  * @date 2017/3/10

  * @since 1.0.0

  */

//@Order 标记组件的加载顺序

@Order (Ordered.HIGHEST_PRECEDENCE)

public class ContextFilter extends OncePerRequestFilter {

     @Override

     protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response,

                                     FilterChain filterChain) throws ServletException, IOException {

         try {

             ThreadContext.putClientIp(IpUtils.getClientIp(request));

             TraceUtil.traceStart();

             filterChain.doFilter(request, response);

         } finally {

             TraceUtil.traceEnd();

         }

     }

}

/**

  * 请求上下文,应该在最外层

  *

  * @return

  */

@Bean

public FilterRegistrationBean requestContextRepositoryFilterRegistrationBean() {

     FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean();

     filterRegistrationBean.setFilter( new ContextFilter());

     filterRegistrationBean.addUrlPatterns( "/*" );

     return filterRegistrationBean;

}

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

< configuration >

     < jmxConfigurator />

     < property name = "LOG_LEVEL_PATTERN" value = "%X{traceId:-} %5p" />

     < property name = "LOG_FILE" value = "${LOG_PATH}/web.logx" />

     < property name = "LOG_FILE_SUFFIX" value = ".logx" />

     < include resource = "org/springframework/boot/logging/logback/defaults.xml" />

     < include resource = "org/springframework/boot/logging/logback/console-appender.xml" />

     < appender name = "FILE"

               class = "ch.qos.logback.core.rolling.RollingFileAppender" >

         < encoder >

             < pattern >${FILE_LOG_PATTERN}</ pattern >

         </ encoder >

         < file >${LOG_FILE}${LOG_FILE_SUFFIX}</ file >

         < rollingPolicy class = "ch.qos.logback.core.rolling.TimeBasedRollingPolicy" >

             < fileNamePattern >${LOG_FILE}.%d{yyyy-MM-dd}${LOG_FILE_SUFFIX}</ fileNamePattern >

         </ rollingPolicy >

     </ appender >

     < appender name = "SYSLOG" class = "ch.qos.logback.classic.net.SyslogAppender" >

         < syslogHost >127.0.0.1</ syslogHost >

         < facility >local6</ facility >

         < port >514</ port >

         < suffixPattern >${FILE_LOG_PATTERN}</ suffixPattern >

     </ appender >

     < logger name = "druid.sql" level = "DEBUG" />

     < root level = "INFO" >

         < appender-ref ref = "CONSOLE" />

         < appender-ref ref = "FILE" />

         < appender-ref ref = "SYSLOG" />

     </ root >

</ configuration >

Access-Control-Allow-Credentials: true

Access-Control-Allow-Origin: http: //test.page.qingin.cn

Cache-Control: max-age= 30

Connection: keep-alive

Content-Type: application/json;charset=UTF- 8

Date: Tue, 11 Aug 2020 12 : 02 : 19 GMT

Expires: Tue, 11 Aug 2020 12 : 02 : 49 GMT

Server: nginx/ 1.16 . 1

traceID: c6019df137174d2b98631474db4156b7

Transfer-Encoding: chunked

Vary: Origin

Vary: Access-Control-Request-Method

Vary: Access-Control-Request-Headers

package com.generator.admin.filter;

import org.apache.logging.log4j.ThreadContext;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import javax.servlet.*;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import java.io.IOException;

import java.util.UUID;

/**

  * @calssName Log4j2Filter

  * @Description 对用户的请求添加日志编号,并将此编号返回给前端，便于日志查询

  */

@WebFilter (filterName = "Log4j2Filter" , urlPatterns = "/*" , initParams = { @WebInitParam (name = "DESCRIPTION" , value = "这是Log4j2Filter过滤器" )})

public class Log4j2Filter implements Filter {

     private String description;

     public static final String TRACE_ID = "traceID" ;

     private static final Logger logger = LoggerFactory.getLogger(Log4j2Filter. class );

     @Override

     public void init(FilterConfig filterConfig) throws ServletException {

         description = filterConfig.getInitParameter( "DESCRIPTION" );

         System.out.println( "过滤器初始化:" + description);

     }

     @Override

     public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain)

             throws IOException,ServletException {

         HttpServletRequest req = (HttpServletRequest) servletRequest;

         HttpServletResponse resp = (HttpServletResponse) servletResponse;

         // 生成一个随机数给到前端

         String traceId = UUID.randomUUID().toString().replace( "-" , "" );

         // 随机数放到此线程的上下文中，可以在每条日志前加入。具体看下面log4j2.xml

         ThreadContext.put(TRACE_ID, traceId);

         // 随机数放到Header中，在Response Headers中可查看到此数据

         resp.addHeader(TRACE_ID, traceId); 

         filterChain.doFilter(req, resp);

         ThreadContext.clearAll();

     }

     @Override

     public void destroy() {

         System.out.println( "过滤器，被销毁：" + description);

     }

}

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

<!--设置log4j2的自身log级别为warn-->

<!--日志级别以及优先级排序: OFF > FATAL > ERROR > WARN > INFO > DEBUG > TRACE > ALL -->

<!--Configuration后面的status，这个用于设置log4j2自身内部的信息输出，可以不设置,当设置成trace时，你会看到log4j2内部各种详细输出-->

<!--monitorInterval：Log4j能够自动检测修改配置 文件和重新配置本身，设置间隔秒数-->

< configuration status = "warn" monitorInterval = "30" >

     <!--全局参数-->

     < Properties >

         < Property name = "logPath" >logs</ Property >

     </ Properties >

     <!--先定义所有的appender-->

     < appenders >

         <!--这个输出控制台的配置-->

         < console name = "Console" target = "SYSTEM_OUT" >

             <!-- traceID:就是在过滤器中生成的随机数 -->

             < PatternLayout pattern = "[traceID:%X{traceID}]-[%d{yyyy-MM-dd HH:mm:ss:SSS}]-[%t]-[%p]-[%l]-%m%n" />

         </ console >

     </ appenders >

     <!--然后定义logger，只有定义了logger并引入的appender，appender才会生效-->

     < loggers >

         <!--过滤掉spring和mybatis的一些无用的debug信息-->

         < logger name = "org.springframework" level = "INFO" ></ logger >

         < logger name = "org.mybatis" level = "INFO" ></ logger >

         < logger name = "com.zaxxer" level = "WARN" ></ logger >

         <!-- com.generator开发/测试环境用DEBUG,并用控制台输出即可 -->

         < logger name = "com.generator" level = "DEBUG" additivity = "false" >

             < appender-ref ref = "Console" />

         </ logger >

         <!-- 未指定的包都按此 level 打印日志 -->

         < root level = "DEBUG" >

             < appender-ref ref = "Console" />

         </ root >

     </ loggers >

</ configuration >