Spring Cache抽象-使用SpEL表达式解析

public class UserService {
    private Map<Integer, User> users = new HashMap<Integer, User>();
    {
        users.put(1, new User("1", "w1",37));
        users.put(2, new User("2", "w2", 34));
    }
    @Cacheable(value = "users", key = "#user.userCode" condition = "#user.age < 35")
    public User getUser(User user) {
        System.out.println("User with id " + user.getUserId() + " requested.");
        return users.get(Integer.valueOf(user.getUserId()));
    }

    @cachable(key="#user.uId")
    public User createUser(User user) {
     return user;
    }

     /**
     * 用于SpEL表达式解析.
     */
    private SpelExpressionParser parser = new SpelExpressionParser();
    /**
     * 用于获取方法参数定义名字.
     */
    private DefaultParameterNameDiscoverer nameDiscoverer = new DefaultParameterNameDiscoverer();
    
    public String generateKeyBySpEL(String spELString, ProceedingJoinPoint joinPoint) {
        // 通过joinPoint获取被注解方法
        MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
        Method method = methodSignature.getMethod();
        // 使用spring的DefaultParameterNameDiscoverer获取方法形参名数组
        String[] paramNames = nameDiscoverer.getParameterNames(method);
        // 解析过后的Spring表达式对象
        Expression expression = parser.parseExpression(spELString);
        // spring的表达式上下文对象
        EvaluationContext context = new StandardEvaluationContext();
        // 通过joinPoint获取被注解方法的形参
        Object[] args = joinPoint.getArgs();
        // 给上下文赋值
        for(int i = 0 ; i < args.length ; i++) {
            context.setVariable(paramNames[i], args[i]);
        }
        // 表达式从上下文中计算出实际参数值
        /*如:
            @annotation(key="#student.name")
             method(Student student)
             那么就可以解析出方法形参的某属性值，return “xiaoming”;
          */
        return expression.getValue(context).toString();
    }

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface SelectRedisCache {
    String key(); //Redis缓存的HK
    String fieldKey() ; //Redis缓存的K
    //默认十个小时清空
    int expireTime() default 36000;
}

@Aspect
public class SelectRedisCacheAop extends SPELUtil {
 private Map<String,Map<String,Object>> redisMap = new HashMap();
    @Around("execution(@com.XliXli.annotation.consuRedisCache.SelectRedisCache * *.*(..)) && @annotation(cacheable)")
    public Object aroundCacheable(ProceedingJoinPoint joinPoint, SelectRedisCache cacheable) throws Throwable {
        //首先获取注解的实际值，如果是SpEl表达式则进行解析
        String key = "";
        String fieldKey = "";
        Object redisObj = null;
        try {
            if (!cacheable.key().contains("#")) {
                //注解的值非SPEL表达式，直接解析就好
                key = cacheable.key();
            } else {
                //使用注解中的key, 支持SpEL表达式
                String spEL = cacheable.key();
                //调用SpelExpressionParser方法解析出注解的实际值
                key = generateKeyBySpEL(spEL, joinPoint);
                System.out.println("key=" +key);
            }
            //获取fieldKey，同上面的key一样
            if (cacheable.fieldKey().equals("")) {
                //等于空，则查询整个大Key
                fieldKey = "SelectString";
            } else {
                //使用注解中的key, 支持SpEL表达式
                String spEL = cacheable.fieldKey();
                fieldKey = generateKeyBySpEL(spEL, joinPoint);
            }
   //如果注解的fieldKey值为""，则查询大Key
            if (fieldKey.equals("SelectString")) {
                //直接查询的是大Key
                Set keys = redisMap.get(key).keySet();
                //使用集合来接收查询出来的对象
                List<Object>  redisList = new ArrayList<>();
                //遍历缓存fieldKey，查出缓存中每一个对象，放入redisList中
                for (Object fieldKey2 : keys) {
                    Object innerObj = redisMap.get(key).get(fieldKey2);
                    redisList.add(innerObj);
                }
                redisObj = redisList;
                if (redisList == null || redisList.size() <1) {
                    redisObj = null;
                }
            } else {
            //否则，查询的是单个对象
                redisObj =redisMap.get(key).get(fieldKey);
            }
            if (redisObj !=null) {
                return redisObj;
            }
        }catch (Exception e) {
            Exception e2 = new Exception("查询不到缓存异常");
            e.printStackTrace();
            e2.printStackTrace();
        }
        //以上，是使用AOP拦截查询方法，如果缓存中存在，则直接返回缓存结果，
        //减少数据库查询压力。
        //没有缓存则读取MySQL
        System.out.println("查询不到缓存");
        //执行方法
        Object resultOld = joinPoint.proceed();
        //查询结果不为空，则存入缓存，便于下次直接从缓存中查询数据
        if (resultOld != null) {
            try {
                //        然后将读取的结果保存至Redis缓存
                boolean resultRow = false;
                if (fieldKey.equals("SelectString")) {
                    //保存的是集合，需要遍历存储
                    //先类型强转
                    List<Object> objectList = (List<Object>) resultOld;
                    //遍历返回值集合，进行缓存
                    for (Object o : objectList) {
                    //由于不同对象存储缓存时，使用的key、fieldKey都不相同，
                    //本次模拟都是以数据表的主键值作为fieldKey来存储，然后用不同的key作为区分。
                    //因此需要进行类型转换来获取每个不同对象的不同主键调用方法。
                    //当然，如果你所有的对象获取主键的方法名都一样的话，
                    //完全可以使用反射中的【使用方法名获取方法】来调用对象返回主键值。
                        if (o instanceof Barrage) { //缓存弹幕对象
                            Barrage barrageO = (Barrage) o;
                            fieldKey = barrageO.getBaId() + "";
                            //增加单个
                            redisMap.put(key, new HashMap<>().put(fieldKey,barrageO ))
                         
                        } else if (o instanceof Video){//缓存视频对象
                            Video videoO = (Video) o;
                            fieldKey = barrageO.getvId() + "";
                            //增加单个
                            redisMap.put(key, new HashMap<>().put(fieldKey,videoO ))
                        } else {
                            //TODO 继续增
                        }
                    }
                } else {
                    //增加单个
                    redisTemplate.opsForHash().put(key, fieldKey, resultOld);
                }
            } catch (Exception e) {
                Exception e2 = new Exception("查询后添加缓存异常");
                e.printStackTrace();
                e2.printStackTrace();
            }
        }
        return resultOld;
    }
        public String generateKeyBySpEL(String spELString, ProceedingJoinPoint joinPoint) {
        MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
        String[] paramNames = nameDiscoverer.getParameterNames(methodSignature.getMethod());
        Expression expression = parser.parseExpression(spELString);
        EvaluationContext context = new StandardEvaluationContext();
        Object[] args = joinPoint.getArgs();
        for(int i = 0 ; i < args.length ; i++) {
            context.setVariable(paramNames[i], args[i]);
        }
        return expression.getValue(context).toString();
    }
}

 @SelectRedisCache(key = "'VideoByVSId' + #V_OriginId", fieldKey = "")
    public List<Video> findByOrigin(Long V_OriginType, Long V_OriginId) {
        List<Video> videoList = videoMapper.selectList(new EntityWrapper<Video>().eq("V_OriginType",V_OriginType).eq("V_OriginId",V_OriginId));
        for (Video video:videoList) {
            video.setBarrages(barrageService.findByVId(video.getvId()));
        }
        return videoList;
    }