Java本地缓存工具，LoadingCache的使用（附代码） | Java工具类

最新推荐文章于 2024-04-25 21:06:58 发布
最新推荐文章于 2024-04-25 21:06:58 发布
阅读量4.5k 收藏 29
点赞数 32
分类专栏： Java工具类 文章标签： 缓存 java loadingCache
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhiweihongyan1/article/details/122256607
版权

目录

前言

环境依赖

代码

总结

前言

在工作总常常需要用到缓存，而redis往往是首选，但是短期的数据缓存一般我们还是会用到本地缓存。本文提供一个我在工作中用到的缓存工具，该工具代码为了演示做了一些调整。如果拿去使用的话，可以考虑做成注入Bean对象，看具体需求了。

环境依赖

先添加maven依赖

.

        <dependency>
            <groupId>com.google.guava</groupId>
            <artifactId>guava</artifactId>
            <version>30.1.1-jre</version>
        </dependency>
        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>5.5.2</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>

代码

不废话，上代码了。

package ai.guiji.csdn.tools;

import cn.hutool.core.thread.ThreadUtil;
import com.google.common.cache.*;
import lombok.extern.slf4j.Slf4j;

import java.text.MessageFormat;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.stream.LongStream;

/** @Author 剑客阿良_ALiang @Date 2021/12/30 17:57 @Description: 缓存工具 */
@Slf4j
public class CacheUtils {

  private static LoadingCache<Long, String> cache;

  /**
   * 初始化缓存方法
   *
   * @param totleCount 缓存池上限
   * @param overtime 超时时间
   * @param unit 时间单位
   * @param handleNotExist 处理不存在key方法
   * @param handleRemove 移除主键消费
   */
  private static void initCache(
      Integer totleCount,
      Integer overtime,
      TimeUnit unit,
      Function<Long, String> handleNotExist,
      Consumer<Long> handleRemove) {
    cache =
        CacheBuilder.newBuilder()
            // 缓存池大小
            .maximumSize(totleCount)
            // 设置时间对象没有被读/写访问则对象从内存中删除
            .expireAfterWrite(overtime, unit)
            // 移除监听器
            .removalListener(
                new RemovalListener<Long, String>() {
                  @Override
                  public void onRemoval(RemovalNotification<Long, String> rn) {
                    handleRemove.accept(rn.getKey());
                  }
                })
            .recordStats()
            .build(
                new CacheLoader<Long, String>() {
                  @Override
                  public String load(Long aLong) throws Exception {
                    return handleNotExist.apply(aLong);
                  }
                });
    log.info("初始化缓存");
  }

  /**
   * 存入缓存
   *
   * @param key 键
   * @param value 值
   */
  public static void put(Long key, String value) {
    try {
      log.info("缓存存入:[{}]-[{}]", key, value);
      cache.put(key, value);
    } catch (Exception exception) {
      log.error("存入缓存异常", exception);
    }
  }

  /**
   * 批量存入缓存
   *
   * @param map 映射
   */
  public static void putMap(Map<Long, String> map) {
    try {
      log.info("批量缓存存入:[{}]", map);
      cache.putAll(map);
    } catch (Exception exception) {
      log.error("批量存入缓存异常", exception);
    }
  }

  /**
   * 获取缓存
   *
   * @param key 键
   */
  public static String get(Long key) {
    try {
      return cache.get(key);
    } catch (Exception exception) {
      log.error("获取缓存异常", exception);
      return null;
    }
  }

  /**
   * 删除缓存
   *
   * @param key 键
   */
  public static void removeKey(Long key) {
    try {
      cache.invalidate(key);
    } catch (Exception exception) {
      log.error("删除缓存异常", exception);
    }
  }

  /**
   * 批量删除缓存
   *
   * @param keys 键
   */
  public static void removeAll(Iterable<Long> keys) {
    try {
      cache.invalidateAll(keys);
    } catch (Exception exception) {
      log.error("批量删除缓存异常", exception);
    }
  }

  /** 清理缓存 */
  public static void clear() {
    try {
      cache.invalidateAll();
    } catch (Exception exception) {
      log.error("清理缓存异常", exception);
    }
  }

  /**
   * 获取缓存大小
   *
   * @return 长度
   */
  public static long size() {
    return cache.size();
  }

  public static void main(String[] args) {
    initCache(
        Integer.MAX_VALUE,
        10,
        TimeUnit.SECONDS,
        k -> {
          log.info("缓存:[{}]，不存在", k);
          return "";
        },
        x -> log.info("缓存:[{}]，已经移除", x));
    System.out.println(size());
    LongStream.range(0, 10).forEach(a -> put(a, MessageFormat.format("tt-{0}", a)));
    System.out.println(cache.asMap());
    ThreadUtil.sleep(5000);
    LongStream.range(0, 10)
        .forEach(
            a -> {
              System.out.println(get(a));
              ThreadUtil.sleep(1000);
            });
    System.out.println(cache.asMap());
    ThreadUtil.sleep(10000);
    System.out.println(cache.asMap());
  }
}

代码说明

1、在初始化loadingCache的时候，可以添加缓存的最大数量、消逝时间、消逝或者移除监听事件、不存在键处理等等。在上面的代码中，我初始化缓存大小为Integer的最大值，写入10秒后消逝，如不存在key返回空字符串等等。

2、该类也提供了put、putAll、get、remove、removeAll、clear、size方法，可以对缓存进行存、取、删、清理、大小等操作。

3、main演示方法中，先往缓存存入10个数据，然后过5秒后每秒取一个数据，并且打印一下缓存中的全部内容。

4、补充一句LoadingCache是线程安全的哦。

演示一下

15:31:53.495 [main] INFO ai.guiji.csdn.tools.CacheUtils - 初始化缓存
0
15:31:53.502 [main] INFO ai.guiji.csdn.tools.CacheUtils - 缓存存入:[0]-[tt-0]
15:31:53.508 [main] INFO ai.guiji.csdn.tools.CacheUtils - 缓存存入:[1]-[tt-1]
15:31:53.508 [main] INFO ai.guiji.csdn.tools.CacheUtils - 缓存存入:[2]-[tt-2]
15:31:53.508 [main] INFO ai.guiji.csdn.tools.CacheUtils - 缓存存入:[3]-[tt-3]
15:31:53.508 [main] INFO ai.guiji.csdn.tools.CacheUtils - 缓存存入:[4]-[tt-4]
15:31:53.508 [main] INFO ai.guiji.csdn.tools.CacheUtils - 缓存存入:[5]-[tt-5]
15:31:53.508 [main] INFO ai.guiji.csdn.tools.CacheUtils - 缓存存入:[6]-[tt-6]
15:31:53.508 [main] INFO ai.guiji.csdn.tools.CacheUtils - 缓存存入:[7]-[tt-7]
15:31:53.509 [main] INFO ai.guiji.csdn.tools.CacheUtils - 缓存存入:[8]-[tt-8]
15:31:53.509 [main] INFO ai.guiji.csdn.tools.CacheUtils - 缓存存入:[9]-[tt-9]
{6=tt-6, 5=tt-5, 0=tt-0, 8=tt-8, 7=tt-7, 2=tt-2, 1=tt-1, 9=tt-9, 3=tt-3, 4=tt-4}
tt-0
tt-1
tt-2
tt-3
tt-4
15:32:03.572 [main] INFO ai.guiji.csdn.tools.CacheUtils - 缓存:[5]，已经移除
15:32:03.573 [main] INFO ai.guiji.csdn.tools.CacheUtils - 缓存:[6]，已经移除
15:32:03.573 [main] INFO ai.guiji.csdn.tools.CacheUtils - 缓存:[5]，不存在

15:32:04.581 [main] INFO ai.guiji.csdn.tools.CacheUtils - 缓存:[6]，不存在

15:32:05.589 [main] INFO ai.guiji.csdn.tools.CacheUtils - 缓存:[0]，已经移除
15:32:05.589 [main] INFO ai.guiji.csdn.tools.CacheUtils - 缓存:[7]，已经移除
15:32:05.589 [main] INFO ai.guiji.csdn.tools.CacheUtils - 缓存:[8]，已经移除
15:32:05.589 [main] INFO ai.guiji.csdn.tools.CacheUtils - 缓存:[7]，不存在

15:32:06.589 [main] INFO ai.guiji.csdn.tools.CacheUtils - 缓存:[8]，不存在

15:32:07.591 [main] INFO ai.guiji.csdn.tools.CacheUtils - 缓存:[1]，已经移除
15:32:07.591 [main] INFO ai.guiji.csdn.tools.CacheUtils - 缓存:[2]，已经移除
15:32:07.591 [main] INFO ai.guiji.csdn.tools.CacheUtils - 缓存:[9]，已经移除
15:32:07.591 [main] INFO ai.guiji.csdn.tools.CacheUtils - 缓存:[9]，不存在

{6=, 5=, 8=, 7=, 9=}
{}

Process finished with exit code 0
 

可以看到，后面的5-9在内存中已经不存在对应的值了。

总结

本文提供的工具代码主要是为了演示，实际工作中可以按照自己的需求做调整。

 还有补充一下，最近博主在参加评选博客之星活动。如果你喜欢我的文章的话，不妨给我点个五星，投投票吧，谢谢大家的支持！！链接地址：https://bbs.csdn.net/topics/603956455

分享：

        在梦中，我以为人生很漫长，会远得连尽头也看不见，没想到我匆匆翻看，人生，却再也无法逆转。在当下，我以为时间很重，会重得连时针都走不动。 没想到我轻轻一吹，时间，却再也没回来过。——《言叶之庭》

如果本文对你有帮助的话，点个赞吧，谢谢！！

剑客阿良_ALiang
关注
  • 32
    点赞
  • 踩
  • 29
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 13
    评论
专栏目录
Java中LocalCache本地缓存实现代码
08-30
本篇文章主要介绍了Java中LocalCache本地缓存实现代码，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
JAVA如何实现本地缓存?
小徐的博客
01-24 1129
本文主要探讨如何设计本地缓存，欢迎评论区留言，一起讨论。
【java】本地（内存）缓存实战--LocalCacheUtil.java
IT_Most的博客
10-23 1377
本地缓存项目实战，不看后悔一辈子~
Java 本地缓存：提高应用程序性能的必备技术
里查叔叔
02-26 859
Java 本地缓存指的是在应用程序本地（即 JVM 内部）存储数据副本的技术。与远程缓存（如 Redis、Memcached）相比，本地缓存无需网络通信，因此访问速度更快。本地缓存适用于存储热点数据、临时数据以及计算结果等，以减少对数据库、文件系统等外部存储的访问次数。Java 本地缓存是提高应用程序性能的重要工具之一。通过合理地使用本地缓存，我们可以显著地提升应用程序的响应速度，降低数据库的压力，提升用户的体验。然而，使用缓存也带来了一些新的挑战，如数据一致性、缓存管理等。
Java内存缓存工具Guava LoadingCache使用解析
08-25
主要介绍了Java内存缓存工具Guava LoadingCache使用解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
java手写本地缓存示例
07-28
基于java的map和timer实现本地缓存及定时清理失效缓存的功能 本项目仅用于初学者学习使用 初学者可基于此项目初步了解缓存实现的基本原理 后期在项目中使用建议使用现成的缓存框架：redis、ehcache等
Java实现本地缓存的几种方式
qinxun2008081的博客
07-27 6897
Java实现本地缓存的几种方式
java中的缓存工具类
weixin_45058750的博客
12-16 276
package com.zhizhi.util; import java.util.Map; import java.util.concurrent.ConcurrentHashMap; /** * Map 缓存实现 * Created by winterchen on 2018/4/30. */ public class MapCache { /** * 默认存储1024个缓存 */ private static final int DEFAULT_CACH
java本地缓存工具类
codeccb
06-24 176
使用ConcurrentHashMap实现本地缓存，工具类如下： ```java public class LocalCache { // 默认缓存时长, 单位秒 private static final int DEFAULT_TIMEOUT = 3600; // 默认缓存容量 private static final int DEFAULT_SIZE = 1000; // 存储数据 pr...
java 简易定时缓存工具
yjw_2019的博客
05-18 243
自制简易缓存工具学习使用记录
java 静态map缓存_java 使用静态hashmap实现简单缓存(示例代码)
weixin_30673943的博客
02-13 696
因项目需要的数据查询较多，数量大，所以要用到缓存，在未引用redis的情况下，仅仅只做一个速度的提升1、Cache类public class Cache {private String key;//缓存ID，根据iD往hashmap存放值private E value;//缓存数据 ，需要缓存的对象实体private long timeOut;//更新时间private boolean expir...
如何基于LoadingCache实现Java本地缓存
08-25
主要介绍了如何基于LoadingCache实现Java本地缓存,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
缓存工具类ACache使用方法详解
08-25
主要为大家详细介绍了缓存工具类ACache的使用方法，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
Java利用ConcurrentHashMap实现本地缓存demo
05-25
Java利用ConcurrentHashMap实现本地缓存demo； 基本功能有缓存有效期、缓存最大数、缓存存入记录、清理线程、过期算法删除缓存、LRU算法删除、获取缓存值等功能。 复制到本地项目的时候，记得改包路径哦~
链表-LRU缓存
最新发布
qq_68006585的博客
04-25 384
如果你又从其他地方拿了一本书读完之后，打算放入这堆书中，如果这堆书中还有同名书，只是年份不同，那么就用这本书进行替换，如果没有同名书，由于“空间”不够使用，只能将最底下的书移走，再放入这本书。每当缓存命中时，就将命中的数据移动到列表的头部，每当缓存缺失时，就将新数据插入到列表的头部，并将列表尾部的数据淘汰掉。int get(int key) 如果关键字 key 存在于缓存中，则返回关键字的值，否则返回 -1。LRU是一种常用的缓存淘汰策略，用于管理缓存中的数据。刚开始时，使用一个哨兵节点。
13 如何利用缓存实现万级并发扣减
周大壮的博客
04-25 1078
在上一讲中的纯数据库方案无法完全满足量级要求时，本讲介绍了纯缓存的扣减方案。着重讲解了为什么纯缓存可以满足扣减的功能需求，对于分析的过程希望你能够理解并应用，而不是关注最终提出的方案。作为一名优秀的开发人员，你要知道架构图是一个最终态，是静止的，它并不能 100% 直接应用到你所面对的场景，而分析思路却是可以复制和模仿的。其次，本讲也分析了纯缓存方案存在的一些异常场景。在实战中，正常流程是简单的，而异常流程的思考与处理十分的复杂与烦琐，同时也最能体现技术性，请你务必注意与加强。
三、CPU基础-缓存
技术分子博客
04-16 807
程序执行时，会先将内存中的数据加载到共享的 L3 Cache 中，再加载到每个核心独有的 L2 Cache，最后进入到最快的 L1 Cache，之后才会被 CPU 读取。L1 Cache 和 L2 Cache 都是每个 CPU 核心独有的（通常会分为「数据缓存」和「指令缓存」），而 L3 Cache 是多个 CPU 核心共享的。CPU Cache 通常分为大小不等的三级缓存，分别是 L1 Cache、L2 Cache 和 L3 Cache。三、CPU Cache结构。
Cache缓存
xiaofeixia002X的博客
04-25 269
在计算机架构中，缓存（Cache）是一种高速数据存储层，它存储了一部分从原始数据源（如主内存）频繁访问的数据副本。通过将数据暂时存储在物理上更接近处理器的位置，缓存能够减少数据访问的延迟，从而加快数据访问速度和提高整体系统性能。
146.LRU缓存
Mar_mxs的博客
04-19 490
146.LRU缓存
java本地缓存cache工具类
05-30
Java中有很多本地缓存的工具类，以下是其中几个比较常用的： 1. Guava Cache：Google开发的缓存工具类，提供了很多功能，如自动回收、定时回收、缓存统计等。 2. Caffeine：Guava Cache的升级版，提供更高效的缓存...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

剑客阿良_ALiang

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值