Caffenie配合Redis做两级缓存

news2024/9/20 9:29:29

一、什么是两级缓存

在项目中。一级缓存用Caffeine，二级缓存用Redis，查询数据时首先查本地的Caffeine缓存，没有命中再通过网络去访问Redis缓存，还是没有命中再查数据库。具体流程如下
在这里插入图片描述

二、简单的二级缓存实现-v1

目录结构
在这里插入图片描述

2.1 double-cache模块主要文件

在这里插入图片描述

pom文件

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.example</groupId>
    <artifactId>double-cache</artifactId>
    <version>1.0-SNAPSHOT</version>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.2</version>
        <relativePath/>
    </parent>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</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-data-redis</artifactId>
        </dependency>
    </dependencies>

</project>

2.2 测试模块的主要文件

在这里插入图片描述

OrderServiceImpl

@Slf4j
@Service
@RequiredArgsConstructor
public class OrderServiceImpl extends ServiceImpl<OrderMapper, Order> implements OrderService {
    private final OrderMapper orderMapper;
    private final Cache cache;
    private final RedisTemplate redisTemplate;
    @Override
    public Order getOrderById(Long id) {
        String key = CacheConstant.ORDER + id;
        Order order = (Order) cache.get(key,
                k -> {
                    //先查询 Redis
                    Object obj = redisTemplate.opsForValue().get(k);
                    if (Objects.nonNull(obj)) {
                        log.info("get data from redis");
                        return obj;
                    }
                    // Redis没有则查询 DB
                    log.info("get data from database");
                    Order myOrder = orderMapper.selectOne(new LambdaQueryWrapper<Order>()
                            .eq(Order::getId, id));
                    redisTemplate.opsForValue().set(k, myOrder, 120, TimeUnit.SECONDS);
                    return myOrder;
                });
        return order;
    }
    @Override
    public void updateOrder(Order order) {
        log.info("update order data");
        String key = CacheConstant.ORDER + order.getId();
        orderMapper.updateById(order);
        //修改 Redis
        redisTemplate.opsForValue().set(key, order, 120, TimeUnit.SECONDS);
        // 修改本地缓存
        cache.put(key, order);
    }
    @Override
    public void deleteOrder(Long id) {
        log.info("delete order");
        orderMapper.deleteById(id);
        String key = CacheConstant.ORDER + id;
        redisTemplate.delete(key);
        cache.invalidate(key);
    }
}

application.yml

server:
  port: 8090

spring:
  application:
    name: test-demo
  datasource:
    url: jdbc:mysql://localhost:3306/ktl?useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC
    username: root
    password: root
    driver-class-name: com.mysql.cj.jdbc.Driver
  redis:
    host: 192.168.200.131
    port: 6379
    database: 0
    timeout: 10000ms
    lettuce:
      pool:
        max-active: 8
        max-wait: -1ms
        max-idle: 8
        min-idle: 0
    password: root

logging:
  level:
    com.cn.dc: debug
    org.springframework: warn

pom文件

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.example</groupId>
    <artifactId>testcache</artifactId>
    <version>1.0-SNAPSHOT</version>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.2</version>
        <relativePath/>
    </parent>
    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <mybatis-plus.version>3.3.2</mybatis-plus.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.example</groupId>
            <artifactId>double-cache</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
            <version>2.8.1</version>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>${mybatis-plus.version}</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.12</version>
            <scope>provided</scope>
        </dependency>
    </dependencies>
</project>

2.3 测试

测试get/{id}接口的时候，会把从db查出来的数据放入到redis和Caffeine中，在有效期内不需要再次从数据库查询

三、二级缓存实现-v2

v1的代码入侵性很强，因此加入了注解@Cacheable，@CachePut，@CacheEvict

3.1 double-cache模块

在这里插入图片描述

3.2 测试模块

OrderServiceImpl

@Slf4j
@Service
@RequiredArgsConstructor
public class OrderServiceImpl extends ServiceImpl<OrderMapper, Order> implements OrderService {
    private final OrderMapper orderMapper;
    private final RedisTemplate redisTemplate;

    @Override
    @Cacheable(value = "order",key = "#id")
//@Cacheable(cacheNames = "order",key = "#p0")
    public Order getOrderById(Long id) {
        String key= CacheConstant.ORDER + id;
        //先查询 Redis
        Object obj = redisTemplate.opsForValue().get(key);
        if (Objects.nonNull(obj)){
            log.info("get data from redis");
            return (Order) obj;
        }
        // Redis没有则查询 DB
        log.info("get data from database");
        Order myOrder = orderMapper.selectOne(new LambdaQueryWrapper<Order>()
                .eq(Order::getId, id));
        redisTemplate.opsForValue().set(key,myOrder,120, TimeUnit.SECONDS);
        return myOrder;
    }


    @Override
    @CachePut(cacheNames = "order",key = "#order.id")
    public Order updateOrder(Order order) {
        log.info("update order data");
        orderMapper.updateById(order);
        //修改 Redis
        redisTemplate.opsForValue().set(CacheConstant.ORDER + order.getId(),
                order, 120, TimeUnit.SECONDS);
        return order;
    }

    @Override
    @CacheEvict(cacheNames = "order",key = "#id")
    public void deleteOrder(Long id) {
        log.info("delete order");
        orderMapper.deleteById(id);
        redisTemplate.delete(CacheConstant.ORDER + id);
    }
}

四、二级缓存实现-v3

模仿spring通过注解管理缓存的方式，我们也可以选择自定义注解，然后在切面中处理缓存，从而将对业务代码的入侵降到最低。

首先定义一个注解，用于添加在需要操作缓存的方法上：

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface DoubleCache {
    String cacheName();
    String key();	//支持springEl表达式
    long l2TimeOut() default 120;
    CacheType type() default CacheType.FULL;
}

我们使用cacheName + key作为缓存的真正key（仅存在一个Cache中，不做CacheName隔离），l2TimeOut为可以设置的二级缓存Redis的过期时间，type是一个枚举类型的变量，表示操作缓存的类型，枚举类型定义如下：

public enum CacheType {
    FULL,   //存取
    PUT,    //只存
    DELETE  //删除
}

因为要使key支持springEl表达式，所以需要写一个方法，使用表达式解析器解析参数：

public class ElParser {
    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相关参数的配置，我们沿用V1版本中的配置即可。准备工作做完了，下面我们定义切面，在切面中操作Cache来读写Caffeine的缓存，操作RedisTemplate读写Redis缓存。

@Slf4j
@Component
@Aspect
@AllArgsConstructor
public class CacheAspect {
    private final Cache cache;
    private final RedisTemplate redisTemplate;
    private final String COLON = ":";

    @Pointcut("@annotation(org.example.doublecache.annotation.DoubleCache)")
    public void cacheAspect() {
    }

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

//        if (!method.isAnnotationPresent(DoubleCache.class))
//            return null;

        //拼接解析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]);
        }

        DoubleCache annotation = method.getAnnotation(DoubleCache.class);
        String elResult = ElParser.parse(annotation.key(), treeMap);
        String realKey = annotation.cacheName() + COLON + elResult;

        //强制更新
        if (annotation.type()== CacheType.PUT){
            Object object = point.proceed();
            redisTemplate.opsForValue().set(realKey, object,annotation.l2TimeOut(), TimeUnit.SECONDS);
            cache.put(realKey, object);
            return object;
        }
        //删除
        else if (annotation.type()== CacheType.DELETE){
            redisTemplate.delete(realKey);
            cache.invalidate(realKey);
            return point.proceed();
        }

        //读写，查询Caffeine
        Object caffeineCache = cache.getIfPresent(realKey);
        if (Objects.nonNull(caffeineCache)) {
            log.info("get data from caffeine");
            return caffeineCache;
        }

        //查询Redis
        Object redisCache = redisTemplate.opsForValue().get(realKey);
        if (Objects.nonNull(redisCache)) {
            log.info("get data from redis");
            cache.put(realKey, redisCache);
            return redisCache;
        }

        log.info("get data from database");
        Object object = point.proceed();
        if (Objects.nonNull(object)){
            //写回Redis
            redisTemplate.opsForValue().set(realKey, object,annotation.l2TimeOut(), TimeUnit.SECONDS);
            //写入Caffeine
            cache.put(realKey, object);
        }
        return object;
    }
}

4.1 double-cache模块

在这里插入图片描述

4.2 测试模块

在这里插入图片描述

OrderServiceImpl修改如下

@Slf4j
@Service
@RequiredArgsConstructor
public class OrderServiceImpl extends ServiceImpl<OrderMapper, Order> implements OrderService {
    private final OrderMapper orderMapper;
    @Override
    @DoubleCache(cacheName = "order", key = "#id",
            type = CacheType.FULL)
    public Order getOrderById(Long id) {
        Order myOrder = orderMapper.selectOne(new LambdaQueryWrapper<Order>()
                .eq(Order::getId, id));
        return myOrder;
    }

    @Override
    @DoubleCache(cacheName = "order",key = "#order.id",
            type = CacheType.PUT)
    public Order updateOrder(Order order) {
        orderMapper.updateById(order);
        return order;
    }

    @Override
    @DoubleCache(cacheName = "order",key = "#id",
            type = CacheType.DELETE)
    public void deleteOrder(Long id) {
        orderMapper.deleteById(id);
    }

    @Override
    @DoubleCache(cacheName = "order",key = "#id")
    public Order getOrderByIdAndStatus(Long id,Integer status) {
        Order myOrder = orderMapper.selectOne(new LambdaQueryWrapper<Order>()
                .eq(Order::getId, id)
                .eq(Order::getStatus,status));
        return myOrder;
    }

在TestApplication上加@EnableCaching

4.3 测试

从数据库10ms+，生产中会走网络通信会更长。
从Caffeine平均4ms

在这里插入图片描述

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

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

相关文章

MySQL——主从复制、读写分离

MySQL——主从复制、读写分离

目录 前言 一、MySQL主从复制的概述 1、MySQL主从复制的概念 2、Mysql主从复制功能和使用场景 2.1、Mysql主从复制功能 2.2、Mysql主从复制使用场景 3、MySQL支持的复制类型 3.1、基于语句的复制 3.2、基于行的复制 3.3、混合复制 4、主从复制的工作过程 5、MySQL三…
阅读更多...
iOS 15推出后利用邮件打开率的7种方法

iOS 15推出后利用邮件打开率的7种方法

自从苹果在2021年底推出iOS 15以来&#xff0c;邮件打开率就一直是一个让人头疼的指标。 Klaviyo市场情报主管Mindy Regnell表示&#xff1a;“对于启用了Apple邮件隐私保护&#xff08;MPP&#xff09;的用户来说&#xff0c;苹果会打开这些邮件并预先下载内容到他们的服务器…
阅读更多...
2024年“华为杯”第二十一届中国研究生数学建模竞赛（附2004-2023年优秀论文合集）

2024年“华为杯”第二十一届中国研究生数学建模竞赛（附2004-2023年优秀论文合集）

中国研究生数学建模竞赛&#xff08;以下简称“竞赛”&#xff09;是教育部学位管理与研究生教育司指导&#xff0c;中国学位与研究生教育学会、中国科协青少年科技中心主办的“中国研究生创新实践系列大赛”主题赛事之一。本届比赛报名时间为&#xff1a;2024年6月1日&#xf…
阅读更多...
数据结构——线性表（静态链表、循环链表以及双向链表）

数据结构——线性表（静态链表、循环链表以及双向链表）

1、静态链表 用数组描述的链表叫做静态链表&#xff0c;这种描述方法叫做游标实现法。 静态链表需要对数组的第一个和最后一个元素作为特殊元素处理&#xff0c;不存数据。 最后一个指向第一个有数据的下标地址&#xff0c;第一个游标指向第一个没有数据的下标地址。 我们对…
阅读更多...
[译] 大模型推理的极限：理论分析、数学建模与 CPU/GPU 实测（2024）

[译] 大模型推理的极限：理论分析、数学建模与 CPU/GPU 实测（2024）

译者序 本文翻译自 2024 年的一篇文章&#xff1a; LLM inference speed of light&#xff0c; 分析了大模型推理的速度瓶颈及量化评估方式&#xff0c;并给出了一些实测数据&#xff08;我们在国产模型上的实测结果也大体吻合&#xff09;&#xff0c; 对理解大模型推理内部工…
阅读更多...
职场答案薄

职场答案薄

公司做大的过程就是创始人把职责一层层分摊下去的过程&#xff0c;公司里的各级领导在招聘时的原始诉求都是一样的&#xff0c;就是招到可以帮自己分担一部分工作的人&#xff0c;然后自己好集中精力去做更重要的工作 如何去做运营 1.流程制度&#xff08;三个目的&#xff1a;…
阅读更多...
AI边缘计算在安防领域的智能化革新：赋能安防系统的智能化升级

AI边缘计算在安防领域的智能化革新：赋能安防系统的智能化升级

随着人工智能&#xff08;AI&#xff09;和边缘计算技术的快速发展&#xff0c;两者在安防视频领域的应用日益广泛&#xff0c;为传统安防系统带来了革命性的变革。AI边缘计算技术通过将AI算法和模型部署在边缘设备上&#xff0c;实现了数据处理和智能决策的即时响应&#xff0…
阅读更多...
FuTalk设计周刊-Vol.073

FuTalk设计周刊-Vol.073

#AI漫谈 热点捕手 1.Midjourney 样式分享网站 群里设计师创建的 Midjourney 风格网站&#xff0c;用来收集高质量 Sref Codes&#xff0c;展示示例图并且展示风格关键词&#xff0c;使用场景&#xff0c;以及示例提示词&#xff0c;作者称会持续更新 链接https://aiartsecre…
阅读更多...
【Java】String StringBuffer与StringBuilder（实操+面试+记忆方法）

【Java】String StringBuffer与StringBuilder（实操+面试+记忆方法）

Java系列文章目录 补充内容 Windows通过SSH连接Linux 第一章 Linux基本命令的学习与Linux历史 文章目录 Java系列文章目录一、前言二、学习内容&#xff1a;三、问题描述四、解决方案&#xff1a;4.1 代码学习与性能测试4.1.1 代码4.1.2 性能测试结果 4.2 区别 五、总结&#…
阅读更多...
uniapp升级Vue3：避坑指南与步骤详解

uniapp升级Vue3：避坑指南与步骤详解

为什么要升级到 Vue3 Vue3 是 Vue.js 的最新版本&#xff0c;相比 Vue2&#xff0c;它带来了许多改进和新特性&#xff0c;比如更小的包体积、更好的性能、更强大的组合式 API 等。通过升级到 Vue3&#xff0c;我们可以享受到这些新特性带来的好处&#xff0c;提升项目的开发效…
阅读更多...
全国-住宅区AOI数据

全国-住宅区AOI数据

数据量级&#xff1a;54万&#xff0c;更新时间&#xff1a;2024年3月 覆盖字段&#xff1a; 名称&#xff0c;地址&#xff0c;经纬度&#xff0c;一级分类&#xff0c;二级分类&#xff0c;三级分类&#xff0c;默认图片&#xff0c;AOI围栏 数据来源于&#xff1a;魔行观察…
阅读更多...
从知识孤岛到知识共享：内部知识库如何促进团队协作

从知识孤岛到知识共享：内部知识库如何促进团队协作

在当今快速变化的商业环境中&#xff0c;企业内部的知识管理和协作能力成为决定其竞争力的关键因素之一。然而&#xff0c;许多企业面临着“知识孤岛”的困境&#xff0c;即各部门和团队之间信息交流不畅&#xff0c;知识和经验难以有效传递和共享&#xff0c;导致资源浪费、决…
阅读更多...
Sanster/IOPaint：AIGC大模型GFPGAN人像修复/美颜：修复历史人物老照片（3）

Sanster/IOPaint：AIGC大模型GFPGAN人像修复/美颜：修复历史人物老照片（3）

Sanster/IOPaint&#xff1a;AIGC大模型GFPGAN人像修复/美颜&#xff1a;修复历史人物老照片&#xff08;3&#xff09; 使用大模型GFPGAN进行人像修复/美颜&#xff0c;比如修复历史上某些人物的老照片。 一、首先pip安装组件依赖库&#xff1a; pip install gfpgan 二&…
阅读更多...
大模型之三十-语音合成TTS(coqui)

大模型之三十-语音合成TTS(coqui)

TTS是text2speech的简称&#xff0c;TTS主要的一些常见包括小说、对话、视频配音、chatbot、虚拟人等场景&#xff0c;因coqui/XTTS-v2生成质量高、完全开源、多语言支持等特点&#xff0c;所以本篇基于coqui/XTTS-v2工具包浅出TTS。官方文档见[link]。 介绍 Coqui TTS 是一个…
阅读更多...
形象化理解pytorch中的tensor.scatter操作

形象化理解pytorch中的tensor.scatter操作

定义 scatter_(dim, index, src, *, reduceNone) -> Tensor pytorch官网说这个函数的作用是从src中把index指定的位置把数据写入到self里面&#xff0c;然后给了一个公式&#xff1a; self[index[i][j][k]][j][k] src[i][j][k] # if dim 0self[i][index[i][…
阅读更多...
ROS CDK魔法书：建立你的游戏王国（TypeScript篇）

ROS CDK魔法书：建立你的游戏王国（TypeScript篇）

引言 在虚拟游戏的世界里&#xff0c;数字化的乐趣如同流动的音符&#xff0c;谱写着无数玩家的共同回忆。而在这片充满创意与冒险的乐园中&#xff0c;您的使命就是将独特的游戏体验与丰富的技术知识相结合&#xff0c;打造出令人难以忘怀的作品。当面对如何实现这一宏伟蓝图…
阅读更多...
MOS管G极串联电阻的作用是什么

MOS管G极串联电阻的作用是什么

MOS管栅极串联电阻是如何抑制谐振？ 为什么会震荡？ 首先了解一下LC串联谐振电路，虽然，LC串联在电路中运用的并不多，但是在无意中总会形成串联谐振，从而产生很多各种各样的现象。如果不了解其本质，会让我们很难理解。比如，使用同样的LC电路滤波，用到两个电路上，有的电…
阅读更多...
CCF推荐B类会议和期刊总结：（计算机体系结构/并行与分布计算/存储系统领域）

CCF推荐B类会议和期刊总结：（计算机体系结构/并行与分布计算/存储系统领域）

目录 前言 B类会议 1. SoCC 2. SPAA 3. PODC 4. FPGA 5. CGO 6. DATE 7. HOT CHIPS 8. CLUSTER 9. ICCD 10. ICCAD 11. ICDCS 12. CODESISSS 13. HiPEAC 14. SIGMETRICS 15. PACT 16. ICPP 17. ICS 18. VEE 19. IPDPS 20. Performance 21. HPDC 22. ITC…
阅读更多...
在亚马逊云科技上利用Graviton4代芯片构建高性能Java应用（下篇）

在亚马逊云科技上利用Graviton4代芯片构建高性能Java应用（下篇）

简介 在AI迅猛发展的时代&#xff0c;芯片算力对于模型性能起到了至关重要的作用。一款能够同时兼具高性能和低成本的芯片&#xff0c;能够帮助开发者快速构建性能稳定的生成式AI应用&#xff0c;同时降低开发成本。今天小李哥将介绍亚马逊推出的4代高性能计算处理器Gravition…
阅读更多...
计算机毕业设计Python电影评论情感分析 电影可视化 豆瓣电影爬虫 电影推荐系统 电影数据分析 电影大数据 大数据毕业设计 机器学习 深度学习 知识图谱

计算机毕业设计Python电影评论情感分析 电影可视化 豆瓣电影爬虫 电影推荐系统 电影数据分析 电影大数据 大数据毕业设计 机器学习 深度学习 知识图谱

相关技术介绍 豆瓣电影数据采集与可视化分析系统是用当前应用很广泛的Python语言和Flask框架&#xff0c;并结合CSS与HTML搭建Web网页&#xff0c;使用MySQL数据库对数据进行存储&#xff0c;依次来开发实现系统的功能。本系统运行需要的软件有Pycharm、普通浏览器、Navicat f…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023