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();
    /**
     * 用于獲取方法參數(shù)定義名字.
     */
    private DefaultParameterNameDiscoverer nameDiscoverer = new DefaultParameterNameDiscoverer();
    
    public String generateKeyBySpEL(String spELString, ProceedingJoinPoint joinPoint) {
        // 通過joinPoint獲取被注解方法
        MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
        Method method = methodSignature.getMethod();
        // 使用spring的DefaultParameterNameDiscoverer獲取方法形參名數(shù)組
        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]);
        }
        // 表達式從上下文中計算出實際參數(shù)值
        /*如:
            @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();
                //調(diào)用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攔截查詢方法，如果緩存中存在，則直接返回緩存結(jié)果，
        //減少數(shù)據(jù)庫查詢壓力。
        //沒有緩存則讀取MySQL
        System.out.println("查詢不到緩存");
        //執(zhí)行方法
        Object resultOld = joinPoint.proceed();
        //查詢結(jié)果不為空，則存入緩存，便于下次直接從緩存中查詢數(shù)據(jù)
        if (resultOld != null) {
            try {
                //        然后將讀取的結(jié)果保存至Redis緩存
                boolean resultRow = false;
                if (fieldKey.equals("SelectString")) {
                    //保存的是集合，需要遍歷存儲
                    //先類型強轉(zhuǎn)
                    List<Object> objectList = (List<Object>) resultOld;
                    //遍歷返回值集合，進行緩存
                    for (Object o : objectList) {
                    //由于不同對象存儲緩存時，使用的key、fieldKey都不相同，
                    //本次模擬都是以數(shù)據(jù)表的主鍵值作為fieldKey來存儲，然后用不同的key作為區(qū)分。
                    //因此需要進行類型轉(zhuǎn)換來獲取每個不同對象的不同主鍵調(diào)用方法。
                    //當然，如果你所有的對象獲取主鍵的方法名都一樣的話，
                    //完全可以使用反射中的【使用方法名獲取方法】來調(diào)用對象返回主鍵值。
                        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 繼續(xù)增
                        }
                    }
                } 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;
    }