【6】编写脱敏插件 - 图1

1. 前言

在日常开发中，身份证号、手机号、卡号、客户号等个人信息都需要进行数据脱敏。否则容易造成个人隐私泄露，客户资料泄露，给不法分子可乘之机。但是数据脱敏不是把敏感信息隐藏起来，而是看起来像真的一样，实际上不能是真的。我以前的公司就因为不重视脱敏，一名员工在离职的时候通过后台的导出功能导出了核心的客户资料卖给了竞品，给公司造成了重大的损失。当然这里有数据管理的原因，但是脱敏仍旧是不可忽略的一环，脱敏可以从一定程度上保证数据的合规使用。下面就是一份经过脱敏的数据：

【6】编写脱敏插件 - 图2

2. Mybatis 脱敏插件

最近在研究Mybatis的插件，所以考虑能不能在ORM中搞一搞脱敏，所以就尝试了一下，这里分享一下思路。借此也分享一下Mybatis插件开发的思路。

2.1 Mybatis 插件接口

Mybatis中使用插件，需要实现接口org.apache.ibatis.plugin.Interceptor，如下所示：

  1. public interface Interceptor {
  3.   Object intercept(Invocation invocation) throws Throwable;
  5.   default Object plugin(Object target) {
  6.     return Plugin.wrap(target, this);
  7.   }
  9.   default void setProperties(Properties properties) {
  10.     // NOP
  11.   }
  13. }

这里其实最核心的是Object intercept(Invocation invocation)方法，这是我们需要实现的方法。

2.2 Invocation 对象

那么核心方法中的Invocation 是个什么概念呢？

  1. public class Invocation {
  3.   private final Object target;
  4.   private final Method method;
  5.   private final Object[] args;
  7.   public Invocation(Object target, Method method, Object[] args) {
  8.     this.target = target;
  9.     this.method = method;
  10.     this.args = args;
  11.   }
  13.   public Object getTarget() {
  14.     return target;
  15.   }
  17.   public Method getMethod() {
  18.     return method;
  19.   }
  21.   public Object[] getArgs() {
  22.     return args;
  23.   }
  25.   public Object proceed() throws InvocationTargetException, IllegalAccessException {
  26.     return method.invoke(target, args);
  27.   }
  29. }

这个东西包含了四个概念：

  • target 拦截的对象
  • method 拦截target中的具体方法，也就是说Mybatis插件的粒度是精确到方法级别的。
  • args 拦截到的参数。
  • proceed 执行被拦截到的方法，你可以在执行的前后做一些事情。

2.3 拦截签名

既然我们知道了Mybatis插件的粒度是精确到方法级别的，那么疑问来了，插件如何知道轮到它工作了呢？

所以Mybatis设计了签名机制来解决这个问题，通过在插件接口上使用注解@Intercepts标注来解决这个问题。

  1. @Intercepts(@Signature(type = ResultSetHandler.class,
  2.         method = "handleResultSets",
  3.         args = {Statement.class}))

就像上面一样，事实上就等于配置了一个Invocation。

2.4 插件的作用域

那么问题又来了，Mybatis插件能拦截哪些对象,或者说插件能在哪个生命周期阶段起作用呢？它可以拦截以下四大对象：

  • Executor 是SQL执行器，包含了组装参数，组装结果集到返回值以及执行SQL的过程，粒度比较粗。
  • StatementHandler 用来处理SQL的执行过程，我们可以在这里重写SQL非常常用。
  • ParameterHandler 用来处理传入SQL的参数，我们可以重写参数的处理规则。
  • ResultSetHandler 用于处理结果集，我们可以重写结果集的组装规则。

你需要做的就是明确的你的业务需要在上面四个对象的哪个处理阶段拦截处理即可。

2.5 MetaObject

Mybatis提供了一个工具类org.apache.ibatis.reflection.MetaObject。它通过反射来读取和修改一些重要对象的属性。我们可以利用它来处理四大对象的一些属性，这是Mybatis插件开发的一个常用工具类。

  • Object getValue(String name) 根据名称获取对象的属性值，支持OGNL表达式。
  • void setValue(String name, Object value) 设置某个属性的值。
  • Class<?> getSetterType(String name) 获取setter方法的入参类型。
  • Class<?> getGetterType(String name) 获取getter方法的返回值类型。

通常我们使用SystemMetaObject.forObject(Object object)来实例化MetaObject对象。你会在接下来的实战DEMO中看到我使用它。

3. Mybatis 脱敏插件实战

接下来我就把开头的脱敏需求实现一下。首先需要对脱敏字段进行标记并确定使用的脱敏策略。

编写脱敏函数：

  1. /**
  2.  * 具体策略的函数
  3.  * @author felord.cn
  4.  * @since 11:24
  5.  **/
  6. public interface Desensitizer  extends Function<String,String>  {
  8. }

编写脱敏策略枚举：

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

编写脱敏字段的标记注解：

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

我们的返回对象中如果某个字段需要脱敏，只需要通过标记就可以了。例如下面这样：

  1. @Data
  2. public class UserInfo {
  4.     private static final long serialVersionUID = -8938650956516110149L;
  5.     private Long userId;
  6.     @Sensitive(strategy = SensitiveStrategy.USERNAME)
  7.     private String name;
  8.     private Integer age;
  9. }

然后就是编写插件了，我可以确定的是需要拦截的是ResultSetHandler对象的handleResultSets方法，我们只需要实现插件接口Interceptor并添加签名就可以了。全部逻辑如下：

  1. @Slf4j
  2. @Intercepts(@Signature(type = ResultSetHandler.class,
  3.         method = "handleResultSets",
  4.         args = {Statement.class}))
  5. public class SensitivePlugin implements Interceptor {
  6.     @SuppressWarnings("unchecked")
  7.     @Override
  8.     public Object intercept(Invocation invocation) throws Throwable {
  9.         List<Object> records = (List<Object>) invocation.proceed();
  10.         // 对结果集脱敏
  11.         records.forEach(this::sensitive);
  12.         return records;
  13.     }
  16.     private void sensitive(Object source) {
  17.         // 拿到返回值类型
  18.         Class<?> sourceClass = source.getClass();
  19.         // 初始化返回值类型的 MetaObject
  20.         MetaObject metaObject = SystemMetaObject.forObject(source);
  21.         // 捕捉到属性上的标记注解 @Sensitive 并进行对应的脱敏处理
  22.         Stream.of(sourceClass.getDeclaredFields())
  23.                 .filter(field -> field.isAnnotationPresent(Sensitive.class))
  24.                 .forEach(field -> doSensitive(metaObject, field));
  25.     }
  28.     private void doSensitive(MetaObject metaObject, Field field) {
  29.         // 拿到属性名
  30.         String name = field.getName();
  31.         // 获取属性值
  32.         Object value = metaObject.getValue(name);
  33.         // 只有字符串类型才能脱敏  而且不能为null
  34.         if (String.class == metaObject.getGetterType(name) && value != null) {
  35.             Sensitive annotation = field.getAnnotation(Sensitive.class);
  36.             // 获取对应的脱敏策略 并进行脱敏
  37.             SensitiveStrategy type = annotation.strategy();
  38.             Object o = type.getDesensitizer().apply((String) value);
  39.             // 把脱敏后的值塞回去
  40.             metaObject.setValue(name, o);
  41.         }
  42.     }
  43. }

然后配置脱敏插件使之生效：

  1. @Bean
  2. public SensitivePlugin sensitivePlugin(){
  3.     return new SensitivePlugin();
  4. }

操作查询获得结果 UserInfo(userId=123123, name=李*龙, age=28) ，成功将指定字段进行了脱敏。

补充一句，其实脱敏也可以在JSON序列化的时候进行。

4. 总结

今天对编写Mybatis插件的一些要点进行了说明，同时根据说明实现了一个脱敏插件。但是请注意一定要熟悉四大对象的生命周期，否则自写插件可能会造成意想不到的结果。插件可以关注：码农小胖哥 回复关键字 sensitive 进行获取。如果你觉得有用请无情的点赞。