springboot集成本地缓存Caffeine的三种使用方式

最新推荐文章于 2023-05-15 14:36:07 发布
最新推荐文章于 2023-05-15 14:36:07 发布
阅读量4.7k 收藏 17
点赞数 4
分类专栏： springboot 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41921994/article/details/109313445
版权

第一种方式（只使用Caffeine）

  1. gradle添加依赖

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-jdbc'
    implementation 'org.springframework.boot:spring-boot-starter-thymeleaf'
    implementation 'org.springframework.boot:spring-boot-starter-web'
    implementation 'org.mybatis.spring.boot:mybatis-spring-boot-starter:2.1.3'
    runtimeOnly 'mysql:mysql-connector-java'
    compileOnly 'org.projectlombok:lombok'
    annotationProcessor 'org.projectlombok:lombok'
    testImplementation('org.springframework.boot:spring-boot-starter-test') {
        exclude group: 'org.junit.vintage', module: 'junit-vintage-engine'
    }
    compile group: 'com.github.ben-manes.caffeine', name: 'caffeine', version: '2.8.4'
//    compile('org.springframework.boot:spring-boot-starter-cache')
}
  1. 编写配置类
package org.example.base.config;

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;

/**
 * @author l
 * @date Created in 2020/10/27 11:05
 */
@Configuration
//@EnableCaching
public class CacheConfig {


    @Bean(value = "caffeineCache")
    public Cache<String, Object> caffeineCache() {
        return Caffeine.newBuilder()
                // 设置最后一次写入或访问后经过固定时间过期
                .expireAfterWrite(60, TimeUnit.SECONDS)
                // 初始的缓存空间大小
                .initialCapacity(1000)
                // 缓存的最大条数
                .maximumSize(10000)
                .build();

    }

    @Bean(value = "caffeineCache2")
    public Cache<String, Object> caffeineCache2() {
        return Caffeine.newBuilder()
                // 设置最后一次写入或访问后经过固定时间过期
                .expireAfterWrite(120, TimeUnit.SECONDS)
                // 初始的缓存空间大小
                .initialCapacity(1000)
                // 缓存的最大条数
                .maximumSize(10000)
                .build();

    }


}
  1. 测试
package org.example.base;

import com.github.benmanes.caffeine.cache.Cache;
import org.example.base.bean.User;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
class BaseApplicationTests {

	@Qualifier("caffeineCache")
	@Autowired
    Cache<String, Object> cache;


	@Qualifier("caffeineCache2")
	@Autowired
	Cache<String, Object> cache2;

    @Test
    public void test() {
        User user = new User(1, "张三", 18);
        cache.put("123", user);
        User user1 = (User) cache.getIfPresent("123");
        assert user1 != null;
        System.out.println(user1.toString());
        User user2 = (User) cache2.getIfPresent("1234");
        System.out.println(user2 == null);
    }






}
  1. 输出
    在这里插入图片描述

第二种方式(使用Caffeine和spring cache)

  1. gradle添加依赖
dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-jdbc'
    implementation 'org.springframework.boot:spring-boot-starter-thymeleaf'
    implementation 'org.springframework.boot:spring-boot-starter-web'
    implementation 'org.mybatis.spring.boot:mybatis-spring-boot-starter:2.1.3'
    runtimeOnly 'mysql:mysql-connector-java'
    compileOnly 'org.projectlombok:lombok'
    annotationProcessor 'org.projectlombok:lombok'
    testImplementation('org.springframework.boot:spring-boot-starter-test') {
        exclude group: 'org.junit.vintage', module: 'junit-vintage-engine'
    }
    compile group: 'com.github.ben-manes.caffeine', name: 'caffeine', version: '2.8.4'
    compile('org.springframework.boot:spring-boot-starter-cache')
}
  1. 编写配置类
package org.example.base.config;

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.time.Duration;
import java.util.ArrayList;


/**
 * @author l
 * @date Created in 2020/10/27 11:05
 */
@Configuration
@EnableCaching
public class CacheConfig {


    public enum CacheEnum {
        /**
         * @date 16:34 2020/10/27
         * 第一个cache
         **/
        FIRST_CACHE(300, 20000, 300),
        /**
         * @date 16:35 2020/10/27
         * 第二个cache
         **/
        SECOND_CACHE(60, 10000, 200);

        private int second;
        private long maxSize;
        private int initSize;

        CacheEnum(int second, long maxSize, int initSize) {
            this.second = second;
            this.maxSize = maxSize;
            this.initSize = initSize;
        }

    }

    @Bean("caffeineCacheManager")
    public CacheManager cacheManager() {
        SimpleCacheManager cacheManager = new SimpleCacheManager();
        ArrayList<CaffeineCache> caffeineCaches = new ArrayList<>();
        for (CacheEnum cacheEnum : CacheEnum.values()) {
            caffeineCaches.add(new CaffeineCache(cacheEnum.name(),
                    Caffeine.newBuilder().expireAfterWrite(Duration.ofSeconds(cacheEnum.second))
                            .initialCapacity(cacheEnum.initSize)
                            .maximumSize(cacheEnum.maxSize).build()));
        }
        cacheManager.setCaches(caffeineCaches);
        return cacheManager;
    }

//    @Bean("FIRST_CACHE")
//    public Cache firstCache(CacheManager cacheManager) {
//        return cacheManager.getCache("FIRST_CACHE");
//    }
//
//    @Bean("SECOND_CACHE")
//    public Cache secondCache(CacheManager cacheManager) {
//        return cacheManager.getCache("SECOND_CACHE");
//    }

}
  1. 编写service层
package org.example.base.service.impl;

import org.example.base.bean.User;
import org.example.base.service.UserService;
import org.springframework.boot.CommandLineRunner;
import org.springframework.cache.Cache;
import org.springframework.cache.CacheManager;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;

/**
 * @author l
 * @date Created in 2020/10/23 14:47
 */
@Service
public class UserServiceImpl implements UserService, CommandLineRunner {


    @Resource(name = "caffeineCacheManager")
    CacheManager cacheManager;
    Cache cache1;
    Cache cache2;
    
//    @Qualifier("FIRST_CACHE")
//    Cache cache1;
//    @Qualifier("SECOND_CACHE")
//    Cache cache2;
    @Override
    public void run(String... args) throws Exception {
        cache1 = cacheManager.getCache("FIRST_CACHE");
        cache2 = cacheManager.getCache("SECOND_CACHE");
    }

    @Override
    public void setUser(User user) {
        cache2.put("123",user);
    }

    @Override
    public User getUser(String id) {
        Cache.ValueWrapper valueWrapper = cache2.get(id);
        assert valueWrapper != null;
        return (User)valueWrapper.get();
    }





}
  1. 测试
package org.example.base;

import org.example.base.bean.User;
import org.example.base.service.UserService;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
class BaseApplicationTests {

    @Autowired
    private UserService userService;

    @Test
    public void test() {
        User user = new User(123,"jack l",18);
        userService.setUser(user);
        System.out.println(userService.getUser("123"));
    }


}
  1. 输出结果

在这里插入图片描述

第三种方式(使用Caffeine和spring cache)

  1. gradle依赖添加同方式二
  2. 配置类添加方式同方式二
  3. 编写service层
package org.example.base.service.impl;

import org.example.base.bean.User;
import org.example.base.service.UserService;
import org.springframework.cache.annotation.CacheConfig;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.CachePut;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;


/**
 * @author l
 * @date Created in 2020/10/23 14:47
 */
@Service
//@CacheConfig(cacheNames = "SECOND_CACHE",cacheManager = "caffeineCacheManager")
public class UserServiceImpl implements UserService {

    /**
     * 使用@CachePut注解的方法，一定要有返回值，该注解声明的方法缓存的是方法的返回结果。
     * it always causes the
     * method to be invoked and its result to be stored in the associated cache
     **/
    @Override
    @CachePut(key = "#user.getId()", value = "SECOND_CACHE", cacheManager = "caffeineCacheManager")
    public User setUser(User user) {
        System.out.println("已经存储进缓存了");
        return user;
    }

    @Override
    @CacheEvict(value = "SECOND_CACHE",cacheManager = "caffeineCacheManager")
    public void deleteUser(Integer id) {
        System.out.println("缓存删除了");
    }

    @Override
    @Cacheable(key = "#id", value = "SECOND_CACHE", cacheManager = "caffeineCacheManager")
    public User getUser(Integer id) {
        System.out.println("从数据库取值");
        //模拟数据库中的数据
       return null;
    }


}
  1. 测试
package org.example.base;

import org.example.base.bean.User;
import org.example.base.service.UserService;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
class BaseApplicationTests {

    @Autowired
    private UserService userService;


    @Test
    public void test4(){
        User user1 = new User(123, "jack l", 18);
        userService.setUser(user1);
        System.out.println("从缓存中获取 "+userService.getUser(123));
        System.out.println(userService.getUser(123322222));
        userService.deleteUser(123);
        System.out.println(userService.getUser(123));

    }


}
  1. 输出结果

在这里插入图片描述

冬风孤立
关注
  • 4
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
Spring Boot缓存实战 Caffeine示例
08-27
本篇文章主要介绍了Spring Boot缓存实战 Caffeine示例，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
Spring Boot 整合 Caffeine 本地缓存及 Spring Cache 注解的使用
qq_45607784的博客
01-05 1818
在现代的Web应用程序中，缓存是提高性能和响应速度的重要手段之一。Spring Boot提供了对缓存的良好支持，并且可以轻松地整合Caffeine本地缓存作为缓存提供者。结合Spring Cache注解，可以实现对方法级别的缓存，从而提高系统的性能和响应速度。
SpringBoot入门建站全系列（十三）本地缓存的使用(Ehcache和caffeine的使用)
feiyangtianyao的专栏
06-28 1051
SpringBoot入门建站全系列（十三）本地缓存的使用(Ehcache和caffeine的使用) 一、概述 本地缓存，就是使用应用内使用本地内存将数据暂缓存储，一般数据库的查询如果不怎么改动，可以用本地缓存暂存。 远程缓存，比如redis，就是第三方缓存服务器，不是在当前应用的，需要用过tcp请求去获得的缓存。 Springboot的官方文档中列出了9种： Generic JCache (JS...
springboot学习(十二)：缓存caffeine的使用
wds的博客
01-13 1万+
说明 在上篇博文中，我使用了guava作为spring的本地缓存，来实现在加载数据到本地的需求。在这个篇博文中，我将记录总结使用caffeine作为本地缓存。在spring5后，spring官方放弃了guava，而使用了性能更优秀的caffeine，本篇将结合springboot2.x来实现caffeine的使用。了解有关caffeine的详细内容请见caffeine。 正文 1.CachePro...
SpringBoot 使用 @Cacheable 进行缓存与取值
weixin_42116127的博客
04-19 3295
1. @Cacheable的作用 缓存使用步骤：@Cacheable这个注解，用它就是为了使用缓存的。所以我们可以先说一下缓存的使用步骤： 开启基于注解的缓存，使用 @EnableCaching 标识在 SpringBoot 的主启动类上。 标注缓存注解即可 第一步：开启基于注解的缓存，使用 @EnableCaching 标注在 springboot 主启动类上 //开启基于注解的缓存 @EnableCaching @EnableRyFeignClients @SpringBootApplicat
SpringBoot 缓存 Caffeine使用
西凉的悲伤博客
03-18 5523
Redis和Caffeine的区别 相同点： 两个都是缓存的方式 不同点： redis是分布式缓存，通过网络将数据存储到redis服务器内存里 caffeine是将数据存储在本地应用里 caffeine和redis相比，没有了网络IO上的消耗 联系： 一般将两者结合起来，形成一二级缓存。 使用流程大致如下： 先去一级缓存中查找数据（caffeine-本地应用内）， 如果没有的话，去二级缓存中查找数据（redis-内存）， 再没有，再去数据库中查找数据（数据库-磁盘） Spring Boot
SpringBoot整合Caffeine
weixin_55850954的博客
05-15 3763
Caffeine 是基于Java 8 开发的、提供了近乎最佳命中率的高性能本地缓存组件，Spring5 开始不再支持 Guava Cache，改为使用 Caffeine。Caffeine与其他本地缓存的性能比较如下：1 . 自动加载条目到缓存中，可选异步方式2 . 可以基于大小剔除3 . 可以设置过期时间，时间可以从上次访问或上次写入开始计算4 . 异步刷新5 . keys自动包装在弱引用中6 . values自动包装在弱引用或软引用中7 . 条目剔除通知8 . 缓存访问统计。
Spring Boot缓存实战 Caffeine
TamdingDojee的博客
01-07 1607
参考： https://memorynotfound.com/spring-boot-caffeine-caching-example-configuration/ http://blog.csdn.net/ClementAD/article/details/53009899 http://www.bijishequ.com/detail/419479?p= http://xp-developer.com/html/springboot/IV.%20Spring%20Boot%20features/
SpringBoot：使用Caffeine实现缓存
JavaMonsterr的博客
06-29 3814
在本博客中，我们将探讨如何使用Spring的缓存框架向任何Spring Boot应用程序添加基本缓存支持，如果没有正确实现，还将探讨缓存的一些问题。最后但并非最不重要的一点是，我们将看几个在真实场景中有用的缓存示例。在深入探讨如何向应用程序添加缓存之前，首先想到的问题是为什么我们需要在应用程序中使用缓存。假设有一个包含客户数据的应用程序，用户发出两个请求来获取客户的数据（id=100）。这就是没有缓存时的情况。如您所见，对于每个请求，应用程序都会转到数据库获取数据。从数据库获取数据是一项成本高昂的操作，因为
springboot Caffeine 详解（一篇就明白）
热门推荐
dgh112233的博客
07-23 1万+
1、添加依赖 首先考虑添加 maven 依赖。 <dependency> <groupId>com.github.ben-manes.caffeine</groupId> <artifactId>caffeine</artifactId> <version>2.6.2</version> </d
springboot 使用 redis guava caffeine 缓存示例.zip
最新发布
02-03
springboot 使用 redis guava caffeine 缓存示例
springboot本地缓存（guava与caffeine）.docx
12-27
springboot本地缓存（guava与caffeine）.docx
Caffeine本地缓存
04-27
Caffeine本地缓存的配置与使用
spring-boot-redis-guava-caffeine-cache:springboot 使用 redis guava caffeine 缓存示例
05-17
springboot使用redis做数据缓存
本地缓存之王Caffeine 保姆级教程（值得珍藏）
01-27
Caffeine是一种非常优秀的本地缓存解决方案，而Redis则广泛用于分布式缓存场景。 Caffeine是一个基于Java 1.8的高性能本地缓存库，源自Guava的改进。自Spring 5开始，Caffeine已成为默认的缓存实现，取代了原先的...
spring boot+spring cache实现两级缓存(redis+caffeine)
08-27
主要介绍了spring boot+spring cache实现两级缓存(redis+caffeine)，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
详细介绍高性能Java缓存库Caffeine
08-28
本篇文章主要介绍了详细介绍高性能Java缓存库Caffeine，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
java编程之Caffeine缓存
12-16
Caffeine是本地缓存，也就是和本机内存交互，读取和存入缓存在本机内存 缓存包括本地缓存和分部署缓存，对于本地缓存而言，不需要考虑集群问题，因为本地缓存就是指服务器的缓存。 ### 注解 @Cacheable：...
caffeine：Java 8的高性能缓存库
02-18
Caffeine是基于Java 8的，缓存库。有关更多详细信息，请参见我们的并浏览以获取最新版本。 快取 咖啡因使用受Google Guava启发的API提供内存中缓存。 这些改进基于我们设计和经验。 LoadingCache< Key> graphs = ...
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; } ``` 希望以上思路对您有帮助！ありがとうございました！

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值