Spring Boot緩存實戰 Redis 設置有效時間和自動刷新緩存，時間支持在配置文件中配置

時間 2019-11-17

標籤 spring boot 緩存實戰 redis 設置有效時間自動刷新支持配置文件配置欄目 Spring 简体版

原文原文鏈接

問題描述

Spring Cache提供的@Cacheable註解不支持配置過時時間，還有緩存的自動刷新。咱們能夠經過配置CacheManneg來配置默認的過時時間和針對每一個緩存容器（value）單獨配置過時時間，可是老是感受不太靈活。下面是一個示例:html

@Bean
public CacheManager cacheManager(RedisTemplate redisTemplate) {
    RedisCacheManager cacheManager= new RedisCacheManager(redisTemplate);
    cacheManager.setDefaultExpiration(60);
    Map<String,Long> expiresMap=new HashMap<>();
    expiresMap.put("Product",5L);
    cacheManager.setExpires(expiresMap);
    return cacheManager;
}

咱們想在註解上直接配置過時時間和自動刷新時間，就像這樣：java

@Cacheable(value = "people#120#90", key = "#person.id")
public Person findOne(Person person) {
    Person p = personRepository.findOne(person.getId());
    System.out.println("爲id、key爲:" + p.getId() + "數據作了緩存");
    return p;
}

value屬性上用#號隔開，第一個是原始的緩存容器名稱，第二個是緩存的有效時間，第三個是緩存的自動刷新時間，單位都是秒。git

緩存的有效時間和自動刷新時間支持SpEl表達式，支持在配置文件中配置，如：github

@Cacheable(value = "people#${select.cache.timeout:1800}#${select.cache.refresh:600}", key = "#person.id", sync = true)//3
public Person findOne(Person person) {
    Person p = personRepository.findOne(person.getId());
    System.out.println("爲id、key爲:" + p.getId() + "數據作了緩存");
    return p;
}

解決思路

查看源碼你會發現緩存最頂級的接口就是CacheManager和Cache接口。redis

CacheManager說明

CacheManager功能其實很簡單就是管理cache，接口只有兩個方法，根據容器名稱獲取一個Cache。還有就是返回全部的緩存名稱。spring

public interface CacheManager {

	/**
	 * 根據名稱獲取一個Cache（在實現類裏面是若是有這個Cache就返回，沒有就新建一個Cache放到Map容器中）
	 * @param name the cache identifier (must not be {@code null})
	 * @return the associated cache, or {@code null} if none found
	 */
	Cache getCache(String name);

	/**
	 * 返回一個緩存名稱的集合
	 * @return the names of all caches known by the cache manager
	 */
	Collection<String> getCacheNames();

}

Cache說明

Cache接口主要是操做緩存的。get根據緩存key從緩存服務器獲取緩存中的值，put根據緩存key將數據放到緩存服務器，evict根據key刪除緩存中的數據。數據庫

public interface Cache {

	ValueWrapper get(Object key);

	void put(Object key, Object value);

	void evict(Object key);

	...
}

請求步驟

請求進來，在方法上面掃描@Cacheable註解，那麼會觸發org.springframework.cache.interceptor.CacheInterceptor緩存的攔截器。
而後會調用CacheManager的getCache方法，獲取Cache，若是沒有（第一次訪問）就新建一Cache並返回。
根據獲取到的Cache去調用get方法獲取緩存中的值。RedisCache這裏有個bug，源碼是先判斷key是否存在，再去緩存獲取值，在高併發下有bug。

代碼分析

在最上面咱們說了Spring Cache能夠經過配置CacheManager來配置過時時間。那麼這個過時時間是在哪裏用的呢？設置默認的時間setDefaultExpiration，根據特定名稱設置有效時間setExpires，獲取一個緩存名稱（value屬性）的有效時間computeExpiration，真正使用有效時間是在createCache方法裏面，而這個方法是在父類的getCache方法調用。經過RedisCacheManager源碼咱們看到：apache

// 設置默認的時間
public void setDefaultExpiration(long defaultExpireTime) {
	this.defaultExpiration = defaultExpireTime;
}

// 根據特定名稱設置有效時間
public void setExpires(Map<String, Long> expires) {
	this.expires = (expires != null ? new ConcurrentHashMap<String, Long>(expires) : null);
}
// 獲取一個key的有效時間
protected long computeExpiration(String name) {
	Long expiration = null;
	if (expires != null) {
		expiration = expires.get(name);
	}
	return (expiration != null ? expiration.longValue() : defaultExpiration);
}

@SuppressWarnings("unchecked")
protected RedisCache createCache(String cacheName) {
    // 調用了上面的方法獲取緩存名稱的有效時間
	long expiration = computeExpiration(cacheName);
	// 建立了Cache對象，並使用了這個有效時間
	return new RedisCache(cacheName, (usePrefix ? cachePrefix.prefix(cacheName) : null), redisOperations, expiration,
			cacheNullValues);
}

// 重寫父類的getMissingCache。去建立Cache
@Override
protected Cache getMissingCache(String name) {
	return this.dynamic ? createCache(name) : null;
}

AbstractCacheManager父類源碼：數組

// 根據名稱獲取Cache若是沒有調用getMissingCache方法，生成新的Cache，並將其放到Map容器中去。
@Override
public Cache getCache(String name) {
	Cache cache = this.cacheMap.get(name);
	if (cache != null) {
		return cache;
	}
	else {
		// Fully synchronize now for missing cache creation...
		synchronized (this.cacheMap) {
			cache = this.cacheMap.get(name);
			if (cache == null) {
			    // 若是沒找到Cache調用該方法，這個方法默認返回值NULL由子類本身實現。上面的就是子類本身實現的方法
				cache = getMissingCache(name);
				if (cache != null) {
					cache = decorateCache(cache);
					this.cacheMap.put(name, cache);
					updateCacheNames(name);
				}
			}
			return cache;
		}
	}
}

由此這個有效時間的設置關鍵就是在getCache方法上，這裏的name參數就是咱們註解上的value屬性。因此在這裏解析這個特定格式的名稱我就能夠拿到配置的過時時間和刷新時間。getMissingCache方法裏面在新建緩存的時候將這個過時時間設置進去，生成的Cache對象操做緩存的時候就會帶上咱們的配置的過時時間，而後過時就生效了。解析SpEL表達式獲取配置文件中的時間也在也一步完成。緩存

CustomizedRedisCacheManager源碼：

package com.xiaolyuh.redis.cache;

import com.xiaolyuh.redis.cache.helper.SpringContextHolder;
import com.xiaolyuh.redis.utils.ReflectionUtils;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.support.DefaultListableBeanFactory;
import org.springframework.cache.Cache;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.core.RedisOperations;

import java.util.Collection;
import java.util.concurrent.ConcurrentHashMap;

/**
 * 自定義的redis緩存管理器
 * 支持方法上配置過時時間
 * 支持熱加載緩存：緩存即將過時時主動刷新緩存
 *
 * @author yuhao.wang
 */
public class CustomizedRedisCacheManager extends RedisCacheManager {

    private static final Logger logger = LoggerFactory.getLogger(CustomizedRedisCacheManager.class);

    /**
     * 父類cacheMap字段
     */
    private static final String SUPER_FIELD_CACHEMAP = "cacheMap";

    /**
     * 父類dynamic字段
     */
    private static final String SUPER_FIELD_DYNAMIC = "dynamic";

    /**
     * 父類cacheNullValues字段
     */
    private static final String SUPER_FIELD_CACHENULLVALUES = "cacheNullValues";

    /**
     * 父類updateCacheNames方法
     */
    private static final String SUPER_METHOD_UPDATECACHENAMES = "updateCacheNames";

    /**
     * 緩存參數的分隔符
     * 數組元素0=緩存的名稱
     * 數組元素1=緩存過時時間TTL
     * 數組元素2=緩存在多少秒開始主動失效來強制刷新
     */
    private static final String SEPARATOR = "#";

    /**
     * SpEL標示符
     */
    private static final String MARK = "$";

    RedisCacheManager redisCacheManager = null;

    @Autowired
    DefaultListableBeanFactory beanFactory;

    public CustomizedRedisCacheManager(RedisOperations redisOperations) {
        super(redisOperations);
    }

    public CustomizedRedisCacheManager(RedisOperations redisOperations, Collection<String> cacheNames) {
        super(redisOperations, cacheNames);
    }

    public RedisCacheManager getInstance() {
        if (redisCacheManager == null) {
            redisCacheManager = SpringContextHolder.getBean(RedisCacheManager.class);
        }
        return redisCacheManager;
    }

    @Override
    public Cache getCache(String name) {
        String[] cacheParams = name.split(SEPARATOR);
        String cacheName = cacheParams[0];

        if (StringUtils.isBlank(cacheName)) {
            return null;
        }

        // 有效時間，初始化獲取默認的有效時間
        Long expirationSecondTime = getExpirationSecondTime(cacheName, cacheParams);
        // 自動刷新時間，默認是0
        Long preloadSecondTime = getExpirationSecondTime(cacheParams);

        // 經過反射獲取父類存放緩存的容器對象
        Object object = ReflectionUtils.getFieldValue(getInstance(), SUPER_FIELD_CACHEMAP);
        if (object != null && object instanceof ConcurrentHashMap) {
            ConcurrentHashMap<String, Cache> cacheMap = (ConcurrentHashMap<String, Cache>) object;
            // 生成Cache對象，並將其保存到父類的Cache容器中
            return getCache(cacheName, expirationSecondTime, preloadSecondTime, cacheMap);
        } else {
            return super.getCache(cacheName);
        }

    }

    /**
     * 獲取過時時間
     *
     * @return
     */
    private long getExpirationSecondTime(String cacheName, String[] cacheParams) {
        // 有效時間，初始化獲取默認的有效時間
        Long expirationSecondTime = this.computeExpiration(cacheName);

        // 設置key有效時間
        if (cacheParams.length > 1) {
            String expirationStr = cacheParams[1];
            if (!StringUtils.isEmpty(expirationStr)) {
                // 支持配置過時時間使用EL表達式讀取配置文件時間
                if (expirationStr.contains(MARK)) {
                    expirationStr = beanFactory.resolveEmbeddedValue(expirationStr);
                }
                expirationSecondTime = Long.parseLong(expirationStr);
            }
        }

        return expirationSecondTime;
    }

    /**
     * 獲取自動刷新時間
     *
     * @return
     */
    private long getExpirationSecondTime(String[] cacheParams) {
        // 自動刷新時間，默認是0
        Long preloadSecondTime = 0L;
        // 設置自動刷新時間
        if (cacheParams.length > 2) {
            String preloadStr = cacheParams[2];
            if (!StringUtils.isEmpty(preloadStr)) {
                // 支持配置刷新時間使用EL表達式讀取配置文件時間
                if (preloadStr.contains(MARK)) {
                    preloadStr = beanFactory.resolveEmbeddedValue(preloadStr);
                }
                preloadSecondTime = Long.parseLong(preloadStr);
            }
        }
        return preloadSecondTime;
    }

    /**
     * 重寫父類的getCache方法，真假了三個參數
     *
     * @param cacheName            緩存名稱
     * @param expirationSecondTime 過時時間
     * @param preloadSecondTime    自動刷新時間
     * @param cacheMap             經過反射獲取的父類的cacheMap對象
     * @return Cache
     */
    public Cache getCache(String cacheName, long expirationSecondTime, long preloadSecondTime, ConcurrentHashMap<String, Cache> cacheMap) {
        Cache cache = cacheMap.get(cacheName);
        if (cache != null) {
            return cache;
        } else {
            // Fully synchronize now for missing cache creation...
            synchronized (cacheMap) {
                cache = cacheMap.get(cacheName);
                if (cache == null) {
                    // 調用咱們本身的getMissingCache方法建立本身的cache
                    cache = getMissingCache(cacheName, expirationSecondTime, preloadSecondTime);
                    if (cache != null) {
                        cache = decorateCache(cache);
                        cacheMap.put(cacheName, cache);

                        // 反射去執行父類的updateCacheNames(cacheName)方法
                        Class<?>[] parameterTypes = {String.class};
                        Object[] parameters = {cacheName};
                        ReflectionUtils.invokeMethod(getInstance(), SUPER_METHOD_UPDATECACHENAMES, parameterTypes, parameters);
                    }
                }
                return cache;
            }
        }
    }

    /**
     * 建立緩存
     *
     * @param cacheName            緩存名稱
     * @param expirationSecondTime 過時時間
     * @param preloadSecondTime    制動刷新時間
     * @return
     */
    public CustomizedRedisCache getMissingCache(String cacheName, long expirationSecondTime, long preloadSecondTime) {

        logger.info("緩存 cacheName：{}，過時時間:{}, 自動刷新時間:{}", cacheName, expirationSecondTime, preloadSecondTime);
        Boolean dynamic = (Boolean) ReflectionUtils.getFieldValue(getInstance(), SUPER_FIELD_DYNAMIC);
        Boolean cacheNullValues = (Boolean) ReflectionUtils.getFieldValue(getInstance(), SUPER_FIELD_CACHENULLVALUES);
        return dynamic ? new CustomizedRedisCache(cacheName, (this.isUsePrefix() ? this.getCachePrefix().prefix(cacheName) : null),
                this.getRedisOperations(), expirationSecondTime, preloadSecondTime, cacheNullValues) : null;
    }
}

那自動刷新時間呢？

在RedisCache的屬性裏面沒有刷新時間，因此咱們繼承該類重寫咱們本身的Cache的時候要多加一個屬性preloadSecondTime來存儲這個刷新時間。並在getMissingCache方法建立Cache對象的時候指定該值。

CustomizedRedisCache部分源碼：

/**
 * 緩存主動在失效前強制刷新緩存的時間
 * 單位：秒
 */
private long preloadSecondTime = 0;

// 重寫後的構造方法
public CustomizedRedisCache(String name, byte[] prefix, RedisOperations<? extends Object, ? extends Object> redisOperations, long expiration, long preloadSecondTime) {
    super(name, prefix, redisOperations, expiration);
    this.redisOperations = redisOperations;
    // 指定自動刷新時間
    this.preloadSecondTime = preloadSecondTime;
    this.prefix = prefix;
}

// 重寫後的構造方法
public CustomizedRedisCache(String name, byte[] prefix, RedisOperations<? extends Object, ? extends Object> redisOperations, long expiration, long preloadSecondTime, boolean allowNullValues) {
    super(name, prefix, redisOperations, expiration, allowNullValues);
    this.redisOperations = redisOperations;
    // 指定自動刷新時間
    this.preloadSecondTime = preloadSecondTime;
    this.prefix = prefix;
}

那麼這個自動刷新時間有了，怎麼來讓他自動刷新呢？

在調用Cache的get方法的時候咱們都會去緩存服務查詢緩存，這個時候咱們在多查一個緩存的有效時間，和咱們配置的自動刷新時間對比，若是緩存的有效時間小於這個自動刷新時間咱們就去刷新緩存（這裏注意一點在高併發下咱們最好只放一個請求去刷新數據，儘可能減小數據的壓力，因此在這個位置加一個分佈式鎖）。因此咱們重寫這個get方法。

CustomizedRedisCache部分源碼：

/**
 * 重寫get方法，獲取到緩存後再次取緩存剩餘的時間，若是時間小余咱們配置的刷新時間就手動刷新緩存。
 * 爲了避免影響get的性能，啓用後臺線程去完成緩存的刷。
 * 而且只放一個線程去刷新數據。
 *
 * @param key
 * @return
 */
@Override
public ValueWrapper get(final Object key) {
    RedisCacheKey cacheKey = getRedisCacheKey(key);
    String cacheKeyStr = new String(cacheKey.getKeyBytes());
    // 調用重寫後的get方法
    ValueWrapper valueWrapper = this.get(cacheKey);

    if (null != valueWrapper) {
        // 刷新緩存數據
        refreshCache(key, cacheKeyStr);
    }
    return valueWrapper;
}

/**
 * 重寫父類的get函數。
 * 父類的get方法，是先使用exists判斷key是否存在，不存在返回null，存在再到redis緩存中去取值。這樣會致使併發問題，
 * 假若有一個請求調用了exists函數判斷key存在，可是在下一時刻這個緩存過時了，或者被刪掉了。
 * 這時候再去緩存中獲取值的時候返回的就是null了。
 * 能夠先獲取緩存的值，再去判斷key是否存在。
 *
 * @param cacheKey
 * @return
 */
@Override
public RedisCacheElement get(final RedisCacheKey cacheKey) {

    Assert.notNull(cacheKey, "CacheKey must not be null!");

    // 根據key獲取緩存值
    RedisCacheElement redisCacheElement = new RedisCacheElement(cacheKey, fromStoreValue(lookup(cacheKey)));
    // 判斷key是否存在
    Boolean exists = (Boolean) redisOperations.execute(new RedisCallback<Boolean>() {

        @Override
        public Boolean doInRedis(RedisConnection connection) throws DataAccessException {
            return connection.exists(cacheKey.getKeyBytes());
        }
    });

    if (!exists.booleanValue()) {
        return null;
    }

    return redisCacheElement;
}

/**
 * 刷新緩存數據
 */
private void refreshCache(Object key, String cacheKeyStr) {
    Long ttl = this.redisOperations.getExpire(cacheKeyStr);
    if (null != ttl && ttl <= CustomizedRedisCache.this.preloadSecondTime) {
        // 儘可能少的去開啓線程，由於線程池是有限的
        ThreadTaskHelper.run(new Runnable() {
            @Override
            public void run() {
                // 加一個分佈式鎖，只放一個請求去刷新緩存
                RedisLock redisLock = new RedisLock((RedisTemplate) redisOperations, cacheKeyStr + "_lock");
                try {
                    if (redisLock.lock()) {
                        // 獲取鎖以後再判斷一下過時時間，看是否須要加載數據
                        Long ttl = CustomizedRedisCache.this.redisOperations.getExpire(cacheKeyStr);
                        if (null != ttl && ttl <= CustomizedRedisCache.this.preloadSecondTime) {
                            // 經過獲取代理方法信息從新加載緩存數據
                            CustomizedRedisCache.this.getCacheSupport().refreshCacheByKey(CustomizedRedisCache.super.getName(), key.toString());
                        }
                    }
                } catch (Exception e) {
                    logger.info(e.getMessage(), e);
                } finally {
                    redisLock.unlock();
                }
            }
        });
    }
}

那麼自動刷新確定要掉用方法訪問數據庫，獲取值後去刷新緩存。這時咱們又怎麼能去調用方法呢？

咱們利用java的反射機制。因此咱們要用一個容器來存放緩存方法的方法信息，包括對象，方法名稱，參數等等。咱們建立了CachedInvocation類來存放這些信息，再將這個類的對象維護到容器中。

CachedInvocation源碼：

public final class CachedInvocation {

    private Object key;
    private final Object targetBean;
    private final Method targetMethod;
    private Object[] arguments;

    public CachedInvocation(Object key, Object targetBean, Method targetMethod, Object[] arguments) {
        this.key = key;
        this.targetBean = targetBean;
        this.targetMethod = targetMethod;
        if (arguments != null && arguments.length != 0) {
            this.arguments = Arrays.copyOf(arguments, arguments.length);
        }
    }

    public Object[] getArguments() {
        return arguments;
    }

    public Object getTargetBean() {
        return targetBean;
    }

    public Method getTargetMethod() {
        return targetMethod;
    }

    public Object getKey() {
        return key;
    }

    /**
     * 必須重寫equals和hashCode方法，不然放到set集合裏無法去重
     * @param o
     * @return
     */
    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (o == null || getClass() != o.getClass()) {
            return false;
        }

        CachedInvocation that = (CachedInvocation) o;

        return key.equals(that.key);
    }

    @Override
    public int hashCode() {
        return key.hashCode();
    }
}

（方案一）維護緩存方法信息的容器（在內存中建一個MAP）和刷新緩存的類CacheSupportImpl 關鍵代碼：

private final String SEPARATOR = "#";

/**
 * 記錄緩存執行方法信息的容器。
 * 若是有不少無用的緩存數據的話，有可能會照成內存溢出。
 */
private Map<String, Set<CachedInvocation>> cacheToInvocationsMap = new ConcurrentHashMap<>();

@Autowired
private CacheManager cacheManager;

// 刷新緩存
private void refreshCache(CachedInvocation invocation, String cacheName) {

	boolean invocationSuccess;
	Object computed = null;
	try {
		// 經過代理調用方法，並記錄返回值
		computed = invoke(invocation);
		invocationSuccess = true;
	} catch (Exception ex) {
		invocationSuccess = false;
	}
	if (invocationSuccess) {
		if (!CollectionUtils.isEmpty(cacheToInvocationsMap.get(cacheName))) {
			// 經過cacheManager獲取操做緩存的cache對象
			Cache cache = cacheManager.getCache(cacheName);
			// 經過Cache對象更新緩存
			cache.put(invocation.getKey(), computed);
		}
	}
}

private Object invoke(CachedInvocation invocation)
		throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, IllegalAccessException {

	final MethodInvoker invoker = new MethodInvoker();
	invoker.setTargetObject(invocation.getTargetBean());
	invoker.setArguments(invocation.getArguments());
	invoker.setTargetMethod(invocation.getTargetMethod().getName());
	invoker.prepare();

	return invoker.invoke();
}

// 註冊緩存方法的執行類信息
@Override
public void registerInvocation(Object targetBean, Method targetMethod, Object[] arguments,
		Set<String> annotatedCacheNames, String cacheKey) {

	// 獲取註解上真實的value值
	Collection<String> cacheNames = generateValue(annotatedCacheNames);

	// 獲取註解上的key屬性值
	Class<?> targetClass = getTargetClass(targetBean);
	Collection<? extends Cache> caches = getCache(cacheNames);
	Object key = generateKey(caches, cacheKey, targetMethod, arguments, targetBean, targetClass,
			CacheOperationExpressionEvaluator.NO_RESULT);

	// 新建一個代理對象（記錄了緩存註解的方法類信息）
	final CachedInvocation invocation = new CachedInvocation(key, targetBean, targetMethod, arguments);
	for (final String cacheName : cacheNames) {
		if (!cacheToInvocationsMap.containsKey(cacheName)) {
			cacheToInvocationsMap.put(cacheName, new CopyOnWriteArraySet<>());
		}
		cacheToInvocationsMap.get(cacheName).add(invocation);
	}
}

@Override
public void refreshCache(String cacheName) {
	this.refreshCacheByKey(cacheName, null);
}


// 刷新特定key緩存
@Override
public void refreshCacheByKey(String cacheName, String cacheKey) {
	// 若是根據緩存名稱沒有找到代理信息類的set集合就不執行刷新操做。
	// 只有等緩存有效時間過了，再走到切面哪裏而後把代理方法信息註冊到這裏來。
	if (!CollectionUtils.isEmpty(cacheToInvocationsMap.get(cacheName))) {
		for (final CachedInvocation invocation : cacheToInvocationsMap.get(cacheName)) {
			if (!StringUtils.isBlank(cacheKey) && invocation.getKey().toString().equals(cacheKey)) {
				logger.info("緩存：{}-{}，從新加載數據", cacheName, cacheKey.getBytes());
				refreshCache(invocation, cacheName);
			}
		}
	}
}

（方案二）維護緩存方法信息的容器（放到Redis）這個部分代碼貼出來，直接看源碼。

如今刷新緩存和註冊緩存執行方法的信息都有了，咱們怎麼來把這個執行方法信息註冊到容器裏面呢？這裏還少了觸發點。

因此咱們還須要一個切面，當執行@Cacheable註解獲取緩存信息的時候咱們還須要註冊執行方法的信息，因此咱們寫了一個切面：

/**
 * 緩存攔截，用於註冊方法信息
 * @author yuhao.wang
 */
@Aspect
@Component
public class CachingAnnotationsAspect {

    private static final Logger logger = LoggerFactory.getLogger(CachingAnnotationsAspect.class);

    @Autowired
    private InvocationRegistry cacheRefreshSupport;

    private <T extends Annotation> List<T> getMethodAnnotations(AnnotatedElement ae, Class<T> annotationType) {
        List<T> anns = new ArrayList<T>(2);
        // look for raw annotation
        T ann = ae.getAnnotation(annotationType);
        if (ann != null) {
            anns.add(ann);
        }
        // look for meta-annotations
        for (Annotation metaAnn : ae.getAnnotations()) {
            ann = metaAnn.annotationType().getAnnotation(annotationType);
            if (ann != null) {
                anns.add(ann);
            }
        }
        return (anns.isEmpty() ? null : anns);
    }

    private Method getSpecificmethod(ProceedingJoinPoint pjp) {
        MethodSignature methodSignature = (MethodSignature) pjp.getSignature();
        Method method = methodSignature.getMethod();
        // The method may be on an interface, but we need attributes from the
        // target class. If the target class is null, the method will be
        // unchanged.
        Class<?> targetClass = AopProxyUtils.ultimateTargetClass(pjp.getTarget());
        if (targetClass == null && pjp.getTarget() != null) {
            targetClass = pjp.getTarget().getClass();
        }
        Method specificMethod = ClassUtils.getMostSpecificMethod(method, targetClass);
        // If we are dealing with method with generic parameters, find the
        // original method.
        specificMethod = BridgeMethodResolver.findBridgedMethod(specificMethod);
        return specificMethod;
    }

    @Pointcut("@annotation(org.springframework.cache.annotation.Cacheable)")
    public void pointcut() {
    }

    @Around("pointcut()")
    public Object registerInvocation(ProceedingJoinPoint joinPoint) throws Throwable {

        Method method = this.getSpecificmethod(joinPoint);

        List<Cacheable> annotations = this.getMethodAnnotations(method, Cacheable.class);

        Set<String> cacheSet = new HashSet<String>();
        String cacheKey = null;
        for (Cacheable cacheables : annotations) {
            cacheSet.addAll(Arrays.asList(cacheables.value()));
            cacheKey = cacheables.key();
        }
        cacheRefreshSupport.registerInvocation(joinPoint.getTarget(), method, joinPoint.getArgs(), cacheSet, cacheKey);
        return joinPoint.proceed();

    }
}

注意：一個緩存名稱（@Cacheable的value屬性），也只能配置一個過時時間，若是配置多個以第一次配置的爲準。

至此咱們就把完整的設置過時時間和刷新緩存都實現了，固然還可能存在必定問題，但願你們多多指教。

使用這種方式有個很差的地方，咱們破壞了Spring Cache的結構，致使咱們切換Cache的方式的時候要改代碼，有很大的依賴性。

下一篇我將對 redisCacheManager.setExpires()方法進行擴展來實現過時時間和自動刷新，進而不會去破壞Spring Cache的原有結構，切換緩存就不會有問題了。

代碼結構圖：