java

关注公众号 jb51net

关闭
首页 > 软件编程 > java > Spring Cache抽象-SpEL表达式

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

作者:小小工匠

这篇文章主要介绍了Spring Cache抽象-使用SpEL表达式解析,具有很好的参考价值,希望对大家有所帮助。如有错误或未考虑完全的地方,望不吝赐教

Spring Cache抽象-使用SpEL表达式

概述

在Spring Cache注解属性中(比如key,condition和unless),Spring的缓存抽象使用了SpEl表达式,从而提供了属性值的动态生成及足够的灵活性。

下面的代码根据用户的userCode进行缓存,对于key属性,使用了表达式自定义键的生成。

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()));
    }

SpEl表达式

SpEL表达式可基于上下文并通过使用缓存抽象,提供与root独享相关联的缓存特定的内置参数。

名称 位置 描述 示例
methodName root对象 当前被调用的方法名 #root.methodname
method root对象 当前被调用的方法 #root.method.name
target root对象 当前被调用的目标对象实例 #root.target
targetClass root对象 当前被调用的目标对象的类 #root.targetClass
args root对象 当前被调用的方法的参数列表 #root.args[0]
caches root对象 当前方法调用使用的缓存列表 #root.caches[0].name
Argument Name 执行上下文 当前被调用的方法的参数,如findArtisan(Artisan artisan),可以通过#artsian.id获得参数 #artsian.id
result 执行上下文 方法执行后的返回值(仅当方法执行后的判断有效,如 unless cacheEvict的beforeInvocation=false) #result

如何让自定义注解支持SpEL表达式

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

SpEL还可以用在xml等等上面的解析,大家可以去查阅相关资料。本文主要介绍如果将SpEl与自定义注解相结合,从而解析出自定义注解value的实际值。

使用方法

generateKeyBySpEL(String spELString, ProceedingJoinPoint joinPoint)方法封装了SpelExpressionParser解析SpEL的方法,使用时只需要传入spELString:注解的值以及AOP的 joinPoint即可,SpelExpressionParser便会自动的为我们解析出注解的实际值

     /**
     * 用于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();
    }

使用案例

1.准备

①.SpringAop相关jar包,

②.Spring-expression

2.自定义注解

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

3.定义AOP拦截注解对方法增强进行读写缓存

@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();
    }
}

4.测试

缓存视频稿件:存储数据格式为:

 @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;
    }

以上为个人经验,希望能给大家一个参考,也希望大家多多支持脚本之家。

您可能感兴趣的文章:
阅读全文