Spring Boot Cache with AES Encryption

为Spring Boot项目快速集成基于AOP + Redis的缓存功能，支持SpEL表达式动态生成缓存key，并对方法参数进行AES加密保护。

快速开始

1. 创建目录结构

在项目中新建以下文件：

src/main/java/com/xxx/config/
├── cache/
│   ├── CacheDataAnnotation.java      # 缓存注解定义
│   └── CacheDataAnnotationAop.java   # AOP切面实现
└── RedisConfig.java                   # Redis配置类

2. 添加Maven依赖

在 pom.xml 中添加：

<dependencies>
    <!-- Spring Data Redis -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>

    <!-- Spring AOP（通常已包含在starter-web中） -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-aop</artifactId>
    </dependency>

    <!-- Hutool工具类（AES加密） -->
    <dependency>
        <groupId>cn.hutool</groupId>
        <artifactId>hutool-crypto</artifactId>
        <version>5.8.25</version>
    </dependency>
</dependencies>

3. 配置Redis

在 application.yml 中配置：

spring:
  redis:
    host: localhost
    port: 6379
    password: your_password  # 如果没有密码则删除此行
    database: 0
    timeout: 3000ms

4. 复制核心代码

将以下三个文件复制到项目中（记得修改包名）：

CacheDataAnnotation.java

package com.xxx.config.cache;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.util.concurrent.TimeUnit;

/**
 * 缓存注解
 * @author YourName
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface CacheDataAnnotation {

    /**
     * 缓存key，优先使用
     */
    String key() default "";

    /**
     * 缓存spElKey，el表达式
     * 使用方式:
     * 1. 获取方法参数: @CacheDataAnnotation(spElKey="#userId+'_info'")
     * 2. 调用静态方法: @CacheDataAnnotation(spElKey="T(com.xxx.Util).encrypt(#userId)")
     */
    String spElKey() default "";

    /**
     * key前缀，默认"haicode:"
     */
    String cacheKeyPrefix() default "haicode:";

    /**
     * 缓存时间，默认60分钟
     */
    long expire() default 60L;

    TimeUnit timeUnit() default TimeUnit.MINUTES;
}

CacheDataAnnotationAop.java

package com.xxx.config.cache;

import cn.hutool.crypto.symmetric.AES;
import org.apache.commons.lang3.ArrayUtils;
import org.apache.commons.lang3.StringUtils;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.expression.ExpressionParser;
import org.springframework.expression.spel.standard.SpelExpressionParser;
import org.springframework.expression.spel.support.StandardEvaluationContext;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;
import java.lang.reflect.Parameter;
import java.nio.charset.StandardCharsets;
import java.util.Arrays;

/**
 * 缓存AOP切面
 * @author YourName
 */
@Aspect
@Component
public class CacheDataAnnotationAop {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    // SpEL解析器
    private static final ExpressionParser PARSER = new SpelExpressionParser();

    // AES密钥（建议改为配置项）
    private static final AES AES_UTIL = new AES("1234567890abcdef".getBytes(StandardCharsets.UTF_8));

    @Around("@annotation(cacheDataAnnotation)")
    public Object around(ProceedingJoinPoint joinPoint, CacheDataAnnotation cacheDataAnnotation) throws Throwable {
        String cacheKey = parseKey(joinPoint, cacheDataAnnotation);

        // 尝试从缓存获取
        Object data = redisTemplate.opsForValue().get(cacheKey);
        if (null != data) {
            return data;
        }

        // 执行原方法
        Object returnData = joinPoint.proceed();
        
        // 存入缓存（null值不缓存）
        if (null != returnData) {
            redisTemplate.opsForValue().set(cacheKey, returnData, 
                cacheDataAnnotation.expire(), cacheDataAnnotation.timeUnit());
        }
        
        return returnData;
    }

    /**
     * 解析缓存key
     */
    private String parseKey(ProceedingJoinPoint joinPoint, CacheDataAnnotation cacheDataAnnotation) {
        String keyPrefix = cacheDataAnnotation.cacheKeyPrefix();
        String key = cacheDataAnnotation.key();
        String spElKey = cacheDataAnnotation.spElKey();
        
        if (StringUtils.isNotBlank(key)) {
            return keyPrefix + key;
        }
        
        if (StringUtils.isNotBlank(spElKey)) {
            String spElKeyValue = parseSpElKey(spElKey, joinPoint);
            return keyPrefix + spElKeyValue;
        }
        
        // 自动生成key：类名.方法名:参数AES加密
        String methodKey = useMethodKey(joinPoint);
        return keyPrefix + methodKey;
    }

    /**
     * 使用方法和参数生成key
     */
    private String useMethodKey(ProceedingJoinPoint joinPoint) {
        String className = joinPoint.getTarget().getClass().getName();
        Method method = ((MethodSignature) joinPoint.getSignature()).getMethod();
        String methodName = method.getName();
        Object[] args = joinPoint.getArgs();

        StringBuilder argsBuilder = new StringBuilder();
        if (ArrayUtils.isNotEmpty(args)) {
            argsBuilder.append(":");
            for (Object arg : args) {
                // 对参数进行AES加密
                String aesArg = AES_UTIL.encryptHex(arg.toString());
                argsBuilder.append(aesArg);
            }
        }
        return className + "." + methodName + argsBuilder;
    }

    /**
     * 解析SpEL表达式
     */
    private String parseSpElKey(String spElKey, ProceedingJoinPoint joinPoint) {
        StandardEvaluationContext context = new StandardEvaluationContext();
        Object[] args = joinPoint.getArgs();
        String[] parameterNames = getParameterNames(joinPoint);

        for (int i = 0; i < args.length; i++) {
            context.setVariable(parameterNames[i], args[i]);
        }
        return PARSER.parseExpression(spElKey).getValue(context, String.class);
    }

    /**
     * 获取方法参数名
     */
    private String[] getParameterNames(JoinPoint joinPoint) {
        Method method = ((MethodSignature) joinPoint.getSignature()).getMethod();
        return Arrays.stream(method.getParameters())
                .map(Parameter::getName)
                .toArray(String[]::new);
    }
}

RedisConfig.java

package com.xxx.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

/**
 * Redis配置类
 * @author YourName
 */
@Configuration
public class RedisConfig {

    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(connectionFactory);

        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        GenericJackson2JsonRedisSerializer jsonSerializer = new GenericJackson2JsonRedisSerializer();

        template.setKeySerializer(stringRedisSerializer);
        template.setValueSerializer(jsonSerializer);
        template.setHashKeySerializer(stringRedisSerializer);
        template.setHashValueSerializer(jsonSerializer);

        return template;
    }
}

5. 使用示例

示例1：固定key

@Service
public class TokenService {

    @CacheDataAnnotation(key = "huawei:token", expire = 23L, timeUnit = TimeUnit.HOURS)
    public String getToken() {
        // 调用API获取token
        return callApi();
    }
}

示例2：SpEL表达式

@Service
public class DeptService {

    @CacheDataAnnotation(
        spElKey = "'ali:dept:' + #deptId", 
        expire = 1L, 
        timeUnit = TimeUnit.DAYS
    )
    public Department getDeptInfo(String deptId) {
        return queryFromApi(deptId);
    }
}

示例3：多参数SpEL

@Service
public class UserService {

    @CacheDataAnnotation(
        spElKey = "'user:info:' + #userId + ':' + #type",
        expire = 30L,
        timeUnit = TimeUnit.MINUTES
    )
    public UserInfo getUserInfo(Long userId, String type) {
        return queryUser(userId, type);
    }
}

示例4：调用静态方法

@Service
public class SecureService {

    @CacheDataAnnotation(
        spElKey = "'secure:data:' + T(com.xxx.util.EncryptUtil).md5(#sensitiveData)",
        expire = 10L,
        timeUnit = TimeUnit.MINUTES
    )
    public String getSensitiveData(String sensitiveData) {
        return fetchData(sensitiveData);
    }
}

Key生成策略

优先级从高到低：

固定key：key = "user:info" → haicode:user:info
SpEL表达式：spElKey = "#userId" → haicode:12345
自动生成：类名.方法名:参数AES加密 → haicode:com.xxx.Service.getUser:aes(...)

注意事项

1. AES密钥配置化（推荐）

当前AES密钥硬编码在代码中，建议改为配置项：

@Value("${cache.aes.key:1234567890abcdef}")
private String aesKey;

private AES getAesUtil() {
    return new AES(aesKey.getBytes(StandardCharsets.UTF_8));
}

2. 返回值可序列化

缓存的对象必须可序列化，建议使用：

基本类型及其包装类
String
实现了Serializable接口的对象
List、Map等集合（元素也需可序列化）

3. 空值不缓存

当前实现中，返回null不会存入缓存。如需缓存null值，需修改AOP逻辑。

4. Redis连接池配置

生产环境建议配置连接池：

spring:
  redis:
    lettuce:
      pool:
        max-active: 8
        max-idle: 8
        min-idle: 0
        max-wait: -1ms

5. 缓存穿透防护

对于可能返回null的场景，建议：

缓存空值（设置较短过期时间）
使用布隆过滤器
参数校验

验证缓存是否生效

创建测试方法：

@Service
public class TestService {

    @CacheDataAnnotation(key = "test:hello", expire = 5L, timeUnit = TimeUnit.MINUTES)
    public String getHello() {
        System.out.println("=== 执行了方法体 ==="); // 第一次会打印，第二次不会
        return "Hello World";
    }
}

调用两次，观察控制台输出和Redis中的数据：

# 查看Redis中的key
redis-cli keys "test:hello"

# 查看value
redis-cli get "test:hello"

常见问题

Q1: 缓存不生效？

检查：

Redis服务是否正常运行
@EnableAspectJAutoProxy 是否启用（Spring Boot默认启用）
方法是否为public且非static
是否通过Spring容器调用（自调用不触发AOP）

Q2: SpEL表达式报错？

确保：

参数名正确（编译时需保留参数名：-parameters）
表达式语法正确
调用的静态方法存在且可访问

Q3: 缓存数据乱码？

检查 RedisConfig 是否正确配置了序列化器。

性能优化建议

合理设置过期时间：避免缓存永久有效
使用合适的key前缀：便于管理和清理
监控缓存命中率：评估缓存效果
大对象谨慎缓存：考虑内存占用
热点数据预热：系统启动时加载常用数据

扩展方向

添加缓存更新策略（主动更新、被动失效）
支持二级缓存（本地缓存 + Redis）
添加缓存统计和监控
支持缓存注解的组合使用

springboot的缓存功能，参数aes加密方式

概述