基于SpringAOP+Caffeine实现本地缓存的实例代码
更新时间：2024年03月22日 09:01:36 作者：花自飘0水自流
公司想对一些不经常变动的数据做一些本地缓存,我们使用AOP+Caffeine来实现,所以本文给大家介绍了
基于SpringAOP+Caffeine实现本地缓存的实例,文中有详细的代码供大家参考,需要的朋友可以参考下
基于SpringAOP+Caffeine实现本地缓存的实例,文中有详细的代码供大家参考,需要的朋友可以参考下
一、背景
公司想对一些不经常变动的数据做一些本地缓存，我们使用AOP+Caffeine来实现
二、实现
1、定义注解
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* 本地缓存
*/
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface LocalCacheable {
// 过期时间 默认10分钟
long expired() default 600;
// key创建器
String keyGenerator() default "org.springframework.cache.interceptor.KeyGenerator";
}
2、切面
import com.google.gson.internal.LinkedTreeMap;
import org.apache.commons.lang3.ArrayUtils;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.aop.framework.AopProxyUtils;
import org.springframework.aop.support.AopUtils;
import org.springframework.cglib.proxy.Enhancer;
import org.springframework.stereotype.Component;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* 本地缓存
*/
@Aspect
@Component
public class LocalCacheAspect {
private static final String separator = ":";
@Around("@annotation(com.framework.localcache.LocalCacheable)")
public Object around(ProceedingJoinPoint point) throws Throwable {
if (AopUtils.isAopProxy(point.getTarget())) {
return point.proceed();
}
Method method = getMethodSignature(point).getMethod();
if (method == null) {
return point.proceed();
}
LocalCacheable annotation = method.getAnnotation(LocalCacheable.class);
if (annotation == null) {
return point.proceed();
}
// 生成key
String key = generateKey(point);
// System.out.println("生成的key:" + key);
long expired = annotation.expired();
Throwable[] throwable = new Throwable[1];
Object proceed = LocalCache.cacheData(key, () -> {
try {
return point.proceed();
} catch (Throwable e) {
throwable[0] = e;
}
return null;
}, expired);
if (throwable[0] != null) {
throw throwable[0];
}
return proceed;
}
/**
* 获取方法
*/
private MethodSignature getMethodSignature(ProceedingJoinPoint point) {
Signature signature = point.getSignature();
if (signature instanceof MethodSignature) {
return ((MethodSignature) signature);
}
return null;
}
/**
* 获取key
*/
private String generateKey(ProceedingJoinPoint point) {
// 目标类、方法、参数等
Class<?> targetClass = AopProxyUtils.ultimateTargetClass(point.getTarget());
Method method = getMethodSignature(point).getMethod();
String[] parameterNames = getMethodSignature(point).getParameterNames();
Object[] args = point.getArgs();
// 解析参数，生成key
LinkedTreeMap<String, Object> paramResolveResult = new LinkedTreeMap<>();
if (ArrayUtils.isNotEmpty(args)) {
for (int i = 0; i < args.length; i++) {
resolveParam(args[i], paramResolveResult, parameterNames[i]);
}
}
StringBuilder key = new StringBuilder(targetClass.getName() + separator + method.getName() + separator);
paramResolveResult.forEach((k, v) -> {
if (v != null) {
key.append(k + "," + v + separator);
}
});
// 根据方法名和参数生成唯一标识
return key.toString();
}
private void resolveParam(Object param, Map<String, Object> paramResolveResult, String prefix) {
if (param == null) {
return;
}
Class<?> type = param.getClass();
if (type == List.class) {
List<Object> param0 = (List) param;
for (int i = 0; i < param0.size(); i++) {
resolveParam(param0.get(i), paramResolveResult, prefix + "[" + i + "]");
}
} else if (type == Map.class) {
Map<Object, Object> param0 = (Map) param;
param0.forEach((k, v) -> {
resolveParam(v, paramResolveResult, prefix + "." + k);
});
} else if (type.isArray()) {
Object[] param0 = (Object[]) param;
for (int i = 0; i < param0.length; i++) {
resolveParam(param0[i], paramResolveResult, prefix + "[" + i + "]");
}
} else if (type == Byte.class
|| type == Short.class
|| type == Integer.class
|| type == Long.class
|| type == Float.class
|| type == Double.class
|| type == Boolean.class
|| type == Character.class
|| type == String.class) {
paramResolveResult.put(prefix, param);
} else {
// 复杂类型
Map<String, Object> fieldMap = new HashMap<>();
// CGLIB代理
if (Enhancer.isEnhanced(type)) {
getAllFieldsAndValue(param, type.getSuperclass(), fieldMap);
} else {
getAllFieldsAndValue(param, type, fieldMap);
}
fieldMap.forEach((k, v) -> {
if (v == null) {
return;
}
resolveParam(v, paramResolveResult, prefix + "." + k);
});
}
}
/**
* 获取所有字段和值
*/
private void getAllFieldsAndValue(Object o, Class type, Map<String, Object> fieldMap) {
for (Field field : type.getDeclaredFields()) {
if (field.trySetAccessible()) {
try {
fieldMap.put(field.getName(), field.get(o));
} catch (IllegalAccessException e) {}
}
}
if (type.getSuperclass() != Object.class) {
getAllFieldsAndValue(o, type.getSuperclass(), fieldMap);
}
}
}
3、缓存工具类
import com.github.benmanes.caffeine.cache.Cache;
import com.github.benmanes.caffeine.cache.CacheLoader;
import com.github.benmanes.caffeine.cache.Caffeine;
import org.springframework.stereotype.Component;
import org.springframework.util.Assert;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.TimeUnit;
import java.util.function.Supplier;
/**
* 本地缓存
*/
public class LocalCache {
private static final Map<Long, Cache<Object, Object>> cacheMap = new ConcurrentHashMap<>();
/**
* 创建本地缓存
* @param seconds 过期时间：秒
*/
private static Cache<Object, Object> createCache(long seconds) {
return Caffeine.newBuilder()
.expireAfterWrite(seconds, TimeUnit.SECONDS)
.build();
}
/**
* 创建本地缓存
* @param seconds 过期时间：秒
* @param loader 缓存方法
*/
private Cache<Object, Object> createLoadingCache(long seconds, CacheLoader<Object, Object> loader) {
return Caffeine.newBuilder()
.expireAfterWrite(seconds, TimeUnit.SECONDS)
.build(loader);
}
/**
* 获取一个缓存组
* @param seconds 缓存过期时间
*/
private static Cache<Object, Object> getAndLoad(long seconds) {
if (cacheMap.containsKey(seconds)) {
return cacheMap.get(seconds);
}
Cache<Object, Object> cache = createCache(seconds);
cacheMap.put(seconds, cache);
return cache;
}
/**
* 缓存数据，过期时间默认10分钟
* @param key key
* @param supplier 数据来源的方法
*/
public static Object cacheData(Object key, Supplier<Object> supplier) {
return cacheData(key, supplier, 600);
}
/**
* 缓存数据
* @param key key
* @param supplier 数据来源的方法
* @param seconds 过期时间：秒
*/
public static Object cacheData(Object key, Supplier<Object> supplier, long seconds) {
Assert.state(seconds > 0, "过期时间必须大于0秒");
Cache<Object, Object> cache = getAndLoad(seconds);
return cache.get(key, k -> supplier.get());
}
}
三、测试
@LocalCacheable
@GetMapping("test1")
public String test1() {
System.out.println("执行了");
return "success";
}
@LocalCacheable
@GetMapping("test2")
public String test2(String a) {
System.out.println("执行了" + a);
return "success";
}
@LocalCacheable
@GetMapping("test3")
public String test3(String a, int b, String c) {
System.out.println("执行了" + a + b + c);
return "success";
}
@LocalCacheable
@GetMapping("test4")
public String test4(UserInfo user) {
System.out.println("执行了" + user);
return "success";
}
@LocalCacheable
@GetMapping("test5")
public String test5(UserInfo[] users) {
System.out.println("执行了" + users);
return "success";
}
@LocalCacheable
@GetMapping("test6")
public String test6(List<UserInfo> users) {
System.out.println("执行了" + users);
return "success";
}
@LocalCacheable
@GetMapping("test7")
public String test7(UserInfo user) {
System.out.println("执行了" + user.getMap());
return "success";
}
到此这篇关于基于SpringAOP+Caffeine实现本地缓存的文章就介绍到这了,更多相关SpringAOP affeine本地缓存内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！
相关文章
这篇文章主要介绍了java中断机制实例讲解，用了风趣幽默的讲法，有对这方面不太懂的同学可以研究下2021-01-01
Swagger 是一个规范和完整的框架，用于生成、描述、调用和可视化RESTful风格的 Web 服务。这篇文章主要介绍了spring boot整合Swagger2,需要的朋友可以参考下2017-04-04
深入探究Bean生命周期的扩展点Bean Post Processor
在Spring框架中，Bean生命周期的管理是非常重要的一部分，在Bean的创建、初始化和销毁过程中，Spring提供了一系列的扩展点，其中，Bean Post Processor（后处理器）是一个重要的扩展点，它能够在Bean的初始化前后做一些额外的处理，本文就和大家一起深入探究2023-07-07
IDEA启动Springboot报错：无效的目标发行版：17 的解决办法
这篇文章主要给大家介绍了IDEA启动Springboot报错：无效的目标发行版：17 的解决办法,文中通过代码示例和图文讲解的非常详细,对大家的学习或工作有一定的帮助,需要的朋友可以参考下2024-02-02
下面小编就为大家带来一篇Java基础的几道练习题(分享)。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧，希望可以帮到你2021-08-08
在 Spring Boot 中,拦截器和动态代理都是用来实现功能增强的,所以在很多时候,有人会认为拦截器的底层是通过动态代理实现的,所以本文就来盘点一下他们两的区别,以及拦截器的底层实现吧2023-09-09
java 汉诺塔Hanoi递归、非递归(仿系统递归)和非递归规律 实现代码
汉诺塔（Hanoi） 算法Java实现。通过三个函数，分别对Hanoi进行递归、非递归和非递归规律实现。2013-05-05
这篇文章主要为大家介绍了spring IOC容器Bean管理基于XML的自动装配过程，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步，早日升职加薪2022-05-05
Kotlin 的设计过程中就考虑到了与 Java 的互操作性。在 Kotlin 中可以直接调用既有的 Java 代码, 反过来在 Java 中也可以很流畅地使用 Kotlin 代码，下面这篇文章主要给大家介绍了关于kotlin和Java的相互调用的相关资料，需要的朋友可以参考下。2018-02-02
本文详细介绍了如何在Spring Boot项目中实现Jar包加密,我们首先了解了Jar包加密的基本概念和作用,然后学习了如何使用Spring Boot的Jar工具和第三方库来实现Jar包的加密和解密,感兴趣的朋友一起看看吧2024-02-02
最新评论