Springboot自定义注解，支持SPEL表达式

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

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface CacheEvictFuzzy {
    /**
     * redis key集合，模糊删除
     * @return
     */
    String[] key() default "";

}

import org.apache.commons.lang3.StringUtils;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.LocalVariableTableParameterNameDiscoverer;
import org.springframework.core.annotation.Order;
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.util.Set;
@Aspect
@Order(1)
@Component
public class CacheCleanFuzzyAspect {
Logger logger = LoggerFactory.getLogger(this.getClass());
@Autowired
private RedisUtil redis;
//指定要执行AOP的方法
@Pointcut(value = "@annotation(cacheEvictFuzzy)")
public void pointCut(CacheEvictFuzzy cacheEvictFuzzy){}
// 设置切面为加有 @RedisCacheable注解的方法
@Around("@annotation(cacheEvictFuzzy)")
public Object around(ProceedingJoinPoint proceedingJoinPoint, CacheEvictFuzzy cacheEvictFuzzy){
return doRedis(proceedingJoinPoint, cacheEvictFuzzy);
}
@AfterThrowing(pointcut = "@annotation(cacheEvictFuzzy)", throwing = "error")
public void afterThrowing (Throwable  error, CacheEvictFuzzy cacheEvictFuzzy){
logger.error(error.getMessage());
}
/**
* 删除缓存
* @param proceedingJoinPoint
* @param cacheEvictFuzzy
* @return
*/
private Object doRedis (ProceedingJoinPoint proceedingJoinPoint, CacheEvictFuzzy cacheEvictFuzzy){
Object result = null;
//得到被切面修饰的方法的参数列表
Object[] args = proceedingJoinPoint.getArgs();
// 得到被代理的方法
Method method = ((MethodSignature) proceedingJoinPoint.getSignature()).getMethod();
String[] keys = cacheEvictFuzzy.key();
Set<String> keySet = null;
String realkey = "";
for (int i = 0; i < keys.length; i++) {
if (StringUtils.isBlank(keys[i])){
continue;
}
realkey = parseKey(keys[i], method, args);
keySet = redis.keys("*"+realkey+"*");
if (null != keySet && keySet.size()>0){
redis.delKeys(keySet);
logger.debug("拦截到方法：" + proceedingJoinPoint.getSignature().getName() + "方法");
logger.debug("删除的数据key为："+keySet.toString());
}
}
try {
result = proceedingJoinPoint.proceed();
} catch (Throwable throwable) {
throwable.printStackTrace();
}finally {
return result;
}
}
/**
* 获取缓存的key
* key 定义在注解上，支持SPEL表达式
* @return
*/
private String parseKey(String key, Method method, Object [] args){
if(StringUtils.isEmpty(key)) return null;
//获取被拦截方法参数名列表(使用Spring支持类库)
LocalVariableTableParameterNameDiscoverer u = new LocalVariableTableParameterNameDiscoverer();
String[] paraNameArr = u.getParameterNames(method);
//使用SPEL进行key的解析
ExpressionParser parser = new SpelExpressionParser();
//SPEL上下文
StandardEvaluationContext context = new StandardEvaluationContext();
//把方法参数放入SPEL上下文中
for(int i=0;i<paraNameArr.length;i++){
context.setVariable(paraNameArr[i], args[i]);
}
return parser.parseExpression(key).getValue(context,String.class);
}
}

    /**
* 获取缓存的key
* key 定义在注解上，支持SPEL表达式
* @return
*/
private String parseKey(String key, Method method, Object [] args){
if(StringUtils.isEmpty(key)) return null;
//获取被拦截方法参数名列表(使用Spring支持类库)
LocalVariableTableParameterNameDiscoverer u = new LocalVariableTableParameterNameDiscoverer();
String[] paraNameArr = u.getParameterNames(method);
//使用SPEL进行key的解析
ExpressionParser parser = new SpelExpressionParser();
//SPEL上下文
StandardEvaluationContext context = new StandardEvaluationContext();
//把方法参数放入SPEL上下文中
for(int i=0;i<paraNameArr.length;i++){
context.setVariable(paraNameArr[i], args[i]);
}
return parser.parseExpression(key).getValue(context,String.class);
}