脚本之家 服务器常用软件
快捷导航
您的位置：首页 → 软件编程 → java → SpringAOP affeine本地缓存

基于SpringAOP+Caffeine实现本地缓存的实例代码

 更新时间：2024年03月22日 09:01:36   作者：花自飘0水自流  
公司想对一些不经常变动的数据做一些本地缓存,我们使用AOP+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本地缓存内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:

相关文章

  • SpringBoot3.x中自定义开发通用SDK的实现

    SpringBoot3.x中自定义开发通用SDK的实现

    本文介绍了SpringBoot和Maven创建自定义的SDK,包括创建项目、修改配置、编写配置类、设置配置文件、构建Jar包等,具有一定的参考价值,感兴趣的可以了解一下
    2024-12-12
  • Mybatis批处理、Mysql深分页操作

    Mybatis批处理、Mysql深分页操作

    这篇文章主要介绍了Mybatis批处理、Mysql深分页操作,Mybatis批量操作包括Foreach方式和ExecutorType.BATCH插入操作,本文给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下
    2023-08-08
  • spring boot拦截器注入不了java bean的原因

    spring boot拦截器注入不了java bean的原因

    这篇文章主要介绍了spring boot拦截器注入不了java bean的原因，帮助大家更好的理解和学习spring boot框架，感兴趣的朋友可以了解下
    2020-11-11
  • Java中Lambda表达式使用详细解读

    Java中Lambda表达式使用详细解读

    这篇文章主要介绍了Java中Lambda表达式使用及详解,lambda运行将函数作为一个方法的参数，也就是函数作为参数传递到方法中，使用lambda表达式可以让代码更加简洁，需要的朋友可以参考下
    2023-04-04
  • IntelliJ IDEA 2020最新激活码(亲测有效，可激活至 2089 年)

    IntelliJ IDEA 2020最新激活码(亲测有效，可激活至 2089 年

    这篇文章主要介绍了IntelliJ IDEA 2021最新激活码(亲测有效，可激活至 2089 年),非常不错，对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下
    2020-04-04
  • SpringBoot对接Spark过程详解

    SpringBoot对接Spark过程详解

    这篇文章主要介绍SpringBoot接入Spark的方法的相关知识，小编通过实际案例向大家展示操作过程，操作方法简单快捷，实用性强，希望能帮助大家解决问题
    2023-02-02
  • SpringBoot开发技巧启动时配置校验实现示例

    SpringBoot开发技巧启动时配置校验实现示例

    这篇文章主要为大家介绍了SpringBoot开发在启动时自动配置校验的实现示例及原理解析，有需要的朋友可以借鉴参考下希望能够有所帮助
    2021-10-10
  • Spring Boot 使用 logback、logstash、ELK 记录日志文件的方法

    Spring Boot 使用 logback、logstash、ELK 记录日志文件的方法

    这篇文章主要介绍了Spring Boot 使用 logback、logstash、ELK 记录日志文件的思路详解，文中给大家提到了logback 取代 log4j的理由,需要的朋友可以参考下
    2017-12-12
  • SpringBoot中基于JWT的单token授权和续期方案步骤详解

    SpringBoot中基于JWT的单token授权和续期方案步骤详解

    在前后端分离架构中,用户登录后,后端生成JWT Token返给前端存于LocalStorage,每次请求携带Token验证身份,后端校验其有效性,本文给大家介绍SpringBoot中基于JWT的单token授权和续期方案步骤详解,感兴趣的朋友一起看看吧
    2024-09-09
  • java servlet手机app访问接口(三)高德地图云存储及检索

    java servlet手机app访问接口(三)高德地图云存储及检索

    这篇文章主要为大家详细介绍了java servlet手机app访问接口(三)，高德地图云存储及检索，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
    2016-12-12

最新评论