Java实现日志脱敏处理

其他 2019-02-23 13:08:18 阅读次数: 0

Java实现日志脱敏处理

题记

在日常工作中，日志处理是我们每一个程序员必备的素质，但是在有些场景下客户信息敏感，需要进行某些字段，或者某部分字段的脱敏处理。接到需求我们开始操刀！

需求分析

处理字段的方式多种多样，如何方便，高效才是关键，众所周知在java中最好的处理方式就是封装，即，对程序员暴露出的最好是一个统一的API，不关心具体的处理逻辑，能拿到想要的返回值就好。

实现第一版

由于在RPC调用过程当中，大部分接口的参数封装数据类型都是Map，所以在此先针对Map形式实现日志脱敏功能

实现思路：

有两种实现方法：

第一种：写死配置
第二种：使用注解驱动
由于写死配置的扩展性实在是差，所以我们本次实现主要是注解驱动

定义注解

/**
 * @ClassName: DesensitizedAnnotation
 * @Description: 注解类
 * @Author: 尚先生
 * @CreateDate: 2019/1/24 17:42
 * @Version: 1.0
 */
@Target({ElementType.METHOD,ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface DesensitizedAnnotation {
    /*脱敏数据类型(规则)*/
    TypeEnum type();
    /*判断注解是否生效，暂时没有用到*/
    String isEffictiveMethod() default "";

}

引入枚举

主要是便于统一处理同类型的字段

public enum TypeEnum {
    /**客户名称**/
    PERSON_NAME,
    /**客户证件号**/
    PERSON_CERT_NO,
    /**客户手机号**/
    PERSON_PHONE_NO,
    /**客户银行卡名称**/
    PERSON_BANK_NAME,
    /**客户银行卡号**/
    PERSON_BANK_NO,
    /**密码**/
    PASSWORD,
}

定义基本数据模板类

主要作用是定义待过滤字段集合

/**
 * @ClassName: BaseInfo
 * @Description: 日志过滤字段基类
 * @Author: 尚先生
 * @CreateDate: 2019/1/24 17:38
 * @Version: 1.0
 */
public class BaseInfo implements Serializable {

    private static final long serialVersionUID = 1L;

    @DesensitizedAnnotation(type = TypeEnum.PERSON_NAME)
    private String custName;

    @DesensitizedAnnotation(type = TypeEnum.PERSON_CERT_NO)
    private String certNo;
}

定义处理工具类

/**
 * @ClassName: DesensitizedUtils
 * @Description: 日志脱敏工具类
 * @Author: 尚先生
 * @CreateDate: 2019/1/24 17:52
 * @Version: 1.0
 */
public class DesensitizedUtils {

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

    private static final Map<String, TypeEnum> annotationMaps = new HashMap<>();

    /**
     * 类加载时装配待脱敏字段
     */
    static {
        try {
            Class<?> clazz = Class.forName(BaseInfo.class.getName());
            Field[] fields = clazz.getDeclaredFields();
            for (int i = 0; i < fields.length; i++) {
                fields[i].setAccessible(true);
                DesensitizedAnnotation annotation = fields[i].getAnnotation(DesensitizedAnnotation.class);
                if (annotation != null) {
                    TypeEnum type = annotation.type();
                    String name = fields[i].getName();
                    //name为注解字段名称，value为注解类型。方便后续根据注解类型扩展
                    annotationMaps.put(name, type);
                }
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
            logger.error("类加载时装配待脱敏字段异常，异常信息:[{}]", new Object[]{e});
        }
    }


    /**
     * 脱敏处理方法
     *
     * @param object
     * @return
     */
    public static String getConverent(Map<String,Object> object) {
        try {
            // 1.处理Map数据类型
            if (object instanceof Map) {
                HashMap<String, Object> reqMap = (HashMap) object;
                Iterator<String> iterator = annotationMaps.keySet().iterator();
                iterator.forEachRemaining(annotationName -> {
                    if (reqMap.keySet().contains(annotationName)) {
                        doconverentForMap(reqMap, annotationName);
                    }
                });
                return JSON.toJSONString(reqMap);
            }      
            return JSON.toJSONString(object);
        } catch (Exception e) {
            e.printStackTrace();
            logger.error("日志脱敏处理失败，回滚，详细信息:[{}]", new Object[]{e});
            return JSON.toJSONString(object);
        }
    }

    /**
     * 脱敏数据源为Map时处理方式
     *
     * @param reqMap
     * @param annotationName
     * @return
     */
    private static void doconverentForMap(HashMap<String, Object> reqMap, String annotationName) {
        String value = String.valueOf(reqMap.get(annotationName));
        if (StringUtils.isNotEmpty(value)) {
            value = doConverentByType(value, annotationName);
        }
        reqMap.put(annotationName, value);
    }


    /**
     * 根据不同注解类型处理不同字段
     *
     * @param value
     * @param annotationName
     * @return
     */
    private static String doConverentByType(String value, String annotationName) {
        TypeEnum typeEnum = annotationMaps.get(annotationName);
        switch (typeEnum) {
            case PERSON_NAME:
                value = getStringByLength(value);
                break;
            case PERSON_CERT_NO:
                value = getStringByLength(value);
            default:
                value = getStringByLength(value);
        }
        return value;
    }

    /**
     * 根据value长度取值(切分)
     *
     * @param value
     * @return
     */
    private static String getStringByLength(String value) {
        int length = value.length();
        if (length == 2){
            value = value.substring(0, 1) + "*";
        }else if (length == 3){
            value = value.substring(0,1) + "*" + value.substring(length -1);
        }else if (length > 3 && length <= 5){
            value = value.substring(0,1) + "**" + value.substring(length -2);
        }else if (length > 5 && length <= 7){
            value = value.substring(0,2) + "***" + value.substring(length -2);
        }else if (length > 7){
            value = value.substring(0,3) + "*****" + value.substring(length -3);
        }
        return value;
    }

}

定义测试类

测试第一版实现的针对Map处理的脱敏操作

/**
 * @ClassName: TestDeaensitized
 * @Description: 日志脱敏测试类
 * @Author: 尚先生
 * @CreateDate: 2019/1/24 18:27
 * @Version: 1.0
 */
public class TestDeaensitized {

    public static void main(String[] args) {
        HashMap<String, Object> hashMap = new HashMap<>();
        hashMap.put("custName", "小妮儿");
        hashMap.put("certNo", "12345678909876543");
        hashMap.put("phone", "12345678909");
        System.out.println("脱敏前：" + hashMap);
        String converent1 = DesensitizedUtils.getConverent(hashMap);
        System.out.println("脱敏后：" + converent1);
    }
}

第一版实现测试结果

针对Map实现的脱敏结果
脱敏前：{certNo=12345678909876543, phone=12345678909, custName=小妮儿}
脱敏后：{"certNo":"123*****543","phone":"12345678909","custName":"小*儿"}

至此第一版功能实现顺利完成。

实现第二版

由于在RPC调用过程当中，大部分接口的参数封装数据类型都是Map，但是部分接口还是使用Java Bean所以在此针对Java Bean形式实现日志脱敏功能

实现思路：

根据不同的数据类型进行不同判断，屏蔽上层调用者的可见度，在底层动态实现分情况处理
在结果处理完之后，统一返回调用者序列化完成的数据信息

在第一版实现的基础之上，我们开始第二版的实现

添加实体类

主要是为了封装模拟RPC调用过程中参数实体的属性

/**
 * @ClassName: Person
 * @Description: Person实体类
 * @Author: 尚先生
 * @CreateDate: 2019/1/24 17:50
 * @Version: 1.0
 */
public class Person {

    private String custName;

    private int idNo;

    private String certNo;

    public String getCustName() {
        return custName;
    }

    public void setCustName(String custName) {
        this.custName = custName;
    }

    public int getIdNo() {
        return idNo;
    }

    public void setIdNo(int idNo) {
        this.idNo = idNo;
    }

    public String getCertNo() {
        return certNo;
    }

    public void setCertNo(String certNo) {
        this.certNo = certNo;
    }

    @Override
    public String toString() {
        return "Person{" +
                "custName='" + custName + '\'' +
                ", idNo=" + idNo +
                ", certNo='" + certNo + '\'' +
                '}';
    }
}

改造处理工具类

/**
 * @ClassName: DesensitizedUtils
 * @Description: 日志脱敏工具类
 * @Author: 尚先生
 * @CreateDate: 2019/1/24 17:52
 * @Version: 1.0
 */
public class DesensitizedUtils {

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

    private static final Map<String, TypeEnum> annotationMaps = new HashMap<>();

    /**
     * 类加载时装配待脱敏字段
     */
    static {
        try {
            Class<?> clazz = Class.forName(BaseInfo.class.getName());
            Field[] fields = clazz.getDeclaredFields();
            for (int i = 0; i < fields.length; i++) {
                fields[i].setAccessible(true);
                DesensitizedAnnotation annotation = fields[i].getAnnotation(DesensitizedAnnotation.class);
                if (annotation != null) {
                    TypeEnum type = annotation.type();
                    String name = fields[i].getName();
                    //name为注解字段名称，value为注解类型。方便后续根据注解类型扩展
                    annotationMaps.put(name, type);
                }
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
            logger.error("类加载时装配待脱敏字段异常，异常信息:[{}]", new Object[]{e});
        }
    }


    /**
     * 脱敏处理方法
     *
     * @param object
     * @return
     */
    public static String getConverent(Object object) {

        String objClassName = object.getClass().getName();

        try {
            // 1.处理Map数据类型
            if (object instanceof Map) {
                HashMap<String, Object> reqMap = (HashMap) object;
                Iterator<String> iterator = annotationMaps.keySet().iterator();
                iterator.forEachRemaining(annotationName -> {
                    if (reqMap.keySet().contains(annotationName)) {
                        doconverentForMap(reqMap, annotationName);
                    }
                });
                return JSON.toJSONString(reqMap);
            }
            // 2.处理Object数据类型
            Object val = new Object();
            Class<?> objClazz = Class.forName(objClassName);
            Field[] declaredFields = objClazz.getDeclaredFields();
            for (int j = 0; j < declaredFields.length; j++) {
                Iterator<String> iterator = annotationMaps.keySet().iterator();
                while (iterator.hasNext()) {
                    String annotationName = iterator.next();
                    if (declaredFields[j].getName().equals(annotationName)) {
                        declaredFields[j].setAccessible(true);
                        val = declaredFields[j].get(object);
                        //获取属性后现在默认处理的是String类型，其他类型数据可扩展
                        String value = doconverentForObject(val, annotationName);
                        declaredFields[j].set(object, value);
                    }
                }
            }
            return JSON.toJSONString(object);
        } catch (Exception e) {
            e.printStackTrace();
            logger.error("日志脱敏处理失败，回滚，详细信息:[{}]", new Object[]{e});
            return JSON.toJSONString(object);
        }
    }

    /**
     * 脱敏数据源为Object时处理方式
     *
     * @param val
     * @param annotationName
     * @return
     */
    private static String doconverentForObject(Object val, String annotationName) {

        String value = String.valueOf(val);
        if (StringUtils.isNotEmpty(value)) {
            value = doConverentByType(value, annotationName);
        }
        return value;
    }

    /**
     * 脱敏数据源为Map时处理方式
     *
     * @param reqMap
     * @param annotationName
     * @return
     */
    private static void doconverentForMap(HashMap<String, Object> reqMap, String annotationName) {
        String value = String.valueOf(reqMap.get(annotationName));
        if (StringUtils.isNotEmpty(value)) {
            value = doConverentByType(value, annotationName);
        }
        reqMap.put(annotationName, value);
    }


    /**
     * 根据不同注解类型处理不同字段
     *
     * @param value
     * @param annotationName
     * @return
     */
    private static String doConverentByType(String value, String annotationName) {
        TypeEnum typeEnum = annotationMaps.get(annotationName);
        switch (typeEnum) {
            case PERSON_NAME:
                value = getStringByLength(value);
                break;
            case PERSON_CERT_NO:
                value = getStringByLength(value);
            default:
                value = getStringByLength(value);
        }
        return value;
    }

    /**
     * 根据value长度取值(切分)
     *
     * @param value
     * @return
     */
    private static String getStringByLength(String value) {
        int length = value.length();
        if (length == 2){
            value = value.substring(0, 1) + "*";
        }else if (length == 3){
            value = value.substring(0,1) + "*" + value.substring(length -1);
        }else if (length > 3 && length <= 5){
            value = value.substring(0,1) + "**" + value.substring(length -2);
        }else if (length > 5 && length <= 7){
            value = value.substring(0,2) + "***" + value.substring(length -2);
        }else if (length > 7){
            value = value.substring(0,3) + "*****" + value.substring(length -3);
        }
        return value;
    }

}

定义测试类

测试第二版实现的针对Object处理的脱敏操作

/**
 * @ClassName: TestDeaensitized
 * @Description: 日志脱敏测试类
 * @Author: 尚先生
 * @CreateDate: 2019/1/24 18:27
 * @Version: 1.0
 */
public class TestDeaensitized {

    public static void main(String[] args) {
        HashMap<String, Object> hashMap = new HashMap<>();
        hashMap.put("custName", "小妮儿");
        hashMap.put("certNo", "12345678909876543");
        hashMap.put("phone", "12345678909");
        System.out.println("脱敏前：" + hashMap);
        String converent1 = DesensitizedUtils.getConverent(hashMap);
        System.out.println("脱敏后：" + converent1);
        Person person = new Person();
        person.setCertNo("12345678909876541");
        person.setCustName("小妮儿真可爱！");
        System.out.println("脱敏前：" + person);
        String converent2 = DesensitizedUtils.getConverent(person);
        System.out.println("脱敏后：" + converent2);
    }

第二版实现测试结果

针对Map实现的脱敏结果
脱敏前：{certNo=12345678909876543, phone=12345678909, custName=小妮儿}
脱敏后：{"certNo":"123*****543","phone":"12345678909","custName":"小*儿"}
针对Object实现的脱敏结果
脱敏前：Person{custName='小妮儿真可爱！', idNo=0, certNo='12345678909876541'}
脱敏后：{"certNo":"123*****541","custName":"小妮***爱！","idNo":0}

至此所有功能实现顺利完成。

完整代码和相关依赖请见GitHub

https://github.com/dwyanewede/project-learn/tree/master/src/main/java/com/learn/demo/desensitization

微信公众号

java界的小学生

猜你喜欢

转载自blog.csdn.net/shang_xs/article/details/86632071
今日推荐
TIOBE 5 月榜单：Fortran “复活”进入 Top 10
GCC 14.1 发布
面壁智能发布 Eurux-8x22B 开源大模型 —— 堪称「理科状元」
开源日报 | 谷歌扶持鸿蒙上位；开源Rabbit R1；Docker加持的安卓手机；微软的焦虑和野心；海尔电器把开放平台关了
中国码农的“35岁魔咒”
蘭雅 CorelDRAW 插件 2024.5.1 国际劳动节版，免费下载
Arc Browser for Windows 1.0 正式 GA
90后程序员开发视频搬运软件、不到一年获利超 700 万，结局很刑！
周排行
Java自定义时间格式
同步整形电路
在开发中最最最常用的字符串的属性大集合
Linux 查看端口占用并杀掉
Java基础四：ArrayList
多线程之死锁就是这么简单
mysql 基础命令集
awk 命令详解
Centos6.3编译安装nginx+php步骤
OCR （Optical Character Recognition，光学字符识别）
每日归档
更多
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)
2024-05-03(19)
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022