Java 本地缓存CaffeineCache简单使用案例

已于 2024-01-17 10:19:17 修改
阅读量619 收藏 11
点赞数 9
分类专栏： java springboot caffeine 文章标签： java 缓存 spring boot caffeine cache
于 2024-01-16 18:46:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43969830/article/details/135632272
版权
java 同时被 3 个专栏收录
19 篇文章 0 订阅
订阅专栏
springboot
11 篇文章 0 订阅
订阅专栏
caffeine
1 篇文章 0 订阅
订阅专栏

一、需求

项目中用到了本地缓存CaffeineCache，在这里简单介绍一下使用方法。

二、CaffeineCache缓存的两种方式

缓存配置有两种：SimpleCacheManager和CaffeineCacheManager
它们配置的区别如下：

1、SimpleCacheManager

当应用程序启动时，通过配置多个CaffeineCache来创建多个缓存。可以为每个方法单独配置缓存过期时间。

2、CaffeineCacheManager

使用一个全局的Caffeine配置，来创建所有的缓存。不能为每个方法，单独配置缓存过期时间，但可以在程序启动时，
全局的配置缓存，方便设置所有方法的缓存过期时间。

3、总结

如果想要每个方法单独配置缓存过期时间，使用第一种方式。否则，想全局设置的缓存配置，使用第二种方式。

三、pom依赖

         <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-cache</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>com.github.ben-manes.caffeine</groupId>
            <artifactId>caffeine</artifactId>
            <version>2.6.2</version>
        </dependency>

四、配置管理器方式一–采用SimpleCacheManager

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;

/**
 * 缓存配置有两种：SimpleCacheManager和CaffeineCacheManager
 * 它们配置的区别如下：
 * <p>
 * SimpleCacheManager：
 * 当应用程序启动时，通过配置多个CaffeineCache来创建多个缓存。可以为每个方法单独配置缓存过期时间。
 * <p>
 * CaffeineCacheManager：
 * 使用一个全局的Caffeine配置，来创建所有的缓存。不能为每个方法，单独配置缓存过期时间，但可以在程序启动时，
 * 全局的配置缓存，方便设置所有方法的缓存过期时间。
 * <p>
 * 总结：
 * 如果想要每个方法单独配置缓存过期时间，建议使用第一种方式。
 * 否则，你想设置全局的缓存配置，建议使用第二种方式。
 */
@EnableCaching
@Configuration
public class SimpleCaffeineConfig {


//    /**
//     * 写法一：初始化SimpleCacheManager管理器
//     * @return
//     */
//    @Bean
//    @Primary
//    public CacheManager simpleCacheManager() {
//        SimpleCacheManager cacheManager = new SimpleCacheManager();
//        ArrayList<CaffeineCache> caches = new ArrayList<>();
//        Map<String, Object> map = putCacheRule();
//        for (String name : map.keySet()) {
//            caches.add(new CaffeineCache(name, (Cache<Object, Object>) map.get(name)));
//        }
//        cacheManager.setCaches(caches);
//        return cacheManager;
//    }
//
//    /**
//     * 配置多个缓存
//     *
//     * @return
//     */
//    private static Map<String, Object> putCacheRule() {
//        Map<String, Object> map = new ConcurrentHashMap<>();
//        map.put("caffeine_test_1", Caffeine.newBuilder().recordStats()
//                .expireAfterWrite(1, TimeUnit.MINUTES)
                .maximumSize(10000)
//                .build());
//        map.put("caffeine_test_2", Caffeine.newBuilder().recordStats()
//                .expireAfterWrite(2, TimeUnit.HOURS)
                .maximumSize(10000)
//                .build());
//        return map;
//    }

    /**
     * 写法二：初始化SimpleCacheManager管理器
     *
     * @return
     */
    @Bean
    public CacheManager caffeineCacheManager() {
        SimpleCacheManager cacheManager = new SimpleCacheManager();
        List<CaffeineCache> caches = new ArrayList<>();
        //缓存一：失效时间是1分钟
        caches.add(new CaffeineCache("simple_caffeine_test_1",
                Caffeine.newBuilder().expireAfterWrite(1, TimeUnit.MINUTES).build()));
        //缓存二：失效时间是1小时
        caches.add(new CaffeineCache("simple_caffeine_test_2",
                Caffeine.newBuilder().expireAfterWrite(1, TimeUnit.HOURS).build()));
        cacheManager.setCaches(caches);
        return cacheManager;
    }
}

五、配置管理器方式一–采用CaffeineCacheManager

import com.github.benmanes.caffeine.cache.Caffeine;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cache.caffeine.CaffeineCacheManager;
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;

/**
 * 缓存配置有两种：SimpleCacheManager和CaffeineCacheManager
 * 它们配置的区别如下：
 * <p>
 * SimpleCacheManager：
 * 当应用程序启动时，通过配置多个CaffeineCache来创建多个缓存。可以为每个方法单独配置缓存过期时间。
 * <p>
 * CaffeineCacheManager：
 * 使用一个全局的Caffeine配置，来创建所有的缓存。不能为每个方法，单独配置缓存过期时间，但可以在程序启动时，
 * 全局的配置缓存，方便设置所有方法的缓存过期时间。
 * <p>
 * 总结：
 * 如果想要每个方法单独配置缓存过期时间，建议使用第一种方式。
 * 否则，你想设置全局的缓存配置，建议使用第二种方式。
 */
@EnableCaching
@Configuration
public class CaffeineCacheConfig {

    @Bean
    public CacheManager caffeineCacheManager() {
        CaffeineCacheManager caffeineCacheManager = new CaffeineCacheManager();
        Caffeine<Object, Object> caffeine = Caffeine.newBuilder()
                // 初始大小
                .initialCapacity(10)
                // 最大容量
                .maximumSize(100)
                // 打开统计
                .recordStats()
                // 5分钟不访问自动丢弃
                .expireAfterAccess(5, TimeUnit.MINUTES);
        caffeineCacheManager.setCaffeine(caffeine);
        // 设定缓存器名称
        caffeineCacheManager.setCacheNames(getKeys());
        // 值不可为空
        caffeineCacheManager.setAllowNullValues(false);
        return caffeineCacheManager;
    }

    /**
     * 配置缓存key
     *
     * @return
     */
    public static List<String> getKeys() {
        List<String> names = new ArrayList<>(1);
        names.add("cache_caffeine_test_1");
        return names;
    }
}

六、定义service

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

import java.util.UUID;

/**
 * @Author:
 * @Description
 * @Date: 上午9:32 2024/1/16
 */
@Service
public class CaffeineService {

    /**
     * 方式一：SimpleCacheManager
     * <p>
     * 注解的参数包括：
     * <p>
     * cacheNames：指定缓存的名称。
     * key：指定缓存的 key。这里的 key 是一个 SpEL 表达式，表示使用方法的参数，作为 key。
     * unless：指定当方法的返回值为 null 时，不将结果缓存。
     * unless这个注解的作用是，当调用这个方法时，会先在本地缓存中查找是否已经缓存了结果，如果有，则直接返回缓存中的结果；
     * 如果没有，则执行方法体，并将方法的返回值缓存到本地缓存中，供下次使用。如果方法的返回值为 null，则不会将结果缓存。
     * <p>
     *
     * @param name
     * @param address
     * @return
     */
//    @Cacheable(value = "simple_caffeine_test_1", key = "#root.methodName+'_'+#root.args[0]+'_'+#root.args[1]", unless = "#result == null")
    @Cacheable(value = "simple_caffeine_test_1", key = "#root.args[0]+'_'+#root.args[1]", unless = "#result == null")
    public String testSimpleCaffeine(String name, String address) {
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return name + address;
    }

    /**
     * 更新缓存
     */
    @CachePut(value = "simple_caffeine_test_1", key = "#root.args[0]+'_'+#root.args[1]", unless = "#result == null")
    public String update(String name, String address) {
        return name + address+ UUID.randomUUID().toString();
    }

    /**
     * 删除缓存
     */
    @CacheEvict(value = "simple_caffeine_test_1", key = "#root.args[0]+'_'+#root.args[1]")
    public String del(String name, String address) {
        return "";
    }

    /**
     * 方式二：CaffeineCacheManager
     *
     * @param name
     * @param address
     * @return
     */
    @Cacheable(value = "cache_caffeine_test_1", key = "#root.methodName+'_'+#root.args[0]+'_'+#root.args[1]", unless = "#result == null")
    public String testCacheCaffeine(String name, String address) {
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return name + address;
    }
}

七、定义controller

import com.example.service.CaffeineService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @Author:
 * @Description
 * @Date: 上午9:32 2024/1/16
 */
@RestController
@RequestMapping("/caffeine")
public class CaffeineController {

    @Autowired
    private CaffeineService caffeineService;

    @GetMapping("/simple")
    public String testSimpleCaffeine(String name, String address){

        return caffeineService.testSimpleCaffeine(name,address);
    }

    @GetMapping("/update")
    public String testUpdate(String name, String address){

        return caffeineService.update(name,address);
    }

    @GetMapping("/del")
    public String testDel(String name, String address){
        return caffeineService.del(name,address);
    }

    @GetMapping("/cache")
    public String testCacheCaffeine(String name, String address){

        return caffeineService.testCacheCaffeine(name,address);
    }
}

八、测试

注意：SimpleCaffeineConfig和CaffeineCacheConfig必须注释掉其中一个类，来分别测试

1、启动项目，这里以SimpleCaffeine方式进行测试
2、模拟加入缓存，地址栏输入：localhost:8077/caffeine/simple?name=111&address=222 等待三秒数据返回
3、继续操作第2步，这时候看到数据返回需要6毫秒，缓存生效
4、模拟数据更新，地址栏输入：localhost:8077/caffeine/update?name=111&address=222
5、模拟读取缓存更新后的数据，地址栏输入：localhost:8077/caffeine/simple?name=111&address=222 看到数据已更新，且数据返回需要5毫秒，缓存更新生效
6、模拟清空缓存，地址栏输入：localhost:8077/caffeine/del?name=111&address=222 ，然后地址栏输入：localhost:8077/caffeine/simple?name=111&address=222 返回数据需要3.15秒，缓存清空生效

九、完整代码

Gitee地址：https://gitee.com/Dev9925/caffeine-demo

愛～杦辷个訾
关注
  • 9
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
springBoot集成caffeine，自定义缓存配置 CacheManager
weixin_53142722的博客
08-08 3755
springBoot集成Caffeine，Redis，以及定制化配置cachemanager
Java利用ConcurrentHashMap实现本地缓存demo
05-25
Java利用ConcurrentHashMap实现本地缓存demo； 基本功能有缓存有效期、缓存最大数、缓存存入记录、清理线程、过期算法删除缓存、LRU算法删除、获取缓存值等功能。 复制到本地项目的时候，记得改包路径哦~
你还在用Guava Cache？它才是Java本地缓存之王
最新发布
2401_83817392的博客
03-27 775
我个人认为，如果你想靠着背面试题来获得心仪的offer，用癞蛤蟆想吃天鹅肉形容完全不过分。想必大家能感受到面试越来越难，想找到心仪的工作也是越来越难，高薪工作羡慕不来，却又对自己目前的薪资不太满意，工作几年甚至连一个应届生的薪资都比不上，终究是错付了，错付了自己没有去提升技术。这些面试题分享给大家的目的，其实是希望大家通过大厂面试题分析自己的技术栈，给自己梳理一个更加明确的学习方向，当你准备好去面试大厂，你心里有底，大概知道面试官会问多广，多深，避免面试的时候一问三不知。
详细介绍高性能Java缓存库Caffeine
08-28
本篇文章主要介绍了详细介绍高性能Java缓存库Caffeine，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
Java中LocalCache本地缓存实现代码
08-30
本篇文章主要介绍了Java中LocalCache本地缓存实现代码，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
Spring boot Caffeine缓存（一）——CacheManager与配置文件
热门推荐
坤哥的博客
09-03 4万+
spring5（springboot2）开始用Caffeine取代guava，至于其性能对比可以参考Caffeine给的测试结果各缓存性能对比。 这里贴出一个读写的对比 Caffeine在springboot中集成非常简单，可以通过配置文件来设置 spring: cache: cache-names: outLimit，notOutLimit caffeine: ...
CacheManager.java 管理缓存
06-30
package com.cnfilm.utils; import java.util.ArrayList; import java.util.HashMap; import java.util.Iterator; /** * 文件名：CacheManager.java 管理缓存 * 版本信息：V1.0 * 日期：2013-06-18 * Copyright BDVCD Corporation 2013 * 版权所有 http://www.bdvcd.com * */ @SuppressWarnings("all") public class CacheManager { private static HashMap cacheMap = new HashMap(); /** * 单实例构造方法 */ private CacheManager() { super(); } /** * 得到缓存。同步静态方法 * * @param key * @return */ public synchronized static Object getCache(String key) { return cacheMap.get(key); } /** * 判断是否存在一个缓存 * * @param key * @return */ public synchronized static boolean hasCache(String key) { return cacheMap.containsKey(key); } /** * 清除所有缓存 */ public synchronized static void clearAll() { cacheMap.clear(); } /** * 清除指定的缓存 * * @param key */ public synchronized static void clearOnly(String key) { cacheMap.remove(key); } /** * 载入缓存 * * @param key * @param obj */ public synchronized static void putCache(String key, Object obj) { cacheMap.put(key, obj); } }
java 缓存 cachemanager_在java中使用cacheManager清除缓存
weixin_29658015的博客
02-13 3738
是的,您的代码会清除您在cacheManager中拥有的所有缓存.ehcache-documentation说：void clearAll()清除CacheManager中所有缓存的内容,但不删除任何缓存如果要测试它,可以在缓存中添加一些元素,调用clearCache()然后尝试获取值. get() – 方法应该只返回null.您不能直接在cacheManager中添加值,它只管理您在配置文件中声...
java缓存模块,ehcache/guava cache/自定义spring的CacheManager/自定义缓存
tiantiantbtb的博客
12-17 1030
注意ehcache的原生API在实际开发中一般不使用,而是和Spring或者SpringBoot集成使用,但是原理还是ehcache,只不过在Spring和SpringBoot中对它进行了包装,学习ehcache原生API可以帮助理解。这里是建了个Maven工程,引入的依赖,包含了Spring,SpringBoot。使用原生ehcache的API。ehcache.xml配置。
springboot缓存之CacheManager详解
qq_35876365的博客
01-06 5172
整合spring-cache的关键就在于配置一个缓存管理器CacheManager，让我们慢慢走近redis看看他的缓存管理器的实现吧~
java 静态map缓存_java 使用静态hashmap实现简单缓存(示例代码)
weixin_30673943的博客
02-13 701
因项目需要的数据查询较多，数量大，所以要用到缓存，在未引用redis的情况下，仅仅只做一个速度的提升1、Cache类public class Cache {private String key;//缓存ID，根据iD往hashmap存放值private E value;//缓存数据 ，需要缓存的对象实体private long timeOut;//更新时间private boolean expir...
Java LocalCache 本地缓存的实现实例
08-30
本篇文章主要介绍了Java LocalCache 本地缓存的实现实例，具有一定的参考价值，感兴趣的小伙伴们可以参考一下。
如何基于LoadingCache实现Java本地缓存
08-25
主要介绍了如何基于LoadingCache实现Java本地缓存,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Caffeine Cache 简单示例
心要是孤单了，到了那里都是流浪~~~
11-20 800
Caffeine 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
本地缓存Caffeine的使用
J_bean的博客
12-28 437
本地缓存Caffeine的使用
Caffeine Cache实战
rocklee的专栏
07-03 990
Caffeine简介 Caffeine是基于JAVA 1.8 Version的高性能缓存库。Caffeine提供的内存缓存使用参考Google guava的API。Caffeine是基于Google Guava Cache设计经验上改进的成果。 并发测试 官方性能比较： 可以清楚的看到Caffeine效率明显的高于其他缓存。 Caffeine可以通过建造者模式灵活的组合以下特性： * 通过异步自动加载实体到缓存中 * 基于大小的回收策略 * 基于时间...
SpringBoot 集成缓存性能之王 Caffeine
weixin_70730532的博客
06-21 604
使用缓存的目的就是提高性能，今天码哥带大家实践运用 抽象的缓存组件去集成本地缓存性能之王 。大家需要注意的是： 缓存只适合在单体应用，不适合与分布式环境。分布式环境的情况下需要将缓存修改同步到每个节点，需要一个同步机制保证每个节点缓存数据最终一致。不使用 Spring Cache 抽象的缓存接口，我们需要根据不同的缓存框架去实现缓存，需要在对应的代码里面去对应缓存加载、删除、更新等。比如查询我们使用旁路缓存策略：先从缓存中查询数据，如果查不到则从数据库查询并写到缓存中。伪代码如下：我们需要写大量的这种繁琐
Caffeine缓存的使用
aaaPostcard的博客
10-15 4900
jvm缓存之Caffeine的使用。
【Java】java | CacheManager | redisCacheManager | @Cacheable失效
hgSuper的博客
11-21 470
1、查询增加缓存，使用@Cacheable注解2、项目中已经用到了ehcache，现在需求是两个都用二、备份配置1、redisConfig增加代码。
java本地缓存cache
09-19
Java本地缓存cache是一种在内存中存储数据的机制，它可以提高应用程序的性能和响应速度。在上面的代码示例中，使用了Caffeine库来实现本地缓存。具体来说，CacheConfig类中定义了两个缓存对象accessToken和refreshToken，并通过注解@Bean将它们注册为Spring的bean。这两个缓存对象分别用于存储访问令牌和刷新令牌，并分别设置了过期时间和缓存的最大条数。 在EasyController类中，通过@Autowired注解将accessToken和refreshToken注入到控制器中。其中，set方法用于向refreshToken缓存中添加数据，get方法用于从缓存中获取数据。 通过使用本地缓存cache，可以减少对数据库或其他外部资源的频繁访问，提高系统的性能和响应速度。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值