求求你别乱脱敏了！MyBatis 插件 + 注解轻松实现数据脱敏，So easy~! ...

问题

在项目中需要对用户敏感数据进行脱敏处理，例如身份号、手机号等信息进行加密再入库。
解决思路

• 就是：一种最简单直接的方式，在所有涉及数据敏感的查询到对插入时进行密码加解密
  
• 方法二：有方法一到出现对所有重大问题的影响，需要考虑到问题的出现，并且需要考虑可能出现的组员时添加数据的方法。
  

最后决定采用mybatis的插件在mybatis的SQL执行和结果填充操作上进行切入。上层业务调用不再需要考虑数据的加敏同时也保证了数据的加解密

Mybatis 插件原理

Mybatis 的是通过拦截器实现的，Mabatis 支持对当事人进行拦截

实现

• 设置对参数中带有敏感参数字段的数据时进行加密
  
• 对返回的结果进行解密处理
  

根据不同的要求，我们只需要对ParameterHandler和ResultSetHandler进行切入。
定义特定注解，在切入时需要检查字段中是否包含注解来是否加解密
加注解

定义SensitiveData注解

1. import java.lang.annotation.*;
2. /**
3. * 该注解定义在类上
4. * 插件通过扫描类对象是否包含这个注解来决定是否继续扫描其中的字段注解
5. * 这个注解要配合EncryptTransaction注解
6. **/
7. @Inherited
8. @Target({ElementType.TYPE})
9. @Retention(RetentionPolicy.RUNTIME)
10. public @interface SensitiveData {
12. }

复制代码

定义EncryptTransaction注解

1. import java.lang.annotation.*;
2. /**
3. * 该注解有两种使用方式
4. * ①：配合@SensitiveData加在类中的字段上
5. * ②：直接在Mapper中的方法参数上使用
6. **/
7. @Documented
8. @Inherited
9. @Target({ElementType.FIELD, ElementType.PARAMETER})
10. @Retention(RetentionPolicy.RUNTIME)
11. public @interface EncryptTransaction {
13. }

复制代码

加解密工具类

解密

1. package sicnu.cs.ich.common.interceptor.transaction.service;
3. public interface IDecryptUtil {
4.     /**
5.      * 解密
6.      *
7.      * @param result resultType的实例
8.      * @return T
9.      * @throws IllegalAccessException 字段不可访问异常
10.      */
11.     <T> T decrypt(T result) throws IllegalAccessException;
12. }

复制代码

加密接口

1. package sicnu.cs.ich.common.interceptor.transaction.service;
3. import java.lang.reflect.Field;
5. public interface IEncryptUtil {
6.     /**
7.      * 加密
8.      *
9.      * @param declaredFields 加密字段
10.      * @param paramsObject   对象
11.      * @param <T>            入参类型
12.      * @return 返回加密
13.      * @throws IllegalAccessException 不可访问
14.      */
15.     <T> T encrypt(Field[] declaredFields, T paramsObject) throws IllegalAccessException;
16. }
17. package sicnu.cs.ich.common.interceptor.transaction.service.impl;
19. import org.springframework.stereotype.Component;
20. import sicnu.cs.ich.api.common.annotations.transaction.EncryptTransaction;
21. import sicnu.cs.ich.common.interceptor.transaction.service.IDecryptUtil;
22. import sicnu.cs.ich.common.util.keyCryptor.DBAESUtil;
24. import java.lang.reflect.Field;
25. import java.util.Objects;
27. @Component
28. public class DecryptImpl implements IDecryptUtil {
30.     /**
31.      * 解密
32.      *
33.      * @param result resultType的实例
34.      */
35.     @Override
36.     public <T> T decrypt(T result) throws IllegalAccessException {
37.         //取出resultType的类
38.         Class<?> resultClass = result.getClass();
39.         Field[] declaredFields = resultClass.getDeclaredFields();
40.         for (Field field : declaredFields) {
41.             //取出所有被DecryptTransaction注解的字段
42.             EncryptTransaction encryptTransaction = field.getAnnotation(EncryptTransaction.class);
43.             if (!Objects.isNull(encryptTransaction)) {
44.                 field.setAccessible(true);
45.                 Object object = field.get(result);
46.                 //String的解密
47.                 if (object instanceof String) {
48.                     String value = (String) object;
49.                     //对注解的字段进行逐一解密
50.                     try {
51.                         field.set(result, DBAESUtil.decrypt(value));
52.                     } catch (Exception e) {
53.                         e.printStackTrace();
54.                     }
55.                 }
56.             }
57.         }
58.         return result;
59.     }
60. }

复制代码

加密实现类

1. package sicnu.cs.ich.common.interceptor.transaction.service.impl;
3. import com.fasterxml.jackson.databind.ObjectReader;
4. import org.springframework.stereotype.Component;
5. import sicnu.cs.ich.api.common.annotations.transaction.EncryptTransaction;
6. import sicnu.cs.ich.common.interceptor.transaction.service.IEncryptUtil;
7. import sicnu.cs.ich.common.util.keyCryptor.DBAESUtil;
9. import java.io.ObjectInputStream;
10. import java.lang.reflect.Field;
11. import java.util.Arrays;
12. import java.util.Objects;
13. import java.util.Random;
15. @Component
16. public class EncryptUtilImpl implements IEncryptUtil {
18.     @Override
19.     public <T> T encrypt(Field[] declaredFields, T paramsObject) throws IllegalAccessException {
20.             //取出所有被EncryptTransaction注解的字段
21.         for (Field field : declaredFields) {
22.             EncryptTransaction encryptTransaction = field.getAnnotation(EncryptTransaction.class);
23.             if (!Objects.isNull(encryptTransaction)) {
24.                 field.setAccessible(true);
25.                 Object object = field.get(paramsObject);
26.                 //暂时只实现String类型的加密
27.                 if (object instanceof String) {
28.                     String value = (String) object;
29.                     //加密
30.                     try {
31.                         field.set(paramsObject, DBAESUtil.encrypt(value));
32.                     } catch (Exception e) {
33.                         e.printStackTrace();
34.                     }
35.                 }
36.             }
37.         }
38.         return paramsObject;
39.     }
40. }

复制代码

模拟类

1. package sicnu.cs.ich.common.interceptor.transaction.service.impl;
3. import org.springframework.stereotype.Component;
4. import sicnu.cs.ich.api.common.annotations.transaction.EncryptTransaction;
5. import sicnu.cs.ich.common.interceptor.transaction.service.IDecryptUtil;
6. import sicnu.cs.ich.common.util.keyCryptor.DBAESUtil;
8. import java.lang.reflect.Field;
9. import java.util.Objects;
11. @Component
12. public class DecryptImpl implements IDecryptUtil {
14.     /**
15.      * 解密
16.      *
17.      * @param result resultType的实例
18.      */
19.     @Override
20.     public <T> T decrypt(T result) throws IllegalAccessException {
21.         //取出resultType的类
22.         Class<?> resultClass = result.getClass();
23.         Field[] declaredFields = resultClass.getDeclaredFields();
24.         for (Field field : declaredFields) {
25.             //取出所有被DecryptTransaction注解的字段
26.             EncryptTransaction encryptTransaction = field.getAnnotation(EncryptTransaction.class);
27.             if (!Objects.isNull(encryptTransaction)) {
28.                 field.setAccessible(true);
29.                 Object object = field.get(result);
30.                 //String的解密
31.                 if (object instanceof String) {
32.                     String value = (String) object;
33.                     //对注解的字段进行逐一解密
34.                     try {
35.                         field.set(result, DBAESUtil.decrypt(value));
36.                     } catch (Exception e) {
37.                         e.printStackTrace();
38.                     }
39.                 }
40.             }
41.         }
42.         return result;
43.     }
44. }

复制代码

加解密工具类

1. package sicnu.cs.ich.common.util.keyCryptor;
3. import javax.crypto.Cipher;
4. import javax.crypto.spec.IvParameterSpec;
5. import javax.crypto.spec.SecretKeySpec;
6. import java.util.Base64;
8. public class DBAESUtil {
9.     private static final String DEFAULT_V = "6859505890402435";
10.     // 自己填写
11.     private static final String KEY = "***";
12.     private static final String ALGORITHM = "AES";
14.     private static SecretKeySpec getKey() {
15.         byte[] arrBTmp = DBAESUtil.KEY.getBytes();
16.         // 创建一个空的16位字节数组（默认值为0）
17.         byte[] arrB = new byte[16];
18.         for (int i = 0; i < arrBTmp.length && i < arrB.length; i++) {
19.             arrB[i] = arrBTmp[i];
20.         }
21.         return new SecretKeySpec(arrB, ALGORITHM);
22.     }
24.     /**
25.      * 加密
26.      */
27.     public static String encrypt(String content) throws Exception {
28.         final Base64.Encoder encoder = Base64.getEncoder();
29.         SecretKeySpec keySpec = getKey();
30.         Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
31.         IvParameterSpec iv = new IvParameterSpec(DEFAULT_V.getBytes());
32.         cipher.init(Cipher.ENCRYPT_MODE, keySpec, iv);
33.         byte[] encrypted = cipher.doFinal(content.getBytes());
34.         return encoder.encodeToString(encrypted);
35.     }
37.     /**
38.      * 解密
39.      */
40.     public static String decrypt(String content) throws Exception {
41.         final Base64.Decoder decoder = Base64.getDecoder();
42.         SecretKeySpec keySpec = getKey();
43.         Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
44.         IvParameterSpec iv = new IvParameterSpec(DEFAULT_V.getBytes());
45.         cipher.init(Cipher.DECRYPT_MODE, keySpec, iv);
46.         byte[] base64 = decoder.decode(content);
47.         byte[] original = cipher.doFinal(base64);
48.         return new String(original);
49.     }
51. }

复制代码

推荐一个开源免费的 Spring Boot 最全教程：

https://github.com/javastacks/spring-boot-best-practice

插件实现

参数插件ParameterInterceptor

切入mybatis设置参数时对敏感数据进行加密
Mybatis插件的使用就是通过实现Mybatis中的Interceptor接口
再@Intercepts注解

1. // 使用mybatis插件时需要定义签名
2. // type标识需要切入的Handler
3. // method表示要要切入的方法
4. @Intercepts({
5. @Signature(type = ParameterHandler.class, method = “setParameters”, args = PreparedStatement.class),
6. })
7. package sicnu.cs.ich.common.interceptor.transaction;
9. import com.baomidou.mybatisplus.core.MybatisParameterHandler;
10. import lombok.extern.slf4j.Slf4j;
11. import org.apache.ibatis.executor.parameter.ParameterHandler;
12. import org.apache.ibatis.mapping.BoundSql;
13. import org.apache.ibatis.mapping.MappedStatement;
14. import org.apache.ibatis.plugin.*;
15. import org.springframework.beans.factory.annotation.Autowired;
16. import org.springframework.core.annotation.AnnotationUtils;
17. import org.springframework.stereotype.Component;
18. import org.springframework.util.CollectionUtils;
19. import sicnu.cs.ich.api.common.annotations.transaction.EncryptTransaction;
20. import sicnu.cs.ich.api.common.annotations.transaction.SensitiveData;
21. import sicnu.cs.ich.common.interceptor.transaction.service.IEncryptUtil;
22. import sicnu.cs.ich.common.util.keyCryptor.DBAESUtil;
23. import java.lang.annotation.Annotation;
24. import java.lang.reflect.Field;
25. import java.lang.reflect.Method;
26. import java.lang.reflect.Parameter;
27. import java.sql.PreparedStatement;
28. import java.util.*;
30. @Slf4j
31. // 注入Spring
32. @Component
33. @Intercepts({
34.         @Signature(type = ParameterHandler.class, method = "setParameters", args = PreparedStatement.class),
35. })
36. public class ParameterInterceptor implements Interceptor {
38.     @Autowired
39.     private IEncryptUtil IEncryptUtil;
41.     @Override
42.     public Object intercept(Invocation invocation) throws Throwable {
43.         //@Signature 指定了 type= parameterHandler 后，这里的 invocation.getTarget() 便是parameterHandler
44.         //若指定ResultSetHandler ，这里则能强转为ResultSetHandler
45.         MybatisParameterHandler parameterHandler = (MybatisParameterHandler) invocation.getTarget();
46.         // 获取参数对像，即 mapper 中 paramsType 的实例
47.         Field parameterField = parameterHandler.getClass().getDeclaredField("parameterObject");
48.         parameterField.setAccessible(true);
49.         //取出实例
50.         Object parameterObject = parameterField.get(parameterHandler);
51.         // 搜索该方法中是否有需要加密的普通字段
52.         List<String> paramNames = searchParamAnnotation(parameterHandler);
53.         if (parameterObject != null) {
54.             Class<?> parameterObjectClass = parameterObject.getClass();
55.             //对类字段进行加密
56.             //校验该实例的类是否被@SensitiveData所注解
57.             SensitiveData sensitiveData = AnnotationUtils.findAnnotation(parameterObjectClass, SensitiveData.class);
58.             if (Objects.nonNull(sensitiveData)) {
59.                 //取出当前当前类所有字段，传入加密方法
60.                 Field[] declaredFields = parameterObjectClass.getDeclaredFields();
61.                 IEncryptUtil.encrypt(declaredFields, parameterObject);
62.             }
63.             // 对普通字段进行加密
64.             if (!CollectionUtils.isEmpty(paramNames)) {
65.                 // 反射获取 BoundSql 对象，此对象包含生成的sql和sql的参数map映射
66.                 Field boundSqlField = parameterHandler.getClass().getDeclaredField("boundSql");
67.                 boundSqlField.setAccessible(true);
68.                 BoundSql boundSql = (BoundSql) boundSqlField.get(parameterHandler);
69.                 PreparedStatement ps = (PreparedStatement) invocation.getArgs()[0];
70.                 // 改写参数
71.                 processParam(parameterObject, paramNames);
72.                 // 改写的参数设置到原parameterHandler对象
73.                 parameterField.set(parameterHandler, parameterObject);
74.                 parameterHandler.setParameters(ps);
75.             }
76.         }
77.         return invocation.proceed();
78.     }
80.     private void processParam(Object parameterObject, List<String> params) throws Exception {
81.         // 处理参数对象  如果是 map 且map的key 中没有 tenantId，添加到参数map中
82.         // 如果参数是bean，反射设置值
84.         if (parameterObject instanceof Map) {
85.             @SuppressWarnings("unchecked")
86.             Map<String, String> map = ((Map<String, String>) parameterObject);
87.             for (String param : params) {
88.                 String value = map.get(param);
89.                 map.put(param, value==null?null:DBAESUtil.encrypt(value));
90.             }
91. //            parameterObject = map;
92.         }
93.     }
95.     private List<String> searchParamAnnotation(ParameterHandler parameterHandler) throws NoSuchFieldException, ClassNotFoundException, IllegalAccessException {
96.         Class<MybatisParameterHandler> handlerClass = MybatisParameterHandler.class;
97.         Field mappedStatementFiled = handlerClass.getDeclaredField("mappedStatement");
98.         mappedStatementFiled.setAccessible(true);
99.         MappedStatement mappedStatement = (MappedStatement) mappedStatementFiled.get(parameterHandler);
100.         String methodName = mappedStatement.getId();
101.         Class<?> mapperClass = Class.forName(methodName.substring(0, methodName.lastIndexOf('.')));
102.         methodName = methodName.substring(methodName.lastIndexOf('.') + 1);
103.         Method[] methods = mapperClass.getDeclaredMethods();
104.         Method method = null;
105.         for (Method m : methods) {
106.             if (m.getName().equals(methodName)) {
107.                 method = m;
108.                 break;
109.             }
110.         }
111.         List<String> paramNames = null;
112.         if (method != null) {
114.             Annotation[][] pa = method.getParameterAnnotations();
115.             Parameter[] parameters = method.getParameters();
116.             for (int i = 0; i < pa.length; i++) {
117.                 for (Annotation annotation : pa[i]) {
118.                     if (annotation instanceof EncryptTransaction) {
119.                         if (paramNames == null) {
120.                             paramNames = new ArrayList<>();
121.                         }
122.                         paramNames.add(parameters[i].getName());
123.                     }
124.                 }
125.             }
126.         }
127.         return paramNames;
128.     }
130.     @Override
131.     public Object plugin(Object target) {
132.         return Plugin.wrap(target, this);
133.     }
135.     @Override
136.     public void setProperties(Properties properties) {
138.     }
139. }

复制代码

返回值插件ResultSetInterceptor

1. package sicnu.cs.ich.common.interceptor.transaction;
3. import lombok.extern.slf4j.Slf4j;
4. import org.apache.ibatis.executor.resultset.ResultSetHandler;
5. import org.apache.ibatis.plugin.*;
6. import org.springframework.beans.factory.annotation.Autowired;
7. import org.springframework.core.annotation.AnnotationUtils;
8. import org.springframework.stereotype.Component;
9. import org.springframework.util.CollectionUtils;
10. import sicnu.cs.ich.api.common.annotations.transaction.SensitiveData;
12. import java.sql.Statement;
13. import java.util.ArrayList;
14. import java.util.Objects;
15. import java.util.Properties;
17. @Slf4j
18. @Component
19. @Intercepts({
20.         @Signature(type = ResultSetHandler.class, method = "handleResultSets", args = {Statement.class})
21. })
22. public class ResultSetInterceptor implements Interceptor {
24.     @Autowired
25.     private sicnu.cs.ich.common.interceptor.transaction.service.IDecryptUtil IDecryptUtil;
27.     @Override
28.     public Object intercept(Invocation invocation) throws Throwable {
29.         //取出查询的结果
30.         Object resultObject = invocation.proceed();
31.         if (Objects.isNull(resultObject)) {
32.             return null;
33.         }
34.         //基于selectList
35.         if (resultObject instanceof ArrayList) {
36.             @SuppressWarnings("unchecked")
37.             ArrayList<Objects> resultList = (ArrayList<Objects>) resultObject;
38.             if (!CollectionUtils.isEmpty(resultList) && needToDecrypt(resultList.get(0))) {
39.                 for (Object result : resultList) {
40.                     //逐一解密
41.                     IDecryptUtil.decrypt(result);
42.                 }
43.             }
44.             //基于selectOne
45.         } else {
46.             if (needToDecrypt(resultObject)) {
47.                 IDecryptUtil.decrypt(resultObject);
48.             }
49.         }
50.         return resultObject;
51.     }
53.     private boolean needToDecrypt(Object object) {
54.         Class<?> objectClass = object.getClass();
55.         SensitiveData sensitiveData = AnnotationUtils.findAnnotation(objectClass, SensitiveData.class);
56.         return Objects.nonNull(sensitiveData);
57.     }
59.     @Override
60.     public Object plugin(Object target) {
61.         return Plugin.wrap(target, this);
62.     }
64.     @Override
65.     public void setProperties(Properties properties) {
67.     }
68. }

复制代码

使用

注意解在实体类上

1. import lombok.*;
2. import org.springframework.security.core.userdetails.UserDetails;
3. import sicnu.cs.ich.api.common.annotations.transaction.EncryptTransaction;
4. import sicnu.cs.ich.api.common.annotations.transaction.SensitiveData;
6. @With
7. @Builder
8. @Data
9. @NoArgsConstructor
10. @AllArgsConstructor
11. @SensitiveData // 插件只对加了该注解的类进行扫描，只有加了这个注解的类才会生效
12. public class User implements Serializable {
13.     private Integer id;
14.     private String username;
15.     private String openId;
16.     private String password;
17.     // 表明对该字段进行加密
18.     @EncryptTransaction
19.     private String email;
20.     // 表明对该字段进行加密
21.     @EncryptTransaction
22.     private String mobile;
23.     private Date createTime;
24.     private Date expireTime;
25.     private Boolean status = true;
26. }

复制代码

注解在参数上

1. import org.apache.ibatis.annotations.Mapper;
2. import org.apache.ibatis.annotations.Param;
3. import sicnu.cs.ich.api.common.annotations.transaction.EncryptTransaction;
5. @Mapper
6. public interface UserMapper extends BaseMapper<User> {
7.    // 只需要在参数前加上@EncryptTransaction 即可
8.    long countByEmail(@EncryptTransaction @Param("email") String email);
10.    long countByMobile(@EncryptTransaction @Param("mobile") String mobile);
12. }

复制代码

版权声明：本文为CSDN博主「shenyang1026」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/relosy/article/details/123494036
近期热文推荐：
1.1,000+ 道 Java面试题及答案整理(2022最新版)
2.劲爆！Java 协程要来了。。。
3.Spring Boot 2.x 教程，太全了！
4.别再写满屏的爆爆爆炸类了，试试装饰器模式，这才是优雅的方式！！
5.《Java开发手册（嵩山版）》最新发布，速速下载！
觉得不错，别忘了随手点赞+转发哦！

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！