1. 前言

在学习 PageHelper 分页插件的时候，对于其如何和 Mybatis 结合进行拦截，还是有些朦胧，这里通过一个例子实现自定义的 Mtbatis 拦截器插件。

2、什么是 Mybatis Plugin

在 Mybatis 官方文档中，对于 Mybatis plugin 的的介绍是这样的：
MyBatis 允许在已映射语句执行过程中的某一点进行拦截调用。默认情况下，MyBatis 允许使用插件来拦截的方法调用包括：

1
2
3
4
5
6
7
8
//语句执行拦截
Executor (update, query, flushStatements, commit, rollback, getTransaction, close, isClosed)
// 参数获取、设置时进行拦截
ParameterHandler (getParameterObject, setParameters)
// 对返回结果进行拦截
ResultSetHandler (handleResultSets, handleOutputParameters)
//sql语句拦截
StatementHandler (prepare, parameterize, batch, update, query)

简而言之，即在执行 sql 的整个周期中，可以任意切入到某一点对 sql 的参数、sql 执行结果集、sql 语句本身等进行切面处理。基于这个特性，便可以使用其需要进行加密的数据进行切面统一加密处理了（分页插件 pageHelper 就是这样实现数据库分页查询的）。

3、实现基于注解的敏感信息加解密拦截器

3.1 实现思路

对于数据的加密与解密，应当存在两个拦截器对数据进行拦截操作，参照官方文档，因此此处应当使用ParameterHandler拦截器对入参进行加密
使用ResultSetHandler拦截器对出参进行解密操作。
2021-06-19-20-20-08-703234.png
目标需要加密、解密的字段可能需要灵活变更，此时定义一个注解，对需要加密的字段进行注解，那么便可以配合拦截器对需要的数据进行加密与解密操作了。
Mybatis 的interceptor接口有以下方法需要实现。

1
2
3
4
5
6
7
8
9
10
11
public interface Interceptor {

    //主要参数拦截方法
    Object intercept(Invocation invocation) throws Throwable;

    //mybatis插件链
    default Object plugin(Object target) {return Plugin.wrap(target, this);}

    //自定义插件配置文件方法
    default void setProperties(Properties properties) {}
}

3.2 定义需要加密解密的敏感信息注解

定义注解敏感信息类（如实体类 POJO\PO）的注解

1
2
3
4
5
6
7
8
/**
 * 注解敏感信息类的注解
 */
@Inherited
@Target({ ElementType.TYPE })
@Retention(RetentionPolicy.RUNTIME)
public @interface SensitiveData {
}

定义注解敏感信息类中敏感字段的注解

1
2
3
4
5
6
7
8
/**
 * 注解敏感信息类中敏感字段的注解
 */
@Inherited
@Target({ ElementType.Field })
@Retention(RetentionPolicy.RUNTIME)
public @interface SensitiveField {
}

3.3 定义加密接口及其实现类

定义加密接口，方便以后拓展加密方法（如 AES 加密算法拓展支持 PBE 算法，只需要注入时指定一下便可）

1
2
3
4
5
6
7
8
9
10
11
public interface EncryptUtil {
    /**
     * 加密
     *
     * @param declaredFields paramsObject所声明的字段
     * @param paramsObject   mapper中paramsType的实例
     * @return T
     * @throws IllegalAccessException 字段不可访问异常
     */
    <T> T encrypt(Field[] declaredFields, T paramsObject) throws IllegalAccessException;
}

EncryptUtil 的 AES 加密实现类，此处 AESUtil 为自封装的 AES 加密工具，需要的小伙伴可以自行封装，本文不提供。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
@Component
public class AESEncrypt implements EncryptUtil {
    @Autowired
    AESUtil aesUtil;
    /**
     * 加密
     *
     * @param declaredFields paramsObject所声明的字段
     * @param paramsObject   mapper中paramsType的实例
     * @return T
     * @throws IllegalAccessException 字段不可访问异常
     */
    @Override
    public <T> T encrypt(Field[] declaredFields, T paramsObject) throws IllegalAccessException {
        for (Field field : declaredFields) {
            //取出所有被EncryptDecryptField注解的字段
            SensitiveField sensitiveField = field.getAnnotation(SensitiveField.class);
            if (!Objects.isNull(sensitiveField)) {
                field.setAccessible(true);
                Object object = field.get(paramsObject);
                //暂时只实现String类型的加密
                if (object instanceof String) {
                    String value = (String) object;
                    //加密  这里我使用自定义的AES加密工具
                    field.set(paramsObject, aesUtil.encrypt(value));
                }
            }
        }
        return paramsObject;
    }
}

3.4 实现入参加密拦截器

Mybatis 包中的org.apache.ibatis.plugin.Interceptor拦截器接口要求实现以下三个方法

1
2
3
4
5
6
7
8
9
10
11
public interface Interceptor {

    //核心拦截逻辑
    Object intercept(Invocation invocation) throws Throwable;

    //拦截器链
    default Object plugin(Object target) {return Plugin.wrap(target, this);}

    //自定义配置文件操作
    default void setProperties(Properties properties) { }
}

因此，参考官方文档的示例，自定义一个入参加密拦截器。
@Intercepts 注解开启拦截器，@Signature 注解定义拦截器的实际类型。
@Signature中

  • type 属性指定当前拦截器使用StatementHandler、ResultSetHandler、ParameterHandler，Executor的一种
  • method 属性指定使用以上四种类型的具体方法（可进入 class 内部查看其方法）。
  • args 属性指定预编译语句

此处使用了 ParameterHandler.setParamters()方法，拦截 mapper.xml 中paramsType的实例（即在每个含有paramsType属性 mapper 语句中，都执行该拦截器，对paramsType的实例进行拦截处理）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

@Slf4j
@Component
@Intercepts({
    @Signature(type = ParameterHandler.class, method = "setParameters", args = PreparedStatement.class),
})
public class EncryptInterceptor implements Interceptor {

    private final EncryptDecryptUtil encryptUtil;

    @Autowired
    public EncryptInterceptor(EncryptDecryptUtil encryptUtil) {
        this.encryptUtil = encryptUtil;
    }


    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        //@Signature 指定了 type= parameterHandler 后，这里的 invocation.getTarget() 便是parameterHandler
        //若指定ResultSetHandler ，这里则能强转为ResultSetHandler
        ParameterHandler parameterHandler = (ParameterHandler) invocation.getTarget();
        // 获取参数对像，即 mapper 中 paramsType 的实例
        Field parameterField = parameterHandler.getClass().getDeclaredField("parameterObject");
        parameterField.setAccessible(true);
        //取出实例
        Object parameterObject = parameterField.get(parameterHandler);
        if (parameterObject != null) {
            Class<?> parameterObjectClass = parameterObject.getClass();
            //校验该实例的类是否被@SensitiveData所注解
            SensitiveData sensitiveData = AnnotationUtils.findAnnotation(parameterObjectClass, SensitiveData.class);
            if (Objects.nonNull(sensitiveData)) {
                //取出当前当前类所有字段，传入加密方法
                Field[] declaredFields = parameterObjectClass.getDeclaredFields();
                encryptUtil.encrypt(declaredFields, parameterObject);
            }
        }
        return invocation.proceed();
    }

   /**
 	* 切记配置，否则当前拦截器不会加入拦截器链
    */
    @Override
    public Object plugin(Object o) {
        return Plugin.wrap(o, this);
    }

    //自定义配置写入，没有自定义配置的可以直接置空此方法
    @Override
    public void setProperties(Properties properties) {
    }
}

至此完成自定义加密拦截加密。

3.5 定义解密接口及其实现类

解密接口，其中 result 为 mapper.xml 中resultType的实例。

1
2
3
4
5
6
7
8
9
10
public interface DecryptUtil {
    /**
 * 解密
 *
 * @param result resultType的实例
 * @return T
 * @throws IllegalAccessException 字段不可访问异常
 */
    <T> T decrypt(T result) throws IllegalAccessException;
}

解密接口 AES 工具解密实现类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
public class AESDecrypt implements DecryptUtil {
    @Autowired
    AESUtil aesUtil;

    /**
     * 解密
     *
     * @param result resultType的实例
     * @return T
     * @throws IllegalAccessException 字段不可访问异常
     */
    @Override
    public <T> T decrypt(T result) throws IllegalAccessException {
        //取出resultType的类
        Class<?> resultClass = result.getClass();
        Field[] declaredFields = resultClass.getDeclaredFields();
        for (Field field : declaredFields) {
            //取出所有被EncryptDecryptField注解的字段
            SensitiveField sensitiveField = field.getAnnotation(SensitiveField.class);
            if (!Objects.isNull(sensitiveField)) {
                field.setAccessible(true);
                Object object = field.get(result);
                //只支持String的解密
                if (object instanceof String) {
                    String value = (String) object;
                    //对注解的字段进行逐一解密
                    field.set(result, aesUtil.decrypt(value));
                }
            }
        }
        return result;
    }
}

3.6 定义出参解密拦截器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
@Slf4j
@Component
@Intercepts({
    @Signature(type = ResultSetHandler.class, method = "handleResultSets", args = {Statement.class})
})
public class DecryptInterceptor implements Interceptor {
    @Autowired
    DecryptUtil aesDecrypt;

    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        //取出查询的结果
        Object resultObject = invocation.proceed();
        if (Objects.isNull(resultObject)) {
            return null;
        }
        //基于selectList
        if (resultObject instanceof ArrayList) {
            ArrayList resultList = (ArrayList) resultObject;
            if (!CollectionUtils.isEmpty(resultList) && needToDecrypt(resultList.get(0))) {
                for (Object result : resultList) {
                    //逐一解密
                    aesDecrypt.decrypt(result);
                }
            }
            //基于selectOne
        } else {
            if (needToDecrypt(resultObject)) {
                aesDecrypt.decrypt(resultObject);
            }
        }
        return resultObject;
    }

    private boolean needToDecrypt(Object object) {
        Class<?> objectClass = object.getClass();
        SensitiveData sensitiveData = AnnotationUtils.findAnnotation(objectClass, SensitiveData.class);
        return Objects.nonNull(sensitiveData);
    }


    @Override
    public Object plugin(Object target) {
        return Plugin.wrap(target, this);
    }

    @Override
    public void setProperties(Properties properties) {

    }
}

至此完成解密拦截器的配置工作。

3.7 注解实体类中需要加解密的字段

2021-06-19-20-20-08-848844.png
此时在 mapper 中，指定paramType=User resultType=User 便可实现脱离业务层，基于 Mybatis 拦截器的加解密操作。

3.7 注入插件到拦截链

这里有两种方式注入

方式一：直接注入
1
2
3
4
5
<!-- mybatis-config.xml  注册插件-->
<plugins>
    <plugin interceptor="xxx.EncryptInterceptor"/>
     <plugin interceptor="xxx.DecryptInterceptor"/>
</plugins>