注解实现SpringCache⾃定义失效时间（升级版）
注解实现SpringCache⾃定义失效时间(升级版)
之前做过注解实现⾃定义失效时间，但是需要重写spring-cache中的RedisCache源码，有些不怎么容易扩展，这⾥使⽤⾃定义的CacheManager、和RedisCache类来实现对应的逻辑：
1）⾃定义注解
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import urrent.TimeUnit;
/**
* 缓存失效的注解，⽬前只⽀持在类级别上有效
*/
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface CacheExpire {
/**
* 失效时间，默认是60
* @return
*/
public long ttl() default 60L;
/**
* 单位，默认是秒
* @return
*/
public TimeUnit unit() default TimeUnit.SECONDS;
}
2）CacheManagerHelper获得注解的值
package fig.cache.helper;
import fig.cache.RedisCacheCustomize;
import com.spboot.utils.BeanUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.BeansException;
import org.springframework.cache.annotation.CacheConfig;
import t.ApplicationContext;
import t.ApplicationContextAware;
import org.dis.cache.RedisCache;
import org.dis.cache.RedisCacheConfiguration;
import org.springframework.stereotype.Component;
import flect.Field;
import flect.Modifier;
import java.time.Duration;
import java.util.HashMap;
import java.util.Map;
import urrent.TimeUnit;
/**
* 修改CacheManager的辅助类调⽤时机： execute:314, CacheAspectSupport
* (org.springframework.cache.interceptor) invoke:61, CacheInterceptor
* (org.springframework.cache.interceptor) proceed:185,
* ReflectiveMethodInvocation (org.springframework.aop.framework) 由于 SpringAOP
* 只能切 Spring 容器管理的类，⽽调⽤时机本⾝就是使⽤反射来实现的同是全局使⽤的是同⼀个 CacheManager，所以⽆法使⽤aop
*/
@Component
public class CacheManagerHelper implements ApplicationContextAware {
private final Logger logger = Logger(CacheManagerHelper.class);
private static ApplicationContext applicationContext;
private static Map<String, Duration> CACHE_DURATION = new HashMap<>();
/** ttl字段 */
@Deprecated
private static Field CACHE_TTL;
/** ttl字段的修饰器 */
@Deprecated
private static Field CACHE_TTL_MODIFIERS;
static {
// 缓存以提⾼反射的性能
try {
CACHE_TTL = DeclaredField("ttl");
CACHE_TTL.setAccessible(true);
// 获取字段修改器
CACHE_TTL_MODIFIERS = Class().getDeclaredField("modifiers");
CACHE_TTL_MODIFIERS.setAccessible(true);
} catch (Exception e) {
}
}
@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
CacheManagerHelper.applicationContext = applicationContext;
}
/**
* 获得失效时间，不存在就按照默认的失效时间
* @param redisCacheCustomize
* @return
*/
public static Duration getByCache(RedisCacheCustomize redisCacheCustomize) {
Duration duration = Name());
if( null == duration) {
CacheConfig().getTtl();
}
return duration;
}
/**
* 根据cacheName获得对应的duration值
*
* @param name
* @return
*/
public static Duration getByKey(String name) {
return findAllCacheBean().get(name);
}
/
**
* 修改redisCache对象中持有的RedisCacheConfiguration的 private final Duration ttl;
*
* @param redisCache
*/
@Deprecated
public void modifyRedisCacheConfiguration(RedisCache redisCache) {
Duration duration = findAllCacheBean().Name());
if (null == duration) {
return;
}
/
/ 到了就修改
CacheConfiguration(), duration);
}
/**
* 修改RedisCacheConfiguration的private final Duration ttl;
*
* @param cacheConfiguration
* @param duration
*/
@Deprecated
private void modify(RedisCacheConfiguration cacheConfiguration, Duration duration) {
try {
// 去掉final修饰符
CACHE_TTL_MODIFIERS.setInt(CACHE_TTL, Modifiers() & ~Modifier.FINAL);
// 修改字段值
CACHE_TTL.set(cacheConfiguration, duration);
// 添加final修饰符
CACHE_TTL_MODIFIERS.setInt(CACHE_TTL, Modifiers() & ~Modifier.FINAL);
} catch (Exception e) {
<("修改cacheConfiguration的ttl失败，原因：{}", e.getMessage());
}
}
/
**
* 到所有的被 @CacheConfig 和 @CacheExpire 修饰的类对象
*/
public static Map<String, Duration> findAllCacheBean() {
if (CACHE_DURATION.size() == 0) {
Map<String, Object> beansWithAnnotation = BeansWithAnnotation(CacheConfig.class);  if (beansWithAnnotation != null && beansWithAnnotation.size() > 0) {
for (Map.Entry<String, Object> entry : Set()) {
Object proxyObject = Value(); // 代理类
Object realObject = Target(proxyObject); // 获得真实的对象
CacheExpire cacheExpire = Class().getAnnotation(CacheExpire.class);
if (null != cacheExpire) {
CacheConfig cacheConfig = Class().getAnnotation(CacheConfig.class);
String[] cacheNames = cacheConfig.cacheNames();
long convert = l(), cacheExpire.unit());
Duration duration = Duration.ofSeconds(convert);
for (String cacheName : cacheNames) {
CACHE_DURATION.put(cacheName, duration);
}
}
}
}
}
return CACHE_DURATION;
}
3）⾃定义RedisCacheCustomize
package fig.cache;
import fig.cache.helper.CacheManagerHelper;
import org.springframework.cache.support.SimpleValueWrapper;
import onvert.ConversionService;
import org.dis.cache.RedisCache;
import org.dis.cache.RedisCacheConfiguration;
import org.dis.cache.RedisCacheWriter;
import org.springframework.util.Assert;
public class RedisCacheCustomize extends RedisCache {
private final String name;
private final RedisCacheWriter cacheWriter;
private final RedisCacheConfiguration cacheConfig;
private final ConversionService conversionService;
protected RedisCacheCustomize(String name, RedisCacheWriter cacheWriter, RedisCacheConfiguration cacheConfig) {
super(name, cacheWriter, cacheConfig);
this.name = name;
springboot实现aopthis.cacheWriter = cacheWriter;
this.cacheConfig = cacheConfig;
}
public RedisCacheConfiguration getCacheConfig() {
return cacheConfig;
}
@Override
public void put(Object key, Object value) {
Object cacheValue = preProcessCacheValue(value);
if (!isAllowNullValues() && cacheValue == null) {
throw new IllegalArgumentException(String.format(
"Cache '%s' does not allow 'null' values. Avoid storing null via '@Cacheable(unless=\"#result == null\")' or configure RedisCache to allow 'null' via RedisCacheConfiguration.",                    name));
}
cacheWriter.put(name, createAndConvertCacheKey(key), serializeCacheValue(cacheValue), ByCache(this));
}
@Override
public ValueWrapper putIfAbsent(Object key, Object value) {
Object cacheValue = preProcessCacheValue(value);
if (!isAllowNullValues() && cacheValue == null) {
return get(key);
}
byte[] result = cacheWriter.putIfAbsent(name, createAndConvertCacheKey(key), serializeCacheValue(cacheValue),
if (result == null) {
return null;
}
return new SimpleValueWrapper(fromStoreValue(deserializeCacheValue(result)));
}
private byte[] createAndConvertCacheKey(Object key) {
return serializeCacheKey(createCacheKey(key));
}
}
4）⾃定义RedisCacheManagerCustomize
package fig.cache;
import org.dis.cache.RedisCache;
import org.dis.cache.RedisCacheConfiguration;
import org.dis.cache.RedisCacheManager;
import org.dis.cache.RedisCacheWriter;
public class RedisCacheManagerCustomize extends RedisCacheManager {
private final RedisCacheWriter cacheWriter;
private final RedisCacheConfiguration defaultCacheConfig;
public RedisCacheManagerCustomize(RedisCacheWriter cacheWriter, RedisCacheConfiguration defaultCacheConfiguration) {
super(cacheWriter, defaultCacheConfiguration);
this.cacheWriter = cacheWriter;
this.defaultCacheConfig = defaultCacheConfiguration;
@Override
protected RedisCache createRedisCache(String name, RedisCacheConfiguration cacheConfig) {
// 使⽤⾃⼰的  RedisCacheCustomize
return new RedisCacheCustomize(name, cacheWriter, cacheConfig != null ? cacheConfig : defaultCacheConfig);
}
}
5）缓存配置类
package fig.cache;
import java.time.Duration;
import org.springframework.cache.annotation.EnableCaching;
import t.annotation.Bean;
import t.annotation.Configuration;
import t.annotation.Primary;
import org.dis.cache.RedisCacheConfiguration;
import org.dis.cache.RedisCacheManager;
import org.dis.cache.RedisCacheWriter;
import org.tion.RedisConnectionFactory;
import org.dis.serializer.Jackson2JsonRedisSerializer;
import org.dis.serializer.RedisSerializationContext;
import org.dis.serializer.StringRedisSerializer;
import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
@Configuration
@EnableCaching // 开启spring的缓存
public class CacheConfig {
/**
* ⾃定义得缓存管理器
* @param redisConnectionFactory
* @return
*/
@Primary
@Bean
public RedisCacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
//初始化⼀个RedisCacheWriter
RedisCacheWriter redisCacheWriter = LockingRedisCacheWriter(redisConnectionFactory);
// key 序列化⽅式
StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
// value的序列化机制
Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = jackson2JsonRedisSerializer();
// 配置
RedisCacheConfiguration defaultCacheConfig = RedisCacheConfiguration.defaultCacheConfig()
.entryTtl(Duration.ofHours(1))
.serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(stringRedisSerializer))  // 设置 k v 序列化机制                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(jackson2JsonRedisSerializer));
//初始化RedisCacheManager
//        RedisCacheManager cacheManager = new RedisCacheManager(redisCacheWriter, defaultCacheConfig);
// 重点在这⾥，使⽤⾃⼰的CacheManager
RedisCacheManager cacheManager = new RedisCacheManagerCustomize(redisCacheWriter, defaultCacheConfig);
return cacheManager;
}
Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer() {
Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
ObjectMapper objectMapper = new ObjectMapper();
objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
return jackson2JsonRedisSerializer;
}
}
6) 使⽤注解
假设在⼀个controller使⽤注解，例如：
@CacheExpire(ttl = 10, unit = TimeUnit.SECONDS) // ⾃定义注解，10秒钟就过期
@CacheConfig(
cacheNames = "testApiService")
@RestController
public class TestApi {
@Cacheable
@GetMapping("/api/redis")
public Map<String,String> data() {
Map<String,String> map = new HashMap<String, String>();  map.put("k1", "v1");
map.put("k2", "v2");
map.put("k3", "v3");
return map;
}
}

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。