MyBatis 拦截器实现数据加密：针对特定表和字段的增删改查加密

以下是一个示例代码实现，使用 MyBatis 的拦截器来处理符合条件的表的修改、新增和查询字段值进行加密。

首先，创建一个自定义的拦截器类，实现 org.apache.ibatis.plugin.Interceptor 接口。

import org.apache.ibatis.executor.Executor;
import org.apache.ibatis.mapping.BoundSql;
import org.apache.ibatis.mapping.MappedStatement;
import org.apache.ibatis.plugin.*;

import java.lang.reflect.Field;
import java.sql.Connection;
import java.util.List;
import java.util.Map;
import java.util.Properties;

@Intercepts({
        @Signature(type = Executor.class, method = "update", args = {MappedStatement.class, Object.class}),
        @Signature(type = Executor.class, method = "query", args = {MappedStatement.class, Object.class, org.apache.ibatis.session.RowBounds.class, org.apache.ibatis.session.ResultHandler.class})
})
public class EncryptionInterceptor implements Interceptor {

    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        Object target = invocation.getTarget();
        if (target instanceof Executor) {
            Executor executor = (Executor) target;
            MappedStatement mappedStatement = (MappedStatement) invocation.getArgs()[0];
            Object parameter = invocation.getArgs()[1];

            // 判断是否需要进行加密处理的表和字段，可以根据业务需求自行定义
            if (mappedStatement.getId().contains("update") || mappedStatement.getId().contains("insert") || mappedStatement.getId().contains("select")) {
                // 进行加密处理
                BoundSql boundSql = mappedStatement.getBoundSql(parameter);
                String sql = boundSql.getSql();

                // 修改或新增操作
                if (mappedStatement.getId().contains("update") || mappedStatement.getId().contains("insert")) {
                    // 处理参数值加密
                    Field field = boundSql.getClass().getDeclaredField("parameterMappings");
                    field.setAccessible(true);
                    List<ParameterMapping> parameterMappings = (List<ParameterMapping>) field.get(boundSql);
                    for (ParameterMapping parameterMapping : parameterMappings) {
                        String property = parameterMapping.getProperty();
                        Object value = boundSql.getParameterObject();
                        // 对符合条件的字段进行加密处理
                        if (isEncryptField(property)) {
                            // 对value进行加密处理
                            // ...
                            // 将加密后的值设置回boundSql中
                            // boundSql.setAdditionalParameter(property, encryptedValue);
                        }
                    }
                }

                // 查询操作
                if (mappedStatement.getId().contains("select")) {
                    // 处理结果值加密
                    List<Object> result = executor.query(mappedStatement, parameter, org.apache.ibatis.session.RowBounds.DEFAULT, org.apache.ibatis.session.ResultHandler.DEFAULT);
                    for (Object object : result) {
                        if (object instanceof Map) {
                            Map<String, Object> resultMap = (Map<String, Object>) object;
                            for (String key : resultMap.keySet()) {
                                Object value = resultMap.get(key);
                                // 对符合条件的字段进行加密处理
                                if (isEncryptField(key)) {
                                    // 对value进行加密处理
                                    // ...
                                    // 将加密后的值设置回resultMap中
                                    // resultMap.put(key, encryptedValue);
                                }
                            }
                        }
                    }
                    return result;
                }
            }
        }

        return invocation.proceed();
    }

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

    @Override
    public void setProperties(Properties properties) {
        // 设置拦截器的属性
    }

    // 判断是否是需要加密的字段
    private boolean isEncryptField(String fieldName) {
        // 根据业务需求自行实现判断逻辑
        return fieldName.startsWith("encrypted_");
    }
}

然后，在 MyBatis 的配置文件中配置该拦截器：

<configuration>
  <plugins>
    <plugin interceptor="com.example.EncryptionInterceptor">
      <!-- 设置拦截器的属性 -->
      <!-- <property name="key" value="value"/> -->
    </plugin>
  </plugins>
</configuration>

请注意，上述代码只是一个示例，具体的加密实现需要根据业务需求自行编写。另外，拦截器只能对 MyBatis 的 Executor 中的 update 和 query 方法进行拦截，如果使用其他方法或其他 ORM 框架可能需要做相应的调整。

代码解读

拦截器定义
- 创建 EncryptionInterceptor 类，实现 Interceptor 接口，并使用 @Intercepts 注解指定拦截的 Executor 方法（update、query）。
拦截逻辑
- 在 intercept 方法中，获取拦截到的 Executor、MappedStatement 和 parameter 对象。
- 判断 MappedStatement.getId() 是否包含 update、insert 或 select，以确定是否需要进行加密操作。
- 根据操作类型分别处理参数值加密和结果值加密：
  - 参数值加密：
    - 通过反射获取 BoundSql 的 parameterMappings 属性。
    - 遍历 parameterMappings，获取每个参数的 property 和 value。
    - 调用 isEncryptField 方法判断是否需要加密该字段。
    - 如果需要加密，对 value 进行加密处理，并将加密后的值设置回 BoundSql 中。
  - 结果值加密：
    - 执行查询操作获取结果集 result。
    - 遍历 result，如果是 Map 类型，则遍历 Map 的键值对。
    - 调用 isEncryptField 方法判断是否需要加密该字段。
    - 如果需要加密，对 value 进行加密处理，并将加密后的值设置回 resultMap 中。
加密字段判断
- isEncryptField 方法用于判断是否需要加密某个字段。
- 示例中使用 fieldName.startsWith("encrypted_") 进行判断，实际应用中可以根据业务需求自行定义判断逻辑。
拦截器配置
- 在 MyBatis 配置文件中添加 plugins 节点，并配置 EncryptionInterceptor 类。
- 可以通过 <property> 元素设置拦截器的属性。

注意事项

加密算法的选择要根据实际需求和安全要求确定。
加密密钥的管理和安全性至关重要，避免密钥泄露。
需要考虑性能影响，避免加密过程过于耗时。
针对不同数据类型和字段的加密方式可能需要进行特殊处理。
需要保证解密逻辑与加密逻辑一致，才能正确地解密数据。

总结

使用 MyBatis 拦截器实现数据加密是一种有效的方式，可以对特定的表和字段进行加密处理，提高数据的安全性。通过本文的示例代码和解读，可以了解 MyBatis 拦截器的使用方式和加密逻辑的实现思路。在实际应用中，还需要根据具体的业务需求进行调整和完善。