Java本地缓存工具之LoadingCache的使用详解

前言

在工作总常常需要用到缓存，而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在内存中已经不存在对应的值了。

总结

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

到此这篇关于java本地缓存工具之loadingcache的使用详解的文章就介绍到这了,更多相关java loadingcache本地缓存内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！