君子之交淡如水|
收藏闪存小组博问

庄周de蝴蝶

园龄：6年9个月粉丝：0关注：0

SpringBoot 实现数据加密存储的五种方式

前言

最近由于项目需要做等保，其中有一项要求是系统中的个人信息和业务信息需要进行加密存储。经过一番搜索，最终总结出了五种数据加密存储的方法（结合SpringBoot和MyBatisPlus框架进行实现），不知道家人们在项目中使用的是哪种方式🤔，如果有更好地方式也欢迎一起交流😊~~~，本文所贴出的完整代码已上传到GitHub。

思路总览

在具体讲解实现方式之前，先讲一下五种方式的思路：

  1. 手动处理字段加解密

    最简单、朴素的方式。如果项目中只有个别字段，例如密码字段需要加密，则可以使用这种方法。不过，通常密码都是做单向 Hash 加密，不存在解密的情况，本文后续为了统一讲解加解密的方式，就对字段统一使用了 AES 对称加密算法。听说有的项目需要使用 SM2 之类非对称加密算法，本文就不再介绍了，只需要参考思路替换相应加解密调用的方法即可。

    优点：使用简单、易懂，技术难度低

    缺点：全手工处理，容易遗漏，费时。

  2. 注解结合 AOP 实现

    相对简便的方式，在需要进行加解密处理的字段上添加字段注解，然后在有加解密处理需求的方法上添加方法注解，之后结合 AOP ，对入参和返回结果进行处理即可。

    优点：使用相对简单，加解密处理统一在切面处理中完成。

    缺点：只能处理入参和返回结果中的字段加解密，如果处理逻辑中涉及到加解密需求还是需要手动处理。同时需要在所有有加解密处理需求的类或方法（可以定义类级别和方法级别的注解，本文只讲解方法级别的注解）上添加注解，也容易遗漏，测试时需要特别注意。

  3. 自定义序列化 / 反序列化类结合注解实现

    通过自定义序列化 / 反序列化处理类，然后结合序列化 / 反序列化注解中指定相应类进行实现。

    优点：使用简单，加解密处理统一在自定义的序列化化类中完成，只需要在字段上添加注解。

    缺点：只能处理序列化数据中的加解密，如果业务逻辑中需要手动设置某个加密字段的值，还是需要手工处理。

  4. MybatisPlus自定义TypeHandler实现

    和自定义序列化 / 反序列化类的思路类似，不过是和框架功能相耦合，通过使用MybatisPlus自定义TypeHandler实现。

    优点：使用简单，加解密处理统一在自定义的TypeHandler中完成，只需要在字段上添加注解。

    缺点：只能处理 SQL 的查询和保存的结果，如果业务逻辑中需要手动设置某个加密字段的值，还是需要手工处理，如果存在自定义 SQL ，还需要额外添加注解处理，与框架绑定。

  5. MybatisPlus自定义拦截器实现

    相对底层的方式，结合框架自带的拦截器功能，通过对 SQL 拼接和处理 SQL 查询结果进行实现。

    优点：使用简单，加解密处理统一在自定义的拦截器中完成，无需使用注解。

    缺点：只能处理 SQL 的查询和保存的结果，如果业务逻辑中需要手动设置某个加密字段的值，还是需要手工处理，此外还需要整理所有需要加解密操作的字段名，与框架绑定。

小结：当然除了以上几种方法，根据使用技术和框架的不同，还有很多种方式，例如 JPA 可以自定义 Convert，类似方法 3 和 4，这里不再介绍。其实，在实现的过程中，有想过通过修改字节码，修改字段的 Getter / Setter 方法进行实现，但是在实现的时候才发现两者的操作是成对的，入库的时候也就还是明文，不过如果是数据脱敏，由于只需要修改 Setter 方法，则可以考虑使用修改字节码的方式。

具体实现

手工处理

话不多说，直接上代码：

public User method1(User user) {
    Long userId = 1L;
    user.setId(userId);
    user.setUsername(AESUtils.encrypt(user.getUsername()));
    user.setPassword(AESUtils.encrypt(user.getPassword()));
    saveOrUpdate(user);
    User resultUser = getById(userId);
    resultUser.setUsername(AESUtils.decrypt(resultUser.getUsername()));
    resultUser.setPassword(AESUtils.decrypt(resultUser.getPassword()));
    return resultUser;
}

这个就不再做详细解释了~~~

注解结合 AOP

首先需要定义一个字段注解和方法注解：

/**
 * 字段加密注解
 *
 * @author 庄周de蝴蝶
 * @date 2023-11-07
 */
@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
public @interface EncryptField {
}
/**
 * 方法加密处理注解
 *
 * @author 庄周de蝴蝶
 * @date 2023-11-07
 */
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Order(Ordered.HIGHEST_PRECEDENCE)
public @interface EncryptMethod {
 
	/**
	 * 需要处理对象在参数列表中的位置
	 */
	int[] value() default { 0 };
 
	/**
	 * 是否启用解密处理
	 */
	boolean enableDecrypt() default true;
 
}

然后结合 AOP 去处理方法注解：

/**
 * 处理加密注解切面
 * 特别注意, 这里的排序需要 + 1, 否则会报错, 具体原因参考链接: 
 * <a href="https://blog.csdn.net/qq_18300037/article/details/128626005">...</a>
 *
 * @author 庄周de蝴蝶
 * @date 2023-11-07
 */
@Slf4j
@Aspect
@Component
@Order(Ordered.HIGHEST_PRECEDENCE + 1)
public class EncryptMethodAspect {
 
	/**
	 * 处理加密方法注解
	 *
	 * @param joinPoint 切点
	 * @param encryptMethod 加密方法注解
	 * @return 结果
	 */
	@Around("@annotation(encryptMethod)")
    public Object around(ProceedingJoinPoint joinPoint, EncryptMethod encryptMethod) throws Throwable {
        try {
			int[] indexArr = encryptMethod.value();
			Object[] args = joinPoint.getArgs();
			for (int i = 0; i < indexArr.length; i++) {
				if (i >= args.length) {
					break;
				}
                // 处理入参中的加密
				handleEncrypt(args[i]);
			}
            Object result = joinPoint.proceed();
			if (encryptMethod.enableDecrypt()) {
                // 对返回结果中的字段进行解密处理
				return handleDecrypt(result);
			}
			return result;
        } catch (Throwable throwable) {
            log.error("加密注解处理出现异常", throwable);
			throw throwable;
        }
    }
 
	/**
	 * 对添加了 EncryptField 注解的字段进行加密
	 *
	 * @param obj 要处理的对象
	 */
	private void handleEncrypt(Object obj) throws IllegalAccessException {
		handleEnDecrypt(obj, AESUtils::encrypt);
	}
 
	/**
	 * 对添加了 EncryptField 注解的字段进行解密, <b>只考虑了返回值是对象的情况</b>
	 *
	 * @param obj 要处理的对象
	 * @return 结果
	 */
	private Object handleDecrypt(Object obj) throws IllegalAccessException {
		return handleEnDecrypt(obj, AESUtils::decrypt);
	}
	
	/**
	 * 对添加了 EncryptField 注解的字段进行加解密处理
	 *
	 * @param obj 要处理的对象
	 * @param handleFun 处理函数
	 * @return 结果
	 */
	private Object handleEnDecrypt(Object obj, UnaryOperator<String> handleFun) throws IllegalAccessException {
		if (obj == null) {
            return null;
        }
		Field[] fields = obj.getClass().getDeclaredFields();
        for (Field field : fields) {
            boolean hasSecureField = field.isAnnotationPresent(EncryptField.class);
            if (hasSecureField) {
                field.setAccessible(true);
                String val = (String) field.get(obj);
                String result = handleFun.apply(val);
                field.set(obj, result);
            }
        }
		return obj;
	}
 
}

这里只考虑了返回结果是实体对象的情况，如果返回类型的是分页或者是列表亦或者是类似Result的形式，需要自己进行额外的处理。

最后是使用的方式，首先是在实体的字段上添加注解：

/**
 * 用户类
 *
 * @author 庄周de蝴蝶
 * @date 2023-10-27
 */
@Data
@TableName("user")
public class User {
    
    /**
     * id
     */
    @TableId(value = "id", type = IdType.ASSIGN_ID)
    private Long id;
 
    /**
     * 用户名
     */
    @EncryptField
    private String username;
 
    /**
     * 密码
     */
    @EncryptField
    private String password;
 
}

然后是在方法上添加注解，这里是在控制层使用，当然也可以在ServiceImpl里的方法上使用：

@EncryptMethod
@PostMapping("/method2")
public User method2(@RequestBody User user) {
	return userService.method2(user);
}

自定义序列化注解

首先需要实现序列化 / 反序列化处理类：

/**
 * 解密序列化处理器
 *
 * @author 庄周de蝴蝶
 * @date 2023-11-07
 */
@NoArgsConstructor
public class DecryptSerializer extends JsonSerializer<String> {
 
    @Override
    public void serialize(String value, JsonGenerator jsonGenerator, SerializerProvider serializerProvider) throws IOException {
        if (StringUtils.isNotBlank(value)) {
			value = AESUtils.decrypt(value);
		}
        jsonGenerator.writeString(value);
    }
 
}
/**
 * 加密序列化处理器
 *
 * @author 庄周de蝴蝶
 * @date 2023-2023-11-07
 */
@NoArgsConstructor
public class EncryptDeserializer extends JsonDeserializer<String> {
 
    @Override
    public String deserialize(JsonParser jsonParser, DeserializationContext deserializationContext) throws IOException {
        if (jsonParser != null && StringUtils.isNotBlank(jsonParser.getText())) {
            String text = jsonParser.getText();
			return AESUtils.encrypt(text);
		}
		return null;
    }
 
}

然后定义注解，这里通过使用Jackson的JacksonAnnotationsInside注解将序列化和反序列化合并，这样在使用时就可以只使用一个注解：

/**
 * 字段加解密序列化注解
 *
 * @author 庄周de蝴蝶
 * @date 2023-10-23
 */
@JsonSerialize(using = DecryptSerializer.class)
@JsonDeserialize(using = EncryptDeserializer.class)
@JacksonAnnotationsInside
@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
public @interface EncryptSerializer {
}

最后在相应的实体字段中添加注解即可：

/**
 * 用户类
 *
 * @author 庄周de蝴蝶
 * @date 2023-10-27
 */
@Data
@TableName("user")
public class User {
    
    /**
     * id
     */
    @TableId(value = "id", type = IdType.ASSIGN_ID)
    private Long id;
 
    /**
     * 用户名
     */
    @EncryptSerializer
    private String username;
 
    /**
     * 密码
     */
    @EncryptSerializer
    private String password;
 
}

MybatisPlus自定义TypeHandler

首先是自定义的TypeHandler：

/**
 * 加密类型字段处理类
 *
 * @author 庄周de蝴蝶
 * @date 2023-10-27
 */
public class EncryptTypeHandler extends BaseTypeHandler<String> {
 
    @Override
    public void setNonNullParameter(PreparedStatement ps, int i, String parameter, JdbcType jdbcType) throws SQLException {
        ps.setString(i, handleResult(parameter, AESUtils::encrypt));
    }
 
    @Override
    public String getNullableResult(ResultSet rs, String columnName) throws SQLException {
        return handleResult(rs.getString(columnName), AESUtils::decrypt);
    }
 
    @Override
    public String getNullableResult(ResultSet rs, int columnIndex) throws SQLException {
        return handleResult(rs.getString(columnIndex), AESUtils::decrypt);
    }
 
    @Override
    public String getNullableResult(CallableStatement cs, int columnIndex) throws SQLException {
        return handleResult(cs.getString(columnIndex), AESUtils::decrypt);
    }
    
    /**
     * 值加解密处理
     *
	 * @param val 值
     * @param fun 处理函数
     * @return 结果
     */
    private String handleResult(String val, UnaryOperator<String> fun) {
        HttpServletRequest request = ServletUtils.getRequest();
        return StringUtils.isBlank(val) ? val : fun.apply(val);
    }
    
}

然后在相应的实体字段中添加注解即可：

/**
 * 用户类
 *
 * @author 庄周de蝴蝶
 * @date 2023-10-27
 */
@Data
@TableName("user")
public class User {
    
    /**
     * id
     */
    @TableId(value = "id", type = IdType.ASSIGN_ID)
    private Long id;
 
    /**
     * 用户名
     */
    @TableField(typeHandler = EncryptTypeHandler.class)
    private String username;
 
    /**
     * 密码
     */
    @TableField(typeHandler = EncryptTypeHandler.class)
    private String password;
 
}

MybatisPlus自定义拦截器

首先是定义一个保存操作的拦截器，关于拦截器的使用，由于和框架相关联，这里不再详细介绍使用方式：

/**
 * 加密更新拦截器处理
 *
 * @author 庄周de蝴蝶
 * @date 2023-10-27
 */
@Configuration
public class EncryptUpdateInterceptor implements InnerInterceptor {
    
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        interceptor.addInnerInterceptor(new EncryptUpdateInterceptor());
        return interceptor;
    }
 
    @Override
    public void beforeUpdate(Executor executor, MappedStatement ms, Object parameter) {
        SQLUtils.handleSql(ms.getConfiguration(), ms.getBoundSql(parameter));
    }
 
}

然后再定义一个查询操作的拦截器：

/**
 * 加密查询拦截器处理
 *
 * @author 庄周de蝴蝶
 * @date 2023-11-08
 */
@Component
@Intercepts({
        @Signature(type = Executor.class, method = "query", args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class, CacheKey.class, BoundSql.class}),
        @Signature(type = Executor.class, method = "query", args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class}),
})
public class EncryptQueryInterceptor implements Interceptor {
    
    @Override
    public Object intercept(Invocation invocation) throws InvocationTargetException, IllegalAccessException {
        MappedStatement mappedStatement = (MappedStatement) invocation.getArgs()[0];
        String sqlId = mappedStatement.getId();
        if (sqlId.contains("selectCount")) {
            return invocation.proceed();
        }
        Object proceed = invocation.proceed();
        @SuppressWarnings("unchecked")
        List<Object> objectList = (List<Object>) proceed;
        if (objectList.isEmpty()) {
            return proceed;
        }
        Class<?> type = objectList.get(0).getClass();
        List<Object> resultList = new ArrayList<>();
        for (Object o : objectList) {
            Map<String, Object> map = JSONUtil.toBean(JSONUtil.toJsonStr(o), new TypeReference<Map<String, Object>>() {}, true);
            for (String keyword : SQLUtils.ENCRYPT_SET) {
                map.put(keyword, AESUtils.decrypt(String.valueOf(map.get(keyword))));
            }
            resultList.add(JSONUtil.toBean(JSONUtil.toJsonStr(map), type));
        }
        return resultList;
    }
 
}

其中SQLUtils的内容如下：

/**
 * sql 工具类
 *
 * @author 庄周de蝴蝶
 * @date 2023-11-08
 */
public class SQLUtils {
    
    public static final Set<String> ENCRYPT_SET = new HashSet<>(Arrays.asList("username", "password"));
    
    private SQLUtils() {}
    
    /**
     * 处理 sql
     *
	 * @param configuration 配置
	 * @param boundSql sql
     */
    public static void handleSql(Configuration configuration, BoundSql boundSql) {
        Object parameterObject = boundSql.getParameterObject();
        List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
        if (parameterMappings.isEmpty() || parameterObject == null) {
           return;
        }
        MetaObject metaObject = configuration.newMetaObject(parameterObject);
        for (ParameterMapping parameterMapping : parameterMappings) {
            String propertyName = parameterMapping.getProperty().toLowerCase();
            Object value = metaObject.getValue(propertyName);
            if (ENCRYPT_SET.contains(propertyName.substring(propertyName.indexOf(".") + 1))) {
                metaObject.setValue(propertyName, AESUtils.encrypt(String.valueOf(value)));
            }
        }
    }
    
}

总结

以上简单介绍了五种数据加密存储的方式和实际编码实现，虽然都经过简单测试，不过如果在项目中使用，还是建议多对相关接口和方法进行测试。如果你有其它的思路和方法，也欢迎一起交流~~~

本文作者：庄周de蝴蝶

本文链接：https://www.cnblogs.com/butterfly-fish/p/17817676.html

版权声明：本作品采用知识共享署名-非商业性使用-禁止演绎 2.5 中国大陆许可协议进行许可。

posted @   庄周de蝴蝶  阅读(419)  评论(0)  编辑  收藏  举报
点击右上角即可分享
微信分享提示
评论
收藏
关注
推荐
深色
回顶
收起