利用责任链模式及AOP对日志进行脱敏分享

利用责任链模式及AOP对日志进行脱敏分享

现在公司需要对日志进行脱敏，对一些敏感的值需要掩码处理，已保护用户的数据的安全，对脱敏的字段包括姓名、身份证号码、手机号码、银行账号、邮箱等。
思路如下：
1、如何匹配这些字段，想到的是有两种，
一种是对字段名的判断，这种有可能会误伤一些字段，但考虑到只是对字段的掩码并且只是日志，误伤也应该没事，
另外一种是对字段的值用正则表达式判断
2、对每个字段都要过滤，那么每一个字段都要过滤各种规则，应该说每种规则都要过滤每一个字段，知道符合某一种规则，
这里的规则指的就是符合姓名、身份证等的字段或者正则表达式，这个很容易想到struts2的拦截器，所以我打算用责任链模式把这些规则串连起来，并且如果有新的规则能够自动添加过来，即形成了链条式的过滤器。
3、对这些过滤器加入到spring容器中，并形成一个bean，对那些需要脱敏的日志，只要把这个bean加入就好，并调用这个过滤器。
4、把这个过滤器封装到AOP中，写一个注解，对要日志脱敏的方法入参和出参进行脱敏。这样不用组合这个过滤器。

相关代码如下：

1、先定义过滤的字段和值

package com.shux.brop.nbi.common.filter;
/**
 * 描述：
 * @author Simba
 * @date 2018年7月24日
 */
public class Paramter {
    private String key;//需要过滤字段的名字
    private String value;//需要过滤字段的值
    
    
    public Paramter(String key, String value) {
        super();
        this.key = key;
        this.value = value;
    }
    public String getKey() {
        return key;
    }
    public void setKey(String key) {
        this.key = key;
    }
    public String getValue() {
        return value;
    }
    public void setValue(String value) {
        this.value = value;
    }
    
}
2、定义过滤器

package com.shux.brop.nbi.common.filter;

import com.shux.brop.nbi.common.filter.impl.FilterChain;

/**
 * 描述：
 * @author Simba
 * @date 2018年7月24日
 */
public interface Filter {
    void doFilter(Paramter param,FilterChain chain);
}

3、定义FilterChain，这个主要把所有的filter整合在一起，一个个迭代执行,它本身也是一个filter

package com.shux.brop.nbi.common.filter.impl;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Map;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Service;

import com.shux.brop.nbi.common.filter.Filter;
import com.shux.brop.nbi.common.filter.Paramter;

/**
 * 描述：
 * @author Simba
 * @date 2018年7月24日
 */
@Service("filterChain")
public class FilterChain implements Filter,ApplicationContextAware,InitializingBean {
    private List filters = new ArrayList();
    private ApplicationContext context;
    private int index = 0;
    
    public FilterChain addFilter(Filter filter) {
        this.filters.add(filter);
        return this;
    }
    
    @Override
    public void doFilter(Paramter param,FilterChain chain) {
        if (index >= filters.size()) {
            return;
        }
        Filter filter = filters.get(index);
        index ++;
        filter.doFilter(param, chain);
    }

    public int getIndex() {
        return index;
    }

    public void setIndex(int index) {
        this.index = index;
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        Map filterMap = context.getBeansOfType(Filter.class);
        Collection allFilters = filterMap.values();
        for (Filter filter : allFilters) {
            if (filter instanceof FilterChain) {
                continue;
            }
            filters.add(filter);//把所有的filter加入进来
        }
    }

    @Override
    public void setApplicationContext(ApplicationContext context)
            throws BeansException {
        this.context = context;
    }
}

4、把所有的filter抽象出一个父类，只要继承这个类并且加入到spring容器就认为是责任链中的一个链条.

package com.shux.brop.nbi.common.filter.impl;

import com.shux.brop.nbi.common.filter.Filter;
import com.shux.brop.nbi.common.filter.Paramter;

/**
 * 描述：
 * @author Simba
 * @date 2018年7月25日
 */
public abstract class AbstractFilter implements Filter {

    @Override
    public void doFilter(Paramter param, FilterChain chain) {
        if (doFilter(param)) {
            return;
        }
        chain.doFilter(param, chain);
    }
    /**
     * 如果符合对应的脱敏逻辑则返回true，否则返回false
     * @param param 包含key和value,指字段名和对应的值，可以根据字段名或值进行脱敏
     * @return
     */
    protected abstract boolean doFilter(Paramter param);

}

5、对敏感字段脱敏的几个规则，即链条

package com.shux.brop.nbi.common.filter.impl;

import org.apache.commons.lang.StringUtils;
import org.springframework.stereotype.Component;

import com.shux.brop.nbi.common.filter.Paramter;

/**
 * 描述：生日脱敏，只要字段名含有BIRTHDAY关键字，则需要脱敏
 * @author Simba
 * @date 2018年7月25日
 */
@Component
public class BirthdayFilter extends AbstractFilter {

    @Override
    protected boolean doFilter(Paramter param) {
        String key = param.getKey();
        if (StringUtils.isNotEmpty(key) && key.toUpperCase().contains("BIRTHDAY")) {
            param.setValue("******");
            return true;
        }
        return false;
    }

}

package com.shux.brop.nbi.common.filter.impl;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.apache.commons.lang.StringUtils;
import org.springframework.stereotype.Component;

import com.shux.brop.nbi.common.filter.Paramter;

/**
 * 描述：邮箱脱敏，字段值符合正则表达式，则需要脱敏
 * @author Simba
 * @date 2018年7月25日
 */
@Component
public class EmailFilter extends AbstractFilter {
    private static final String EMAIL_REGEX =  "\\w+([-+.]\\w+)*@\\w+([-.]\\w+)*\\.\\w+([-.]\\w+)*";
    @Override
    protected boolean doFilter(Paramter param) {
        String value = param.getValue();
        Pattern pattern = Pattern.compile(EMAIL_REGEX);
        Matcher matcher = pattern.matcher(value);
        if (StringUtils.isNotEmpty(value) && matcher.matches()) {
            param.setValue("******" + value.substring(value.indexOf("@")));
        }
        return false;
    }

}

6、把整个过滤器封装到spring中，可以对String、List，Object及嵌套bean等进行脱敏。

package com.shux.brop.nbi.common.service;

/**
 * 描述：日志过敏处理
 * @author Simba
 * @date 2018年7月30日
 */

public interface ISensitivityMessageFilter {
    String doSensitivityFilter(Object param);
}

package com.shux.brop.nbi.common.service;

import java.math.BigDecimal;
import java.util.Collection;
import java.util.Date;
import java.util.Iterator;
import java.util.List;
import java.util.Map.Entry;
import java.util.Set;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.shux.brop.nbi.common.filter.Paramter;
import com.shux.brop.nbi.common.filter.impl.FilterChain;

/**
 * 描述：
 * @author Simba
 * @date 2018年7月30日
 */
@Service
public class SensitivityMessageFilterImpl implements ISensitivityMessageFilter {
    @Autowired
    @Qualifier("filterChain")
    private FilterChain filterChain;
    
    @Value("${common.logger.entrypt.log.flag:true}")
    private String entryptLog;
    
    private final Logger logger = LoggerFactory.getLogger(getClass());
    
    @Override
    public String doSensitivityFilter(Object param) {
        /*if (logger.isDebugEnabled()) {
            logger.debug(" the source param is :{}",JSON.toJSONString(param));
        }*/
        try {
            if (param == null) {
                return null;
            }
            if (!Boolean.valueOf(entryptLog)) {//如果脱敏开关关闭的话就不脱敏
                return JSON.toJSONString(param);
            }
            FilterChain fc = filterChain;
            StringBuilder result = new StringBuilder();
            fc.setIndex(0);
            if (param instanceof String || param instanceof Enum) {
                Paramter paramter = new Paramter("key", String.valueOf(param));
                fc.doFilter(paramter, fc);
                result.append("\"");
                result.append(paramter.getValue());
                result.append("\"");
                return result.toString();
            } else if (objectInstanceofNotStringBaseType(param)) {
                return String.valueOf(param);
            } else if (param instanceof List || param instanceof Collection) {
                String listParam = JSON.toJSONString(param);
                JSONArray parseArray = JSON.parseArray(listParam);
                Iterator