log4j2 日志脱敏/特殊处理

深碍√TFBOYSˉ_ 2022-03-19 02:44 1093阅读 0赞

#### 一、最简单方式 ####

> 如果你对日志进行特殊处理的需求，可以只通过一个正则表达式完成，那么使用原生方式

> 如果满足不了，那么看下面

#### 二、先看下slf4j+log4j2的主要流程 ####

slf4j-api --> slf4j-log4j-impl --> log4j-api
    
    流程：比如 log.info
    AbstractLogger --> messageFactory.newMessage() --> ParameterizedMessage/SimpleMessage/ObjectMessage --> push (LogEvent)    这里具体使用的是 disruptor 发布事件
      
    --> 异步接收到监听事件
    listen event --> LogEvent --> PatternLayout 
    --> toSerializable() { 
    	format (根据%m%n等配置的各种layout，对应有各种Convert，经过各种Convert之后，得到最终打印内容) 
    	其中%m 是日志主体内容，对应的Convert为 MessagePatternConverter --> format() 获取message --> formateTo() 
    }

#### 三、处理思路 ####

通过观察上面的流程，我们可以再其中几个点做修改：

##### 1. 发送日志阶段 #####

AbstractLogger --> 【messageFactory.newMessage() --> ParameterizedMessage/SimpleMessage/ObjectMessage】 --> push (LogEvent)

也就是重写一个新的工厂`messageFactory`，重写新的`ParameterizedMessage/SimpleMessage/ObjectMessage`，在日志输出时进行特殊处理，比如脱敏

ParameterizedMessage : 带参数的日志，比如 log.info("hello {}", "world");
    SimpleMessage : 即直接打印的日志，比如 log.info("hello, world");
    ObjectMessage ：即直接打印对应的日志，比如 log.info(user);

##### 2. 接收监听阶段 #####

--> 异步接收到监听事件
    listen event --> LogEvent --> PatternLayout 
    --> toSerializable() { 
    	format (根据%m%n等配置的各种layout，对应有各种Convert，经过各种Convert之后，得到最终打印内容) 
    	其中%m 是日志主体内容，对应的Convert为 MessagePatternConverter --> format() 获取message --> formateTo() 
    }

也就是format() 方法里面处理，这里需要自定义一个PatternLayout，重写format方法

处理方式有两种

1.  自定义Layout，直接在format方法里面脱敏/处理
2.  自定义Convert，默认解析 %m 的Convert 为MessagePatternConverter，我们可以自定义一个转化器，比如解析%customMessage，然后再里面进行特殊处理

> 以上共三种方式可以对输出日志进行特殊处理。

#### 四、处理方式一：自定义messageFactory ####

> 版本基于log4j2 2.9.0，其他版本变动未测试

1、在classpath路径下，比如src/main/resources下，新建一个文件，文件名为`log4j2.component.properties`，内容为：

log4j2.messageFactory=cn.saytime.entity.log4j2.CustomParameterizedMessageFactory

2、`CustomParameterizedMessageFactory`

package cn.saytime.entity.log4j2;
    
    import org.apache.logging.log4j.message.AbstractMessageFactory;
    import org.apache.logging.log4j.message.Message;
    import org.apache.logging.log4j.message.MessageFactory;
    import org.apache.logging.log4j.message.ParameterizedMessageFactory;
    
    /** * @description: 自定义log4j2参数化消息工厂 * @date: 2019-01-07 19:42 **/
    public class CustomParameterizedMessageFactory extends AbstractMessageFactory { 
    
        /** * Instance of ParameterizedMessageFactory. */
        public static final ParameterizedMessageFactory INSTANCE = new ParameterizedMessageFactory();
    
        private static final long serialVersionUID = -8970940216592525651L;
    
        /** * Constructs a message factory. */
        public CustomParameterizedMessageFactory() { 
            super();
        }
    
        /** * Creates {@link CustomParameterizedMessage} instances. * * @param message The message pattern. * @param params The message parameters. * @return The Message. * * @see MessageFactory#newMessage(String, Object...) */
        @Override
        public Message newMessage(final String message, final Object... params) { 
            return new CustomParameterizedMessage(message, params);
        }
    
        /** * @since 2.6.1 */
        @Override
        public Message newMessage(final String message, final Object p0) { 
            return new CustomParameterizedMessage(message, p0);
        }
    
        /** * @since 2.6.1 */
        @Override
        public Message newMessage(final String message, final Object p0, final Object p1) { 
            return new CustomParameterizedMessage(message, p0, p1);
        }
    
        /** * @since 2.6.1 */
        @Override
        public Message newMessage(final String message, final Object p0, final Object p1, final Object p2) { 
            return new CustomParameterizedMessage(message, p0, p1, p2);
        }
    
        /** * @since 2.6.1 */
        @Override
        public Message newMessage(final String message, final Object p0, final Object p1, final Object p2, final Object p3) { 
            return new CustomParameterizedMessage(message, p0, p1, p2, p3);
        }
    
        /** * @since 2.6.1 */
        @Override
        public Message newMessage(final String message, final Object p0, final Object p1, final Object p2, final Object p3, final Object p4) { 
            return new CustomParameterizedMessage(message, p0, p1, p2, p3, p4);
        }
    
        /** * @since 2.6.1 */
        @Override
        public Message newMessage(final String message, final Object p0, final Object p1, final Object p2, final Object p3, final Object p4, final Object p5) { 
            return new CustomParameterizedMessage(message, p0, p1, p2, p3, p4, p5);
        }
    
        /** * @since 2.6.1 */
        @Override
        public Message newMessage(final String message, final Object p0, final Object p1, final Object p2, final Object p3, final Object p4, final Object p5,
                                  final Object p6) { 
            return new CustomParameterizedMessage(message, p0, p1, p2, p3, p4, p5, p6);
        }
    
        /** * @since 2.6.1 */
        @Override
        public Message newMessage(final String message, final Object p0, final Object p1, final Object p2, final Object p3, final Object p4, final Object p5,
                                  final Object p6, final Object p7) { 
            return new CustomParameterizedMessage(message, p0, p1, p2, p3, p4, p5, p6, p7);
        }
    
        /** * @since 2.6.1 */
        @Override
        public Message newMessage(final String message, final Object p0, final Object p1, final Object p2, final Object p3, final Object p4, final Object p5,
                                  final Object p6, final Object p7, final Object p8) { 
            return new CustomParameterizedMessage(message, p0, p1, p2, p3, p4, p5, p6, p7, p8);
        }
    
        /** * @since 2.6.1 */
        @Override
        public Message newMessage(final String message, final Object p0, final Object p1, final Object p2, final Object p3, final Object p4, final Object p5,
                                  final Object p6, final Object p7, final Object p8, final Object p9) { 
            return new CustomParameterizedMessage(message, p0, p1, p2, p3, p4, p5, p6, p7, p8, p9);
        }
    }

3、`CustomParameterizedMessage`

其实就是复制原先的`ParameterizedMessage`以及`ParameterFormatter`，然后修改`formatTo()`，在里面进行特殊处理

package cn.saytime.entity.log4j2;
 
 import org.apache.logging.log4j.message.Message;
 import org.apache.logging.log4j.util.Constants;
 import org.apache.logging.log4j.util.StringBuilderFormattable;
 import org.apache.logging.log4j.util.StringBuilders;
 
 import java.text.SimpleDateFormat;
 import java.util.*;
 
 /** * @description: 自定义log4j2 参数化消息 * @author: hao_zhang2 * @date: 2019-01-07 19:43 **/
 public class CustomParameterizedMessage implements Message, StringBuilderFormattable { 
 
 // Should this be configurable?
 private static final int DEFAULT_STRING_BUILDER_SIZE = 255;
 
 /** * Prefix for recursion. */
 public static final String RECURSION_PREFIX = ParameterFormatter.RECURSION_PREFIX;
 /** * Suffix for recursion. */
 public static final String RECURSION_SUFFIX = ParameterFormatter.RECURSION_SUFFIX;
 
 /** * Prefix for errors. */
 public static final String ERROR_PREFIX = ParameterFormatter.ERROR_PREFIX;
 
 /** * Separator for errors. */
 public static final String ERROR_SEPARATOR = ParameterFormatter.ERROR_SEPARATOR;
 
 /** * Separator for error messages. */
 public static final String ERROR_MSG_SEPARATOR = ParameterFormatter.ERROR_MSG_SEPARATOR;
 
 /** * Suffix for errors. */
 public static final String ERROR_SUFFIX = ParameterFormatter.ERROR_SUFFIX;
 
 private static final long serialVersionUID = -665975803997290697L;
 
 private static final int HASHVAL = 31;
 
 // storing JDK classes in ThreadLocals does not cause memory leaks in web apps, so this is okay
 private static ThreadLocal<StringBuilder> threadLocalStringBuilder = new ThreadLocal<>();
 
 private String messagePattern;
 private transient Object[] argArray;
 
 private String formattedMessage;
 private transient Throwable throwable;
 private int[] indices;
 private int usedCount;
 
 @Deprecated
 public CustomParameterizedMessage(final String messagePattern, final String[] arguments, final Throwable throwable) { 
 this.argArray = arguments;
 this.throwable = throwable;
 init(messagePattern);
 }
 
 public CustomParameterizedMessage(final String messagePattern, final Object[] arguments, final Throwable throwable) { 
 this.argArray = arguments;
 this.throwable = throwable;
 init(messagePattern);
 }
 
 public CustomParameterizedMessage(final String messagePattern, final Object... arguments) { 
 this.argArray = arguments;
 init(messagePattern);
 }
 
 public CustomParameterizedMessage(final String messagePattern, final Object arg) { 
 this(messagePattern, new Object[]{ arg});
 }
 
 public CustomParameterizedMessage(final String messagePattern, final Object arg0, final Object arg1) { 
 this(messagePattern, new Object[]{ arg0, arg1});
 }
 
 private void init(final String messagePattern) { 
 this.messagePattern = messagePattern;
 final int len = Math.max(1, messagePattern == null ? 0 : messagePattern.length() >> 1); // divide by 2
 this.indices = new int[len]; // LOG4J2-1542 ensure non-zero array length
 final int placeholders = ParameterFormatter.countArgumentPlaceholders2(messagePattern, indices);
 initThrowable(argArray, placeholders);
 this.usedCount = Math.min(placeholders, argArray == null ? 0 : argArray.length);
 }
 
 private void initThrowable(final Object[] params, final int usedParams) { 
 if (params != null) { 
 final int argCount = params.length;
 if (usedParams < argCount && this.throwable == null && params[argCount - 1] instanceof Throwable) { 
 this.throwable = (Throwable) params[argCount - 1];
 }
 }
 }
 
 @Override
 public String getFormat() { 
 return messagePattern;
 }
 
 @Override
 public Object[] getParameters() { 
 return argArray;
 }
 
 @Override
 public Throwable getThrowable() { 
 return throwable;
 }
 
 @Override
 public String getFormattedMessage() { 
 if (formattedMessage == null) { 
 final StringBuilder buffer = getThreadLocalStringBuilder();
 formatTo(buffer);
 formattedMessage = buffer.toString();
 StringBuilders.trimToMaxSize(buffer, Constants.MAX_REUSABLE_MESSAGE_SIZE);
 }
 return formattedMessage;
 }
 
 private static StringBuilder getThreadLocalStringBuilder() { 
 StringBuilder buffer = threadLocalStringBuilder.get();
 if (buffer == null) { 
 buffer = new StringBuilder(DEFAULT_STRING_BUILDER_SIZE);
 threadLocalStringBuilder.set(buffer);
 }
 buffer.setLength(0);
 return buffer;
 }
 
 @Override
 public void formatTo(final StringBuilder buffer) { 
 if (formattedMessage != null) { 
 buffer.append(formattedMessage);
 } else { 
 if (indices[0] < 0) { 
 ParameterFormatter.formatMessage(buffer, messagePattern, argArray, usedCount);
 } else { 
 ParameterFormatter.formatMessage2(buffer, messagePattern, argArray, usedCount, indices);
 }
 // 此处进行特殊处理
 }
 }
 
 public static String format(final String messagePattern, final Object[] arguments) { 
 return ParameterFormatter.format(messagePattern, arguments);
 }
 
 @Override
 public boolean equals(final Object o) { 
 if (this == o) { 
 return true;
 }
 if (o == null || getClass() != o.getClass()) { 
 return false;
 }
 
 final CustomParameterizedMessage that = (CustomParameterizedMessage) o;
 
 if (messagePattern != null ? !messagePattern.equals(that.messagePattern) : that.messagePattern != null) { 
 return false;
 }
 if (!Arrays.equals(this.argArray, that.argArray)) { 
 return false;
 }
 //if (throwable != null ? !throwable.equals(that.throwable) : that.throwable != null) return false;
 
 return true;
 }
 
 @Override
 public int hashCode() { 
 int result = messagePattern != null ? messagePattern.hashCode() : 0;
 result = HASHVAL * result + (argArray != null ? Arrays.hashCode(argArray) : 0);
 return result;
 }
 
 public static int countArgumentPlaceholders(final String messagePattern) { 
 return ParameterFormatter.countArgumentPlaceholders(messagePattern);
 }
 
 public static String deepToString(final Object o) { 
 return ParameterFormatter.deepToString(o);
 }
 
 public static String identityToString(final Object obj) { 
 return ParameterFormatter.identityToString(obj);
 }
 
 @Override
 public String toString() { 
 return "CustomCustomParameterizedMessage[messagePattern=" + messagePattern + ", stringArgs=" +
 Arrays.toString(argArray) + ", throwable=" + throwable + ']';
 }
 }
 
 
 class ParameterFormatter { 
 /** * Prefix for recursion. */
 static final String RECURSION_PREFIX = "[...";
 /** * Suffix for recursion. */
 static final String RECURSION_SUFFIX = "...]";
 
 /** * Prefix for errors. */
 static final String ERROR_PREFIX = "[!!!";
 /** * Separator for errors. */
 static final String ERROR_SEPARATOR = "=>";
 /** * Separator for error messages. */
 static final String ERROR_MSG_SEPARATOR = ":";
 /** * Suffix for errors. */
 static final String ERROR_SUFFIX = "!!!]";
 
 private static final char DELIM_START = '{';
 private static final char DELIM_STOP = '}';
 private static final char ESCAPE_CHAR = '\\';
 
 private static ThreadLocal<SimpleDateFormat> threadLocalSimpleDateFormat = new ThreadLocal<>();
 
 private ParameterFormatter() { 
 }
 
 static int countArgumentPlaceholders(final String messagePattern) { 
 if (messagePattern == null) { 
 return 0;
 }
 final int length = messagePattern.length();
 int result = 0;
 boolean isEscaped = false;
 for (int i = 0; i < length - 1; i++) { 
 final char curChar = messagePattern.charAt(i);
 if (curChar == ESCAPE_CHAR) { 
 isEscaped = !isEscaped;
 } else if (curChar == DELIM_START) { 
 if (!isEscaped && messagePattern.charAt(i + 1) == DELIM_STOP) { 
 result++;
 i++;
 }
 isEscaped = false;
 } else { 
 isEscaped = false;
 }
 }
 return result;
 }
 
 static int countArgumentPlaceholders2(final String messagePattern, final int[] indices) { 
 if (messagePattern == null) { 
 return 0;
 }
 final int length = messagePattern.length();
 int result = 0;
 boolean isEscaped = false;
 for (int i = 0; i < length - 1; i++) { 
 final char curChar = messagePattern.charAt(i);
 if (curChar == ESCAPE_CHAR) { 
 isEscaped = !isEscaped;
 indices[0] = -1; // escaping means fast path is not available...
 result++;
 } else if (curChar == DELIM_START) { 
 if (!isEscaped && messagePattern.charAt(i + 1) == DELIM_STOP) { 
 indices[result] = i;
 result++;
 i++;
 }
 isEscaped = false;
 } else { 
 isEscaped = false;
 }
 }
 return result;
 }
 
 static int countArgumentPlaceholders3(final char[] messagePattern, final int length, final int[] indices) { 
 int result = 0;
 boolean isEscaped = false;
 for (int i = 0; i < length - 1; i++) { 
 final char curChar = messagePattern[i];
 if (curChar == ESCAPE_CHAR) { 
 isEscaped = !isEscaped;
 } else if (curChar == DELIM_START) { 
 if (!isEscaped && messagePattern[i + 1] == DELIM_STOP) { 
 indices[result] = i;
 result++;
 i++;
 }
 isEscaped = false;
 } else { 
 isEscaped = false;
 }
 }
 return result;
 }
 
 static String format(final String messagePattern, final Object[] arguments) { 
 final StringBuilder result = new StringBuilder();
 final int argCount = arguments == null ? 0 : arguments.length;
 formatMessage(result, messagePattern, arguments, argCount);
 return result.toString();
 }
 
 static void formatMessage2(final StringBuilder buffer, final String messagePattern,
 final Object[] arguments, final int argCount, final int[] indices) { 
 if (messagePattern == null || arguments == null || argCount == 0) { 
 buffer.append(messagePattern);
 return;
 }
 int previous = 0;
 for (int i = 0; i < argCount; i++) { 
 buffer.append(messagePattern, previous, indices[i]);
 previous = indices[i] + 2;
 recursiveDeepToString(arguments[i], buffer, null);
 }
 buffer.append(messagePattern, previous, messagePattern.length());
 }
 
 static void formatMessage3(final StringBuilder buffer, final char[] messagePattern, final int patternLength,
 final Object[] arguments, final int argCount, final int[] indices) { 
 if (messagePattern == null) { 
 return;
 }
 if (arguments == null || argCount == 0) { 
 buffer.append(messagePattern);
 return;
 }
 int previous = 0;
 for (int i = 0; i < argCount; i++) { 
 buffer.append(messagePattern, previous, indices[i]);
 previous = indices[i] + 2;
 recursiveDeepToString(arguments[i], buffer, null);
 }
 buffer.append(messagePattern, previous, patternLength);
 }
 
 static void formatMessage(final StringBuilder buffer, final String messagePattern,
 final Object[] arguments, final int argCount) { 
 if (messagePattern == null || arguments == null || argCount == 0) { 
 buffer.append(messagePattern);
 return;
 }
 int escapeCounter = 0;
 int currentArgument = 0;
 int i = 0;
 final int len = messagePattern.length();
 for (; i < len - 1; i++) { // last char is excluded from the loop
 final char curChar = messagePattern.charAt(i);
 if (curChar == ESCAPE_CHAR) { 
 escapeCounter++;
 } else { 
 if (isDelimPair(curChar, messagePattern, i)) { // looks ahead one char
 i++;
 
 // write escaped escape chars
 writeEscapedEscapeChars(escapeCounter, buffer);
 
 if (isOdd(escapeCounter)) { 
 // i.e. escaped: write escaped escape chars
 writeDelimPair(buffer);
 } else { 
 // unescaped
 writeArgOrDelimPair(arguments, argCount, currentArgument, buffer);
 currentArgument++;
 }
 } else { 
 handleLiteralChar(buffer, escapeCounter, curChar);
 }
 escapeCounter = 0;
 }
 }
 handleRemainingCharIfAny(messagePattern, len, buffer, escapeCounter, i);
 }
 
 private static boolean isDelimPair(final char curChar, final String messagePattern, final int curCharIndex) { 
 return curChar == DELIM_START && messagePattern.charAt(curCharIndex + 1) == DELIM_STOP;
 }
 
 private static void handleRemainingCharIfAny(final String messagePattern, final int len,
 final StringBuilder buffer, final int escapeCounter, final int i) { 
 if (i == len - 1) { 
 final char curChar = messagePattern.charAt(i);
 handleLastChar(buffer, escapeCounter, curChar);
 }
 }
 
 private static void handleLastChar(final StringBuilder buffer, final int escapeCounter, final char curChar) { 
 if (curChar == ESCAPE_CHAR) { 
 writeUnescapedEscapeChars(escapeCounter + 1, buffer);
 } else { 
 handleLiteralChar(buffer, escapeCounter, curChar);
 }
 }
 
 private static void handleLiteralChar(final StringBuilder buffer, final int escapeCounter, final char curChar) { 
 // any other char beside ESCAPE or DELIM_START/STOP-combo
 // write unescaped escape chars
 writeUnescapedEscapeChars(escapeCounter, buffer);
 buffer.append(curChar);
 }
 
 private static void writeDelimPair(final StringBuilder buffer) { 
 buffer.append(DELIM_START);
 buffer.append(DELIM_STOP);
 }
 
 private static boolean isOdd(final int number) { 
 return (number & 1) == 1;
 }
 
 private static void writeEscapedEscapeChars(final int escapeCounter, final StringBuilder buffer) { 
 final int escapedEscapes = escapeCounter >> 1; // divide by two
 writeUnescapedEscapeChars(escapedEscapes, buffer);
 }
 
 private static void writeUnescapedEscapeChars(int escapeCounter, final StringBuilder buffer) { 
 while (escapeCounter > 0) { 
 buffer.append(ESCAPE_CHAR);
 escapeCounter--;
 }
 }
 
 private static void writeArgOrDelimPair(final Object[] arguments, final int argCount, final int currentArgument,
 final StringBuilder buffer) { 
 if (currentArgument < argCount) { 
 recursiveDeepToString(arguments[currentArgument], buffer, null);
 } else { 
 writeDelimPair(buffer);
 }
 }
 
 static String deepToString(final Object o) { 
 if (o == null) { 
 return null;
 }
 if (o instanceof String) { 
 return (String) o;
 }
 final StringBuilder str = new StringBuilder();
 final Set<String> dejaVu = new HashSet<>(); // that's actually a neat name ;)
 recursiveDeepToString(o, str, dejaVu);
 return str.toString();
 }
 
 private static void recursiveDeepToString(final Object o, final StringBuilder str, final Set<String> dejaVu) { 
 if (appendSpecialTypes(o, str)) { 
 return;
 }
 if (isMaybeRecursive(o)) { 
 appendPotentiallyRecursiveValue(o, str, dejaVu);
 } else { 
 tryObjectToString(o, str);
 }
 }
 
 private static boolean appendSpecialTypes(final Object o, final StringBuilder str) { 
 if (o == null || o instanceof String) { 
 str.append((String) o);
 return true;
 } else if (o instanceof CharSequence) { 
 str.append((CharSequence) o);
 return true;
 } else if (o instanceof StringBuilderFormattable) { 
 ((StringBuilderFormattable) o).formatTo(str);
 return true;
 } else if (o instanceof Integer) { // LOG4J2-1415 unbox auto-boxed primitives to avoid calling toString()
 str.append(((Integer) o).intValue());
 return true;
 } else if (o instanceof Long) { 
 str.append(((Long) o).longValue());
 return true;
 } else if (o instanceof Double) { 
 str.append(((Double) o).doubleValue());
 return true;
 } else if (o instanceof Boolean) { 
 str.append(((Boolean) o).booleanValue());
 return true;
 } else if (o instanceof Character) { 
 str.append(((Character) o).charValue());
 return true;
 } else if (o instanceof Short) { 
 str.append(((Short) o).shortValue());
 return true;
 } else if (o instanceof Float) { 
 str.append(((Float) o).floatValue());
 return true;
 }
 return appendDate(o, str);
 }
 
 private static boolean appendDate(final Object o, final StringBuilder str) { 
 if (!(o instanceof Date)) { 
 return false;
 }
 final Date date = (Date) o;
 final SimpleDateFormat format = getSimpleDateFormat();
 str.append(format.format(date));
 return true;
 }
 
 private static SimpleDateFormat getSimpleDateFormat() { 
 SimpleDateFormat result = threadLocalSimpleDateFormat.get();
 if (result == null) { 
 result = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSSZ");
 threadLocalSimpleDateFormat.set(result);
 }
 return result;
 }
 
 private static boolean isMaybeRecursive(final Object o) { 
 return o.getClass().isArray() || o instanceof Map || o instanceof Collection;
 }
 
 private static void appendPotentiallyRecursiveValue(final Object o, final StringBuilder str,
 final Set<String> dejaVu) { 
 final Class<?> oClass = o.getClass();
 if (oClass.isArray()) { 
 appendArray(o, str, dejaVu, oClass);
 } else if (o instanceof Map) { 
 appendMap(o, str, dejaVu);
 } else if (o instanceof Collection) { 
 appendCollection(o, str, dejaVu);
 }
 }
 
 private static void appendArray(final Object o, final StringBuilder str, Set<String> dejaVu,
 final Class<?> oClass) { 
 if (oClass == byte[].class) { 
 str.append(Arrays.toString((byte[]) o));
 } else if (oClass == short[].class) { 
 str.append(Arrays.toString((short[]) o));
 } else if (oClass == int[].class) { 
 str.append(Arrays.toString((int[]) o));
 } else if (oClass == long[].class) { 
 str.append(Arrays.toString((long[]) o));
 } else if (oClass == float[].class) { 
 str.append(Arrays.toString((float[]) o));
 } else if (oClass == double[].class) { 
 str.append(Arrays.toString((double[]) o));
 } else if (oClass == boolean[].class) { 
 str.append(Arrays.toString((boolean[]) o));
 } else if (oClass == char[].class) { 
 str.append(Arrays.toString((char[]) o));
 } else { 
 if (dejaVu == null) { 
 dejaVu = new HashSet<>();
 }
 // special handling of container Object[]
 final String id = identityToString(o);
 if (dejaVu.contains(id)) { 
 str.append(RECURSION_PREFIX).append(id).append(RECURSION_SUFFIX);
 } else { 
 dejaVu.add(id);
 final Object[] oArray = (Object[]) o;
 str.append('[');
 boolean first = true;
 for (final Object current : oArray) { 
 if (first) { 
 first = false;
 } else { 
 str.append(", ");
 }
 recursiveDeepToString(current, str, new HashSet<>(dejaVu));
 }
 str.append(']');
 }
 //str.append(Arrays.deepToString((Object[]) o));
 }
 }
 
 private static void appendMap(final Object o, final StringBuilder str, Set<String> dejaVu) { 
 // special handling of container Map
 if (dejaVu == null) { 
 dejaVu = new HashSet<>();
 }
 final String id = identityToString(o);
 if (dejaVu.contains(id)) { 
 str.append(RECURSION_PREFIX).append(id).append(RECURSION_SUFFIX);
 } else { 
 dejaVu.add(id);
 final Map<?, ?> oMap = (Map<?, ?>) o;
 str.append('{');
 boolean isFirst = true;
 for (final Object o1 : oMap.entrySet()) { 
 final Map.Entry<?, ?> current = (Map.Entry<?, ?>) o1;
 if (isFirst) { 
 isFirst = false;
 } else { 
 str.append(", ");
 }
 final Object key = current.getKey();
 final Object value = current.getValue();
 recursiveDeepToString(key, str, new HashSet<>(dejaVu));
 str.append('=');
 recursiveDeepToString(value, str, new HashSet<>(dejaVu));
 }
 str.append('}');
 }
 }
 
 private static void appendCollection(final Object o, final StringBuilder str, Set<String> dejaVu) { 
 // special handling of container Collection
 if (dejaVu == null) { 
 dejaVu = new HashSet<>();
 }
 final String id = identityToString(o);
 if (dejaVu.contains(id)) { 
 str.append(RECURSION_PREFIX).append(id).append(RECURSION_SUFFIX);
 } else { 
 dejaVu.add(id);
 final Collection<?> oCol = (Collection<?>) o;
 str.append('[');
 boolean isFirst = true;
 for (final Object anOCol : oCol) { 
 if (isFirst) { 
 isFirst = false;
 } else { 
 str.append(", ");
 }
 recursiveDeepToString(anOCol, str, new HashSet<>(dejaVu));
 }
 str.append(']');
 }
 }
 
 private static void tryObjectToString(final Object o, final StringBuilder str) { 
 // it's just some other Object, we can only use toString().
 try { 
 str.append(o.toString());
 } catch (final Throwable t) { 
 handleErrorInObjectToString(o, str, t);
 }
 }
 
 private static void handleErrorInObjectToString(final Object o, final StringBuilder str, final Throwable t) { 
 str.append(ERROR_PREFIX);
 str.append(identityToString(o));
 str.append(ERROR_SEPARATOR);
 final String msg = t.getMessage();
 final String className = t.getClass().getName();
 str.append(className);
 if (!className.equals(msg)) { 
 str.append(ERROR_MSG_SEPARATOR);
 str.append(msg);
 }
 str.append(ERROR_SUFFIX);
 }
 
 static String identityToString(final Object obj) { 
 if (obj == null) { 
 return null;
 }
 return obj.getClass().getName() + '@' + Integer.toHexString(System.identityHashCode(obj));
 }
 }

其实就是在这里处理

@Override
 public void formatTo(final StringBuilder buffer) {
 if (formattedMessage != null) {
 buffer.append(formattedMessage);
 } else {
 if (indices[0] < 0) {
 ParameterFormatter.formatMessage(buffer, messagePattern, argArray, usedCount);
 } else {
 ParameterFormatter.formatMessage2(buffer, messagePattern, argArray, usedCount, indices);
 }
 // 此处进行特殊处理
 }
 }

##### 注意点：这里我只处理了`ParameterizedMessage`，用了自定义的`CustomParameterizedMessage` #####

简单日志`SimpleMessage`，`ObjectMessage`一般情况下不会出现敏感数据，所以暂时只自定义了`CustomParameterizedMessage`，当然如果要自定义它们也是可以的，重写继承的`AbstractMessageFactory`里面的方法，比如`new ObjectMessage(message)`改成`new CustomeObjectMessage(message)`，然后你要新建一个`CustomeObjectMessage`类，复制原先`ObjectMessage`内容，然后修改`formatTo()`方法,与上面修改方式同理。

#### 五、处理方式二：自定义PatternLayout ####

package cn.saytime.util;
 
 import org.apache.logging.log4j.core.Layout;
 import org.apache.logging.log4j.core.LogEvent;
 import org.apache.logging.log4j.core.config.Configuration;
 import org.apache.logging.log4j.core.config.DefaultConfiguration;
 import org.apache.logging.log4j.core.config.Node;
 import org.apache.logging.log4j.core.config.plugins.*;
 import org.apache.logging.log4j.core.layout.*;
 import org.apache.logging.log4j.core.pattern.LogEventPatternConverter;
 import org.apache.logging.log4j.core.pattern.PatternFormatter;
 import org.apache.logging.log4j.core.pattern.PatternParser;
 import org.apache.logging.log4j.core.pattern.RegexReplacement;
 import org.apache.logging.log4j.util.Strings;
 
 import java.nio.charset.Charset;
 import java.util.Arrays;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 
 /** * @description: * @date: 2019-01-07 13:57 **/
 @Plugin(name = "CustomPatternLayout", category = Node.CATEGORY, elementType = Layout.ELEMENT_TYPE, printObject = true)
 public final class CustomPatternLayout extends AbstractStringLayout { 
 
 /** * Default pattern string for log output. Currently set to the string "%m%n" which just prints the * application supplied message. */
 public static final String DEFAULT_CONVERSION_PATTERN = "%m%n";
 
 /** * A conversion pattern equivalent to the TTCCLayout. Current value is %r [%t] %p %c %notEmpty{%x }- %m%n. */
 public static final String TTCC_CONVERSION_PATTERN = "%r [%t] %p %c %notEmpty{%x }- %m%n";
 
 /** * A simple pattern. Current value is %d [%t] %p %c - %m%n. */
 public static final String SIMPLE_CONVERSION_PATTERN = "%d [%t] %p %c - %m%n";
 
 /** Key to identify pattern converters. */
 public static final String KEY = "Converter";
 
 /** * Conversion pattern. */
 private String conversionPattern;
 private PatternSelector patternSelector;
 private Serializer eventSerializer;
 
 /** * Constructs a CustomPatternLayout using the supplied conversion pattern. * * @param config The Configuration. * @param replace The regular expression to match. * @param eventPattern conversion pattern. * @param patternSelector The PatternSelector. * @param charset The character set. * @param alwaysWriteExceptions Whether or not exceptions should always be handled in this pattern (if {@code true}, * exceptions will be written even if the pattern does not specify so). * @param disableAnsi * If {@code "true"}, do not output ANSI escape codes * @param noConsoleNoAnsi * If {@code "true"} (default) and {@link System#console()} is null, do not output ANSI escape codes * @param headerPattern header conversion pattern. * @param footerPattern footer conversion pattern. */
 private CustomPatternLayout(final Configuration config, final RegexReplacement replace, final String eventPattern,
 final PatternSelector patternSelector, final Charset charset, final boolean alwaysWriteExceptions,
 final boolean disableAnsi, final boolean noConsoleNoAnsi, final String headerPattern,
 final String footerPattern) { 
 super(config, charset,
 newSerializerBuilder()
 .setConfiguration(config)
 .setReplace(replace)
 .setPatternSelector(patternSelector)
 .setAlwaysWriteExceptions(alwaysWriteExceptions)
 .setDisableAnsi(disableAnsi)
 .setNoConsoleNoAnsi(noConsoleNoAnsi)
 .setPattern(headerPattern)
 .build(),
 newSerializerBuilder()
 .setConfiguration(config)
 .setReplace(replace)
 .setPatternSelector(patternSelector)
 .setAlwaysWriteExceptions(alwaysWriteExceptions)
 .setDisableAnsi(disableAnsi)
 .setNoConsoleNoAnsi(noConsoleNoAnsi)
 .setPattern(footerPattern)
 .build());
 this.conversionPattern = eventPattern;
 this.patternSelector = patternSelector;
 this.eventSerializer = newSerializerBuilder()
 .setConfiguration(config)
 .setReplace(replace)
 .setPatternSelector(patternSelector)
 .setAlwaysWriteExceptions(alwaysWriteExceptions)
 .setDisableAnsi(disableAnsi)
 .setNoConsoleNoAnsi(noConsoleNoAnsi)
 .setPattern(eventPattern)
 .setDefaultPattern(DEFAULT_CONVERSION_PATTERN)
 .build();
 }
 
 protected CustomPatternLayout(Charset charset) { 
 super(charset);
 }
 
 public static SerializerBuilder newSerializerBuilder() { 
 return new SerializerBuilder();
 }
 
 /** * Deprecated, use {@link #newSerializerBuilder()} instead. * * @param configuration * @param replace * @param pattern * @param defaultPattern * @param patternSelector * @param alwaysWriteExceptions * @param noConsoleNoAnsi * @return a new Serializer. * @deprecated Use {@link #newSerializerBuilder()} instead. */
 @Deprecated
 public static Serializer createSerializer(final Configuration configuration, final RegexReplacement replace,
 final String pattern, final String defaultPattern, final PatternSelector patternSelector,
 final boolean alwaysWriteExceptions, final boolean noConsoleNoAnsi) { 
 final SerializerBuilder builder = newSerializerBuilder();
 builder.setAlwaysWriteExceptions(alwaysWriteExceptions);
 builder.setConfiguration(configuration);
 builder.setDefaultPattern(defaultPattern);
 builder.setNoConsoleNoAnsi(noConsoleNoAnsi);
 builder.setPattern(pattern);
 builder.setPatternSelector(patternSelector);
 builder.setReplace(replace);
 return builder.build();
 }
 
 /** * Gets the conversion pattern. * * @return the conversion pattern. */
 public String getConversionPattern() { 
 return conversionPattern;
 }
 
 /** * Gets this CustomPatternLayout's content format. Specified by: * <ul> * <li>Key: "structured" Value: "false"</li> * <li>Key: "formatType" Value: "conversion" (format uses the keywords supported by OptionConverter)</li> * <li>Key: "format" Value: provided "conversionPattern" param</li> * </ul> * * @return Map of content format keys supporting CustomPatternLayout */
 @Override
 public Map<String, String> getContentFormat() { 
 final Map<String, String> result = new HashMap<>();
 result.put("structured", "false");
 result.put("formatType", "conversion");
 result.put("format", conversionPattern);
 return result;
 }
 
 /** * Formats a logging event to a writer. * * @param event logging event to be formatted. * @return The event formatted as a String. */
 @Override
 public String toSerializable(final LogEvent event) { 
 return eventSerializer.toSerializable(event);
 }
 
 @Override
 public void encode(final LogEvent event, final ByteBufferDestination destination) { 
 if (!(eventSerializer instanceof Serializer2)) { 
 super.encode(event, destination);
 return;
 }
 final StringBuilder text = toText((Serializer2) eventSerializer, event, getStringBuilder());
 final Encoder<StringBuilder> encoder = getStringBuilderEncoder();
 encoder.encode(text, destination);
 trimToMaxSize(text);
 }
 
 /** * Creates a text representation of the specified log event * and writes it into the specified StringBuilder. * * Implementations are free to return a new StringBuilder if they can * detect in advance that the specified StringBuilder is too small. */
 private StringBuilder toText(final Serializer2 serializer, final LogEvent event,
 final StringBuilder destination) { 
 return serializer.toSerializable(event, destination);
 }
 
 /** * Creates a PatternParser. * @param config The Configuration. * @return The PatternParser. */
 public static PatternParser createPatternParser(final Configuration config) { 
 if (config == null) { 
 return new PatternParser(config, KEY, LogEventPatternConverter.class);
 }
 PatternParser parser = config.getComponent(KEY);
 if (parser == null) { 
 parser = new PatternParser(config, KEY, LogEventPatternConverter.class);
 config.addComponent(KEY, parser);
 parser = config.getComponent(KEY);
 }
 return parser;
 }
 
 @Override
 public String toString() { 
 return patternSelector == null ? conversionPattern : patternSelector.toString();
 }
 
 /** * Creates a pattern layout. * * @param pattern * The pattern. If not specified, defaults to DEFAULT_CONVERSION_PATTERN. * @param patternSelector * Allows different patterns to be used based on some selection criteria. * @param config * The Configuration. Some Converters require access to the Interpolator. * @param replace * A Regex replacement String. * @param charset * The character set. The platform default is used if not specified. * @param alwaysWriteExceptions * If {@code "true"} (default) exceptions are always written even if the pattern contains no exception tokens. * @param noConsoleNoAnsi * If {@code "true"} (default is false) and {@link System#console()} is null, do not output ANSI escape codes * @param headerPattern * The footer to place at the top of the document, once. * @param footerPattern * The footer to place at the bottom of the document, once. * @return The * @deprecated Use {@link #newBuilder()} instead. This will be private in a future version. */
 @PluginFactory
 @Deprecated
 public static CustomPatternLayout createLayout(
 @PluginAttribute(value = "pattern", defaultString = DEFAULT_CONVERSION_PATTERN) final String pattern,
 @PluginElement("PatternSelector") final PatternSelector patternSelector,
 @PluginConfiguration final Configuration config,
 @PluginElement("Replace") final RegexReplacement replace,
 // LOG4J2-783 use platform default by default, so do not specify defaultString for charset
 @PluginAttribute(value = "charset") final Charset charset,
 @PluginAttribute(value = "alwaysWriteExceptions", defaultBoolean = true) final boolean alwaysWriteExceptions,
 @PluginAttribute(value = "noConsoleNoAnsi") final boolean noConsoleNoAnsi,
 @PluginAttribute("header") final String headerPattern,
 @PluginAttribute("footer") final String footerPattern) { 
 return newBuilder()
 .withPattern(pattern)
 .withPatternSelector(patternSelector)
 .withConfiguration(config)
 .withRegexReplacement(replace)
 .withCharset(charset)
 .withAlwaysWriteExceptions(alwaysWriteExceptions)
 .withNoConsoleNoAnsi(noConsoleNoAnsi)
 .withHeader(headerPattern)
 .withFooter(footerPattern)
 .build();
 }
 
 private static class PatternSerializer implements Serializer, Serializer2 { 
 
 private final PatternFormatter[] formatters;
 private final RegexReplacement replace;
 
 private PatternSerializer(final PatternFormatter[] formatters, final RegexReplacement replace) { 
 super();
 this.formatters = formatters;
 this.replace = replace;
 }
 
 @Override
 public String toSerializable(final LogEvent event) { 
 final StringBuilder sb = getStringBuilder();
 try { 
 return toSerializable(event, sb).toString();
 } finally { 
 trimToMaxSize(sb);
 }
 }
 
 @Override
 public StringBuilder toSerializable(final LogEvent event, final StringBuilder buffer) { 
 final int len = formatters.length;
 for (int i = 0; i < len; i++) { 
 formatters[i].format(event, buffer);
 }
 
 // 对数据进行脱敏处理
 String strCustomize = (buffer.toString()).replace("1", "**********");
 buffer.setLength(0);
 buffer.append(strCustomize);
 
 if (replace != null) { // creates temporary objects
 String str = buffer.toString();
 str = replace.format(str);
 buffer.setLength(0);
 buffer.append(str);
 }
 return buffer;
 }
 
 @Override
 public String toString() { 
 final StringBuilder builder = new StringBuilder();
 builder.append(super.toString());
 builder.append("[formatters=");
 builder.append(Arrays.toString(formatters));
 builder.append(", replace=");
 builder.append(replace);
 builder.append("]");
 return builder.toString();
 }
 }
 
 public static class SerializerBuilder implements org.apache.logging.log4j.core.util.Builder<Serializer> { 
 
 private Configuration configuration;
 private RegexReplacement replace;
 private String pattern;
 private String defaultPattern;
 private PatternSelector patternSelector;
 private boolean alwaysWriteExceptions;
 private boolean disableAnsi;
 private boolean noConsoleNoAnsi;
 
 @Override
 public Serializer build() { 
 if (Strings.isEmpty(pattern) && Strings.isEmpty(defaultPattern)) { 
 return null;
 }
 if (patternSelector == null) { 
 try { 
 final PatternParser parser = createPatternParser(configuration);
 final List<PatternFormatter> list = parser.parse(pattern == null ? defaultPattern : pattern,
 alwaysWriteExceptions, disableAnsi, noConsoleNoAnsi);
 final PatternFormatter[] formatters = list.toArray(new PatternFormatter[0]);
 return new PatternSerializer(formatters, replace);
 } catch (final RuntimeException ex) { 
 throw new IllegalArgumentException("Cannot parse pattern '" + pattern + "'", ex);
 }
 }
 return new PatternSelectorSerializer(patternSelector, replace);
 }
 
 public SerializerBuilder setConfiguration(final Configuration configuration) { 
 this.configuration = configuration;
 return this;
 }
 
 public SerializerBuilder setReplace(final RegexReplacement replace) { 
 this.replace = replace;
 return this;
 }
 
 public SerializerBuilder setPattern(final String pattern) { 
 this.pattern = pattern;
 return this;
 }
 
 public SerializerBuilder setDefaultPattern(final String defaultPattern) { 
 this.defaultPattern = defaultPattern;
 return this;
 }
 
 public SerializerBuilder setPatternSelector(final PatternSelector patternSelector) { 
 this.patternSelector = patternSelector;
 return this;
 }
 
 public SerializerBuilder setAlwaysWriteExceptions(final boolean alwaysWriteExceptions) { 
 this.alwaysWriteExceptions = alwaysWriteExceptions;
 return this;
 }
 
 public SerializerBuilder setDisableAnsi(final boolean disableAnsi) { 
 this.disableAnsi = disableAnsi;
 return this;
 }
 
 public SerializerBuilder setNoConsoleNoAnsi(final boolean noConsoleNoAnsi) { 
 this.noConsoleNoAnsi = noConsoleNoAnsi;
 return this;
 }
 
 }
 
 private static class PatternSelectorSerializer implements Serializer, Serializer2 { 
 
 private final PatternSelector patternSelector;
 private final RegexReplacement replace;
 
 private PatternSelectorSerializer(final PatternSelector patternSelector, final RegexReplacement replace) { 
 super();
 this.patternSelector = patternSelector;
 this.replace = replace;
 }
 
 @Override
 public String toSerializable(final LogEvent event) { 
 final StringBuilder sb = getStringBuilder();
 try { 
 return toSerializable(event, sb).toString();
 } finally { 
 trimToMaxSize(sb);
 }
 }
 
 @Override
 public StringBuilder toSerializable(final LogEvent event, final StringBuilder buffer) { 
 final PatternFormatter[] formatters = patternSelector.getFormatters(event);
 final int len = formatters.length;
 for (int i = 0; i < len; i++) { 
 formatters[i].format(event, buffer);
 }
 if (replace != null) { // creates temporary objects
 String str = buffer.toString();
 str = replace.format(str);
 buffer.setLength(0);
 buffer.append(str);
 }
 return buffer;
 }
 
 @Override
 public String toString() { 
 final StringBuilder builder = new StringBuilder();
 builder.append(super.toString());
 builder.append("[patternSelector=");
 builder.append(patternSelector);
 builder.append(", replace=");
 builder.append(replace);
 builder.append("]");
 return builder.toString();
 }
 }
 
 /** * Creates a CustomPatternLayout using the default options. These options include using UTF-8, the default conversion * pattern, exceptions being written, and with ANSI escape codes. * * @return the * @see #DEFAULT_CONVERSION_PATTERN Default conversion pattern */
 public static CustomPatternLayout createDefaultLayout() { 
 return newBuilder().build();
 }
 
 /** * Creates a CustomPatternLayout using the default options and the given configuration. These options include using UTF-8, * the default conversion pattern, exceptions being written, and with ANSI escape codes. * * @param configuration The Configuration. * * @return the * @see #DEFAULT_CONVERSION_PATTERN Default conversion pattern */
 public static CustomPatternLayout createDefaultLayout(final Configuration configuration) { 
 return newBuilder().withConfiguration(configuration).build();
 }
 
 /** * Creates a builder for a custom * * @return a CustomPatternLayout builder. */
 @PluginBuilderFactory
 public static Builder newBuilder() { 
 return new Builder();
 }
 
 /** * Custom CustomPatternLayout builder. Use the {@link CustomPatternLayout#newBuilder() builder factory method} to create this. */
 public static class Builder implements org.apache.logging.log4j.core.util.Builder<CustomPatternLayout> { 
 
 @PluginBuilderAttribute
 private String pattern = DEFAULT_CONVERSION_PATTERN;
 
 @PluginElement("PatternSelector")
 private PatternSelector patternSelector;
 
 @PluginConfiguration
 private Configuration configuration;
 
 @PluginElement("Replace")
 private RegexReplacement regexReplacement;
 
 // LOG4J2-783 use platform default by default
 @PluginBuilderAttribute
 private Charset charset = Charset.defaultCharset();
 
 @PluginBuilderAttribute
 private boolean alwaysWriteExceptions = true;
 
 @PluginBuilderAttribute
 private boolean disableAnsi;
 
 @PluginBuilderAttribute
 private boolean noConsoleNoAnsi;
 
 @PluginBuilderAttribute
 private String header;
 
 @PluginBuilderAttribute
 private String footer;
 
 private Builder() { 
 }
 
 
 /** * @param pattern * The pattern. If not specified, defaults to DEFAULT_CONVERSION_PATTERN. */
 public Builder withPattern(final String pattern) { 
 this.pattern = pattern;
 return this;
 }
 
 /** * @param patternSelector * Allows different patterns to be used based on some selection criteria. */
 public Builder withPatternSelector(final PatternSelector patternSelector) { 
 this.patternSelector = patternSelector;
 return this;
 }
 
 /** * @param configuration * The Configuration. Some Converters require access to the Interpolator. */
 public Builder withConfiguration(final Configuration configuration) { 
 this.configuration = configuration;
 return this;
 }
 
 /** * @param regexReplacement * A Regex replacement */
 public Builder withRegexReplacement(final RegexReplacement regexReplacement) { 
 this.regexReplacement = regexReplacement;
 return this;
 }
 
 /** * @param charset * The character set. The platform default is used if not specified. */
 public Builder withCharset(final Charset charset) { 
 // LOG4J2-783 if null, use platform default by default
 if (charset != null) { 
 this.charset = charset;
 }
 return this;
 }
 
 /** * @param alwaysWriteExceptions * If {@code "true"} (default) exceptions are always written even if the pattern contains no exception tokens. */
 public Builder withAlwaysWriteExceptions(final boolean alwaysWriteExceptions) { 
 this.alwaysWriteExceptions = alwaysWriteExceptions;
 return this;
 }
 
 /** * @param disableAnsi * If {@code "true"} (default is false), do not output ANSI escape codes */
 public Builder withDisableAnsi(final boolean disableAnsi) { 
 this.disableAnsi = disableAnsi;
 return this;
 }
 
 /** * @param noConsoleNoAnsi * If {@code "true"} (default is false) and {@link System#console()} is null, do not output ANSI escape codes */
 public Builder withNoConsoleNoAnsi(final boolean noConsoleNoAnsi) { 
 this.noConsoleNoAnsi = noConsoleNoAnsi;
 return this;
 }
 
 /** * @param header * The footer to place at the top of the document, once. */
 public Builder withHeader(final String header) { 
 this.header = header;
 return this;
 }
 
 /** * @param footer * The footer to place at the bottom of the document, once. */
 public Builder withFooter(final String footer) { 
 this.footer = footer;
 return this;
 }
 
 @Override
 public CustomPatternLayout build() { 
 // fall back to DefaultConfiguration
 if (configuration == null) { 
 configuration = new DefaultConfiguration();
 }
 return new CustomPatternLayout(configuration, regexReplacement, pattern, patternSelector, charset,
 alwaysWriteExceptions, disableAnsi, noConsoleNoAnsi, header, footer);
 }
 }
 }

也就是复制原先的

@Override
 public StringBuilder toSerializable(final LogEvent event, final StringBuilder buffer) { 
 final int len = formatters.length;
 for (int i = 0; i < len; i++) { 
 formatters[i].format(event, buffer);
 }
 
 // 对数据进行脱敏处理，比如
 // String strCustomize = (buffer.toString()).replace("1", "**********");
 // buffer.setLength(0);
 // buffer.append(strCustomize);
 
 if (replace != null) { // creates temporary objects
 String str = buffer.toString();
 str = replace.format(str);
 buffer.setLength(0);
 buffer.append(str);
 }
 return buffer;
 }

> 注意修改log4j2.xml中的PatternLayout为CustomPatternLayout

一：扫描包路径
 <configuration status="INFO" packages="cn.saytime">
 
 二、自定义PatternLayout
 <CustomPatternLayout pattern="%m%n"></CustomPatternLayout>

##### 变种：正则配置方式 #####

[https://blog.csdn.net/VcStrong/article/details/80527455][https_blog.csdn.net_VcStrong_article_details_80527455]

#### 六、处理方式三：自定义Converter方式 ####

> 自行百度lo4j2自定义Converter

#### 七：处理方式优缺点对比 ####

##### 1. 自定义PatternLayout #####

优点：日志总出口，全量数据，不用担心遗漏数据  
缺点：只能针对完整日志进行处理，容易将不该脱敏的数据也脱敏了，比如日志自带的日期、时间、对应类等等，所以脱敏规则要注意

##### 2. 自定义MessageFactory ParameterizedMessage #####

优点：可以直接获取到日志变量，方便修改，比如判断变量是json，那么可以转化成json后，修改其中指定key的value  
缺点：代码量大一点？

##### 3. 自定义MessageConvert #####