在现代应用中,数据的安全性越来越受到重视。为了保护敏感数据,我们常常需要对数据进行加密和解密。在这篇博客中,我将展示如何使用Spring AOP(面向切面编程)来实现对方法参数的加解密。
什么是Spring AOP?
Spring AOP是Spring框架中的一个模块,它提供了面向切面编程的功能。AOP允许我们将横切关注点(如日志记录、事务管理、安全性等)从业务逻辑中分离出来,从而使代码更加模块化和易于维护。
实现思路
我们将使用Spring AOP拦截目标方法的调用,在方法执行前对参数进行加密,在方法执行后对返回值进行解密。具体步骤如下:
定义一个注解,用于标记需要加解密的方法。
创建一个切面类,使用AOP拦截标记了该注解的方法。
在切面类中实现加解密逻辑。
代码示例:
一、第一步:引入相关依赖Spirngboot aop包
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-aop</artifactId>
</dependency>
二、创建自动注解接口类文件
import org.springframework.core.Ordered;
import org.springframework.core.annotation.Order;
import java.lang.annotation.*;
/**
* 安全字段注解
* 加在需要加密/解密的字段上
*
* @author: zetting
* @date:2018/12/27
*/
@Documented
@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@Order(Ordered.HIGHEST_PRECEDENCE)
public @interface EncryptField {
}
import org.springframework.core.Ordered;
import org.springframework.core.annotation.Order;
import java.lang.annotation.*;
/**
* 安全字段注解
* 加在需要加密/解密的方法上
* 实现自动加密解密
*
* @author: zetting
* @date:2018/12/27
*/
@Documented
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Order(Ordered.HIGHEST_PRECEDENCE)
public @interface EncryptMethod {
}
创建切面工具栏
import com.bzfar.util.AseUtil;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.core.Ordered;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
import java.lang.reflect.Field;
import java.util.Objects;
/**
* 安全字段加密解密切面
*
* @author: zetting
* @date:2018/12/27
*/
@Order(Ordered.HIGHEST_PRECEDENCE)
@Aspect
@Component
public class EncryptFieldAop {
Logger log = LoggerFactory.getLogger(this.getClass());
@Value("${secretkey}") //加密解密密钥
private String secretKey;
@Pointcut("@annotation(com.bzfar.aop.EncryptMethod)")
public void annotationPointCut() {
}
@Around("annotationPointCut()") //环绕
public Object around(ProceedingJoinPoint joinPoint) {
Object responseObj = null;
try {
Object requestObj = joinPoint.getArgs()[0];
handleDecrypt(requestObj);
// handleEncrypt(requestObj);
responseObj = joinPoint.proceed();
handleEncrypt(responseObj);
} catch (NoSuchMethodException e) {
e.printStackTrace();
log.error("SecureFieldAop处理出现异常{}", e);
} catch (Throwable throwable) {
throwable.printStackTrace();
log.error("SecureFieldAop处理出现异常{}", throwable);
}
return responseObj;
}
/**
* 处理加密
*
* @param requestObj
*/
private void handleEncrypt(Object requestObj) throws IllegalAccessException {
if (Objects.isNull(requestObj)) {
return;
}
Field[] fields = requestObj.getClass().getDeclaredFields();
for (Field field : fields) {
boolean hasSecureField = field.isAnnotationPresent(EncryptField.class);
if (hasSecureField) {
field.setAccessible(true);
String plaintextValue = (String) field.get(requestObj);
String encryptValue = AseUtil.encrypt(plaintextValue, secretKey);
field.set(requestObj, encryptValue);
}
}
}
/**
* 处理解密
*
* @param responseObj
*/
private Object handleDecrypt(Object responseObj) throws IllegalAccessException {
if (Objects.isNull(responseObj)) {
return null;
}
Field[] fields = responseObj.getClass().getDeclaredFields();
for (Field field : fields) {
boolean hasSecureField = field.isAnnotationPresent(EncryptField.class);
if (hasSecureField) {
field.setAccessible(true);
String encryptValue = (String) field.get(responseObj);
String plaintextValue = AseUtil.decrypt(encryptValue, secretKey);
field.set(responseObj, plaintextValue);
}
}
return responseObj;
}
}
三、封装AES加密解密工具类
package com.bzfar.util;
import org.springframework.util.Base64Utils;
import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.util.logging.Level;
import java.util.logging.Logger;
/**
* Ase加密
*
* @Author: zetting
* @Date: 2018-05-23 22:13
*/
public class AseUtil {
private static final String KEY_ALGORITHM = "AES";
private static final String DEFAULT_CIPHER_ALGORITHM = "AES/ECB/PKCS5Padding";//默认的加密算法
/**
* AES 加密操作
*
* @param content 待加密内容
* @param password 加密密码
* @return 返回Base64转码后的加密数据
*/
public static String encrypt(String content, String password) {
try {
Cipher cipher = Cipher.getInstance(DEFAULT_CIPHER_ALGORITHM);// 创建密码器
byte[] byteContent = content.getBytes("utf-8");
cipher.init(Cipher.ENCRYPT_MODE, getSecretKey(password));// 初始化为加密模式的密码器
byte[] result = cipher.doFinal(byteContent);// 加密
return Base64Utils.encodeToString(result);
} catch (Exception ex) {
Logger.getLogger(com.bzfar.util.AseUtil.class.getName()).log(Level.SEVERE, null, ex);
}
return null;
}
/**
* AES 解密操作
*
* @param content
* @param password
* @return
*/
public static String decrypt(String content, String password) {
try {
//实例化
Cipher cipher = Cipher.getInstance(DEFAULT_CIPHER_ALGORITHM);
//使用密钥初始化,设置为解密模式
cipher.init(Cipher.DECRYPT_MODE, getSecretKey(password));
//执行操作
byte[] result = cipher.doFinal(Base64Utils.decodeFromString(content));
return new String(result, "utf-8");
} catch (Exception ex) {
Logger.getLogger(com.bzfar.util.AseUtil.class.getName()).log(Level.SEVERE, null, ex);
}
return null;
}
/**
* 生成加密秘钥
*
* @return
*/
private static SecretKeySpec getSecretKey(final String password) {
//返回生成指定算法密钥生成器的 KeyGenerator 对象
KeyGenerator kg = null;
try {
kg = KeyGenerator.getInstance(KEY_ALGORITHM);
//AES 要求密钥长度为 128
kg.init(128, new SecureRandom(password.getBytes()));
//生成一个密钥
SecretKey secretKey = kg.generateKey();
return new SecretKeySpec(secretKey.getEncoded(), KEY_ALGORITHM);// 转换为AES专用密钥
} catch (NoSuchAlgorithmException ex) {
Logger.getLogger(com.bzfar.util.AseUtil.class.getName()).log(Level.SEVERE, null, ex);
}
return null;
}
}
四、请求参数Dto增加 @EncryptField 注解,进行自动自动加密解密
@ApiModel("登录参数请求")
public class BaseLoginDto {
@ApiModelProperty("用户姓名")
private String userName;
@ApiModelProperty("用户身份证信息")
@EncryptField
private String userCard;
}
五、测试验证
AOP的基本概念
-
Advice(通知、切面): 某个连接点所采用的处理逻辑,也就是向连接点注入的代码, AOP在特定的切入点上执行的增强处理。
1.1 @Before: 标识一个前置增强方法,相当于BeforeAdvice的功能.
1.2 @After: final增强,不管是抛出异常或者正常退出都会执行.
1.3 @AfterReturning: 后置增强,似于AfterReturningAdvice, 方法正常退出时执行.
1.4 @AfterThrowing: 异常抛出增强,相当于ThrowsAdvice.
1.5 @Around: 环绕增强,相当于MethodInterceptor. -
JointPoint(连接点):程序运行中的某个阶段点,比如方法的调用、异常的抛出等。
-
Pointcut(切入点): JoinPoint的集合,是程序中需要注入Advice的位置的集合,指明Advice要在什么样的条件下才能被触发,在程序中主要体现为书写切入点表达式。
-
Advisor(增强): 是PointCut和Advice的综合体,完整描述了一个advice将会在pointcut所定义的位置被触发。
-
@Aspect(切面): 通常是一个类的注解,里面可以定义切入点和通知
-
AOP Proxy:AOP框架创建的对象,代理就是目标对象的加强。Spring中的AOP代理可以使JDK动态代理,也可以是CGLIB代理,前者基于接口,后者基于子类。