Spring AOP整合redis 實現緩存統一管理

阿新 • • 發佈：2018-08-01

integer eva spring eas chm 形參結束 system 常量

項目使用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 + "]";
    }
*/
}

Spring AOP整合redis 實現緩存統一管理

integer eva spring eas chm 形參結束 system 常量項目使用redis作為緩存數據，但面臨著問題，比如，項目A，項目B都用到redis，而且用的redis都是一套集群，這樣會帶來一些問題。問題：比如項目A的開發人員，要緩存一些熱門數據，想到

Spring AOP整合redis 實現緩存統一管理

Spring AOP整合redis 實現緩存統一管理

[轉]Redis實現緩存，你應該懂的哪些思路！

Spring Boot 整合 Redis 實現快取操作

spring boot整合redis實現shiro的分散式session共享

35. Spring Boot整合Redis實現快取機制【從零開始學Spring Boot】

Spring Boot整合Redis實現快取機制

Spring Boot 整合 Shiro實現認證及授權管理

spring boot整合reids 然後實現緩存分頁(方法之一) 以及RedisTemplate存到reids 裏面get 就消失的坑

spring boot使用Jedis整合Redis實現快取（AOP）

SpringBoot集成Redis來實現緩存技術方案

spring boot 學習(十四)SpringBoot+Redis+SpringSession緩存之實戰

springboot2.0+redis實現消息隊列+redis做緩存+mysql

Spring boot整合websocket實現分散式websocketsession共享(一)--基於redis的釋出訂閱

Spring Boot 整合Spring Session 通過Redis實現分散式共享Session

利用Spring AOP和redis的鎖來實現防止表單重複提交

Spring整合Redis實現資料快取

spring boot 開發—第五篇SpringDataJPA整合 Redis 實現快取

@Cacheable註解在spring3中的使用-實現緩存

Java實現緩存(LRU,FIFO)

【新手總結】在.Net項目中使用Redis作為緩存服務

Spring AOP整合redis 實現緩存統一管理

相關推薦