Spring AOP整合redis 实现缓存统一管理

项目使用redis作为缓存数据，但面临着问题，比如，项目A，项目B都用到redis，而且用的redis都是一套集群，这样会带来一些问题。
问题：比如项目A的开发人员，要缓存一些热门数据，想到了redis，于是乎把数据放入到了redis，自定义一个缓存key：hot_data_key，数据格式是项目A自己的数据格式，项目B也遇到了同样的问题，也要缓存热门数据，也是hot_data_key，数据格式是项目B是自己的数据格式，由于用的都是同一套redis集群，这样key就是同一个key，有的数据格式适合项目A，有的数据格式适合项目B，会报错的，我们项目中就遇到这样的一个错误，找不到原因，结果就是两个平台用到了同一key，很懊恼。

解决方式：
1、弄一个常量类工程，所有的redis的key都放入到这个工程里，加上各自的平台标识，这样就不错错了
2、spring Aop结合redis，再相应的service层，加上注解，key的规范是包名+key名，这样就不错重复了

思路：
1、自定义注解，加在需要缓存数据的地方
2、spring aop 结合redis实现
3、SPEL解析注解参数，用来得到响应的注解信息
4、redis的key：包名+key 防止redis的key重复

实现如下：
项目准备，由于是maven项目，需要引入相关的包

fastjson包
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>${com.alibaba.fastjson}</version>
        </dependency>

spring-data-redis
        <dependency>
                <groupId>org.springframework.data</groupId>
                <artifactId>spring-data-redis</artifactId>
                <version>${spring.redis.version}</version>
        </dependency>
        <dependency>
                <groupId>redis.clients</groupId>
                <artifactId>jedis</artifactId>
                <version>${jedis.redis.clients.version}</version>
        </dependency>

    还有一些必备的就是spring工程相关的包

1、自定义注解

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.util.concurrent.TimeUnit;

/**
 * 缓存注解
 *
 * @author shangdc
 *
 */
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface RedisCache {

    /**
     * 缓存key的名称
     * @return
     */
    String key();

    /**
     * key是否转换成md5值，有的key是整个参数对象，有的大内容的，比如一个大文本，导致redis的key很长
     * 需要转换成md5值作为redis的key
     * @return
     */
    boolean keyTransformMd5() default false;

    /**
     * key 过期日期 秒
     * @return
     */
    int expireTime() default 60;

    /**
     * 时间单位，默认为秒
     * @return
     */
    TimeUnit dateUnit() default TimeUnit.SECONDS;

}

2、定义切点Pointcut

/**
 * redis 缓存切面
 *
 * @author shangdc
 *
 */
public class RedisCacheAspect {

    //由于每个人的环境，日志用的不一样，怕报错，就直接关掉了此日志输出，如有需要可加上
    //private Logger LOG = Logger.getLogger(RedisCacheAspect.class);

    /**
     * 这块可配置，每个公司都要自己的缓存配置方式，到时候可配置自己公司所用的缓存框架和配置方式
     */
    @Resource(name = "redisTemplate")
    private ValueOperations<String, String> valueOperations;

    /**
     * 具体的方法
     * @param jp
     * @return
     * @throws Throwable
     */
    public Object cache(ProceedingJoinPoint jp, RedisCache cacheable) throws Throwable{
        // result是方法的最终返回结果
        Object result = null;

        // 得到类名、方法名和参数
        Object[] args = jp.getArgs();

        //获取实现类的方法
        Method method = getMethod(jp);

        //注解信息 key
        String key = cacheable.key();

        //是否转换成md5值
        boolean keyTransformMd5 = cacheable.keyTransformMd5();
        //----------------------------------------------------------
        // 用SpEL解释key值
        //----------------------------------------------------------
        //解析EL表达式后的的redis的值
        String keyVal = SpringExpressionUtils.parseKey(key, method, jp.getArgs(), keyTransformMd5);

        // 获取目标对象
        Object target = jp.getTarget();
        //这块是全路径包名+目标对象名 ，默认的前缀，防止有的开发人员乱使用key，乱定义key的名称，导致重复key，这样在这加上前缀了，就不会重复使用key
        String target_class_name = target.getClass().getName();
        StringBuilder redis_key = new StringBuilder(target_class_name);
        redis_key.append(keyVal);

        //最终的redis的key
        String redis_final_key = redis_key.toString();
        String value = valueOperations.get(redis_final_key);

        if (value == null) { //这块是判空
            // 缓存未命中，这块没用log输出，可以自定义输出
            System.out.println(redis_final_key + "缓存未命中缓存");

            // 如果redis没有数据则执行拦截的方法体
            result = jp.proceed(args);

            //存入json格式字符串到redis里
            String result_json_data = JSONObject.toJSONString(result);
            System.out.println(result_json_data);
            // 序列化结果放入缓存
            valueOperations.set(redis_final_key, result_json_data, getExpireTimeSeconds(cacheable), TimeUnit.SECONDS);
        } else {
            // 缓存命中，这块没用log输出，可以自定义输出
            System.out.println(redis_final_key + "命中缓存，得到数据");

            // 得到被代理方法的返回值类型
            Class<?> returnType = ((MethodSignature) jp.getSignature()).getReturnType();

            //拿到数据格式
            result = getData(value, returnType);
        }
        return result;
    }

    /**
     * 根据不同的class返回数据
     * @param value
     * @param clazz
     * @return
     */
    public <T> T getData(String value, Class<T> clazz){
        T result = JSONObject.parseObject(value, clazz);
        return result;
    }

    /**
     * 获取方法
     * @param pjp
     * @return
     * @throws NoSuchMethodException
     */
    public static Method getMethod(ProceedingJoinPoint pjp) throws NoSuchMethodException {
        // --------------------------------------------------------------------------
        // 获取参数的类型
        // --------------------------------------------------------------------------
        Object[] args = pjp.getArgs();
        Class[] argTypes = new Class[pjp.getArgs().length];
        for (int i = 0; i < args.length; i++) {
            argTypes[i] = args[i].getClass();
        }

        String methodName = pjp.getSignature().getName();
        Class<?> targetClass = pjp.getTarget().getClass();
        Method[] methods = targetClass.getMethods();

        // --------------------------------------------------------------------------
        // 查找Class<?>里函数名称、参数数量、参数类型（相同或子类）都和拦截的method相同的Method
        // --------------------------------------------------------------------------
        Method method = null;
        for (int i = 0; i < methods.length; i++) {
            if (methods[i].getName() == methodName) {
                Class<?>[] parameterTypes = methods[i].getParameterTypes();
                boolean isSameMethod = true;

                // 如果相比较的两个method的参数长度不一样，则结束本次循环，与下一个method比较
                if (args.length != parameterTypes.length) {
                    continue;
                }

                // --------------------------------------------------------------------------
                // 比较两个method的每个参数，是不是同一类型或者传入对象的类型是形参的子类
                // --------------------------------------------------------------------------
                for (int j = 0; parameterTypes != null && j < parameterTypes.length; j++) {
                    if (parameterTypes[j] != argTypes[j] && !parameterTypes[j].isAssignableFrom(argTypes[j])) {
                        isSameMethod = false;
                        break;
                    }
                }
                if (isSameMethod) {
                    method = methods[i];
                    break;
                }
            }
        }
        return method;
    }

    /**
     * 计算根据Cacheable注解的expire和DateUnit计算要缓存的秒数
     * @param cacheable
     * @return
     */
    public int getExpireTimeSeconds(RedisCache redisCache) {
        int expire = redisCache.expireTime();
        TimeUnit unit = redisCache.dateUnit();
        if (expire <= 0) {//传入非法值，默认一分钟,60秒
            return 60;
        }
        if (unit == TimeUnit.MINUTES) {
            return expire * 60;
        } else if(unit == TimeUnit.HOURS) {
            return expire * 60 * 60;
        } else if(unit == TimeUnit.DAYS) {
            return expire * 60 * 60 * 24;
        }else {//什么都不是，默认一分钟,60秒
            return 60;
        }
    }

}

3、spring相关配置

由于是公司的项目，所有包就的路径就去掉了
  <!-- aop配置，切面类  .RedisCacheAspect类 bean-->
    <bean id="redisCacheAspect" class="包.RedisCacheAspect">
    </bean>

    <!-- 拦截所有指定 包和指定类型下的 下所有的方法 ，你是想这个在哪些包下可以实现-->
    <aop:config proxy-target-class="true">
        <aop:aspect ref="redisCacheAspect">
            <aop:pointcut id="redisCacheAopPointcut"
                    expression="(execution(* 包.business.web.service.*.*(..)) and @annotation(cacheable))"/>

            <!-- 环绕 ，命中缓存则直接放回缓存数据，不会往下走，未命中直接放行，直接执行对应的方法-->
            <aop:around pointcut-ref="redisCacheAopPointcut" method="cache"/>
        </aop:aspect>
    </aop:config>

4、工具类 SPEL

/**
 * spring EL表达式
 *
 * @author shangdc
 *
 */
public class SpringExpressionUtils {

    /**
     * 获取缓存的key key 定义在注解上，支持SPEL表达式 注： method的参数支持Javabean和Map
     * method的基本类型要定义为对象，否则没法读取到名称
     *
     * example1: Phone phone = new Phone(); "#{phone.cpu}" 为对象的取值 、
     * example2: Map apple = new HashMap(); apple.put("name","good apple"); "#{apple[name]}" 为map的取值
     * example3: "#{phone.cpu}_#{apple[name]}"
     *
     *
     * @param key
     * @param method
     * @param args
     * @return
     */
    public static String parseKey(String key, Method method, Object[] args, boolean keyTransformMd5) {
        // 获取被拦截方法参数名列表(使用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]);
        }
        ParserContext parserContext = new TemplateParserContext();

        // ----------------------------------------------------------
        // 把 #{ 替换成 #{# ,以适配SpEl模板的格式
        // ----------------------------------------------------------
        //例如，@注解名称(key="#{player.userName}",expire = 200)
        //#{phone[cpu]}_#{phone[ram]}
        //#{player.userName}_#{phone[cpu]}_#{phone[ram]}_#{pageNo}_#{pageSize}
        Object returnVal = parser.parseExpression(key.replace("#{", "#{#"), parserContext).getValue(context, Object.class);

        //这块这么做，是为了Object和String都可以转成String类型的，可以作为key
        String return_data_key = JSONObject.toJSONString(returnVal);
        //转换成md5，是因为redis的key过长，并且这种大key的数量过多，就会占用内存，影响性能
        if(keyTransformMd5) {
            return_data_key = MD5Util.digest(return_data_key);
        }

        return returnVal == null ? null : return_data_key;
    }

}

5、redis相关配置

        重要的是自己的redis配置，可能跟我的不太一样，用自己的就好
        <!-- redisTemplate defination -->
    <bean id="redisTemplate" class="org.springframework.data.redis.core.StringRedisTemplate">
        <property name="connectionFactory" ref="jedisConnectionFactory" />
    </bean>

测试

public class RedisCacheTest {

    @Test
    public void test() {

        ApplicationContext context = new ClassPathXmlApplicationContext("classpath:spring/spring-applicationContext.xml");

        RedisCacheAopService redisCacheAopService = (RedisCacheAopService) context.getBean("redisCacheAopService");
        Api api = redisCacheAopService.getApi(1l);
        System.out.println(api.getClass());
        System.out.println(JSONObject.toJSONString(api));

        ApiParam param = new ApiParam();
        param.setId(2l);
        param.setApiName("短信服务接口数据");
//      System.out.println("toString:" + param.toString());
//      System.out.println(MD5Util.digest(param.toString()));
        Api api_1 = redisCacheAopService.getApiByParam(param);
        System.out.println(api_1.getClass());
        System.out.println(JSONObject.toJSONString(api_1));

    }

}

测试打印信息：

大体思路是这样，需要自己动手实践，不要什么都是拿过来直接copy，使用，整个过程都不操作，也不知道具体的地方，该用什么，自己实际操作，可以得到很多信息。

辅助信息类：


public class Api implements Serializable {

    private static final long serialVersionUID = 1L;
    /**
     *
     * 自增主键id
     */
    private Long id;
    /**
     *
     * api名称
     */
    private String apiName;
    /**
     *
     * api描述
     */
    private String apiDescription;
    /**
     *
     * 有效时间
     */
    private Integer valid;
    /**
     * 处理类
     */
    private String handlerClass;
    /**
     *
     *
     */
    private Date updateTime;
    /**
     *
     *
     */
    private Date createTime;

    public Api() {
    }

    public String toString() {
        return "id:" + id + ", apiName:" + apiName + ", apiDescription:" + apiDescription + ", valid:" + valid + ", updateTime:" + updateTime + ", createTime:" + createTime;
    }

    public Long getId() {
        return this.id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getApiName() {
        return this.apiName;
    }

    public void setApiName(String apiName) {
        this.apiName = apiName;
    }

    public String getApiDescription() {
        return this.apiDescription;
    }

    public void setApiDescription(String apiDescription) {
        this.apiDescription = apiDescription;
    }

    public Integer getValid() {
        return this.valid;
    }

    public void setValid(Integer valid) {
        this.valid = valid;
    }

    public Date getUpdateTime() {
        return this.updateTime;
    }

    public void setUpdateTime(Date updateTime) {
        this.updateTime = updateTime;
    }

    public Date getCreateTime() {
        return this.createTime;
    }

    public void setCreateTime(Date createTime) {
        this.createTime = createTime;
    }

    public String getHandlerClass() {
        return handlerClass;
    }

    public void setHandlerClass(String handlerClass) {
        this.handlerClass = handlerClass;
    }

}

参数类信息
public class ApiParam {

    /**
     *
     */
    private static final long serialVersionUID = 1L;

    /**
     * api表主键id
     */
    private Long id;

    /**
     *
     * api名称
     */
    private String apiName;

    /**
     *
     * 有效OR无效
     */
    private Integer valid;

    public String getApiName() {
        return apiName;
    }

    public void setApiName(String apiName) {
        this.apiName = apiName;
    }

    public Integer getValid() {
        return valid;
    }

    public void setValid(Integer valid) {
        this.valid = valid;
    }

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    /*@Override
    public String toString() {
        return "ApiParam [id=" + id + ", apiName=" + apiName + ", valid=" + valid + "]";
    }
*/
}

原文地址：http://blog.51cto.com/shangdc/2153324

时间： 2024-10-29 08:12:25

Spring AOP整合redis 实现缓存统一管理的相关文章

Spring Boot 整合Redis 实现缓存

本文提纲 一.缓存的应用场景 二.更新缓存的策略 三.运行 springboot-mybatis-redis 工程案例 四.springboot-mybatis-redis 工程代码配置详解 运行环境: Mac OS 10.12.x JDK 8 + Redis 3.2.8 Spring Boot 1.5.1.RELEASE 一.缓存的应用场景 什么是缓存? 在互联网场景下,尤其 2C 端大流量场景下,需要将一些经常展现和不会频繁变更的数据,存放在存取速率更快的地方.缓存就是一个存储器,在技术选型

Spring优雅整合Redis缓存

“小明,多系统的session共享,怎么处理?”“Redis缓存啊!” “小明,我想实现一个简单的消息队列?”“Redis缓存啊!” “小明,分布式锁这玩意有什么方案?”“Redis缓存啊!” “小明,公司系统响应如蜗牛,咋整?”“Redis缓存啊!” 本着研究的精神,我们来分析下小明的第四个问题. 准备: Idea2019.03/Gradle6.0.1/Maven3.6.3/JDK11.0.4/Lombok0.28/SpringBoot2.2.4RELEASE/mybatisPlus3.3.0

使用Memcached、Spring AOP构建数据库前端缓存框架

数据库访问可能是很多网站的瓶颈.动不动就连接池耗尽.内存溢出等.前面已经讲到如果我们的网站是一个分布式的大型站点,那么使用 memcached实现数据库的前端缓存是个很不错的选择:但如果网站本身足够小只有一个服务器,甚至是vps的那种,不推荐使用memcached,使 用Hibernate或者Mybatis框架自带的缓存系统就行了. 一.开启memcached服务器端服务 如果已经安装了memcached服务器端程序,请确认服务器端服务已开启. 二.引入jar 1.  alisoft-xplat

spring AOP自定义注解方式实现日志管理

转:spring AOP自定义注解方式实现日志管理 今天继续实现AOP,到这里我个人认为是最灵活,可扩展的方式了,就拿日志管理来说,用Spring AOP 自定义注解形式实现日志管理.废话不多说,直接开始!!! 关于配置我还是的再说一遍. 在applicationContext-mvc.xml中要添加的 <mvc:annotation-driven />     <!-- 激活组件扫描功能,在包com.gcx及其子包下面自动扫描通过注解配置的组件 -->     <conte

（转）Spring整合Redis作为缓存

采用Redis作为Web系统的缓存.用Spring的Cache整合Redis. 一.关于redis的相关xml文件的写法 <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:cache="http://www.springframework.org/schema/c

Spring Boot整合Redis

一.Spring Boot对Redis的支持 Spring对Redis的支持是使用Spring Data Redis来实现的,一般使用Jedis或者lettuce(默认),Java客户端在 org.springframework.boot.autoconfigure.data.redis(Spring Boot 2.x) 中redis的自动配置 AutoConfigureDataRedis RedisAutoConfiguration提供了RedisTemplate与StringRedisTem

Spring AOP+自定义注解实现缓存

Spring AOP配置: <aop:config> <aop:aspect ref="cacheAdvice"> <aop:pointcut id="cachePointcut" expression="execution(* cn.vobile.service..*.*(..)) and @annotation(cacheable)"/> <aop:around method="cacheD

spring boot 整合 redis

自己开发环境需要安装 redis 服务,百度一下很多,下面主要说明Springboot 集成 redis 讲解 我的版本 java8 + redis3.0 + springboot 1.5.9. Spring redis 集成了 jedis redis 中存储的是 bytes 1 spring boot已经支持集成 redis,在 mvn 中只需添加依赖即可.pom 配置片段如下 <parent> <groupId>org.springframework.boot</grou

Java-Shiro（八）：Shiro集成Redis实现Session统一管理

声明:本证项目基于<Java-Shiro(六):Shiro Realm讲解(三)Realm的自定义及应用>构建项目为基础. 在实际应用中使用Redis管理Shiro默认的Session(SessionManager)是必要的,因为默认的SessionManager内部默认采用了内存方式存储Session相关信息():当配置了内部cacheManager时(默认配置采用EhCache--内存或磁盘缓存),会将已经登录的用户的Session信息存储到内存或磁盘.无论是采用纯内存方式或者EhCach