CaffeineCache基本使用 & SpringBoot集成缓存

最新推荐文章于 2024-07-26 18:36:31 发布
最新推荐文章于 2024-07-26 18:36:31 发布
阅读量5.4k 收藏 18
点赞数
分类专栏： Java基础 springboot 文章标签： java restful spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44641388/article/details/121595313
版权

文章目录

平常开发中我们经常会使用到缓存，比如对于一些不常更新的数据却需要经常的访问或者计算，为这些热点数据加缓存可以有效减少服务器的性能损失和资源浪费。
本地缓存相比Redis缓存以及其他存储避免了网络IO的开销，它不需要发送redis命令，直接在本地jvm进程中操作缓存数据，而且基于内存的读写效率很高，所以在需要的时候合理使用本地缓存可以有效提高系统的吞吐量。CaffeineCache是非常优秀的开源本地缓存框架。本篇不分析其原理，只关注其简单用法。

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

一、常用API

CaffeineCache 有非常简易的API，可以通过如下方式快速构建一个本地缓存。

LoadingCache<String, Object> cache = Caffeine.newBuilder()
                .expireAfterWrite(1, TimeUnit.SECONDS)
                .expireAfterAccess(1, TimeUnit.SECONDS)
                .maximumSize(10)
                .build(new CacheLoader<String, Object>() {
                    @Override
                    public Object load(String s)  {
                        return s + "loadValue";
                    }
                });

缓存的常用API如下：

public interface Cache<K, V> {
    //取值，如果不存在则返回null
    @Nullable
    V getIfPresent(@Nonnull Object key);

    //取值，如果不存在则执行函数并将执行结果缓存
    @Nullable
    V get(@Nonnull K key, @Nonnull Function<? super K, ? extends V> var2);

    //存值
    void put(@Nonnull K key, @Nonnull V value);

    //批量存值，接受一个map类型的参数，将map中的元素缓存起来
    void putAll(@Nonnull Map<? extends K, ? extends V> map);

    //移除缓存项
    void invalidate(@Nonnull Object key);

    //接受一个可迭代的参数进行批量移除
    void invalidateAll(@Nonnull Iterable<?> var1);

    //清空缓存
    void invalidateAll();
    
    //获取当前缓存项的数量（map中的条目数）
    @Nonnegative
    long estimatedSize();
    
    //缓存的map视图
    @Nonnull
    ConcurrentMap<K, V> asMap();
    //……
}

public interface LoadingCache<K, V> extends Cache<K, V> {
	@Nullable
    V get(@Nonnull K key);
    @Nonnull
    Map<K, V> getAll(@Nonnull Iterable<? extends K> var1);
    void refresh(@Nonnull K var1);
}

可以看到LoadingCache继承了Cache接口，扩展了三个API，这三个API描述如下：

1.get

  1. 获取key对应的value，在必要时通过CacheLoader加载数据。
  2. 加载的 非null数据会缓存 到Cache中。
  3. 如果同时已有其他线程在加载key对应的数据，当前线程阻塞waits，等待那个线程加载并返回那个加载到的数据。

2.getAll

  1. 获取所有key对应的value，在必要时通过CacheLoader加载数据。
  2. 加载的非null数据会缓存到Cache中。
  3. 如果同时已有其他线程在加载某个key对应的数据，当前线程阻塞waits，等待那个线程加载并返回那个加载到的数据。

3.refresh

  1. 异步刷新key对应的缓存数据
  2. 在新数据加载成功前，旧数据仍可用（除非过期或被驱逐）
  3. 新数据加载成功后，replace旧数据
  4. 如果数据加载时异常，会被swallowed。
  5. 如果数据加载的value为null，key对应的Entry会从缓存中移除。

此处参考自：http://events.jianshu.io/p/881c6f716850

二、缓存回收(清除)：

1. 显式回收

  1. invalidate(@Nonnull Object key);
  2. invalidateAll(@Nonnull Iterable<?> var1);
  3. invalidateAll()

2. 隐式回收

2.1 基于容量

maximumSize(long)：通过指定缓存的最大条目数，当缓存的条目超过最大大小，则按照一定的淘汰算法将旧数据移除。

LoadingCache<String, Object> cache = Caffeine.newBuilder().maximumSize(10)//……

Caffeine采用W-TinyLFU算法作为缓存淘汰算法，这种算法结合了LRU和LFU。算法描述可参考https://my.oschina.net/manmao/blog/603253，https://blog.csdn.net/l_dongyang/article/details/108583476

2.2 基于时间

  1. TTL(Time To Live): 通过expireAfterWrite(long, TimeUnit)指定当缓存项被写入(创建/覆盖)多久后被回收。
  2. TTI(Time To Idle): 通过expireAfterAccess(long, TimeUnit)指定缓存项多久没有被访问(读/写)而将其回收。
LoadingCache<String, Object> cache = Caffeine.newBuilder().weakValues()
                .expireAfterWrite(5, TimeUnit.SECONDS)
                .expireAfterAccess(5, TimeUnit.SECONDS)//……

特别需要注意的是：设置过期时间之后，到达指定之间后缓存项并不会被马上移除，它没有启动定时器，而是依赖下次对cache的操作(读写操作)，当下次对这个cache对象进行读写操作时，它会利用一个线程将cache中的已失效缓存项从内存中清除。expireAfterWrite和expireAfterAccess如果同时设置，取二者指定的最小时间。

  1. put操作：put当前的缓存项，并启动一个线程去后台执行过期缓存项的移除任务。
  2. get操作：如果发现cache中有过期缓存项，则启动一个线程去后台执行这些缓存项的移除任务，如果get的正好是过期的缓存项，则当前线程会马上执行load方法，直到load方法加载完毕，get方法返回。
  3. getIfPresent操作：如果发现cache中有过期缓存项，则启动一个线程去后台执行这些缓存项的移除任务，如果getIfPresent的正好是过期的缓存项，则当前线程马上返回null。

2.3 基于引用

  1. 软引用：如果一个对象是软引用，那么当JVM堆内存不足时，垃圾回收器可以回收这些对象。软引用适合用来做缓存，从而当JVM堆内存不足时，可以回收这些对象腾出一些空间供强引用对象使用，从而避免OOM。框架提供 softValues() 供我们在创建缓存时调用，可以将值包装成软引用。

  2. 弱引用：当垃圾回收器回收内存时，如果发现弱引用，则将立即回收它。相对于软引用有更短的生命周期。框架提供weakKeys()和weakValues()两个方法供我们在创建缓存时调用，可以将键/值包装成弱引用，但是不要使用weakKeys()，这可能导致缓存无法命中。

LoadingCache<String, Object> cache = Caffeine.newBuilder().weakValues()
//……

2.4 基于权重

通过权重来计算，每个缓存项都有不同的权重，总权重到达最高时按照淘汰算法进行回收。
框架提供maximumWeight()方法指定最大的权重阈值，通过weigher()方法指定缓存项所占权重。

LoadingCache<String, Object> cache = Caffeine.newBuilder()
    .maximumWeight(10)
    .weigher(new Weigher<Object, Object>() {
                @Override
                public int weigh(Object key, Object value) {
                    //TODO
                    return 0;
                }
    }) //……

三、刷新缓存(reload)

LoadingCache<String, Object> cache = Caffeine.newBuilder()
                //方式二
                .refreshAfterWrite(3,TimeUnit.SECONDS)
                .build(new CacheLoader<String, Object>() {
                    @Override
                    public Object load(String key) throws Exception {
                        return key + "loadValue";
                    }

                    @Override
                    public Object reload(String key, Object oldValue) throws Exception {
                        //该方法默认返回 return CacheLoader.super.reload(key, oldValue)---里面直接调用了this.load(key)方法
                        return key + "reloadValue";
                    }
                });
    //方式一
   cache.refresh("key")

  1. 方式一：通过cache.refresh(“key”)显示刷新，如果key已经被缓存，则执行reload方法重新加载；如果key没有被缓存，则执行load方法加载。

  2. 方式二：通过refreshAfterWrite方法定时刷新，该方法并不是通过额外的线程启动定时任务去刷新，而是依赖查询请求，当我们查询(get/getIfPresent)某个缓存时它会去比对当前时间与该缓存项被写入(创建/覆盖)的时间，如果超过了所设置的时间值，则执行reload方法刷新。

注意：reload方法是通过启动后台线程异步执行的，当前线程依然会立刻返回之前的旧值。当后台线程刷新完成并成功取代之前的旧值后再次获取才是刷新后的新值。

四、监听器

框架提供了缓存项被移除的事件监听机制，通过这种机制我们可以得知哪些缓存项被移除了，因为什么原因被移除的。当然也可以在key被移除时做一些其他操作。

LoadingCache<String, Object> cache = Caffeine.newBuilder()
                .removalListener(new RemovalListener<Object, Object>() {
                    @SneakyThrows
                    @Override
                    public void onRemoval(Object key, Object value, RemovalCause removalCause) {
                        System.out.println(key + ":" + value + "被移除了,原因是：" + removalCause);
                    }
                })//……
  1. SIZE：由于超过缓存最大数量被移除
  2. EXPLICIT: 被显式清除的
  3. EXPIRED：超过过期时间
  4. REPLACED：被取代（比如同一个key连续put两次，第一次的缓存项就是被取代的，还有被刷新等）
  5. COLLECTED：被垃圾收集器收集导致的。

五、外部存储

框架提供CacheWriter接口供我们在写入缓存项和删除缓存项时进行扩展，可以用于操作外部存储。

LoadingCache<String, Object> cache = Caffeine.newBuilder()
                .writer(new CacheWriter<Object, Object>() {
                    //写入缓存后会调用此方法
                    @Override
                    public void write(@NonNull Object key, @NonNull Object value) {
                        //这里可以将缓存的数据写入外部存储
                    }

                    //删除缓存项后会调用此方法
                    @Override
                    public void delete(@NonNull Object key, @Nullable Object value, @NonNull RemovalCause removalCause) {
                        //这里可以删除外部存储
                    }
                })//……

六、SpringBoot集成缓存

上述是Caffeine中的一些常用API使用，在SpringBoot项目中可以直接定义一个个LoadingCache的Bean，然后使用原生API操作缓存。除此之外，也可以使用SpringBoot提供的缓存操作的相关注解，可以简化开发（前提是需要配置**@EnableCaching**开启缓存）。

1. 几个常用的缓存注解

1.1 @Cacheable（最重要的注解）

该注解一般标注在方法上，在方法执行前会先查询缓存，如果命中，则不再目标执行方法，如果没有命中缓存，则目标执行方法，并将方法的返回结果缓存（这里就像上面CaffeineCache的CacheLoad一样，没有命中则执行load方法去加载）。该注解的属性如下：

public @interface Cacheable {
    @AliasFor("cacheNames")
    String[] value() default {};

    //  注定缓存的名字，比如员工缓存可以指定为empCache，学生缓存可以指定为stuCache。这些Cache都被CacheManager管理
    @AliasFor("value")
    String[] cacheNames() default {};

    //指定缓存的key，默认使用的是方法的参数值。支持SpEL写法
    String key() default "";

    //指定缓存key的生成器来生成key。若同时指定了key属性，则使用key属性指定的key
    String keyGenerator() default "";

    //指定缓存管理器
    String cacheManager() default "";

    //指定缓存解析器(与cacheManager功能一样)
    String cacheResolver() default "";

    //指定符合条件的情况下才缓存，支持SpEL写法
    String condition() default "";

    //否定缓存。当unless的条件为true，则不会被缓存。可以对结果进行判断，如unless="#result == null"(表示结果为null则不缓存)，支持SpEl写法。
    String unless() default "";

    //是否需要异步去缓存
    boolean sync() default false;
}

CacheManager定义了创建、配置、获取、管理和控制多个唯一命名的Cache，这些Cache存在于CacheManager的上下文中。
上述部分属性可以通过SpEL指定，Spring Cache提供了一些供我们使用的SpEL上下文数据，如下：

名称位置描述示例
methodNameroot对象当前被调用的方法名#root.methodname
methodroot对象当前被调用的方法#root.method.name
targetroot对象当前被调用的目标对象实例#root.target
targetClassroot对象当前被调用的目标对象的类#root.targetClass
argsroot对象当前被调用的方法的参数列表#root.args[0]
cachesroot对象当前方法调用使用的缓存列表#root.caches[0].name
Argument Name执行上下文当前被调用的方法的参数，如findArtisan(Artisan artisan),可以通过#artsian.id获得参数#artsian.id
result执行上下文方法执行后的返回值（仅当 方法执行后 的判断有效，如 unless cacheEvict的beforeInvocation=false）#result

使用如下：

@Cacheable(cacheNames = {"person"}, key = "#tid", cacheManager = "cacheManager")
public Person getPerson(String tid){
	return DBData.selectPerson(tid);
}

上面通过key属性指定了key，除此之外还可以实现KeyGenerator接口来指定key的生成规则。

@FunctionalInterface
public interface KeyGenerator {
	/**
	 * target：目标方法的对象实例
	 * method：目标方法
	 * args：目标方法的执行参数
	 * @return：key
     */
    Object generate(Object target, Method method, Object... args);
}

1.2 @CacheEvict

该注解一般标注在方法上，作用是清除缓存，当方法内对数据进行更新、删除操作的时候，那就需要用到它来清除缓存。否则将拿到旧数据。

public @interface CacheEvict {
    @AliasFor("cacheNames")
    String[] value() default {};
	//指定缓存
    @AliasFor("value")
    String[] cacheNames() default {};
    // 指定要清除的key
    String key() default "";
    //设置为true则表示清空缓存
    boolean allEntries() default false;
    //缓存的清除是否在方法执行之前，默认在方法执行成功之后执行
    boolean beforeInvocation() default false;
   //……
}

1.3 @CacheConfig

该注解只能标注在类上，用于指定缓存属性的全局配置。像上面@Cacheable、@CacheEvict注解如果每次使用都需要指定cacheNames属性的配置，而且这些cacheNames都一样，那就可以使用@CacheConfig将公共的配置提取到类上，改类的方法就默认以全局配置为主，不需要二次配置。

public @interface CacheConfig {
    String[] cacheNames() default {};
    String keyGenerator() default "";
    String cacheManager() default "";
    String cacheResolver() default "";
}

1.4 @CachePut

该注解一般标注在方法上，作用是会将被注解方法的返回值进行缓存。利用该注解也可以做缓存的更新。

1.5 @Caching

该注解是上面三种注解的组合注解，如果缓存规则比较复杂，可以使用它。

public @interface Caching {
    Cacheable[] cacheable() default {};
    CachePut[] put() default {};
    CacheEvict[] evict() default {};
}

2. 集成Caffeine作为缓存框架

SpringBoot默认使用ConcurrentMapCache,内部使用ConcurrentHashMap作缓存。当我们引入Caffeine的依赖之后，SpringBoot中的CaffeineCacheConfiguration就会生效，就会自动装配CaffeineCacheManager，则内部使用的缓存框架就变成Caffeine。默认的CaffeineCacheManager如下：

@Bean
CaffeineCacheManager cacheManager(CacheProperties cacheProperties, CacheManagerCustomizers customizers, ObjectProvider<Caffeine<Object, Object>> caffeine, ObjectProvider<CaffeineSpec> caffeineSpec, ObjectProvider<CacheLoader<Object, Object>> cacheLoader) {
	CaffeineCacheManager cacheManager = this.createCacheManager(cacheProperties, caffeine, caffeineSpec, cacheLoader);
	List<String> cacheNames = cacheProperties.getCacheNames();
	if (!CollectionUtils.isEmpty(cacheNames)) {
		cacheManager.setCacheNames(cacheNames);
	}
	return (CaffeineCacheManager)customizers.customize(cacheManager);
}

private CaffeineCacheManager createCacheManager(CacheProperties cacheProperties, ObjectProvider<Caffeine<Object, Object>> caffeine, ObjectProvider<CaffeineSpec> caffeineSpec, ObjectProvider<CacheLoader<Object, Object>> cacheLoader) {
	CaffeineCacheManager cacheManager = new CaffeineCacheManager();
	this.setCacheBuilder(cacheProperties, (CaffeineSpec)caffeineSpec.getIfAvailable(), (Caffeine)caffeine.getIfAvailable(), cacheManager);
	cacheLoader.ifAvailable(cacheManager::setCacheLoader);
	return cacheManager;
}

当然我们可以自己配置一个缓存管理器的Bean，那么自动配置类CaffeineCacheConfiguration就不会生效，让其内部维护CaffeineCache即可。此处配置CaffeineCacheManager的Bean，如下：

@EnableCaching
@Configuration
public class CacheConfiguration {
    /**
     * 配置缓存管理器
     */
    @Bean("caffeineCacheManager")
    public CacheManager cacheManager() {
        CaffeineCacheManager cacheManager = new CaffeineCacheManager();
        cacheManager.setCaffeine(Caffeine.newBuilder()
                .expireAfterAccess(20, TimeUnit.SECONDS)
                .initialCapacity(10)
                .weakValues()
                .maximumSize(100));
		cacheManager.setCacheLoader(new CacheLoader<Object, Object>() {
            @Override
            public Object load(Object o) throws Exception {
                //从redis中读取缓存项，如果redis中没有则返回null，null不会被缓存。
                // 那么就会执行@Cacheable注解的方法，从DB中读
                return null;
            }
        });
        return cacheManager;
    }
}
落英神剑碧海潮生
关注
专栏目录
【分布式缓存】springboot整合jetcache使用详解
congge
07-18 5477
springboot整合jetcache使用详解
Spring Boot使用Caffeine实现缓存管理 | Spring Cloud 39
热门推荐
gmHappy
04-25 1万+
`SpringCache`框架还提供了`CacheManager`接口，可以实现降低对各种缓存框架的耦合。它不是具体的缓存实现，它只提供一整套的接口和代码规范、配置、注解等，用于整合各种缓存方案，比如`Caffeine`、`Guava Cache`、`Ehcache`、`Redis`等。
springboot集成spring cache缓存示例代码
08-30
本篇文章主要介绍了springboot集成spring cache示例代码，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
Java 本地缓存CaffeineCache简单使用案例
weixin_43969830的博客
01-16 1346
Java 本地缓存CaffeineCache简单使用案例,SimpleCacheManager和CaffeineCacheManager两种方式。
高性能 Java 本地缓存 Caffeine 框架介绍及在 SpringBoot 中的使用
最新发布
栗筝i的博客
07-26 1496
Caffeine 是一个用于 Java 的缓存库，其设计目标是高性能，和近乎最佳的命中率。缓存库的主要功能是存储和快速检索数据，以减少直接访问数据源（例如数据库或远程服务）的次数，从而提高应用程序的性能。Caffeine 的 “高性能” 表示它在处理缓存操作时速度很快，并且占用的资源较少。“近乎最佳的命中率” 指的是 Caffeine 在缓存命中（即请求的数据已经存在于缓存中）方面表现非常出色。高命中率意味着大多数数据请求都可以直接从缓存中获得，而无需访问原始数据源，从而大大提高了效率和响应速度。
caffeine缓存的使用
qq_44871116的博客
04-02 2227
caffeine
缓存之王Caffeine Cache，性能比Guava更强，命中率更高！
大数据星球-浪尖
03-18 952
在项目开发中，为提升系统性能，减少 IO 开销，本地缓存是必不可少的。最常见的本地缓存是 Guava 和 Caffeine，本篇文章将为大家介绍 Caffeine。Caffeine 是基于...
Caffeine Cache使用说明
独自哭泣的专栏
04-23 1万+
原文作者：IT码徒 Guava Cache，他的优点是封装了get，put操作；提供线程安全的缓存操作；提供过期策略；提供回收策略；缓存监控。 当缓存的数据超过最大值时，使用LRU算法替换。这里我们将要谈到一个新的本地缓存框架：Caffeine Cache。它也是站在巨人的肩膀上-Guava Cache，借着他的思想优化了算法发展而来。 本篇博文主要介绍Caffine Cache 的使用方式，以及Caffine Cache在SpringBoot中的使用。 1.Caf...
caffeine cache
ZERO
04-15 2546
转载自：https://blog.csdn.net/rlnLo2pNEfx9c/article/details/85241639   guava cache的功能的确是很强大，满足了绝大多数的人的需求，但是其本质上还是LRU的一层封装,所以在众多其他较为优良的淘汰算法中就相形见绌了。而caffeine cache实现了W-TinyLFU(LFU+LRU算法的变种)。W-TinyLFU是命中率最接近...
SpringBoot 集成缓存性能之王 Caffeine
JavaMonsterr的博客
06-21 123
使用缓存的目的就是提高性能，今天码哥带大家实践运用 抽象的缓存组件去集成本地缓存性能之王 。大家需要注意的是： 缓存 只适合在单体应用，不适合与分布式环境 。分布式环境的情况下需要将缓存修改同步到每个节点，需要一个同步机制保证每个节点缓存数据最终一致。不使用 Spring Cache 抽象的缓存接口，我们需要根据不同的缓存框架去实现缓存，需要在对应的代码里面去对应缓存加载、删除、更新等。比如查询我们使用 旁路缓存策略 ：先从缓存中查询数据，如果查不到则从数据库查询并写到缓存中。伪代码如下： publi
spring-boot-redis-guava-caffeine-cache:springboot 使用 redis guava caffeine 缓存示例
05-17
本项目"spring-boot-redis-guava-caffeine-cache"主要探讨了如何在Spring Boot应用中集成Redis、Guava和Caffeine三种不同的缓存策略。 首先，Redis是一款开源的内存数据结构存储系统，常被用作数据库、缓存和消息...
spring boot+spring cache实现两级缓存(redis+caffeine)
08-27
Spring Boot中集成了Spring Cache，并有多种缓存方式的实现，如：Redis、Caffeine、JCache、EhCache等等。如果只用一种缓存，要么会有较大的网络消耗（如Redis），要么就是内存占用太大（如Caffeine这种应用内存缓存...
Caffeine Cache~高性能 Java 本地缓存之王
芋艿V
08-21 331
点击上方“芋道源码”，选择“设为星标”管她前浪，还是后浪？能浪的浪，才是好浪！每天 8:55 更新文章，每天掉亿点点头发...源码精品专栏原创 | Java 2020 超神之路，很肝~...
Caffeine入门使用
l_dongyang的博客
09-08 1万+
目录一、概况简介：优点：二、使用坐标缓存填充策略过期策略时间监听外部存储springboot集成三、参考文档功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 一、概况 就一般的互联网行业中的应用而言，目前比较通用的并且也是普遍存在的
浅入浅出Caffeine cache
weixin_40413961的博客
07-24 1296
背景 公司项目中有用到caffeine cache 所以来了解一下。 本地缓存也就是我们适用内存缓存一些热点数据，使应用程序的程序处理的更加的快。以及保护我们的一些有IO操作的函数/方法，以达到提高我们应用程序吞吐的目的。 对于java技术栈来讲我们通常使用到的本地缓存都有 一些原有的容器HashMap，google的guava cache等等。今天了解一下caffine缓存。 简介 Caffeine 是基于Java 8 开发的、提供了近乎最佳命中率的高性能本地缓存组件，Spring5 开始不再支持 Gua
真正的缓存之王Caffine Cache
felix
06-20 258
真正的缓存之王
Caffeine Cache-高性能Java本地缓存组件
竹林幽深
02-15 799
https://mp.weixin.qq.com/s/m8DwlimtJs8ezl5hOXj37w
SpringBoot缓存之Caffeine
MyHerux的博客
04-11 3290
SpringBoot缓存之Caffeine Springboot 对缓存的支持 Spring Framework 支持透明地向应用程序添加缓存。从本质上讲，抽象将缓存应用于方法，从而根据缓存中可用的信息减少执行次数。缓存逻辑是透明应用的，不会对调用者造成任何干扰。只要通过 @EnableCaching 批注启用了缓存支持，Spring Boot 就会自动配置缓存基础结构。 比如： import o...
SpringBoot集成Caffeine 缓存
weixin_45926962的博客
11-06 1214
caffeine
springboot集成caffeine缓存
04-18
非常感谢您的提问！关于springboot集成caffeine缓存的问题，我可以提供以下思路： 1. 首先，在pom.xml中添加caffeine依赖： ``` <dependency> <groupId>com.github.ben-manes.caffeine</groupId> <artifactId>caffeine</artifactId> <version>2.6.0</version> </dependency> ``` 2. 接着，在application.yml中配置caffeine缓存，默认的caffeine配置如下： ``` spring.cache.type=caffeine spring.cache.caffeine.spec=maximumSize=500, expireAfterAccess=5m, expireAfterWrite=5m, recordStats ``` 其中，maximumSize表示缓存最大容量，expireAfterAccess表示访问后缓存的过期时间，expireAfterWrite表示写入后缓存的过期时间。 3. 最后，在代码中使用@Cacheable注解即可使用caffeine缓存，示例如下： ``` @Cacheable(value = "myCache", key = "#userId") public User getUserById(String userId) { // 缓存中不存在，则从数据库中查询 User user = userRepository.findByUserId(userId); return user; } ``` 希望以上思路对您有帮助！ありがとうございました！
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值