SpringBoot + MyBatis 攔截器輕松實現數據加減密

作者：小九 2025-01-02 10:10:51

通過本篇文章，我們探討了如何使用 MyBatis 攔截器實現數據加密與解密功能。通過自定義 MyBatis 插件，我們能夠在數據查詢和插入過程中，自動對敏感信息進行加密或解密處理，從而提高系統的安全性。

1. 引言

小編上一篇文章分享了利用mybatis攔截器實現數據脫敏，這次小編在數據脫敏的基礎上進行數據加減密。思路就是保存的時候對數據進行加密，查詢的時候對數據進行解密，如果要脫敏就進行脫敏。

2. MyBatis 攔截器的實現數據加減密并脫敏

2.1 自定義加減密注解

首先需要知曉具體是哪個類中的哪些屬性需要進行加減密處理，因此，需要自定義注解來實現對需要加減密的屬性進行標注。

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)
@Target({ ElementType.FIELD })
public @interface EncryptField {

}

2.2 加減密策略

有了標注后，對于加減密也會涉及到加減密策略的問題。不同的屬性，對應加密或者解密，例如，新增的時候是加密，查詢的時候是解密，這里使用枚舉類類枚出不同屬性對應的正則處理。

import lombok.AllArgsConstructor;
import lombok.Getter;

@Getter
@AllArgsConstructor
public enum DecryptEncryptEnum {
    DECRYPT(s -> DecryptEncryptUtils.sm4Decrypt(s)),
    ENCRYPT(s -> DecryptEncryptUtils.sm4Encrypt(s)),
    ;

    private final Desensitizer desensitizer;
}

2.3 加解密執行者

對于加解密處理還需要一個執行者，將屬性值和正則表達式進行匹配和替換，進而完成加解密處理。這里我們利用了JDK8提供的一個非常好用的接口Fuction，它提供了apply方法，這個方法作用是為了實現函數映射，也就是將一個值轉換為另一個值。如果不了解的同學可以百度下 Fuction 接口。

import java.util.function.Function;

public interface Desensitizer extends Function<String, String> {
}

2.4 加減密工具類

對于加解密，我們還需要一個工具類來處理，小編使用的是SM4來進行加減密。

import cn.hutool.core.util.CharsetUtil;
import cn.hutool.crypto.SmUtil;
import cn.hutool.crypto.symmetric.SymmetricCrypto;
import lombok.extern.slf4j.Slf4j;

@Slf4j
public class DecryptEncryptUtils {
 // 這里設置自己的加減密key
    private static final String key = "";

    /**
     * 加密
     * @param text
     * @param key
     * @return
     */
    private static String sm4Encrypt(String text, String key) {
        SymmetricCrypto sm4 = SmUtil.sm4(key.getBytes());
        return sm4.encryptBase64(text);
    }

    /**
     * 解密
     * @param hexString
     * @param key
     * @return
     */
    private static String sm4Decrypt(String hexString, String key) {
        try {
            SymmetricCrypto sm4 = SmUtil.sm4(key.getBytes());
            return sm4.decryptStr(hexString, CharsetUtil.CHARSET_UTF_8);
        } catch(Exception e) {
            // 解密失敗，直接返回明文，不影響業務進程
            return hexString;
        }
    }

    public static String sm4Encrypt(String text) {
        return sm4Encrypt(text, key);
    }
    
    public static String sm4Decrypt(String hexString) {
        return sm4Decrypt(hexString, key);
    }

2.5 自定義數據加密攔截器

因為要對參數集進行加密處理，所以要攔截的對象是ParameterHandler，攔截的方法是setParameters。

public interface ParameterHandler {
    Object getParameterObject();

    void setParameters(PreparedStatement var1) throws SQLException;
}

來看下具體的實現:

import org.apache.ibatis.executor.parameter.ParameterHandler;
import org.apache.ibatis.plugin.Interceptor;
import org.apache.ibatis.plugin.Intercepts;
import org.apache.ibatis.plugin.Invocation;
import org.apache.ibatis.plugin.Signature;
import org.apache.ibatis.reflection.MetaObject;
import org.apache.ibatis.reflection.SystemMetaObject;
import org.springframework.stereotype.Component;

import java.lang.reflect.Field;
import java.sql.PreparedStatement;
import java.util.stream.Stream;

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

    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        // 獲取參數處理器實例
        ParameterHandler parameterHandler = (ParameterHandler) invocation.getTarget();
        // 獲取參數對象
        Object parameters = parameterHandler.getParameterObject();
        // 加密
        desensitization(parameters);
        // 執行原始方法
        invocation.proceed();
        return null;
    }

    /**
     * 判斷哪些需要加密
     * @param source 加密之前的源對象
     */
    private void desensitization(Object source) {
        // 反射獲取類型中的所有屬性，判斷哪個需要進行脫敏
        Class<?> sourceClass = source.getClass();
        MetaObject metaObject = SystemMetaObject.forObject(source);
        // 對有加減密注解的字段進行加密
        Stream.of(sourceClass.getDeclaredFields())
                .filter(field -> field.isAnnotationPresent(EncryptField.class))
                .forEach(field -> doEncrypt(metaObject, field));
    }

    /**
     * 加密
     * @param metaObject
     * @param field
     */
    private void doEncrypt(MetaObject metaObject, Field field) {
        String name = field.getName();
        Object value = metaObject.getValue(name);
        if (value != null && metaObject.getGetterType(name) == String.class) {
            DecryptEncryptEnum encrypt = DecryptEncryptEnum.ENCRYPT;
            String apply = encrypt.getDesensitizer().apply((String) value);
            metaObject.setValue(name, apply);
        }
    }
}

數據加減密字段:

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.example.cl.mybatisPlugin.Desensitization;
import com.example.cl.mybatisPlugin.EncryptField;
import com.example.cl.mybatisPlugin.StrategyEnum;
import lombok.Getter;
import lombok.Setter;

@Getter
@Setter
public class User {
    @TableId(type = IdType.AUTO)
    private Long id;
    @Desensitization(strategy = StrategyEnum.NAME)
    @EncryptField
    private String name;
    private Integer age;
}

看下加密效果:

2.6 自定義數據解密攔截器(先解密,再脫敏)

import org.apache.ibatis.executor.resultset.ResultSetHandler;
import org.apache.ibatis.plugin.Interceptor;
import org.apache.ibatis.plugin.Intercepts;
import org.apache.ibatis.plugin.Invocation;
import org.apache.ibatis.plugin.Signature;
import org.apache.ibatis.reflection.MetaObject;
import org.apache.ibatis.reflection.SystemMetaObject;
import org.springframework.stereotype.Component;

import java.lang.reflect.Field;
import java.sql.Statement;
import java.util.List;
import java.util.stream.Stream;

@Component
@Intercepts(@Signature(type = ResultSetHandler.class, method = "handleResultSets", args = Statement.class))
public class DesensitizationPlugin implements Interceptor {

    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        // 獲取結果集
        List<Object> records = (List<Object>) invocation.proceed();
        // 處理結果集
        records.forEach(this::desensitization);
        return records;
    }

    /**
     * 2 * 判斷哪些需要脫敏處理
     * 3 * @param source 脫敏之前的源對象
     * 4
     */
    private void desensitization(Object source) {
        // 反射獲取類型中的所有屬性，判斷哪個需要進行脫敏
        Class<?> sourceClass = source.getClass();
        MetaObject metaObject = SystemMetaObject.forObject(source);
        // 有加密先解密
        Stream.of(sourceClass.getDeclaredFields())
                .filter(field -> field.isAnnotationPresent(EncryptField.class))
                .forEach(field -> doDecrypt(metaObject, field));
        // 再看是否需要脫敏
        Stream.of(sourceClass.getDeclaredFields())
                .filter(field -> field.isAnnotationPresent(Desensitization.class))
                .forEach(field -> doDesensitization(metaObject, field));
    }

    /**
     * 解密
     * @param metaObject
     * @param field
     */
    private void doDecrypt(MetaObject metaObject, Field field) {
        String name = field.getName();
        Object value = metaObject.getValue(name);
        if (value != null && metaObject.getGetterType(name) == String.class) {
            DecryptEncryptEnum decrypt = DecryptEncryptEnum.DECRYPT;
            String apply = decrypt.getDesensitizer().apply((String) value);
            metaObject.setValue(name, apply);
        }
    }

    /**
     * 真正的脫敏處理
     * @param metaObject
     *
     */
    private void doDesensitization(MetaObject metaObject, Field field) {
        String name = field.getName();
        Object value = metaObject.getValue(name);
        if (value != null && metaObject.getGetterType(name) == String.class) {
            Desensitization annotation = field.getAnnotation(Desensitization.class);
            StrategyEnum strategy = annotation.strategy();
            String apply = strategy.getDesensitizer().apply((String) value);
            metaObject.setValue(name, apply);
        }
    }
}

最后看下效果:

3. 總結

通過本篇文章，我們探討了如何使用 MyBatis 攔截器實現數據加密與解密功能。通過自定義 MyBatis 插件，我們能夠在數據查詢和插入過程中，自動對敏感信息進行加密或解密處理，從而提高系統的安全性。利用攔截器的靈活性，我們不僅能夠輕松集成加密邏輯，還能確保代碼的簡潔性和可維護性。這個方法為開發者提供了一個高效、優雅的解決方案，確保敏感數據在存儲與傳輸中的安全。

責任編輯：武曉燕來源： Java極客技術

MyBatis 攔截加密