Springboot简单设计两级缓存

news2024/10/7 14:31:22

两级缓存相比单纯使用远程缓存，具有什么优势呢？
本地缓存基于本地环境的内存，访问速度非常快，对于一些变更频率低、实时性要求低的数据，可以放在本地缓存中，提升访问速度
使用本地缓存能够减少和Redis类的远程缓存间的数据交互，减少网络I/O开销，降低这一过程中在网络通信上的耗时
但是在设计中，还是要考虑一些问题的，例如数据一致性问题。首先，两级缓存与数据库的数据要保持一致，一旦数据发生了修改，在修改数据库的同时，本地缓存、远程缓存应该同步更新。
如果是分布式环境下，一级缓存之间也会存在一致性问题，当一个节点下的本地缓存修改后，需要通知其他节点也刷新本地缓存中的数据，否则会出现读取到过期数据的情况，这一问题可以通过类似于Redis中的发布/订阅功能解决。
此外，缓存的过期时间、过期策略以及多线程访问的问题也都需要考虑进去，不过我们今天暂时先不考虑这些问题，简单的在代码中实现两级缓存的管理。

图片中一级缓存找的图是Ehcache，但实际项目中我使用的是caffeine做一级缓存，redis做二级缓存原理都是一样，先引入相关依赖

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-redis</artifactId>
		</dependency>
		<dependency>
			<groupId>com.github.ben-manes.caffeine</groupId>
			<artifactId>caffeine</artifactId>
			<version>2.9.2</version>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-cache</artifactId>
		</dependency>
		<dependency>
			<groupId>org.apache.commons</groupId>
			<artifactId>commons-pool2</artifactId>
			<version>2.8.1</version>
		</dependency>

在yml中配置redis的相关信息

  redis:
    host: localhost
    port: 6379
    password:
    timeout: 5000
#    lettuce:
#      pool:
#        max-active: 8
#        max-wait: -1ms
#        max-idle: 8
#        min-idle: 0

注释的lettuce都是默认值，实际要调整放开注释自行调整即可

枚举类型枚举

public enum CacheType {

    /**
     * 存取
     */
    FULL,

    /**
     * 只存
     */
    PUT,

    /**
     * 删除
     */
    DEL
}

定义一个注解，用于添加在需要操作缓存的方法上，使用cacheName + key作为缓存的真正key，timeOut为可以设置的二级缓存Redis的过期时间，type是一个枚举类型的变量，表示操作缓存的类型

import com.yx.light.element.jpa.enums.CacheType;

import java.lang.annotation.*;

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface L2Cache {

    /**
     * 缓存名字
     * @return
     */
    String cacheName();

    /**
     * 缓存key
     * @return
     */
    String key() default ""; //支持springEl表达式

    /**
     * redis缓存超时时间
     * @return
     */
    long timeOut() default 120;

    /**
     * 缓存类型
     * @return
     */
    CacheType type() default CacheType.FULL;
}

RedisTemplate配置类

import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

@Configuration
@EnableCaching
public class RedisConfig extends CachingConfigurerSupport {

    /**
     * 配置自定义redisTemplate
     *
     * @return
     */
    @Bean
    RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        //设置值（value）的序列化采用Jackson2JsonRedisSerializer。
        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
        //设置键（key）的序列化采用StringRedisSerializer。
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }
}

Caffeine配置类

import com.github.benmanes.caffeine.cache.Cache;
import com.github.benmanes.caffeine.cache.Caffeine;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.concurrent.TimeUnit;

@Configuration
public class CaffeineConfig {

    @Bean
    public Cache<String, Object> caffeineCache() {
        return Caffeine.newBuilder()
                .initialCapacity(128)//初始大小
                .maximumSize(1024)//最大数量
                .expireAfterWrite(60, TimeUnit.SECONDS)//过期时间
                .build();
    }
}

El转换辅助工具类

import org.springframework.expression.EvaluationContext;
import org.springframework.expression.Expression;
import org.springframework.expression.ExpressionParser;
import org.springframework.expression.common.TemplateParserContext;
import org.springframework.expression.spel.standard.SpelExpressionParser;
import org.springframework.expression.spel.support.StandardEvaluationContext;

import java.util.TreeMap;

public class ElParserUtil {

    private ElParserUtil() {
    }

    public static String parse(String elString, TreeMap<String, Object> map) {
        elString = String.format("#{%s}", elString);
        //创建表达式解析器
        ExpressionParser parser = new SpelExpressionParser();
        //通过evaluationContext.setVariable可以在上下文中设定变量。
        EvaluationContext context = new StandardEvaluationContext();
        map.entrySet().forEach(entry ->
                context.setVariable(entry.getKey(), entry.getValue())
        );

        //解析表达式
        Expression expression = parser.parseExpression(elString, new TemplateParserContext());
        //使用Expression.getValue()获取表达式的值，这里传入了Evaluation上下文
        String value = expression.getValue(context, String.class);
        return value;
    }
}

两级缓存切面，在切面中操作Cache来读写Caffeine的缓存，操作RedisTemplate读写Redis缓存。

import com.github.benmanes.caffeine.cache.Cache;
import com.yx.light.element.jpa.annotations.L2Cache;
import com.yx.light.element.jpa.enums.CacheType;
import com.yx.light.element.jpa.utils.ElParserUtil;
import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;

import java.lang.reflect.Method;
import java.util.Objects;
import java.util.TreeMap;
import java.util.concurrent.TimeUnit;

@Slf4j
@Component
@Aspect
@AllArgsConstructor
public class L2CacheAspect {

    private final Cache cache;
    private final RedisTemplate redisTemplate;

    @Pointcut("@annotation(com.yx.light.element.jpa.annotations.L2Cache)")
    public void cacheAspect() {
    }

    @Around("cacheAspect()")
    public Object doAround(ProceedingJoinPoint point) throws Throwable {
        MethodSignature signature = (MethodSignature) point.getSignature();
        Method method = signature.getMethod();

        //拼接解析springEl表达式的map
        String[] paramNames = signature.getParameterNames();
        Object[] args = point.getArgs();
        TreeMap<String, Object> treeMap = new TreeMap<>();
        for (int i = 0; i < paramNames.length; i++) {
            treeMap.put(paramNames[i], args[i]);
        }

        L2Cache annotation = method.getAnnotation(L2Cache.class);
        String elResult = null;
        if (treeMap.size() == 0) {
            elResult = StringUtils.isEmpty(annotation.key()) ? method.getName() : annotation.key();
        } else {
            elResult = ElParserUtil.parse(annotation.key(), treeMap);
        }
        String realKey = annotation.cacheName() + ":" + elResult;

        //强制更新
        if (annotation.type() == CacheType.PUT) {
            Object object = point.proceed();
            if (Objects.isNull(object)) {
                log.info("方法执行完毕无返回值，无需更新缓存");
                return object;
            }
            redisTemplate.opsForValue().set(realKey, object, annotation.timeOut(), TimeUnit.SECONDS);
            cache.put(realKey, object);
            return object;
        } else if (annotation.type() == CacheType.DEL) {
            redisTemplate.delete(realKey);
            cache.invalidate(realKey);
            return point.proceed();
        }

        //读写，查询Caffeine
        Object caffeineCache = cache.getIfPresent(realKey);
        if (Objects.nonNull(caffeineCache)) {
            log.info("从caffeine中获取数据");
            return caffeineCache;
        }

        //查询Redis
        Object redisCache = redisTemplate.opsForValue().get(realKey);
        if (Objects.nonNull(redisCache)) {
            log.info("从redis中获取数据");
            cache.put(realKey, redisCache);
            return redisCache;
        }

        log.info("从数据库中获取数据");
        Object object = point.proceed();
        if (Objects.nonNull(object)) {
            //写入Redis
            redisTemplate.opsForValue().set(realKey, object, annotation.timeOut(), TimeUnit.SECONDS);
            //写入Caffeine
            cache.put(realKey, object);
        }
        return object;
    }
}

改造service实现类的几个方法简单测试一下

    @Override
    @L2Cache(cacheName = "GroupHeader", type = CacheType.FULL)
    public List<GroupHeader> findAllGroupHeader() {
        return groupHeaderRepository.findAll();
    }
	
    @Override
    @L2Cache(cacheName = "GroupHeader", key = "#groupHeader.groupCode", type = CacheType.PUT)
    public void editGroupHeader(GroupHeader groupHeader) {
        groupHeaderRepository.save(groupHeader);
    }

    @Override
    @L2Cache(cacheName = "GroupHeader", key = "#ids", type = CacheType.DEL)
    public void deleteGroupHeader(String ids) {
        String[] split = ids.split(",");
        for (String id : split) {
            groupHeaderRepository.deleteById(Long.parseLong(id));
        }
    }

连续调用两次查询接口看日志打印效果和redis客户端的查询

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1437931.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

JWT令牌 | 一个区别于cookie/session的更安全的校验技术

JWT令牌 | 一个区别于cookie/session的更安全的校验技术

目录 1、简介 2、组成成分 3、应用场景 4、生成和校验 5、登录下发令牌 &#x1f343;作者介绍&#xff1a;双非本科大三网络工程专业在读&#xff0c;阿里云专家博主&#xff0c;专注于Java领域学习&#xff0c;擅长web应用开发、数据结构和算法&#xff0c;初步涉猎Pyth…
阅读更多...
波纹扩散效果

波纹扩散效果

<!DOCTYPE html> <html lang"en"><head><meta charset"UTF-8" /><meta name"viewport" content"widthdevice-width, initial-scale1.0" /><title>波纹扩散</title><style>body {disp…
阅读更多...
在 vite + ts 中，使用require

在 vite + ts 中，使用require

因为 require 属于 Webpack 的方法&#xff0c;所以 Vite 项目中是不能使用require的&#xff0c;所以控制台会给你报错&#xff0c;如下 解决办法如下&#xff1a;就是很不情愿的办法&#xff0c;没招啊 第一步、安装插件 npm i vite-plugin-require-transform --save-de…
阅读更多...
【蓝桥杯冲冲冲】[NOIP2017 提高组] 宝藏

【蓝桥杯冲冲冲】[NOIP2017 提高组] 宝藏

蓝桥杯备赛 | 洛谷做题打卡day29 文章目录 蓝桥杯备赛 | 洛谷做题打卡day29[NOIP2017 提高组] 宝藏题目背景题目描述输入格式输出格式样例 #1样例输入 #1样例输出 #1样例 #2样例输入 #2样例输出 #2提示题解代码我的一些话[NOIP2017 提高组] 宝藏 题目背景 NOIP2017 D2T2 题目描…
阅读更多...
服务器安装Docker （centOS）

服务器安装Docker （centOS）

1. 卸载旧版本的Docker&#xff08;如果有&#xff09; 首先&#xff0c;如果您的系统上安装了旧版本的Docker&#xff0c;需要将其卸载。Docker的旧版本称为docker或docker-engine。使用以下命令来卸载旧版本&#xff1a; sudo yum remove docker \ docker-client \ docker-…
阅读更多...
vCenterServer部署

vCenterServer部署

一、硬件配置 vCenterServer本身最低的硬件要求是14GB&#xff0c;而vCenterServer则是以虚拟机的形式安装在ESXi中的虚拟机&#xff0c;所以ESXi的最低硬件要求是15.5GB&#xff0c;就是15872MB 二、安装vCenterServer 直接解压VMware-VCSA-all-8.0.0-20920323.iso&#xf…
阅读更多...
使用No-SQL数据库支持连接查询用例的讨论

使用No-SQL数据库支持连接查询用例的讨论

简介 在本文中&#xff0c;我们将简单介绍什么是No-SQL数据库。然后我们会讨论一种使用关系数据库比较容易实现的查询&#xff0c;即连接查询&#xff0c;怎么样使用No-SQL来实现。 什么是No-SQL数据库 与No-SQL数据库相对应的是传统的关系数据库&#xff08;RDBMS&#xff…
阅读更多...
Leetcode刷题-(11~15)-Java+Python+JavaScript

Leetcode刷题-(11~15)-Java+Python+JavaScript

算法是程序员的基本功&#xff0c;也是各个大厂必考察的重点&#xff0c;让我们一起坚持写算法题吧 遇事不决&#xff0c;可问春风&#xff0c;春风不语&#xff0c;即是本心。 我们在我们能力范围内&#xff0c;做好我们该做的事&#xff0c;然后相信一切都事最好的安排就可…
阅读更多...
关于可变类型和不可变类型的探究

关于可变类型和不可变类型的探究

个人猜想&#xff08;很遗憾失败了&#xff09; 在硬盘或者系统中存在一个字符集 如果存在硬盘中&#xff0c;那么硬盘出厂的时候他的字符集所占用的空间就已经确定了。 如果存在于系统的话&#xff0c;硬盘应该在出厂的时候为系统设置一个存储系统字符集的地方。在安装系统…
阅读更多...
【Scala】1. 变量和数据类型

【Scala】1. 变量和数据类型

1. 变量和数据类型 1.1 for begining —— hello world 新建hello.scala文件&#xff0c;注意object名字与文件名一致。 object hello { def main(args:Array[String]): Unit { println("hello world!") } }运行后打印结果如下&#xff1a; hello world!Pr…
阅读更多...
go 版本 LeeCode 刷题 在线

go 版本 LeeCode 刷题 在线

https://books.halfrost.com/leetcode/ChapterFour/0001~0099/0001.Two-Sum/ 参考 https://github.com/anzhihe/learning/tree/master/shell/book/abs-3.9.1_cn
阅读更多...
Java Character源码剖析

Java Character源码剖析

Character类除了封装了一个char外&#xff0c;还封装了Unicode字符级别的各种操作&#xff0c;是Java文本处理的基础。下面结合源码分析Character的贡献。 Unicode 也许你没听过Unicode&#xff0c;但应该见过UTF-8。UTF-8&#xff08;8-bit Unicode Transformation Format&a…
阅读更多...
LeetCode:14.最长公共前缀

LeetCode:14.最长公共前缀

14. 最长公共前缀 - 力扣&#xff08;LeetCode&#xff09; 目录 题目&#xff1a; 思路&#xff1a; 代码有限注释&#xff1a; 每日表情包&#xff1a; 题目&#xff1a; 思路&#xff1a; 仅有一种&#xff0c;LeetCode的四种解法&#xff0c;三种都是来水的&#…
阅读更多...
SpringBoot3整合Mybatis-Plus，自定义动态数据源starter

SpringBoot3整合Mybatis-Plus，自定义动态数据源starter

文章目录 前言正文一、项目总览二、核心代码展示2.1 自定义AbstractRoutingDataSource2.2 动态数据源DynamicDataSource2.3 动态数据源自动配置2.4 动态数据源上下文DynamicDataSourceContextHolder2.5 动态数据源修改注解定义2.6 修改切面DynamicDataSourceAspect2.7 动态数据…
阅读更多...
c++设计模式之代理模式

c++设计模式之代理模式

作用 代理模式主要用于&#xff0c;通过代理类&#xff0c;来控制实际对象的访问权限 案例 class VideoSite { public:virtual void freeVideo()0;virtual void vipVideo()0;virtual void trickVideo()0; };class FixBugVideoSite:public VideoSite { public:void freeVideo()…
阅读更多...
AWS创建快照定期备份

AWS创建快照定期备份

备注&#xff1a;aws有快照定期备份工具&#xff0c;名字叫【生命周期管理器】 选择实例点击创建 点击下一步后设置备份频率等 然后点击创建即可
阅读更多...
Vue源码系列讲解——虚拟DOM篇【一】(Vue中的虚拟DOM)

Vue源码系列讲解——虚拟DOM篇【一】(Vue中的虚拟DOM)

目录 1. 前言 2. 虚拟DOM简介 2.1什么是虚拟DOM&#xff1f; 2.2为什么要有虚拟DOM&#xff1f; 3. Vue中的虚拟DOM 3.1 VNode类 3.2 VNode的类型 3.2.1 注释节点 3.2.2 文本节点 3.2.3 克隆节点 3.2.4 元素节点 3.2.5 组件节点 3.2.6 函数式组件节点 3.2.7 小结 3…
阅读更多...
NCNN GPU初始化加速——cache实现

NCNN GPU初始化加速——cache实现

概要 NCNN的CPU初始化速度很快&#xff0c;但是当使用GPU进行推理时&#xff0c;初始化往往要花费几秒甚至更长时间。其他框架例如MNN有载入cache的方式来进行加速&#xff0c;NCNN目前没有相关接口来实现加速&#xff0c;那么NCNN是否也可以加载cache来实现加速呢&#xff1f;…
阅读更多...
程序员的数字化工作台：理解不关机背后的逻辑与需求

程序员的数字化工作台：理解不关机背后的逻辑与需求

目录 程序员为什么不喜欢关电脑&#xff1f; 电脑对程序员的重要性&#xff1a; 工作流程与需求&#xff1a; 数据安全与备份&#xff1a; 即时性与响应&#xff1a; 个人习惯等方面&#xff1a; 程序员为什么不喜欢关电脑&#xff1f; 电脑对程序员的重要性&#xff1a;…
阅读更多...
龙测科技荣获2023年度技术生态构建奖

龙测科技荣获2023年度技术生态构建奖

本月&#xff0c;由极客传媒举办的“有被Q到”2024 InfoQ 极客传媒合作伙伴年会顺利举办&#xff0c;龙测科技喜获2023年度技术生态构建奖。 InfoQ是首批将Node.js、HTML5、Docker等技术全面引入中国的技术媒体之一&#xff0c;秉承“扎根社区、服务社区、引领社区”的理念&…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023