springboot 缓存框架Cache整合redis组成二级缓存
项目性能优化的解决方案除开硬件外的方案无非就是优化sql，减少sql 的执行时间，合理运用缓存让同样的请求和数据库之间的连接尽量减少，内存的处理速度肯定比直接查询数据库来的要快一些。今天就记录一下spring的缓存框架和redis形成二级缓存来优化查询效率，废话不多说直接上代码：
整体目录：
首先定义注解：缓存注解和删除注解
package com.example.test1.cache.aspect.annoation;
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 xx
* @Date 2024/6/27 11:12
* @Description: 数据缓存注解
* @Version 1.0
*/
@Target(value = ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface DateCachePut {
/**
* 模块名：区分模块下的不同功能key，key可能重复
*/
String module() default "";
/**
* 缓存的数据key
*/
String key() default "";
/**
* key生成
*/
String keyGenerator() default "DefaultKeyGenerate";
/**
* 过期时间，默认30
*/
long passTime() default 30;
/**
* 过期时间单位，默认：秒
*/
TimeUnit timeUnit() default TimeUnit.SECONDS;
/**
* 是否出发条件，支持springEl表达式
*/
String condition() default "true";
}
package com.example.test1.cache.aspect.annoation;
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 xx
* @Date 2024/6/27 11:13
* @Description: 缓存删除注解
* @Version 1.0
*/
@Target(value = ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface DataCacheEvict {
/**
* 模块名：区分模块下的不同功能key，key可能重复
*/
String module() default "";
/**
* 缓存的数据key
*/
String key() default "";
/**
* key生成
*/
String keyGenerator() default "DefaultKeyGenerate";
/**
* 删除时间，默认1
*/
long delay() default 1;
/**
* 过期时间单位，默认：秒
*/
TimeUnit timeUnit() default TimeUnit.SECONDS;
/**
* 是否出发条件，支持springEl表达式
*/
String condition() default "true";
}
注解切面类
package com.example.test1.cache.aspect;
import com.example.test1.cache.aspect.annoation.DataCacheEvict;
import com.example.test1.cache.aspect.annoation.DateCachePut;
import com.example.test1.cache.generate.IKeyGenerate;
import com.example.test1.cache.handle.CacheHandle;
import com.example.test1.util.SpElUtils;
import com.example.test1.util.SpiUtils;
import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import org.springframework.util.Assert;
import javax.annotation.Resource;
import java.util.Arrays;
import java.util.Optional;
import java.util.StringJoiner;
/**
* @Author xx
* @Date 2024/6/27 11:34
* @Description:
* @Version 1.0
*/
@Slf4j
@Aspect
@Component
public class CacheAspect {
/**
* 缓存前缀
*/
private static final String CHAR_PREFIX = "cache";
@Resource
private CacheHandle cacheHandle;
@Value(value = "${spring.application.name}")
private String applicationName;
@SneakyThrows
@Around(value = "@annotation(dateCachePut)")
public Object cachePut(ProceedingJoinPoint joinPoint, DateCachePut dateCachePut){
String applicationName = StringUtils.isBlank(dateCachePut.module()) ?
this.applicationName : dateCachePut.module();
//解析key并查询缓存
String key = buildCacheKey(applicationName,
dateCachePut.module(),
joinPoint,
dateCachePut.key(),
dateCachePut.keyGenerator());
Object result = cacheHandle.get(key);
if(result == null){
result = joinPoint.proceed();
if(result != null){
Boolean condition = SpElUtils.getValue(joinPoint,dateCachePut.condition(),Boolean.class,result);
if(condition){
cacheHandle.put(key,result,dateCachePut.passTime(),dateCachePut.timeUnit());
}
}
}
return result;
}
/**
* 删除缓存
* @param joinPoint 连接点
* @param dataCacheEvict 删除注解
* @return
*/
@SneakyThrows
@Around(value = "@annotation(dataCacheEvict)")
public Object cacheRemove(ProceedingJoinPoint joinPoint, DataCacheEvict dataCacheEvict){
String applicationName = StringUtils.isBlank(dataCacheEvict.module()) ?
this.applicationName : dataCacheEvict.module();
//解析key并查询缓存
String key = buildCacheKey(applicationName,
dataCacheEvict.module(),
joinPoint,
dataCacheEvict.key(),
dataCacheEvict.keyGenerator());
cacheHandle.evict(key);
//执行目标方法
Object result = joinPoint.proceed();
// 条件成立则异步删除
Boolean condition = SpElUtils.getValue(joinPoint, dataCacheEvict.condition(), Boolean.class, result);
if(condition){
cacheHandle.asyEvict(key,dataCacheEvict.delay(),dataCacheEvict.timeUnit());
}
return result;
}
/**
* 构建缓存key
* @param applicationName 服务名
* @param module 模块名
* @param joinPoint 链接点
* @param key 编写的key表达式
* @param keyGenerator key生成器实现类名称
* @return
*/
private String buildCacheKey(String applicationName,String module,
ProceedingJoinPoint joinPoint,String key,String keyGenerator){
return new StringJoiner("::")
.add(CHAR_PREFIX)
.add(applicationName)
.add(module)
.add(generateKey(joinPoint,key,keyGenerator))
.toString();
}
/**
* 生成key
* 1：key为空的情况下将会是方法参数列表中的toString集合
* 2：将表达式传递的key生成器实现类生成
*
* @param joinPoint 连接点
* @param key 编写的key表达式
* @param keyGenerator key生成器实现类名
* @return
*/
private CharSequence generateKey(ProceedingJoinPoint joinPoint, String key, String keyGenerator) {
return StringUtils.isEmpty(keyGenerator) ? Arrays.toString(joinPoint.getArgs()) :
Optional.ofNullable(SpiUtils.getServiceImpl(keyGenerator, IKeyGenerate.class))
.map(keyGenerate ->{
Assert.notNull(keyGenerate,String.format("%s找不到keyGenerate实现类", keyGenerator));
return keyGenerate.generateKey(joinPoint,key);
}).orElse(null);
}
}
工具类：
package com.example.test1.util;
import lombok.SneakyThrows;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.core.DefaultParameterNameDiscoverer;
import org.springframework.expression.EvaluationContext;
import org.springframework.expression.spel.standard.SpelExpressionParser;
import org.springframework.expression.spel.support.StandardEvaluationContext;
import java.lang.reflect.Method;
/**
* @Author xx
* @Date 2024/6/27 15:10
* @Description:
* @Version 1.0
*/
public class SpElUtils {
private final static String RESULT = "result";
/**
* 用于springEL表达式的解析
*/
private static SpelExpressionParser spelExpressionParser = new SpelExpressionParser();
/**
* 用于获取方法参数定义的名字
*/
private static DefaultParameterNameDiscoverer defaultParameterNameDiscoverer = new DefaultParameterNameDiscoverer();
/**
* 根据EL表达式获取值
*
* @param joinPoint 连接点
* @param key springEL表达式
* @param classes 返回对象的class
* @return 获取值
*/
public static <T> T getValue(ProceedingJoinPoint joinPoint, String key, Class<T> classes) {
// 解析springEL表达式
EvaluationContext evaluationContext = getEvaluationContext(joinPoint, null);
return spelExpressionParser.parseExpression(key).getValue(evaluationContext, classes);
}
/**
* 根据EL表达式获取值
*
* @param joinPoint 连接点
* @param expression springEL表达式
* @param classes 返回对象的class
* @param result result
* @return 获取值
*/
public static <T> T getValue(JoinPoint joinPoint, String expression, Class<T> classes, Object result) throws NoSuchMethodException {
// 解析springEL表达式
EvaluationContext evaluationContext = getEvaluationContext(joinPoint, result);
return spelExpressionParser.parseExpression(expression).getValue(evaluationContext, classes);
}
/**
* 获取参数上下文
*
* @param joinPoint 连接点
* @return 参数上下文
*/
@SneakyThrows
private static EvaluationContext getEvaluationContext(JoinPoint joinPoint, Object result) {
EvaluationContext evaluationContext = new StandardEvaluationContext();
String[] parameterNames = defaultParameterNameDiscoverer.getParameterNames(getMethod(joinPoint));
for (int i = 0; i < parameterNames.length; i++) {
evaluationContext.setVariable(parameterNames[i], joinPoint.getArgs()[i]);
}
evaluationContext.setVariable(RESULT, result);
return evaluationContext;
}
/**
* 获取目标方法
*
* @param joinPoint 连接点
* @return 目标方法
*/
private static Method getMethod(JoinPoint joinPoint) throws NoSuchMethodException {
Signature signature = joinPoint.getSignature();
return joinPoint.getTarget().getClass()
.getMethod(signature.getName(), ((MethodSignature) signature).getParameterTypes());
}
}
package com.example.test1.util;
import com.github.benmanes.caffeine.cache.Caffeine;
import com.github.benmanes.caffeine.cache.LoadingCache;
import java.util.Objects;
import java.util.ServiceLoader;
import java.util.concurrent.TimeUnit;
/**
* @Author xx
* @Date 2024/6/27 14:19
* @Description:
* @Version 1.0
*/
public class SpiUtils {
/**
* SPI缓存key
*
* @param <T>
*/
private static final class SpiCacheKeyEntity<T> {
/**
* 实现的接口class
*/
private Class<T> classType;
/**
* 实现类的名称
*/
private String serviceName;
public SpiCacheKeyEntity(Class<T> classType, String serviceName) {
this.classType = classType;
this.serviceName = serviceName;
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
SpiCacheKeyEntity<?> spiCacheKeyEntity = (SpiCacheKeyEntity<?>) o;
return Objects.equals(classType, spiCacheKeyEntity.classType) && Objects.equals(serviceName, spiCacheKeyEntity.serviceName);
}
@Override
public int hashCode() {
return Objects.hash(classType, serviceName);
}
}
private SpiUtils() {
}
/**
* 单例
* 根据接口实现类的名称以及接口获取实现类
*
* @param serviceName 实现类的名称
* @param classType 实现的接口class
* @return 具体的实现类
*/
public static <T> T getServiceImpl(String serviceName, Class<T> classType) {
return (T) SERVICE_IMPL_CACHE.get(new SpiCacheKeyEntity(classType, serviceName));
}
/**
* SPI接口实现类 Caffeine软引用同步加载缓存（其内部做了同步处理)
*/
public final static LoadingCache<SpiCacheKeyEntity, Object> SERVICE_IMPL_CACHE = Caffeine.newBuilder()
.expireAfterAccess(24, TimeUnit.HOURS)
.maximumSize(100)
.softValues()
.build(spiCacheKeyEntity -> getServiceImplByPrototype(spiCacheKeyEntity.serviceName, spiCacheKeyEntity.classType));
/**
* 多例
* 根据接口实现类的名称以及接口获取实现类
*
* @param serviceName 实现类的名称
* @param classType 实现的接口class
* @return 具体的实现类
*/
public static <T> T getServiceImplByPrototype(String serviceName, Class<T> classType) {
ServiceLoader<T> services = ServiceLoader.load(classType, Thread.currentThread().getContextClassLoader());
for (T s : services) {
if (s.getClass().getSimpleName().equals(serviceName)) {
return s;
}
}
return null;
}
}
缓存key生成接口
package com.example.test1.cache.generate;
import org.aspectj.lang.ProceedingJoinPoint;
/**
* @Author xx
* @Date 2024/6/27 15:05`在这里插入代码片`
* @Description: 缓存key 接口生成器
* @Version 1.0
*/
public interface IKeyGenerate {
/**
*生成key
* @param joinPoint 连接点
* @param key 编写的key表达式
* @return
*/
String generateKey(ProceedingJoinPoint joinPoint,String key);
}
实现
package com.example.test1.cache.generate.impl;
import com.example.test1.cache.generate.IKeyGenerate;
import com.example.test1.util.SpElUtils;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
/**
* @Author xx
* @Date 2024/6/27 15:08
* @Description: 默认key生成器
* @Version 1.0
*/
@Slf4j
public class DefaultKeyGenerate implements IKeyGenerate {
@Override
public String generateKey(ProceedingJoinPoint joinPoint, String key) {
try {
return SpElUtils.getValue(joinPoint,key,String.class);
} catch (Exception e) {
log.error("DefaultKeyGenerate 抛出异常:{}", e.getMessage(), e);
throw new RuntimeException("DefaultKeyGenerate 生成key出现异常", e);
}
}
}
缓存处理
package com.example.test1.cache.handle;
import com.example.test1.cache.schema.ICacheSchema;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
import java.util.concurrent.ScheduledThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
/**
* @Author xx
* @Date 2024/6/27 15:26
* @Description: 缓存处理
* @Version 1.0
*/
@Component
public class CacheHandle {
@Resource
private ICacheSchema cacheSchema;
@Resource
private ScheduledThreadPoolExecutor asyScheduledThreadPoolExecutor;
/**
*查询缓存
* @param key 缓存key
* @return 缓存值
*/
public Object get(String key){
return cacheSchema.get(key);
}
/**
*存入缓存
* @param key 缓存key
* @param value 缓存值
* @param expirationTime 缓存过期时间
* @param timeUnit 时间单位
*/
public void put(String key, Object value, long expirationTime, TimeUnit timeUnit){
cacheSchema.put(key,value,expirationTime,timeUnit);
}
/**
* 移除缓存
* @param key 缓存key
* @return
*/
public boolean evict(String key){
boolean evict = cacheSchema.evict(key);
if(evict){
}
return evict;
}
/**
* 异步定时删除缓存
* @param key 缓存key
* @param passTime 定时删除时间
* @param timeUnit 定时删除单位
*/
public void asyEvict(String key, long passTime, TimeUnit timeUnit) {
asyScheduledThreadPoolExecutor.schedule(()->this.evict(key),passTime,timeUnit);
}
}
缓存公共接口，和多级缓存接口
package com.example.test1.cache.schema;
import java.util.concurrent.TimeUnit;
/**
* @Author xx
* @Date 2024/6/27 15:28
* @Description: 缓存公共接口
* @Version 1.0
*/
public interface ICacheSchema {
/**
* 查询缓存
*
* @param key 缓存的key
* @return 缓存的值
*/
Object get(String key);
/**
* 存入缓存
*
* @param key 缓存的key
* @param value 缓存的值
* @param expirationTime 缓存的过期时间
* @param timeUnit 缓存过期时间的单位
*/
void put(String key, Object value, long expirationTime, TimeUnit timeUnit);
/**
* 移除缓存
*
* @param key 缓存的key
* @return 移除操作结果
*/
boolean evict(String key);
}
package com.example.test1.cache.schema;
/**
* @Author xx
* @Date 2024/6/27 16:25
* @Description: 多级缓存
* @Version 1.0
*/
public interface IMultipleCache extends ICacheSchema{
/**
* 移除一级缓存
*
* @param key 缓存的key
* @return 移除状态
*/
boolean evictHeadCache(String key);
}
本地缓存实现类
package com.example.test1.cache.schema.caffeien;
import com.example.test1.cache.schema.ICacheSchema;
import com.github.benmanes.caffeine.cache.Cache;
import java.util.concurrent.TimeUnit;
/**
* @Author xx
* @Date 2024/6/27 15:30
* @Description: Caffeine 本地缓存
* @Version 1.0
*/
public class CaffeineCache implements ICacheSchema {
private final Cache cache;
public CaffeineCache(Cache cache) {
this.cache = cache;
}
@Override
public Object get(String key) {
return cache.getIfPresent(key);
}
@Override
public void put(String key, Object value, long expirationTime, TimeUnit timeUnit) {
cache.put(key,value);
}
@Override
public boolean evict(String key) {
cache.invalidate(key);
return true;
}
}
redis缓存实现类
package com.example.test1.cache.schema.redis;
import com.example.test1.cache.schema.ICacheSchema;
import org.springframework.data.redis.core.RedisTemplate;
import java.util.concurrent.TimeUnit;
/**
* @Author xx
* @Date 2024/6/27 15:51
* @Description: redis分布式缓存
* @Version 1.0
*/
public class RedisCache implements ICacheSchema {
private final RedisTemplate redisTemplate;
public RedisCache(RedisTemplate redisTemplate){
this.redisTemplate = redisTemplate;
}
@Override
public Object get(String key) {
return redisTemplate.opsForValue().get(key);
}
@Override
public void put(String key, Object value, long expirationTime, TimeUnit timeUnit) {
if(expirationTime == -1){
redisTemplate.opsForValue().set(key,value);
}else {
redisTemplate.opsForValue().set(key,value.toString(),expirationTime,timeUnit);
}
}
@Override
public boolean evict(String key) {
return redisTemplate.delete(key);
}
}
多级缓存实现类
package com.example.test1.cache.schema.multiple;
import com.example.test1.cache.config.CacheConfig;
import com.example.test1.cache.schema.ICacheSchema;
import com.example.test1.cache.schema.IMultipleCache;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
import lombok.extern.slf4j.Slf4j;
import java.util.concurrent.TimeUnit;
/**
* @Author xx
* @Date 2024/6/27 16:23
* @Description: 多级缓存实现
* @Version 1.0
*/
@Slf4j
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
public class MultipleCache implements IMultipleCache {
/**
* 一级缓存
*/
private ICacheSchema head;
/**
*下级缓存实现
*/
private MultipleCache next;
private CacheConfig cacheConfig;
public MultipleCache(ICacheSchema head){
this.head = head;
}
@Override
public Object get(String key) {
Object value = head.get(key);
if(value == null && next != null){
value = next.get(key);
if(value != null && cacheConfig != null){
head.put(key,value,cacheConfig.getCaffeineDuration(),TimeUnit.SECONDS);
}
}
return value;
}
@Override
public void put(String key, Object value, long expirationTime, TimeUnit timeUnit) {
head.put(key,value,expirationTime,timeUnit);
if(next != null){
next.put(key,value,expirationTime,timeUnit);
}
}
@Override
public boolean evict(String key) {
head.evict(key);
if(next != null){
next.evict(key);
}
return true;
}
@Override
public boolean evictHeadCache(String key) {
log.debug("移除一级缓存key={}", key);
return head.evict(key);
}
}
配置类：
package com.example.test1.cache.config;
import com.example.test1.cache.schema.ICacheSchema;
import com.example.test1.cache.schema.caffeien.CaffeineCache;
import com.example.test1.cache.schema.multiple.MultipleCache;
import com.example.test1.cache.schema.redis.RedisCache;
import com.github.benmanes.caffeine.cache.Cache;
import com.github.benmanes.caffeine.cache.Caffeine;
import com.github.benmanes.caffeine.cache.RemovalListener;
import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.scheduling.concurrent.CustomizableThreadFactory;
import javax.annotation.Resource;
import java.util.concurrent.ScheduledThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
/**
* @Author xx
* @Date 2024/6/27 16:12
* @Description: 缓存管理实例注册
* @Version 1.0
*/
@Slf4j
@EnableCaching
@Configuration
@ComponentScan("com.example.test1.cache")
@EnableConfigurationProperties(CacheConfig.class)
public class CacheManagerAutoConfiguration {
@Resource
private CacheConfig cacheConfig;
@Resource
private RedisTemplate redisTemplate;
@Bean
public ICacheSchema cacheSchema(){
//构建多级缓存
CaffeineCache caffeineCache = buildCaffeineCache();
RedisCache redisCache = buildRedisCache();
//构建组合多级缓存
return new MultipleCache(caffeineCache)
.setNext(new MultipleCache(redisCache))
.setCacheConfig(cacheConfig);
}
@Bean
public ScheduledThreadPoolExecutor asyScheduledEvictCachePool() {
return new ScheduledThreadPoolExecutor(cacheConfig.getAsyScheduledEvictCachePoolSize(),
new CustomizableThreadFactory("asy-evict-cache-pool-%d"));
}
private RedisCache buildRedisCache() {
return new RedisCache(redisTemplate);
}
/**
* 构建Caffeine缓存
*
* @return Caffeine缓存
*/
private CaffeineCache buildCaffeineCache() {
Cache<String, Object> caffeineCache = Caffeine.newBuilder()
.expireAfterWrite(cacheConfig.getCaffeineDuration(), TimeUnit.SECONDS)
.maximumSize(cacheConfig.getCaffeineMaximumSize())
.removalListener((RemovalListener) (k, v, removalCause) -> log.info("caffeine缓存移除:key={},cause={}", k, removalCause))
.build();
return new CaffeineCache(caffeineCache);
}
}
package com.example.test1.cache.config;
import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
/**
* @Author xx
* @Date 2024/6/27 16:10
* @Description:
* @Version 1.0
*/
@Data
@ConfigurationProperties(prefix = "test-cache", ignoreInvalidFields = true)
public class CacheConfig {
/**
* 缓存模式(默认多级缓存)
*/
// private SchemaEnum schemaEnum = SchemaEnum.MULTIPLE;
/**
* 定时异步清理缓存线程池大小(默认50)
*/
private int asyScheduledEvictCachePoolSize = 50;
/**
* caffeine写入后失效时间（默认 5 * 60 秒）
*/
private long caffeineDuration = 5 * 60;
/**
* caffeine最大容量大小（默认500）
*/
private long caffeineMaximumSize = 5000;
}
具体使用示例：
经测试，请求详情后的10秒内（设置的有效时间是10秒）不论请求几次都仅和数据库连接一次，过期后重复第一次的结果，过期时间可以自定义。
如有不合理的地方还请指教！
