我们使用redis缓存大多数用的是差不多的模板，代码侵入性大，此处加个注解，方便使用。
注解：
package com.sd.outbound.common.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* 注解 ListCacheData 用于简便处理需要进行缓存的操作
* 注意 增加了全局缓存开关，参数为 global_list_cache_open_status_key，
* 若是要关闭所有使用这个注解的缓存，可在nacos 配置中心或者其他配置文件配置 global_list_cache_open_status_key: false 即可关闭
* 若是要关闭单个使用注解缓存的地方，在nacos 配置中心或者其他配置文件的地方 配置 prefix: false 即可
*/
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface ListCacheData {
/**
* 前缀
* @return
*/
String prefix();
/**
* 作为key的参数是在方法的第几个参数
* @return
*/
int suffixParamIndex() default 0;
/**
* 后缀字段，，为空时候表示不需要后缀表达式，采用 SPEL
* eg:
* 1.不支持加固定后缀！！！ 目前spEl数据源是来自方法入参，要是需要固定后缀，放置在前缀就好了;
* 2.访问参数 比如 methodName(List<String userId, String pageId) ->"#userId+'_'+#pageId";
* 3.访问对象内属性 比如 methodName(UserBO userBO) ->"#userBO.name";
* 4.访问集合数据 比如 methodName(List<String> list) -> "#list.toString()";
*
* @return
*/
String suffixExpression() default "";
/**
* 后缀字段，，为空时候表示不需要后缀表达式，采用 SPEL
* eg:
* 1.不支持加固定后缀！！！ 目前spEl数据源是来自方法入参，要是需要固定后缀，放置在前缀就好了;
* 2.访问参数 比如 methodName(List<String userId, String pageId) ->"#userId+'_'+#pageId";
* 3.访问对象内属性 比如 methodName(UserBO userBO) ->"#userBO.name";
* 4.访问集合数据 比如 methodName(List<String> list) -> "#list.toString()";
*
* @return
*/
String suffixField();
/**
* 缓存时间 秒
* @return
*/
long expireSecond() default 300;
}
切面：
package com.sd.outbound.core.aspect;
import cn.hutool.core.util.StrUtil;
import com.alibaba.fastjson.JSON;
import com.sd.outbound.common.annotation.ListCacheData;
import com.sd.outbound.core.CoreConstants;
import com.sd.outbound.core.domain.bo.UserBO;
import com.soudian.common.StringHelper;
import com.soudian.utils.CollectionUtils;
import lombok.extern.slf4j.Slf4j;
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.core.LocalVariableTableParameterNameDiscoverer;
import org.springframework.core.env.Environment;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.expression.EvaluationContext;
import org.springframework.expression.Expression;
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.Type;
import java.util.*;
import java.util.concurrent.TimeUnit;
@Slf4j
@Aspect
@Component
public class ListCacheDataAspect {
private ExpressionParser parser = new SpelExpressionParser();
private LocalVariableTableParameterNameDiscoverer discoverer = new LocalVariableTableParameterNameDiscoverer();
@Autowired
StringRedisTemplate stringRedisTemplate;
@Autowired
private Environment env;
@Around("@annotation(listCacheData)")
public Object listCacheDataAround(ProceedingJoinPoint pjp, ListCacheData listCacheData) throws Throwable {
String prefix = listCacheData.prefix();
String currentCacheOpenStatus = env.getProperty(prefix);
String globalCacheStatus = env.getProperty(CoreConstants.GLOBAL_LIST_CACHE_OPEN_STATUS_KEY);
log.info("listCacheOpenStatus of {} = {}, globalListCacheStatus={}", prefix, currentCacheOpenStatus, globalCacheStatus);
if (Boolean.FALSE.toString().toLowerCase().equals(globalCacheStatus) || Boolean.FALSE.toString().toLowerCase().equals(currentCacheOpenStatus)) {
return pjp.proceed();
}
long expireSecond = listCacheData.expireSecond();
int suffixParamIndex = listCacheData.suffixParamIndex();
Method method = getMethod(pjp);
Type genericReturnType = method.getGenericReturnType();
Class<?> returnType = method.getReturnType();
Object arg = null;
if (suffixParamIndex >= pjp.getArgs().length || (arg = pjp.getArgs()[suffixParamIndex]) == null) {
return pjp.proceed();
}
if (arg instanceof List) {
List list = (List) arg;
if (CollectionUtils.isEmpty(list)) {
return pjp.proceed();
}
List cachedList = new ArrayList();
Map mapResult = new HashMap();
List listResult = new ArrayList();
Boolean isMap = false;
if(returnType.getSimpleName().equals("Map")){
isMap = true;
}
for (Object o : list) {
String key = StrUtil.join(StrUtil.COLON, prefix, parseSpel(o, listCacheData.suffixExpression()));
String data = stringRedisTemplate.opsForValue().get(key);
if (!StringHelper.isEmpty(data)) {
cachedList.add(o);
Object itemResult = JSON.parseObject(data, genericReturnType);
if(isMap){
Map itemMap = (Map) itemResult;
mapResult.put(o, itemMap.get(o));
}else{
listResult.add(itemResult);
}
}
}
if (cachedList.size() < ((List<?>) arg).size()) {
for (Object o : cachedList) {
((List<?>) arg).remove(o);
}
Object result = pjp.proceed();
if(result instanceof Map){
Map dbMapResult = (Map) result;
if(CollectionUtils.isEmpty(dbMapResult)){
return mapResult;
}
for (Object o : dbMapResult.keySet()) {
Map map = new HashMap(1, 1);
map.put(o, dbMapResult.get(o));
mapResult.put(o, dbMapResult.get(o));
stringRedisTemplate.opsForValue().set(StrUtil.join(StrUtil.COLON, prefix, parseSpel(o, listCacheData.suffixExpression())), JSON.toJSONString(map), expireSecond, TimeUnit.SECONDS);
}
}else if(result instanceof List){
List dbListResult = (List) result;
if(CollectionUtils.isEmpty(dbListResult)){
return listResult;
}
for (Object o : dbListResult) {
stringRedisTemplate.opsForValue().set(StrUtil.join(StrUtil.COLON, prefix, parseSpel(o, listCacheData.suffixField())), JSON.toJSONString(Arrays.asList(o)), expireSecond, TimeUnit.SECONDS);
listResult.add(o);
}
}
log.info("CacheData get data from db in method:{}", method.getName());
log.info("listCacheDataAround pjp absentList = {}", arg);
}else {
return isMap ? mapResult: listResult;
}
}
return pjp.proceed();
}
private Object parseSpel(Object item, String spel) {
if(StringHelper.isEmpty(spel)){
return item;
}
spel = "#item."+spel;
EvaluationContext context = new StandardEvaluationContext();
context.setVariable("item", item);
try {
Expression expression = parser.parseExpression(spel);
return expression.getValue(context);
} catch (Exception e) {
return StrUtil.EMPTY;
}
}
private static Method getMethod(ProceedingJoinPoint pjp) {
MethodSignature signature = (MethodSignature) pjp.getSignature();
Method method = signature.getMethod();
if (method.getDeclaringClass().isInterface()) {
try {
method = pjp
.getTarget()
.getClass()
.getDeclaredMethod(pjp.getSignature().getName(),
method.getParameterTypes());
} catch (SecurityException | NoSuchMethodException e) {
throw new RuntimeException(e);
}
}
return method;
}
}