java使用注解进行数据脱敏处理

一：日志打印脱敏和页面数据显示处理问题

1， 有的时候需要对打印的数据进行脱敏处理，屏蔽关键信息和提供给页面显示的需要进行数据处理，可以使用日志工具和自行处理，这里使用注解和反射对数据进行处理（个人记录一下，各位看看就行了）

2，显示的效果

{
  "code": "--",
  "data": {
    "name": "小小",
    "address": "收i**佛i",
    "workId": "333**333",
    "count": 152
  }
}

二：实现类容

1：处理单个对象数据

1，首先定义一个注解

/**
 * 用于测试的注解
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface MarkAnnotation {
    //注解的属性可以自行添加
    String value() default ""; 
    int start() default 0;//屏蔽长度，这里是字符前后几位屏蔽，默认全屏蔽
    String mark() default "**";//这个是屏蔽字符，这个是默认的，可以自行选择
}

/**
 * 测试对象
 */
public class Emp {

    private String name;
    @MarkAnnotation(start = 2)//从字符第二位开始，到结束前两位
    private String address;
    @MarkAnnotation(start = 3,mark = "--")//这里使用"--"屏蔽
    private String workId;
    private Integer count;

    @Override
    public String toString() {
        return "Emp{" +
                "name='" + name + '\'' +
                ", address='" + address + '\'' +
                ", workId='" + workId + '\'' +
                ", count=" + count +
                '}';
    }
    public Integer getCount() {
        return count;
    }
    public void setCount(Integer count) {
        this.count = count;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getAddress() {
        return address;
    }
    public void setAddress(String address) {
        this.address = address;
    }
    public String getWorkId() {
        return workId;
    }
    public void setWorkId(String workId) {
        this.workId = workId;
    }
}

2,处理方法

/**
     * 这个方法处理对象的，可以添加对字符和集合的处理
     * @param obj
     * @return
     */
    public static String markDetail1(Object obj) {
      //这里是对数据进行脱敏处理
        if(obj instanceof String){
            return obj.toString();
        }
        if(obj instanceof List){
            return obj.toString();
        }
        StringBuilder strs = new StringBuilder();
        Class aClass = obj.getClass();//获取反射
        Field[] fields = aClass.getDeclaredFields();
        strs.append("{");
        Arrays.stream(fields).forEach(field -> {//通过stream流处理属性集合
            field.setAccessible(true);//设置私有对象可见
            try {
                //这个处理中没有对数据类型判断，统一当作字符串处理
            MarkAnnotation annotation = field.getAnnotation(MarkAnnotation.class);//获取字段上面的注解
            if (annotation != null) {//添加注解的
                String mark = annotation.mark();//获得注解中的属性
                int start = annotation.start();
                if (!"".equals(mark)) {
                    String s = (String) field.get(obj);
                    if (start != 0) {
                        //通过注解的属性对数据处理
                        String replace = s.substring(0, annotation.start()) + mark + s.substring(s.length() - annotation.start());
                        String ss = "\"" + field.getName() + "\":\"" + replace + "\",";
                        strs.append(ss);
                    } else {
                        String ss = "\"" + field.getName() + "\":\"" + mark + "\",";
                        strs.append(ss);
                    }
                }
            } else {//没有添加注解的
                String ss = "\"" + field.getName() + "\":\"" + field.get(obj) + "\",";
                strs.append(ss);
            }
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
        });
        strs.append("}");
        //这里替换了最后一个逗号（可以在循环里处理）
        return strs.toString().replace(",}", "}");
    }

3，处理结果：

//数据        
Emp emp = new Emp();
emp.setName("小小");
emp.setAddress("收四代机哦覅集佛");
emp.setWorkId("3333333333333");
emp.setCount(152);

//结果
{
  "name": "小小",
  "address": "收四**集佛",
  "workId": "333--333",
  "count": "152"
}

1：处理复杂的对象数据

1，对象类型

public class Test01<T> {
   @MarkAnnotation(mark = "--")
   private String code;
   private String[] array;
   private T data;
   private List<T> list;//可以加其他的对象泛型

   public List<T> getList() {
      return list;
   }

   public void setList(List<T> list) {
      this.list = list;
   }

   public String getCode() {
      return code;
   }

   public void setCode(String code) {
      this.code = code;
   }

   public T getData() {
      return data;
   }

   public void setData(T data) {
      this.data = data;
   }
}

2，处理方法

   /**
     * 这个能处理大多数的场景，还有需要处理的属性类型，
     * 可以参照下面方法添加
     * 下面的支持集合，泛型，对象（默认最后是对象），数组
     * @param obj
     * @return
     */ 
public static String markDetail4(Object obj) {
        StringBuilder strs = new StringBuilder();
        Class aClass = obj.getClass();
        Field[] fields = aClass.getDeclaredFields();
        strs.append("{");
        for (Field field : fields) {
            field.setAccessible(true);
            try {
                Object o = field.get(obj);
                if (o == null) {
                    String ss = "\"" + field.getName() + "\":" + field.get(obj) + ",";
                    strs.append(ss);
                }else {
                    if (o instanceof String) {
                        MarkAnnotation annotation = field.getAnnotation(MarkAnnotation.class);
                        if (annotation != null) {//添加注解的
                            String mark = annotation.mark();//获得注解中的属性
                            int start = annotation.start();
                            if (!"".equals(mark)) {
                                if (start != 0) {
                                    String value =(String) o;
                                    String replace = value.substring(0, annotation.start()) + mark + value.substring(value.length() - annotation.start());
                                    String ss = "\"" + field.getName() + "\":\"" + replace + "\",";
                                    strs.append(ss);
                                } else {
                                    String ss = "\"" + field.getName() + "\":\"" + mark + "\",";
                                    strs.append(ss);
                                }
                            }
                        } else {//没有添加注解的
                            String ss = "\"" + field.getName() + "\":\"" + field.get(obj) + "\",";
                            strs.append(ss);
                        }
                    }else if (o instanceof Integer || o instanceof Double||o instanceof Boolean||o instanceof Character) {
                        String ss = "\"" + field.getName() + "\":" + field.get(obj) + ",";
                        strs.append(ss);
                    }else if (o instanceof List) {//处理集合
                        String ss = "\"" + field.getName() + "\":[";
                        List<Object> list =(List<Object>) field.get(obj);
                        if (list != null&&list.size()>0) {
                            for (int j = 0; j < list.size(); j++) {
                                try {
                                    ss += markDetail4(list.get(j))+",";
                                } catch (Exception e) {
                                    e.printStackTrace();
                                }
                            }
                        }
                        ss += "]";
                        strs.append(ss.replace(",]","],"));
                    }else if (o instanceof String[]) {//处理字符数组
                        String ss = "\"" + field.getName() + "\":[";
                        String[] list =(String[]) field.get(obj);
                        if (list != null&&list.length>0) {
                            for (int j = 0; j < list.length; j++) {
                                try {
                                    ss += "\""+list[0]+"\"" +",";
                                } catch (Exception e) {
                                    e.printStackTrace();
                                }
                            }
                        }
                        ss += "]";
                        strs.append(ss.replace(",]","],"));
                    }else {
                        //这里采用递归的方法处理属性值是一个对象的时候
                        String ss = "\"" + field.getName() + "\":" + markDetail4(field.get(obj)) + ",";
                        strs.append(ss);
                    }
                }
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }

        }

        strs.append("}");
        return strs.toString().replace(",}", "}");
    }

3.处理的数据示例

 public static void main(String[] args) {
        ReqDto<ReqBody> reqDto = new ReqDto<>();
        List<ReqBody> list = new ArrayList<>();
        ReqHead head = new ReqHead();
        head.setTranCode("10001");
        head.setSysData("你是个小猪吧");
        reqDto.setHead(head);
        //reqDto.setCode("55555555555555");
        ReqBody body = new ReqBody();
        body.setName("小小");
        body.setAddress("收四代机哦覅集佛");
        body.setWorkId("3333333333333");
        body.setCount(152);
        body.setFlag(true);
      //  body.setMoney(52.00);
        list.add(body);
        list.add(body);
        reqDto.setData(body);
         String[] ss =new String[]{"老王","小王"};
         reqDto.setArray(ss);

        String s = markDetail4(reqDto);
        System.out.println("处理后的对象:" + s);
    }

结果展示

{
  "code": null,
  "array": [
    "老王",
    "老王"
  ],
  "head": {
    "tranCode": "10001",
    "TranDate": null,
    "sysData": "你是个--小猪吧"
  },
  "list": [
    {
      "name": "小小",
      "address": "收四**集佛",
      "workId": "333--333",
      "count": 152,
      "money": null,
      "flag": true
    },
    {
      "name": "小小",
      "address": "收四**集佛",
      "workId": "333--333",
      "count": 152,
      "money": null,
      "flag": true
    }
  ],
  "data": {
    "name": "小小",
    "address": "收四**集佛",
    "workId": "333--333",
    "count": 152,
    "money": null,
    "flag": true
  }
}

以上就是我处理过程，有好的办法可以分享的，希望能分享！！！！！！