改造了以前写的数据脱敏插件,更好用了

开发 开发工具
以前用Mybatis插件的形式写了一个数据脱敏工具,但是发现有一定的局限性。

[[404361]]

以前用Mybatis插件的形式写了一个数据脱敏工具,但是发现有一定的局限性。很多时候我们从ORM查询到的数据有其它逻辑要处理,比如根据电话号查询用户信息,你脱敏了就没有办法来处理该逻辑了。所以脱敏这个步骤需要后置,放在JSON序列化这个阶段比较合适。今天就来实现这个功能。

Jackson序列化中脱敏

改造过程其实就是把脱敏后置到JSON序列化过程中,这里我使用Jackson类库。

原来Mybatis插件中的脱敏注解是这样的:

  1. @Retention(RetentionPolicy.RUNTIME) 
  2. @Target(ElementType.FIELD) 
  3. public @interface Sensitive { 
  4.     SensitiveStrategy strategy(); 

脱敏的策略是这样的:

  1. import java.util.function.Function
  2.  
  3. /** 
  4.  * 脱敏策略. 
  5.  * 
  6.  * @author felord.cn 
  7.  * @since 11 :25 
  8.  */ 
  9. public enum SensitiveStrategy { 
  10.     /** 
  11.      * Username sensitive strategy. 
  12.      */ 
  13.     USERNAME(s -> s.replaceAll("(\\S)\\S(\\S*)""$1*$2")), 
  14.     /** 
  15.      * Id card sensitive type. 
  16.      */ 
  17.     ID_CARD(s -> s.replaceAll("(\\d{4})\\d{10}(\\w{4})""$1****$2")), 
  18.     /** 
  19.      * Phone sensitive type. 
  20.      */ 
  21.     PHONE(s -> s.replaceAll("(\\d{3})\\d{4}(\\d{4})""$1****$2")), 
  22.     /** 
  23.      * Address sensitive type. 
  24.      */ 
  25.     ADDRESS(s -> s.replaceAll("(\\S{3})\\S{2}(\\S*)\\S{2}""$1****$2****")); 
  26.  
  27.  
  28.     private final Function<String, String> desensitizer; 
  29.  
  30.     SensitiveStrategy(Function<String, String> desensitizer) { 
  31.         this.desensitizer = desensitizer; 
  32.     } 
  33.  
  34.     public Function<String, String> desensitizer() { 
  35.         return desensitizer; 
  36.     } 

我将改造它们,是它们在JSON序列化中实现字段属性脱敏。

自定义脱敏序列化

这里我们首先实现自定义的脱敏序列化逻辑:

  1. import com.fasterxml.jackson.core.JsonGenerator; 
  2. import com.fasterxml.jackson.databind.BeanProperty; 
  3. import com.fasterxml.jackson.databind.JsonMappingException; 
  4. import com.fasterxml.jackson.databind.JsonSerializer; 
  5. import com.fasterxml.jackson.databind.SerializerProvider; 
  6. import com.fasterxml.jackson.databind.ser.ContextualSerializer; 
  7.  
  8. import java.io.IOException; 
  9. import java.util.Objects; 
  10.  
  11. /** 
  12.  * @author felord.cn 
  13.  * @since 1.0.8.RELEASE 
  14.  */ 
  15. public class SensitiveJsonSerializer extends JsonSerializer<String> implements ContextualSerializer { 
  16.     private SensitiveStrategy strategy; 
  17.  
  18.     @Override 
  19.     public void serialize(String value, JsonGenerator gen, SerializerProvider serializers) throws IOException { 
  20.            gen.writeString(strategy.desensitizer().apply(value)); 
  21.     } 
  22.  
  23.     @Override 
  24.     public JsonSerializer<?> createContextual(SerializerProvider prov, BeanProperty property) throws JsonMappingException { 
  25.  
  26.             Sensitive annotation = property.getAnnotation(Sensitive.class); 
  27.             if (Objects.nonNull(annotation)&&Objects.equals(String.class, property.getType().getRawClass())) { 
  28.                 this.strategy = annotation.strategy(); 
  29.                 return this; 
  30.             } 
  31.             return prov.findValueSerializer(property.getType(), property); 
  32.  
  33.     } 

其中createContextual方法用来获取实体类上的@Sensitive注解并根据条件初始化对应的JsonSerializer对象;而顾名思义,serialize方法执行脱敏序列化逻辑。

改造脱敏注解

然后就是改造@Sensitive,把上面自定义的JSON序列化和脱敏策略绑定到一起。这里用到了Jackson的捆绑注解@JacksonAnnotationsInside,它的作用是将多个注解组合到一起;另外一个是序列化注解@JsonSerialize,它的作用是声明使用我上面自定义的序列化方法。

  1. @Retention(RetentionPolicy.RUNTIME) 
  2. @Target(ElementType.FIELD) 
  3. @JacksonAnnotationsInside 
  4. @JsonSerialize(using = SensitiveJsonSerializer.class) 
  5. public @interface Sensitive { 
  6.     SensitiveStrategy strategy(); 

使用

这就改造完成了,我们来试一试。我们定义一个需要脱敏的实体类并根据字段标记上对应的脱敏注解:

  1. /** 
  2.  * @author felord.cn 
  3.  * @since 1.0.8.RELEASE 
  4.  */ 
  5. @Data 
  6. public class User { 
  7.  
  8.     /** 
  9.      * 真实姓名 
  10.      */ 
  11.     @Sensitive(strategy = SensitiveStrategy.USERNAME) 
  12.     private String realName; 
  13.     /** 
  14.      * 地址 
  15.      */ 
  16.     @Sensitive(strategy = SensitiveStrategy.ADDRESS) 
  17.     private String address; 
  18.     /** 
  19.      * 电话号码 
  20.      */ 
  21.     @Sensitive(strategy = SensitiveStrategy.PHONE) 
  22.     private String phoneNumber; 
  23.     /** 
  24.      * 身份证号码 
  25.      */ 
  26.     @Sensitive(strategy = SensitiveStrategy.ID_CARD) 
  27.     private String idCard; 

然后Jackson来序列化User实例:

  1. User user = new User(); 
  2.  
  3.   user.setRealName("张三丰"); 
  4.   user.setPhoneNumber("13333333333"); 
  5.   user.setAddress("湖北省十堰市丹江口市武当山"); 
  6.   user.setIdCard("4333333333334334333"); 
  7.  
  8.   ObjectMapper objectMapper = new ObjectMapper(); 
  9.  
  10.   String json = objectMapper.writeValueAsString(user); 
  11.  
  12.   System.out.println(json); 

可以得到:

  1.     "realName":"张*丰"
  2.     "address":"湖北省****市丹江口市武****"
  3.     "phoneNumber":"133****3333"
  4.     "idCard":"4333****34333" 

效果还是可以的,当然如果能加个开关就更好了,根据不同的场景来决定是否进行脱敏。

本文转载自微信公众号「码农小胖哥」,可以通过以下二维码关注。转载本文请联系码农小胖哥公众号。

 

责任编辑:武晓燕 来源: 码农小胖哥
相关推荐

2022-02-10 23:37:10

iOS苹果功能

2023-04-28 12:10:58

ChatGPTAI联网模式

2022-04-20 12:17:50

命令Batcat

2022-04-25 10:04:56

df命令Linux

2022-03-11 17:52:23

iOSiPhone

2022-06-02 12:51:14

Windows 11开始菜单

2024-08-13 17:29:24

2021-03-19 09:48:10

Jupyter Not插件Python

2022-02-21 11:31:25

微软任务栏Windows 11

2018-11-12 00:23:44

谷歌Android开发者

2022-06-07 10:06:16

Windows 11任务管理器

2022-06-10 11:32:05

VSCode 中数据库管理SQLTools

2010-01-06 13:32:27

JSON数据

2021-08-31 09:30:10

Android数据库调试

2020-09-08 08:45:39

jupyter插件代码

2021-07-13 15:35:52

微软Windows 11Windows

2021-03-26 15:18:11

代码工具Mockoon

2012-12-25 09:58:50

数据科学家大数据

2020-05-15 15:20:38

指纹识别人脸识别手机

2017-12-06 15:27:21

IntelliJ插件Grep Consol
点赞
收藏

51CTO技术栈公众号