springboot集成使用caffeine本地缓存

最新推荐文章于 2024-03-14 15:37:13 发布
最新推荐文章于 2024-03-14 15:37:13 发布
阅读量1.1k 收藏 6
点赞数 1
分类专栏： spring boot caffeine 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ninghq/article/details/109193244
版权

一、springboot集成caffeine方法一

1、引入依赖

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

2、配置缓存配置类

/**
 * @ClassName CacheConfig
 * @Description 缓存配置类
 * @Author ninghq
 * @Date 2020/10/19 16:30
 * @Version 1.0.0
 **/
@Configuration
public class CacheConfig {

    @Bean
    public Cache<String, Object> caffeineCache() {
        return Caffeine.newBuilder()
                // 设置最后一次写入或访问后经过固定时间过期
                .expireAfterWrite(60, TimeUnit.SECONDS)
                // 初始的缓存空间大小
                .initialCapacity(100)
                // 缓存的最大条数
                .maximumSize(1000)
                //缓存写入/删除 监控
                .writer(new CacheWriter<Object, Object>() {
                    @Override
                    public void write(Object key, Object value) { //此方法是同步阻塞的
                        System.out.println("--缓存写入--:key=" + key + ", value=" + value);
                    }
                    @Override
                    public void delete(Object key, Object value, RemovalCause cause) {
                        System.out.println("--缓存删除--:key=" + key);
                    }
                })
                .build();
    }

}

3、创建相关测试类

创建UserInfo实体类
public class UserInfo {

    private Integer id;
    private String name;
    private String sex;
    private Integer age;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }
}

 

 

创建service测试类

@Service
public class CacheService {

    private Logger log = LoggerFactory.getLogger(CacheService.class);

    @Autowired
    private CacheDao cacheDao;

    @Autowired
    Cache<String, Object> caffeineCache;

    /**
     * 获取用户信息
     * @param id 用户ID
     * @return   用户信息
     */
    public UserInfo getByName(Integer id) {
        // 先从缓存读取
        caffeineCache.getIfPresent(id);
        UserInfo userInfo = (UserInfo) caffeineCache.asMap().get(String.valueOf(id));
        if (userInfo != null){
            return userInfo;
        }
        // 如果缓存中不存在，则从库中查找
        log.info("get");
        UserInfo userInfo = cacheDao.get(id);
        // 如果用户信息不为空，则加入缓存
        if (userInfo != null){
            caffeineCache.put(String.valueOf(userInfo.getId()), userInfo);
        }
        return userInfo;
    }


    /**
     * 修改用户信息
     * @param userInfo 用户信息
     * @return         用户信息
     */
    public UserInfo updateUserInfo(UserInfo userInfo) {
        log.info("update");
        // 取旧的值
        UserInfo oldUserInfo = cacheDao.get(userInfo.getId());
        if (oldUserInfo == null) {
            return null;
        }
        // 替换内容
        if (!StringUtils.isEmpty(oldUserInfo.getAge())) {
            oldUserInfo.setAge(userInfo.getAge());
        }
        if (!StringUtils.isEmpty(oldUserInfo.getName())) {
            oldUserInfo.setName(userInfo.getName());
        }
        if (!StringUtils.isEmpty(oldUserInfo.getSex())) {
            oldUserInfo.setSex(userInfo.getSex());
        }
        // 将新的对象存储，更新旧对象信息
        cacheDao.put(userInfo);
        // 替换缓存中的值
        caffeineCache.put(String.valueOf(oldUserInfo.getId()),oldUserInfo);
        return oldUserInfo;
    }

    /**
     * 删除用户信息
     * @param id  用户ID
     */
    public void deleteById(Integer id) {
        log.info("delete");
        cacheDao.remove(id);
        // 从缓存中删除
        caffeineCache.asMap().remove(String.valueOf(id));
    }


}

 

创建Dao测试类

public interface CacheDao {

    @Select("select * from `user_info` WHERE `id` = #{id};")
    UserInfo get(int id);

    @Update(" UPDATE `user_info` SET `name` = #{name}, `sex` = #{sex}, `age` = #{age} WHERE `id` = #{id}; ")
    int put(UserInfo userInfo);

    @Delete(" delete from `user_info` WHERE `id` = #{id}; ")
    void remove(Integer id);
}

 

创建Controller测试类

@RestController
@RequestMapping("/v1/cache")
public class CacheController {

    @Autowired
    private CacheService cacheService;


    @GetMapping("/userInfo/{id}")
    public Object getUserInfo(@PathVariable Integer id) {
        UserInfo userInfo = cacheService.getByName(id);
        if (userInfo == null) {
            return "没有该用户";
        }
        return userInfo;
    }

    @PutMapping("/userInfo")
    public Object updateUserInfo(@RequestBody UserInfo userInfo) {
        UserInfo newUserInfo = cacheService.updateUserInfo(userInfo);
        if (newUserInfo == null){
            return "不存在该用户";
        }
        return newUserInfo;
    }

    @DeleteMapping("/userInfo/{id}")
    public Object deleteUserInfo(@PathVariable Integer id) {
        cacheService.deleteById(id);
        return "SUCCESS";
    }



}

 

二、springboot集成caffeine方法二

1、引入依赖

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

<!-- springboot缓存 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-cache</artifactId>
</dependency>

 

2、配置缓存配置类

@Configuration
public class CacheConfig {

    /**
     * 配置缓存管理器
     *
     * @return 缓存管理器
     */
    @Bean("caffeineCacheManager")
    public CacheManager cacheManager() {
        CaffeineCacheManager cacheManager = new CaffeineCacheManager();
        cacheManager.setCaffeine(Caffeine.newBuilder()
                // 设置最后一次写入或访问后经过固定时间过期
                .expireAfterAccess(60, TimeUnit.SECONDS)
                //缓存写入/删除 监控
                .writer(new CacheWriter<Object, Object>() {
                    @Override
                    public void write(Object key, Object value) { //此方法是同步阻塞的
                        System.out.println("--缓存写入--:key=" + key + ", value=" + value);
                    }
                    @Override
                    public void delete(Object key, Object value, RemovalCause cause) {
                        System.out.println("--缓存删除--:key=" + key);
                    }
                })
                // 初始的缓存空间大小
                .initialCapacity(100)
                // 缓存的最大条数
                .maximumSize(1000));
        return cacheManager;
    }
}

 

3、启动类配置缓存注解

新增注解@EnableCaching


@SpringBootApplication
@MapperScan("com.example.demo.dao")
@EnableCaching
public class DemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }

}

4、创建相关测试类

创建UserInfo实体类

public class UserInfo {

    private Integer id;
    private String name;
    private String sex;
    private Integer age;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }
}

 

创建service类

@Service
@CacheConfig(cacheNames = "caffeineCacheManager")
public class CacheService {

    private Logger log = LoggerFactory.getLogger(CacheService.class);

    @Autowired
    private CacheDao cacheDao;

    /**
     * 获取用户信息
     * @param id 用户ID
     * @return   用户信息
     */
    @Cacheable(key = "#id")
    public UserInfo getByName(Integer id) {
        log.info("get");
        UserInfo userInfo = cacheDao.get(id);
        return userInfo;
    }


    /**
     * 修改用户信息
     * @param userInfo 用户信息
     * @return         用户信息
     */
    @CachePut(key = "#userInfo.id")
    public UserInfo updateUserInfo(UserInfo userInfo) {
        log.info("update");
        // 取旧的值
        UserInfo oldUserInfo = cacheDao.get(userInfo.getId());
        if (oldUserInfo == null) {
            return null;
        }
        // 替换内容
        if (!StringUtils.isEmpty(oldUserInfo.getAge())) {
            oldUserInfo.setAge(userInfo.getAge());
        }
        if (!StringUtils.isEmpty(oldUserInfo.getName())) {
            oldUserInfo.setName(userInfo.getName());
        }
        if (!StringUtils.isEmpty(oldUserInfo.getSex())) {
            oldUserInfo.setSex(userInfo.getSex());
        }
        cacheDao.put(userInfo);
        return oldUserInfo;
    }

    /**
     * 删除用户信息
     * @param id  用户ID
     */
    @CacheEvict(key = "#id")
    public void deleteById(Integer id) {
        log.info("delete");
        cacheDao.remove(id);
    }


}

 

创建Dao类

public interface CacheDao {

    @Select("select * from `user_info` WHERE `id` = #{id};")
    UserInfo get(int id);

    @Update(" UPDATE `user_info` SET `name` = #{name}, `sex` = #{sex}, `age` = #{age} WHERE `id` = #{id}; ")
    int put(UserInfo userInfo);

    @Delete(" delete from `user_info` WHERE `id` = #{id}; ")
    void remove(Integer id);
}

创建Controller测试类

@RestController
@RequestMapping("/v1/cache")
public class CacheController {

    @Autowired
    private CacheService cacheService;


    @GetMapping("/userInfo/{id}")
    public Object getUserInfo(@PathVariable Integer id) {
        UserInfo userInfo = cacheService.getByName(id);
        if (userInfo == null) {
            return "没有该用户";
        }
        return userInfo;
    }

    @PutMapping("/userInfo")
    public Object updateUserInfo(@RequestBody UserInfo userInfo) {
        UserInfo newUserInfo = cacheService.updateUserInfo(userInfo);
        if (newUserInfo == null){
            return "不存在该用户";
        }
        return newUserInfo;
    }

    @DeleteMapping("/userInfo/{id}")
    public Object deleteUserInfo(@PathVariable Integer id) {
        cacheService.deleteById(id);
        return "SUCCESS";
    }



}

4.1关于spring缓存标签的说明

  • @Cacheable，首先在缓存中查询，没有的话，进方法执行，执行完成后返回值放缓存；
  • @CachePut，不进行查询判断，直接新增或者更新缓存内容，类似add或update；
  • @CacheEvict，直接清除，类似delete。
  • @Caching，1,2,3个组合
ninghq
关注
  • 1
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
spring-boot-redis-guava-caffeine-cache:springboot 使用 redis guava caffeine 缓存示例
05-17
springboot使用redis做数据缓存
springboot本地缓存（guava与caffeine）.docx
12-27
springboot本地缓存（guava与caffeine）.docx
SpringBoot使用Caffeine实现内存缓存
qinxun2008081的博客
06-05 1152
SpringBoot使用Caffeine实现内存缓存
Caffeine本地缓存学习
m0_46360888的博客
05-27 1283
caffeine
使用Spring Boot中的CaffeineCacheManager进行缓存管理
最新发布
diligent_man_z的博客
03-14 985
在开发应用程序时，缓存是提高系统性能的重要技术之一。Spring Boot提供了对缓存的良好支持，其中之一就是通过CaffeineCacheManager来管理缓存。本文将介绍如何在Spring Boot应用程序中使用CaffeineCacheManager进行缓存管理，包括添加依赖、配置CaffeineCacheManager的Bean并设置相关配置，以及在服务类中使用@Cacheable和@CacheEvict注解启用缓存。通过实例代码，你将了解如何在服务类中实现增删改查操作，并结合缓存提高系统性能。
二分钟快速掌握Caffeine 三种填充策略：手动、同步和异步
学而不思则罔,思而不学则殆！
11-03 6908
 一、简介 Caffeine — 一个高性能的 Java 缓存库。缓存和 Map 之间的一个根本区别在于缓存可以回收存储的 item。回收策略为在指定时间删除哪些对象。此策略直接影响缓存的命中率 — 缓存库的一个重要特征。Caffeine 因使用 Window TinyLfu 回收策略，提供了一个近乎最佳的命中率。 二、Caffeine 为我们提供了三种填充策略：手动、同步和异步 1、手动加...
本地缓存Caffeine的基本使用
u013078871的博客
04-27 4980
1.本地缓存有ehcache,guava cache,caffein这几种常用的实现，下面介绍caffeine在springboot中的使用 参考博客：Caffeine Cache 进程缓存之王 SpringBoot 使用 Caffeine 本地缓存 SpringBoot 使用 Caffeine 本地缓存
缓存 - Caffeine 不完全指北
小工匠
07-11 9985
Caffeine是一个用于Java应用程序的高性能缓存框架。它提供了一个强大且易于使用的缓存库，可以在应用程序中使用，以提高数据访问的速度和效率。下面是一些Caffeine缓存框架的主要特点：高性能：Caffeine的设计目标之一是提供卓越的性能。它通过使用高效的数据结构和优化的算法来实现快速的缓存访问。与其他一些常见的缓存框架相比，Caffeine在缓存访问的速度和响应时间上表现出色。内存管理：Caffeine提供了灵活的内存管理选项。它支持基于大小、基于数量和基于权重的缓存大小限制。
java缓存之com.github.benmanes.caffeine.cache.Cache
shileilei1988的博客
01-11 2000
java缓存之Cache
springboot集成caffeine本地缓存
u013008898的博客
05-04 1019
pom: <dependency> <groupId>com.github.ben-manes.caffeine</groupId> <artifactId>caffeine</artifactId> <version>2.9.3</version> </dependency> CacheConfig:
Caffeine本地缓存
小刺猬喜歡獨角獸
08-05 8487
caffine
springboot 使用 redis guava caffeine 缓存示例.zip
02-03
springboot 使用 redis guava caffeine 缓存示例
Spring Boot缓存实战 Caffeine示例
08-27
本篇文章主要介绍了Spring Boot缓存实战 Caffeine示例，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
【学习笔记】本地缓存Caffeine介绍及使用
泽济天下的专栏
07-31 2275
在java开发过程中，缓存是我们经常会谈到的一个话题，而在java领域有个缓存框架号称本地缓存性能之王， Caffeine。
如何解决多线程高并发场景下的 Java 缓存问题？
CSDN资讯
09-17 7710
作者 |LLLSQ责编|郭芮互联网软件神速发展，用户的体验度是判断一个软件好坏的重要原因，所以缓存就是必不可少的一个神器。在多线程高并发场景中往往是离不开cache...
Caffeine （史上最全）
热门推荐
架构师尼恩
02-08 3万+
备注： 文章很长，建议收藏起来，慢慢读! 并且，持续更新中… 架构师 尼恩 为您推荐 高薪必备 ： 《Netty Zookeeper Redis 高并发实战》 为你打造NIO、Netty 高性能底层原理知识底座 高薪必备 ： 《SpringCloud、Nginx高并发核心编程》 为你打造微服务、分布式 高并发底层原理知识底座 高薪必备 ：价值 1000元网盘资源大礼包，免费拿 【博客园总入口 】 Caffeine简介 在本文中，我们来看看 Caffeine — 一个高性能的 Java
（很全面）SpringBoot 使用 Caffeine 本地缓存
竹林幽深
08-30 1372
小知 ​ 我的微信公众号：Java知音 11 人赞同了该文章 作者：超级小豆丁http://www.mydlq.club/article/56/ 目录 一、本地缓存介绍 二、缓存组件 Caffeine 介绍 Caffeine 性能 Caffeine 配置说明 软引用与弱引用 三、SpringBoot 集成 Caffeine 两种方式 四、SpringBoot 集成 Caffeine 方式一 Maven 引入相关依赖 配置缓存配置类 定义测试的实体对象 定义服务接口类和实现类..
本地缓存天花板-Caffeine
weixin_37799575的博客
12-30 3467
Caffeine是一个基于Java8开发的提供了近乎最佳命中率的高性能的缓存库。 缓存和ConcurrentMap有点相似，但还是有所区别。最根本的区别是ConcurrentMap将会持有所有加入到缓存当中的元素，直到它们被从缓存当中手动移除。但是，Caffeine的缓存Cache 通常会被配置成自动驱逐缓存中元素，以限制其内存占用。在某些场景下，LoadingCache和AsyncLoadingCache 因为其自动加载缓存的能力将会变得非常实用。
springboot集成caffeine缓存
04-18
关于springboot集成caffeine缓存的问题，我可以提供以下思路： 1. 首先，在pom.xml中添加caffeine依赖： ``` <groupId>com.github.ben-manes.caffeine</groupId> <artifactId>caffeine <version>2.6.0 ``` 2....

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值