缓存 - Spring Boot 整合 Caffeine 不完全指北

news2024/11/28 4:36:14

文章目录

  • Pre
  • 名词解释
  • 注解属性
  • 指导步骤
    • 步骤 1：添加依赖
    • 步骤 2：配置缓存
    • 步骤 3：使用缓存
  • Code
    • pom
    • Config
    • Service
    • 缓存名枚举 & 常量
    • 测试入口
    • 测试

在这里插入图片描述

Pre

缓存 - Caffeine 不完全指北

名词解释

  • @Cacheable：表示该方法支持缓存。当调用被注解的方法时，如果对应的键已经存在缓存，则不再执行方法体，而从缓存中直接返回。当方法返回null时，将不进行缓存操作。
  • @CachePut：表示执行该方法后，其值将作为最新结果更新到缓存中，每次都会执行该方法。
  • @CacheEvict：表示执行该方法后，将触发缓存清除操作。
  • @Caching：用于组合前三个注解，比如
    @Caching(cacheable = @Cacheable("CacheConstants.GET_USER"),
         evict = {@CacheEvict("CacheConstants.GET_DYNAMIC",allEntries = true)}
public User find(Integer id) {
    return null;
}

注解属性

在这里插入图片描述

  • cacheNames/value：缓存组件的名字，即cacheManager中缓存的名称。
  • key：缓存数据时使用的key。默认使用方法参数值，也可以使用SpEL表达式进行编写。
  • keyGenerator：和key二选一使用。
  • cacheManager：指定使用的缓存管理器。
  • condition：在方法执行开始前检查，在符合condition的情况下，进行缓存
  • unless：在方法执行完成后检查，在符合unless的情况下，不进行缓存
  • sync：是否使用同步模式。若使用同步模式，在多个线程同时对一个key进行load时，其他线程将被阻塞。

sync开启或关闭，在Cache和LoadingCache中的表现是不一致的：

  • Cache中，sync表示是否需要所有线程同步等待
  • LoadingCache中，sync表示在读取不存在/已驱逐的key时，是否执行被注解方法

指导步骤

要在Spring Boot中整合Caffeine缓存，可以按照以下步骤进行操作：

步骤 1：添加依赖

在pom.xml文件中添加Caffeine依赖项。确保选择与您的Spring Boot版本兼容的Caffeine版本。以下是一个示例依赖项：

<dependency>
    <groupId>com.github.ben-manes.caffeine</groupId>
    <artifactId>caffeine</artifactId>
    <version>2.9.0</version>
</dependency>

步骤 2：配置缓存

在Spring Boot的配置文件（例如application.properties或application.yml）中添加Caffeine缓存的配置。以下是一个示例配置：

application.properties:

spring.cache.type=caffeine
spring.cache.cache-names=myCache
spring.cache.caffeine.spec=maximumSize=100,expireAfterAccess=600s

application.yml:

spring:
  cache:
    type: caffeine
    cache-names: myCache
    caffeine:
      spec: maximumSize=100,expireAfterAccess=600s

这将配置一个名为myCache的Caffeine缓存，最大容量为100，访问后在600秒内过期。

步骤 3：使用缓存

在需要使用缓存的地方，使用@Cacheable注解标记方法。例如，以下是一个使用缓存的示例：

import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;

@Service
public class MyService {

    @Cacheable("myCache")
    public String getDataFromCache(String key) {
        // 如果缓存中存在数据，则直接返回
        // 如果缓存中不存在数据，则执行相应的业务逻辑，并将结果放入缓存
        return fetchDataFromDatabase(key);
    }

    private String fetchDataFromDatabase(String key) {
        // 执行获取数据的业务逻辑
        return "Data for key: " + key;
    }
}

在上面的示例中，getDataFromCache方法使用了@Cacheable("myCache")注解，表示该方法的结果将被缓存到名为myCache的缓存中。

现在，当调用getDataFromCache方法时，首先会检查缓存中是否存在与给定参数对应的数据。如果存在，将直接返回缓存的数据；如果不存在，则会执行方法体内的业务逻辑，并将结果放入缓存。

这就是在Spring Boot中整合Caffeine缓存的基本步骤。我们可以根据自己的需求进行进一步的配置和定制。

Code

在这里插入图片描述

接下来我们使用另一种方式来实现

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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.13</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.artisan</groupId>
    <artifactId>caffeine-demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>caffeine-demo</name>
    <description>caffeine-demo</description>
    <properties>
        <java.version>1.8</java.version>
    </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</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>


        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
        </dependency>


        <dependency>
            <groupId>com.github.ben-manes.caffeine</groupId>
            <artifactId>caffeine</artifactId>
            <!-- Java 8 users can continue to use version 2.x, which will be supported -->
            <version>2.9.3</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-cache</artifactId>
        </dependency>


    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

Config

package com.artisan.caffeinedemo.spring.config;

import com.artisan.caffeinedemo.spring.enums.CacheEnum;
import com.github.benmanes.caffeine.cache.Caffeine;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cache.caffeine.CaffeineCache;
import org.springframework.cache.support.SimpleCacheManager;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;

/**
 * @author 小工匠
 * @version 1.0
 * @mark: show me the code , change the world
 */
@Configuration
@EnableCaching
public class CacheConfig {
    /**
     * Caffeine配置说明：
     * initialCapacity=[integer]: 初始的缓存空间大小
     * maximumSize=[long]: 缓存的最大条数
     * maximumWeight=[long]: 缓存的最大权重
     * expireAfterAccess=[duration]: 最后一次写入或访问后经过固定时间过期
     * expireAfterWrite=[duration]: 最后一次写入后经过固定时间过期
     * refreshAfterWrite=[duration]: 创建缓存或者最近一次更新缓存后经过固定的时间间隔，刷新缓存
     * weakKeys: 打开key的弱引用
     * weakValues：打开value的弱引用
     * softValues：打开value的软引用
     * recordStats：开发统计功能
     * 注意：
     * expireAfterWrite和expireAfterAccess同事存在时，以expireAfterWrite为准。
     * maximumSize和maximumWeight不可以同时使用
     * weakValues和softValues不可以同时使用
     */
    @Bean
    public CacheManager cacheManager() {
        SimpleCacheManager cacheManager = new SimpleCacheManager();
        List<CaffeineCache> list = new ArrayList<>();
        //循环添加枚举类中自定义的缓存，可以自定义
        for (CacheEnum cacheEnum : CacheEnum.values()) {
            list.add(new CaffeineCache(cacheEnum.getName(),
                    Caffeine.newBuilder()
                            .initialCapacity(50)
                            .maximumSize(1000)
                            .expireAfterAccess(cacheEnum.getExpireTime(), TimeUnit.SECONDS)
                            .build()));
        }
        cacheManager.setCaches(list);
        return cacheManager;
    }
}

Service

package com.artisan.caffeinedemo.spring.service;

import com.artisan.caffeinedemo.spring.constants.CacheConstants;
import com.artisan.caffeinedemo.spring.domains.Artisan;
import lombok.extern.slf4j.Slf4j;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.CachePut;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;

/**
 * @author 小工匠
 * @version 1.0
 * @mark: show me the code , change the world
 */

@Service
@Slf4j
public class ArtisanService {

    /**
     * @Cacheable注解是 通过 Spring AOP机制进行的，因此类内的调用将无法触发缓存操作，必须由外部进行调用，之前也算是踩了一遍坑，特别提醒一下
     */

    /**
     * cacheNames/value：缓存组件的名字，即cacheManager中缓存的名称。
     * key：缓存数据时使用的key。默认使用方法参数值，也可以使用SpEL表达式进行编写。
     * keyGenerator：和key二选一使用。
     * cacheManager：指定使用的缓存管理器。
     * condition：在方法执行开始前检查，在符合condition的情况下，进行缓存
     * unless：在方法执行完成后检查，在符合unless的情况下，不进行缓存
     * sync：是否使用同步模式。若使用同步模式，在多个线程同时对一个key进行load时，其他线程将被阻塞。
     */
    @Cacheable(value = CacheConstants.GET_USER, key = "'user'+#userId", sync = true)
    public Artisan getUserByUserId(Integer userId) {
        log.info("----------------触发DB查询----------------------------");
        // 模拟从DB查询数据
        Artisan artisan = Artisan.builder().id(userId).name("artisan-" + userId).address("China-" +  userId).build();
        return artisan;
    }


    @CacheEvict(value = CacheConstants.GET_USER, key = "'user'+#userId")
    public Integer cacheEvictTest(Integer userId) {
        log.info("cacheEvictTest 清除 {} 对应的缓存", userId);
        return 1;
    }

    @CachePut(value = CacheConstants.GET_USER, key = "'user'+#userId")
    public Artisan cachePut(Integer userId) {
        log.info("cachePut execute -------------------");
        Artisan artisan = Artisan.builder().id(userId).name("artisan1").address("China").build();
        return artisan;
    }

}

缓存名枚举 & 常量

package com.artisan.caffeinedemo.spring.enums;

import com.artisan.caffeinedemo.spring.constants.CacheConstants;
import lombok.Getter;

/**
 * @author 小工匠
 * @version 1.0
 * @mark: show me the code , change the world
 */
@Getter
public enum CacheEnum {

    MY_CACHE_1("工匠1", CacheConstants.DEFAULT_EXPIRES),
    MY_CACHE_2("工匠2", CacheConstants.EXPIRES_5_MIN),
    MY_CACHE_3(CacheConstants.GET_USER, CacheConstants.EXPIRES_10_MIN);

    private String name;
    private Integer expireTime;

    CacheEnum(String name, Integer expireTime) {
        this.name = name;
        this.expireTime = expireTime;
    }


}
    

package com.artisan.caffeinedemo.spring.constants;

/**
 * @author 小工匠
 * @version 1.0
 * @mark: show me the code , change the world
 */
public class CacheConstants {
    /**
     * 默认过期时间（配置类中使用的时间单位是秒，所以这里如 3*60 为3分钟）
     */
    public static final int DEFAULT_EXPIRES = 3 * 60;
    public static final int EXPIRES_5_MIN = 5 * 60;
    public static final int EXPIRES_10_MIN = 10 * 60;

    public static final String GET_USER = "GET:USER";
    public static final String GET_DYNAMIC = "GET:DYNAMIC";

}

创建缓存常量类，把公共的常量提取一层，复用，这里也可以通过配置文件加载这些数据，例如@ConfigurationProperties和@Value

package com.artisan.caffeinedemo.spring.domains;

import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.extern.slf4j.Slf4j;

/**
 * @author 小工匠
 * @version 1.0
 * @mark: show me the code , change the world
 */
@Slf4j
@Builder
@NoArgsConstructor
@AllArgsConstructor
@Data
public class Artisan {
    private Integer id;
    private String name;
    private String address;
}

测试入口

package com.artisan.caffeinedemo.spring.controller;

import com.artisan.caffeinedemo.spring.domains.Artisan;
import com.artisan.caffeinedemo.spring.service.ArtisanService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;

/**
 * @author 小工匠
 * @version 1.0
 * @mark: show me the code , change the world
 */
@Slf4j
@RestController
@RequestMapping("/testCache")
public class CacheController {


    @Resource
    private ArtisanService artisanService;

    @RequestMapping("/get/{id}")
    @ResponseBody
    public String getArtisanById(@PathVariable Integer id) {
        Artisan artisan = artisanService.getUserByUserId(id);
        log.info("--------->{}", artisan.toString());
        return artisan.toString();
    }


    @RequestMapping("/evit/{id}")
    @ResponseBody
    public String cacheEvit(@PathVariable Integer id) {
        artisanService.cacheEvictTest(id);

        return "cacheEvit";
    }


    @RequestMapping("/put/{id}")
    @ResponseBody
    public String cachePut(@PathVariable Integer id) {
        Artisan artisan = artisanService.cachePut(id);

        return artisan.toString();
    }
}

测试

根据以下的访问，可以得到如下结论

http://127.0.0.1:8080/testCache/get/1  ----->  查询DB ，加入缓存

http://127.0.0.1:8080/testCache/get/1 ------>  直接从缓存中读取  


http://127.0.0.1:8080/testCache/evit/1 ------> 清除缓存的id=1的数据   


http://127.0.0.1:8080/testCache/get/1  ----->  查询DB ，加入缓存



http://127.0.0.1:8080/testCache/put/1  ----->  操作DB ，加入缓存

http://127.0.0.1:8080/testCache/put/2  ----->  操作DB ，加入缓存


http://127.0.0.1:8080/testCache/get/2 ------>  直接从缓存中读取

在这里插入图片描述

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

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

相关文章

Few-Shot Learning in Wireless Networks: A Meta-Learning Model-Enabled Scheme

Few-Shot Learning in Wireless Networks: A Meta-Learning Model-Enabled Scheme

1 INTRODUCTION 由于6G的复杂管理机制&#xff0c;可以在基站收集历史数据——为克服训练数据集容量的限制提供了极大的便利 问题与挑战&#xff1a; 尽管元学习可以提高网络边缘智能(network edge intelligence)的性能&#xff0c;但其在无线网络(wireless networks)中的应用…
阅读更多...
HCIP实验---OSPF实验2

HCIP实验---OSPF实验2

1.如图连接&#xff0c;合理规划IP地址&#xff0c;所有路由器各自创建一个loopback接口 2.R1再创建三个接口IP地址为201.1.1.1/24、201.1.2.1/24、201.1.3.1/24 R5再创建三个接口IP地址为202.1.1.1/24、202.1.2.1/24、202.1.3.1/24 R7再创建三个接口IP地址为203.1.1.1/2…
阅读更多...
高效办公学习的秘密！打工人高效工作必备的AI神器

高效办公学习的秘密！打工人高效工作必备的AI神器

​人工智能 (AI) 近年来取得了显著进步&#xff0c;并已成为科技行业的流行语。我们随时能看到大量有关人工智能工具的资讯&#xff0c;它有可能自动执行任务&#xff0c;节省时间并提高效率&#xff0c;使其成为企业的宝贵资产和平台。 随着人工智能的进步&#xff0c;旨在让…
阅读更多...
如何在Ubuntu18.04中下载MySQL5.7

如何在Ubuntu18.04中下载MySQL5.7

检查环境 首先检查自己电脑有没有安装过mysql,输入如下&#xff1a; rpm -qa | grep mysql如果有则清理干净在安装&#xff0c;输入 whereis mysql找到文件夹目录&#xff0c;再把它删除 rpm -e --nodeps mysql-xxx检查系统是否自带mariadb&#xff0c;输入如下检查 rpm -…
阅读更多...
基于Tars高并发IM系统的设计与实现-实战篇1

基于Tars高并发IM系统的设计与实现-实战篇1

基于Tars高并发IM系统的设计与实现-实战篇1 通过前文基础篇&#xff0c;进阶篇的介绍&#xff0c;相信大家已经对IM的基础能力实现&#xff0c;难点及其如何解决有了一个全面的了解与认识。 相信大家都迫不及待想看看一个高性能的IM系统到底怎么设计与实现&#xff0c;从本篇开…
阅读更多...
grpc学习笔记

grpc学习笔记

目录 gRPC原理网络传输效率问题基本概念概览ClientServer 异步相关概念异步 Client异步 Server gRPC原理 RPC 即远程过程调用协议&#xff08;Remote Procedure Call Protocol&#xff09;&#xff0c;可以让我们像调用本地对象一样发起 远程调用。 网络传输效率问题 HTTP…
阅读更多...
Mysql---explain详解

Mysql---explain详解

explain命令是用来分析查询语句的执行计划的工具。它可以显示查询语句的执行计划&#xff0c;包括查询的顺序、使用的索引、扫描的行数等信息&#xff0c;帮助开发人员优化查询语句的性能。通过分析执行计划&#xff0c;可以找到查询语句的瓶颈&#xff0c;进而优化查询语句的性…
阅读更多...
机器学习笔记 - 探索PaddlePaddle框架的对象检测、分割和关键点检测

机器学习笔记 - 探索PaddlePaddle框架的对象检测、分割和关键点检测

一、PaddlePaddle简述 PaddlePaddle（PArallel Distributed Deep LEarning）是百度于2016年发布的开源深度学习框架。它为各种机器学习任务提供了统一的平台。 但是最近的基准测试显示 PaddlePaddle 是潜在的领跑者，其基准速度超过了其更知名的竞争对手。 PaddlePaddle 与 PyT…
阅读更多...
2.SpringBoot集成Swagger

2.SpringBoot集成Swagger

1.添加依赖 <!--添加Swagger依赖 --><dependency><groupId>io.springfox</groupId><artifactId>springfox-swagger2</artifactId><version>2.7.0</version></dependency><!--添加Swagger-UI依赖 --><dependenc…
阅读更多...
Python实现操作MySQL【增删改查-示例】

Python实现操作MySQL【增删改查-示例】

闲话少叙，直接上操作！ 一、准备工作 1.本地安装MySQL、Python（以3.6为例） 2.MySQL新建数据库【test】，新建表【user】，新建字段【name】【age】 3.建表方式：navicat工具 字段 二、Python操作—插入数据 #!/usr/bin/env # coding=utf-8import pymysql # Python 连…
阅读更多...
Leetcode-每日一题【430.扁平化多级双向链表】

Leetcode-每日一题【430.扁平化多级双向链表】

题目 你会得到一个双链表&#xff0c;其中包含的节点有一个下一个指针、一个前一个指针和一个额外的 子指针 。这个子指针可能指向一个单独的双向链表&#xff0c;也包含这些特殊的节点。这些子列表可以有一个或多个自己的子列表&#xff0c;以此类推&#xff0c;以生成如下面…
阅读更多...
Java语言程序设计试卷6套

Java语言程序设计试卷6套

目录 Java语言程序设计试卷1 一、单项选择题 二、多项选择题 三、判断题 Java语言程序设计试卷2 一、单项选择题 二、多项选择题 三、判断题 Java语言程序设计试卷3 一、单项选择题 二、多项选择题 三、判断题 Java语言程序设计试卷4 一、单项选择题 二、多项选…
阅读更多...
【7月比赛合集】119场可报名的数据挖掘大奖赛，任君挑选！

【7月比赛合集】119场可报名的数据挖掘大奖赛，任君挑选！

CompHub[1] 主页增加了“近两周上新的奖金赛”&#xff0c;更加方便查找最新比赛&#xff0c;欢迎访问和反馈&#xff01; 最新更新的比赛会第一时间在群里通知&#xff0c;欢迎加群交流&#xff01;&#xff08;公众号回复“加群”即可&#xff09; 以下信息仅供参考&#xff…
阅读更多...
一种简单的数据库性能测试方法

一种简单的数据库性能测试方法

这两天接到一个任务&#xff0c;要测试一个服务器的性能&#xff0c;客户要求向数据库内 1000/s&#xff08;每插入一千条数据&#xff09; 的处理能力&#xff0c;当时脑子赌赛了&#xff0c;想的是用LR来进行&#xff0c;由于LR接触不深&#xff0c;只知道LR实现参数化的时候…
阅读更多...
Java基础---异常

Java基础---异常

目录 典型回答 什么是Throwable Error和Exception的区别和联系 Java异常处理相关的几个关键字&#xff0c;以及简单用法 什么是自定义异常&#xff0c;如何使用自定义异常 Java异常体系结构 以下关于异常处理的代码有哪些问题 典型回答 Java中的异常&#xff0c;主要可以…
阅读更多...
力扣 62. 不同路径

力扣 62. 不同路径

文章目录 题目描述思路代码 题目描述 思路 动态规划 代码 private int UniquePaths(int m, int n) {int[][] dp new int[m][];for (int i 0; i < m; i) {dp[i] new int[n];}for (int i 0; i < m; i) {for (int j 0; j < n; j) {if (i 0 || j 0) dp[i][j] …
阅读更多...
LLM - Baichuan7B Tokenizer 生成训练数据

LLM - Baichuan7B Tokenizer 生成训练数据

目录 一.引言 二.Tokenizer 原始数据 1.原始数据样例 2.加载并 Token 原始数据 2.1 参数准备 2.2 单条样本处理逻辑 2.3 批量处理逻辑 2.4 主函数与完整代码 三.shell 执行 四.总结 一.引言 前面提到了自己在微调 Baichuan7B Lora 的过程中遇到了一些问题&#xff0c…
阅读更多...
Cesium Token申请

Cesium Token申请

一、什么是Cesium ion&#xff1f; Cesium ion是一个提供瓦片图和3D地理空间数据的平台&#xff0c;支持把数据添加到用户自己的应用程序中。 二、为什么需要access token&#xff1f; 使用Cesium ion需要申请access token,当用户将数据添加到自己的账户后&#xff0c;便可以…
阅读更多...
Android-jar包方式连接本地sqlite并操作返回数据

Android-jar包方式连接本地sqlite并操作返回数据

背景： 数据库的创建及字段都是后端人员维护，Android端只是映射相关数据库到本地来操作。为了统一管理操作方式方法，所以提出，后端打jar包的方式封装对Android端数据库sqllite的连接、操作。 说明： 因为之前是后端打jar包，JDBC连接的驱动及方法有差异，导致连接Android…
阅读更多...
PHP在线拨打电话的代码

PHP在线拨打电话的代码

这段代码包括一个HTML表单，用于收集用户的姓名，电子邮件和消息。当用户提交表单时，邮件将发送到指定的电子邮件地址，并显示一条消息，指示我们将在不久的将来拨打电话回复。请注意，在上面的代码中，电话号码硬编码为 $phone_number 变量，您需要将其更改为您想要的电话号码…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023