使用AOP 实现Redis缓存注解，支持SPEL

公司项目对Redis使用比较多，因为之前没有做AOP，所以缓存逻辑和业务逻辑交织在一起，维护比较艰难
所以最近实现了针对于Redis的@Cacheable，把缓存的对象依照类别分别存放到redis的Hash中，对于key也实现了SPEL支持。

1.applicationContext.xml，配置JedisPool

<bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
        <property name="maxTotal" value="50" />
        <property name="maxIdle" value="10" />
        <property name="maxWaitMillis" value="1000" />
        <property name="testOnBorrow" value="true" />
    </bean>

    <bean id="jedisPool" class="redis.clients.jedis.JedisPool">
        <constructor-arg index="0" ref="jedisPoolConfig" />
        <constructor-arg index="1" value="127.0.0.1" />
        <constructor-arg index="2" value="6379" />
    </bean>

2.Redis的封装类,使用FastJSON进行JSON和Object的转化,这里只用到了hset，hget，hdel，其他省略了

@Component
    public class RedisCacheBean {
        @Resource
        JedisPool jedisPool;

        /**
         * 把对象放入Hash中
         */
        public void hset(String key,String field,Object o){
            Jedis jedis =jedisPool.getResource();
            jedis.hset(key,field, JsonUtil.toJSONString(o));
            jedisPool.returnResource(jedis);
        }
        /**
         * 从Hash中获取对象
         */
        public String hget(String key,String field){
            Jedis jedis =jedisPool.getResource();
            String text=jedis.hget(key,field);
            jedisPool.returnResource(jedis);
            return text;
        }
        /**
         * 从Hash中获取对象,转换成制定类型
         */
        public <T> T hget(String key,String field,Class<T> clazz){
            String text=hget(key, field);
            T result=JsonUtil.parseObject(text, clazz);
            return result;
        }
        /**
         * 从Hash中删除对象
         */
        public void hdel(String key,String ... field){
            Jedis jedis =jedisPool.getResource();
            Object result=jedis.hdel(key,field);
            jedisPool.returnResource(jedis);
        }

    }

3.创建注解，其实大部分数据都是以hash形式存储的（使的key易于管理），所以，注解中定义了fieldKey，用作Hash的field。

/**
     * 缓存注解
     * @author liudajiang
     *
     */
    @Target({ElementType.METHOD})
    @Retention(RetentionPolicy.RUNTIME)
    public @interface Cacheable {
        String key();
        String fieldKey() ;
        int expireTime() default 3600;
    }

4.定义切面,定义PointCut 表达式为注解

@Component
    @Aspect
    public class CacheAspect {
        @Resource RedisCacheBean redis;

        /**
        * 定义缓存逻辑
        */
        @Around("@annotation(org.myshop.cache.annotation.Cacheable)")
        public Object cache(ProceedingJoinPoint pjp ) {
            Object result=null;
            Boolean cacheEnable=SystemConfig.getInstance().getCacheEnabled();
            //判断是否开启缓存
            if(!cacheEnable){
                try {
                    result= pjp.proceed();
                } catch (Throwable e) {
                    e.printStackTrace();
                }
                return result;
            }

            Method method=getMethod(pjp);
            Cacheable cacheable=method.getAnnotation(org.myshop.cache.annotation.Cacheable.class);

            String fieldKey =parseKey(cacheable.fieldKey(),method,pjp.getArgs());

            //获取方法的返回类型,让缓存可以返回正确的类型
            Class returnType=((MethodSignature)pjp.getSignature()).getReturnType();

            //使用redis 的hash进行存取，易于管理
            result= redis.hget(cacheable.key(), fieldKey,returnType);

            if(result==null){
                try {
                    result=pjp.proceed();
                    Assert.notNull(fieldKey);
                    redis.hset(cacheable.key(),fieldKey, result);
                } catch (Throwable e) {
                    e.printStackTrace();
                }
            }
            return result;
        }

        /**          * 定义清除缓存逻辑          */
        @Around(value="@annotation(org.myshop.cache.annotation.CacheEvict)")
        public Object evict(ProceedingJoinPoint pjp ){
            //和cache类似，使用Jedis.hdel()删除缓存即可...
        }

        /**
         *  获取被拦截方法对象
         *
         *  MethodSignature.getMethod() 获取的是顶层接口或者父类的方法对象
         *    而缓存的注解在实现类的方法上
         *  所以应该使用反射获取当前对象的方法对象
         */
        public Method getMethod(ProceedingJoinPoint pjp){
            //获取参数的类型
            Object [] args=pjp.getArgs();
            Class [] argTypes=new Class[pjp.getArgs().length];
            for(int i=0;i<args.length;i++){
                argTypes[i]=args[i].getClass();
            }
            Method method=null;
            try {
                method=pjp.getTarget().getClass().getMethod(pjp.getSignature().getName(),argTypes);
            } catch (NoSuchMethodException e) {
                e.printStackTrace();
            } catch (SecurityException e) {
                e.printStackTrace();
            }
            return method;

        }
        /**
         *    获取缓存的key
         *    key 定义在注解上，支持SPEL表达式
         * @param pjp
         * @return
         */
        private String parseKey(String key,Method method,Object [] args){

            //获取被拦截方法参数名列表(使用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);
        }
    }

5.使用

    @Transactional
    @Cacheable(key="getAdminByName",fieldKey="#name")
    public Admin getByName(String name) {
        return adminDao.getByUsername(name);
    }
    @Transactional
    @CacheEvict(key="getAdminByName",fieldKey="#admin.username")
    public void update(Admin admin){
        adminDao.update(admin);
    }

效果：