大家好，又见面了，我是你们的朋友全栈君。

logback自定义日志格式

1.ClassicConverter

继承ClassicConverter

package com.demo.conf;
 
import ch.qos.logback.classic.pattern.ClassicConverter;
import ch.qos.logback.classic.spi.ILoggingEvent;
 
import java.net.InetAddress;
import java.net.UnknownHostException;
 
/** * 配置日志中显示IP */
public class IPLogConfig extends ClassicConverter { 
   
    @Override
    public String convert(ILoggingEvent event) { 
   
        try { 
   
            return InetAddress.getLocalHost().getHostAddress();
        } catch (UnknownHostException e) { 
   
            e.printStackTrace();
        }
        return null;
    }
}

然后再logback.xml中配置

<!--配置规则类的位置-->
<conversionRule conversionWord="ip" converterClass="com.demo.conf.IPLogConfig" />
 <appender name="Console" class="ch.qos.logback.core.ConsoleAppender">
        <layout>
            <pattern>%ip -%date{HH:mm:ss} %highlight(%-5level)[%yellow(%thread)]%green(%logger{56}.%method:%L) -%msg%n"</pattern>
        </layout>
    </appender>

2.实现PropertyDefiner

logback提供自定义属性接口PropertyDefiner

实现PropertyDefiner：getPropertyValue()方法

public class GetIpProperty implements PropertyDefiner{ 
   
    @override
    public String getPropertyValue() { 
   
        try { 
   
                InetAddress address = InetAddress.getLocalHost();
                return address.getHostAddress();
 
          } catch (UnknownHostException e) { 
   
              e.printStackTrace();
          }   
               return null;
      }
   	//....
}

然后在logback.xml配置文件中，定义自定义标签define name代表标签，class指向处理的类。在初始化时调用getPropertyValue()

<configuration>
	<define name="ip" class="com.lay.config.log.GetIpProperty"></define>
    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
    	<encode>
        	<parttern>${ip}-%date{HH:mm:ss} %highlight(%-5level)[%yellow(%thread)]%green(%logger{56}.%method:%L) -%msg%n"</parttern>
        </encode>
    </appender>
</configuration>

3.SLF4JMDC

Logback是在logback-classic模块中实现了SLF4J的MDC功能。

MDC中管理的数据（简称MDC数据）是以单个线程为单位进行访问的，即对MDC数据的操作（如put, get）只对当前线程有效，所以也永远是线程安全的。
在服务端，为每个请求分配一个线程进行处理，所以每个服务端线程处理的请求，都具有唯一的MDC上下文数据。

子线程不会自动继承父线程的MDC数据。所以在创建子线程时，可以先调用MDC的getCopyOfContextMap()方法以返回一个Map<String, String>对象，从而获取父线程的MDC数据，然后再在子线程的开始处，最先调用MDC的setContextMap()方法为子线程设置父线程的MDC数据。从而能够在子线程中访问父线程的MDC数据。

在使用java.util.concurrent.Executors管理线程时，使用同样的方法让子线程继承主线程的MDC数据。

但是，在Web应用中，一个请求可能在不同的阶段被多个线程处理。这时，只是在服务端的处理线程中设置MDC数据，并不能保证请求的某些信息（如用户的认证信息等）总是能够被处理线程访问到。为了在处理一个请求时能够保证某些信息总是可访问，建议使用Servlet Filter，在请求到来时就将信息装入到MDC中，在完成所有的后续处理后，再次通过过滤器时将MDC数据移除。

	public class MyFilter implements Filter { 
   
		public void doFilter(ServletRequest request, ServletResponse response,
			FilterChain chain) throws IOException, ServletException { 
   
			...
			MDC.put(MY_KEY, myValue);
			...
		    try { 
   
			  chain.doFilter(request, response);
			} finally { 
   
			  if (MDC.contains(MY_KEY)) { 
   
				MDC.remove(MY_KEY);
			  }
			}

Logback自带的ch.qos.logback.classic.helpers.MDCInsertingServletFilter能够将HTTP请求的hostname, request URI, user-agent等信息装入MDC，只需在web.xml中设置（建议MDCInsertingServletFilter作为第一个Filter配置，原因请读者思考），后续处理过程就可以直接访问如下请求参数的值：

req.remoteHost
req.xForwardedFor
req.method
req.requestURI
req.requestURL
req.queryString

req.userAgent

源码如下

package com.lay.log.core.filter;

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

import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;
import java.net.InetAddress;
import java.net.UnknownHostException;

/** * @Description: * @Author: lay * @Date: Created in 11:22 2019/3/19 * @Modified By:IntelliJ IDEA */
public class LogFilter implements Filter { 
   
    private static final Logger log = LoggerFactory.getLogger(LogFilter.class);


    @Override
    public void init(FilterConfig filterConfig) { 
   

    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException { 
   
        log.info("start log filter");
        this.insertIntoMDC(request);
        log.info("log filter....");
        try { 
   
            chain.doFilter(request, response);
        } finally { 
   
            log.info("log filter....");
            this.clearMDC();
            log.info("end log filter");
        }

    }

    void insertIntoMDC(ServletRequest request) { 
   
        MDC.put("req.remoteHost", request.getRemoteHost());
        if (request instanceof HttpServletRequest) { 
   
            HttpServletRequest httpServletRequest = (HttpServletRequest) request;
            MDC.put("req.requestURI", httpServletRequest.getRequestURI());
            StringBuffer requestURL = httpServletRequest.getRequestURL();
            if (requestURL != null) { 
   
                MDC.put("req.requestURL", requestURL.toString());
            }
            String requestNo = httpServletRequest.getHeader("Request-No");
            if (requestNo != null && !requestNo.equals("")) { 
   
                MDC.put("req.requestNo", requestNo);
            }
            MDC.put("req.method", httpServletRequest.getMethod());
            MDC.put("req.queryString", httpServletRequest.getQueryString());
            MDC.put("req.userAgent", httpServletRequest.getHeader("User-Agent"));
            MDC.put("req.xForwardedFor", httpServletRequest.getHeader("X-Forwarded-For"));
            MDC.put("req.hostIp", getHostIp());
        }
    }

    void clearMDC() { 
   
        MDC.remove("req.remoteHost");
        MDC.remove("req.requestURI");
        MDC.remove("req.queryString");
        MDC.remove("req.requestURL");
        MDC.remove("req.method");
        MDC.remove("req.userAgent");
        MDC.remove("req.xForwardedFor");
        MDC.remove("req.requestNo");
        MDC.remove("req.ho stIp");
    }

    @Override
    public void destroy() { 
   

    }

    public String getHostIp() { 
   
        try { 
   
            InetAddress address = InetAddress.getLocalHost();
            return address.getHostAddress();

        } catch (UnknownHostException e) { 
   
            e.printStackTrace();
        }
        return null;
    }
}

配置

@Component
public class ApplicationConfig { 
   
    @Bean
    public FilterRegistrationBean filterRegistrationBean() { 
   
        FilterRegistrationBean registrationBean = new FilterRegistrationBean();
        Filter actionFilter = new MDCInsertingServletFilter();
        registrationBean.setFilter(actionFilter);
        List<String> urlPatterns = new ArrayList<>();
        urlPatterns.add("/*");
        registrationBean.setUrlPatterns(urlPatterns);
        return registrationBean;
    }
}

使用

<configuration>
    <!-- 彩色日志 -->
    <!-- 彩色日志依赖的渲染类 -->
    <conversionRule conversionWord="clr" converterClass="org.springframework.boot.logging.logback.ColorConverter"/>
    <conversionRule conversionWord="wex" converterClass="org.springframework.boot.logging.logback.WhitespaceThrowableProxyConverter"/>
    <conversionRule conversionWord="wEx" converterClass="org.springframework.boot.logging.logback.ExtendedWhitespaceThrowableProxyConverter"/>
    <!-- 彩色日志格式 -->
    <property name="CONSOLE_LOG_PATTERN" value="${CONSOLE_LOG_PATTERN:-%clr(%d{yyyy-MM-dd HH:mm:ss.SSS}){faint} %clr(${LOG_LEVEL_PATTERN:-%5p}) %clr(${PID:- }){magenta} %clr(--){faint} %clr([%15.15t]){faint} %clr(%-40.40logger{39}){cyan} %clr(:){faint} %m%n${LOG_EXCEPTION_CONVERSION_WORD:-%wEx}}"/>/>



    <property name="MDC_LOG_PATTERN" value="IP:%X{req.remoteHost} -url:%X{req.requestURI} -Method:%X{req.method} - QueryString:%X{req.queryString} - device:%X{req.userAgent} -ips:%X{req.xForwardedFor} - %m%n "></property>

    <appender name="Console" class="ch.qos.logback.core.ConsoleAppender">
        <layout>
            <pattern>${MDC_LOG_PATTERN}</pattern>
        </layout>
    </appender>


    <root level="INFO">
        <appender-ref ref="Console"/>
        <!--<appender-ref ref="Sentry"/>-->
    </root>
</configuration>

可以看到 MDC_LOG_PATTERN 中获取了从MDC过滤器中的参数，这样我们就能打印出来了