Guava Cache 工具类 [ GuavaCacheUtil ]

最新推荐文章于 2025-06-30 18:07:07 发布
最新推荐文章于 2025-06-30 18:07:07 发布
阅读量1.7k 收藏
点赞数
本文深入探讨了Guava缓存库的使用方法，详细介绍了如何配置缓存的最大容量、有效时间和缓存回收策略。同时，提供了丰富的示例代码，展示了如何进行缓存的增删查改操作，并监控缓存的命中率和加载时间。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >


pom.xml


<dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>24.0-jre</version>
</dependency>


GuavaCacheUtil.java


package com.app.core.util;

import com.google.common.cache.*;
import lombok.extern.log4j.Log4j2;
import org.apache.commons.lang3.ObjectUtils;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.TimeUnit;

@Log4j2
public class GuavaCacheUtil {
    /**
     * 缓存项最大数量
     */
    private static final long GUAVA_CACHE_SIZE = 100000;
    /**
     * 缓存时间：分钟
     */
    private static final long GUAVA_CACHE_TIME = 10;

    /**
     * 缓存操作对象
     */
    private static LoadingCache<String, Object> GLOBAL_CACHE = null;

    static {
        try {
            GLOBAL_CACHE = loadCache(new CacheLoader<String, Object>() {
                public Object load(String key) throws Exception {
                    // 该方法主要是处理缓存键不存在缓存值时的处理逻辑
                    if (log.isDebugEnabled())
                        log.debug("Guava Cache缓存值不存在，初始化空值，键名：{}", key);
                    return ObjectUtils.NULL;
                }
            });
        } catch (Exception e) {
            log.error("初始化Guava Cache出错", e);
        }
    }

    /**
     * 全局缓存设置
     * <ul>
     * <li>缓存项最大数量：100000</li>
     * <li>缓存有效时间（分钟）：10</li>
     * </ul>
     *
     * @param cacheLoader
     * @return
     * @throws Exception
     */
    private static <K, V> LoadingCache<K, V> loadCache(CacheLoader<K, V> cacheLoader) throws Exception {
        /*
         * maximumSize 缓存池大小，在缓存项接近该大小时， Guava开始回收旧的缓存项 expireAfterAccess 表示最后一次使用该缓存项多长时间后失效 removalListener 移除缓存项时执行的逻辑方法 recordStats 开启Guava Cache的统计功能
         */
        LoadingCache<K, V> cache = CacheBuilder.newBuilder().maximumSize(GUAVA_CACHE_SIZE).expireAfterAccess(GUAVA_CACHE_TIME, TimeUnit.MINUTES)
                .removalListener(new RemovalListener<K, V>() {
                    public void onRemoval(RemovalNotification<K, V> rn) {
                        if (log.isDebugEnabled())
                            log.debug("Guava Cache缓存回收成功，键：{}, 值：{}", rn.getKey(), rn.getValue());
                    }
                }).recordStats().build(cacheLoader);
        return cache;
    }

    /**
     * 设置缓存值
     *
     * @param key
     * @param value
     */
    public static void put(String key, Object value) {
        try {
            GLOBAL_CACHE.put(key, value);
            if (log.isDebugEnabled())
                log.debug("缓存命中率：{}，新值平均加载时间：{}", getHitRate(), getAverageLoadPenalty());
        } catch (Exception e) {
            log.error("设置缓存值出错", e);
        }
    }

    /**
     * 批量设置缓存值
     *
     * @param map
     */
    public static void putAll(Map<? extends String, ? extends Object> map) {
        try {
            GLOBAL_CACHE.putAll(map);
            if (log.isDebugEnabled())
                log.debug("缓存命中率：{}，新值平均加载时间：{}", getHitRate(), getAverageLoadPenalty());
        } catch (Exception e) {
            log.error("批量设置缓存值出错", e);
        }
    }

    /**
     * 获取缓存值
     * <p>注：如果键不存在值，将调用CacheLoader的load方法加载新值到该键中</p>
     *
     * @param key
     * @return
     */
    public static Object get(String key) {
        Object obj = null;
        try {
            obj = GLOBAL_CACHE.get(key);
            if (log.isDebugEnabled())
                log.debug("缓存命中率：{}，新值平均加载时间：{}", getHitRate(), getAverageLoadPenalty());
        } catch (Exception e) {
            log.error("获取缓存值出错", e);
        }
        return obj;
    }

    /**
     * 获取缓存值
     * <p>注：如果键不存在值，将直接返回 NULL</p>
     *
     * @param key
     * @return
     */
    public static Object getIfPresent(String key) {
        Object obj = null;
        try {
            obj = GLOBAL_CACHE.getIfPresent(key);
            if (log.isDebugEnabled())
                log.debug("缓存命中率：{}，新值平均加载时间：{}", getHitRate(), getAverageLoadPenalty());
        } catch (Exception e) {
            log.error("获取缓存值出错", e);
        }
        return obj;
    }

    /**
     * 移除缓存
     *
     * @param key
     */
    public static void remove(String key) {
        try {
            GLOBAL_CACHE.invalidate(key);
            if (log.isDebugEnabled())
                log.debug("缓存命中率：{}，新值平均加载时间：{}", getHitRate(), getAverageLoadPenalty());
        } catch (Exception e) {
            log.error("移除缓存出错", e);
        }
    }

    /**
     * 批量移除缓存
     *
     * @param keys
     */
    public static void removeAll(Iterable<String> keys) {
        try {
            GLOBAL_CACHE.invalidateAll(keys);
            if (log.isDebugEnabled())
                log.debug("缓存命中率：{}，新值平均加载时间：{}", getHitRate(), getAverageLoadPenalty());
        } catch (Exception e) {
            log.error("批量移除缓存出错", e);
        }
    }

    /**
     * 清空所有缓存
     */
    public static void removeAll() {
        try {
            GLOBAL_CACHE.invalidateAll();
            if (log.isDebugEnabled())
                log.debug("缓存命中率：{}，新值平均加载时间：{}", getHitRate(), getAverageLoadPenalty());
        } catch (Exception e) {
            log.error("清空所有缓存出错", e);
        }
    }

    /**
     * 获取缓存项数量
     *
     * @return
     */
    public static long size() {
        long size = 0;
        try {
            size = GLOBAL_CACHE.size();
            if (log.isDebugEnabled())
                log.debug("缓存命中率：{}，新值平均加载时间：{}", getHitRate(), getAverageLoadPenalty());
        } catch (Exception e) {
            log.error("获取缓存项数量出错", e);
        }
        return size;
    }

    /**
     * 获取所有缓存项的键
     *
     * @return
     */
    public static List<String> keys() {
        List<String> list = new ArrayList<String>();
        try {
            ConcurrentMap<String, Object> map = GLOBAL_CACHE.asMap();
            for (Map.Entry<String, Object> item : map.entrySet())
                list.add(item.getKey());
            if (log.isDebugEnabled())
                log.debug("缓存命中率：{}，新值平均加载时间：{}", getHitRate(), getAverageLoadPenalty());
        } catch (Exception e) {
            log.error("获取所有缓存项的键出错", e);
        }
        return list;
    }

    /**
     * 缓存命中率
     *
     * @return
     */
    public static double getHitRate() {
        return GLOBAL_CACHE.stats().hitRate();
    }

    /**
     * 加载新值的平均时间，单位为纳秒
     *
     * @return
     */
    public static double getAverageLoadPenalty() {
        return GLOBAL_CACHE.stats().averageLoadPenalty();
    }

    /**
     * 缓存项被回收的总数，不包括显式清除
     *
     * @return
     */
    public static long getEvictionCount() {
        return GLOBAL_CACHE.stats().evictionCount();
    }
}
hinihaoaaa
关注
使用Google Guava Cache Util工具类实现本地缓存设置过期时间的Java应用
CyberLancer的博客
08-10 1627
而在Java开发中，Google Guava提供了一个强大的缓存工具类——Cache Util，可以方便地实现本地缓存并设置过期时间。本文介绍了如何引入Guava依赖、创建缓存对象、使用缓存和定期清理过期缓存的方法，并提供了相应的源代码示例。在需要缓存数据的地方，我们可以通过调用LocalCacheManager的put方法将数据放入缓存中，通过调用get方法从缓存中获取数据。接下来，我们可以通过CacheBuilder类创建一个缓存对象，并配置相关的参数，包括过期时间、最大缓存数量等。
Guava - 一个依托于 Guava cache 的工具类
简简单单Onlinezuozuo
08-06 1173
文章目录Guava - 一个依托于 Guava cache 的工具类1、代码 Guava - 一个依托于 Guava cache 的工具类 1、代码 import com.google.common.cache.Cache; import com.google.common.cache.CacheBuilder; import com.google.common.cache.RemovalListener; import lombok.NoArgsConstructor; import lombok.Sn
缓存之美：Guava Cache 相比于 Caffeine 差在哪里？
cnzzs的博客
06-30 836
本文将结合的源码来分析它的实现原理，并阐述它相比于 Caffeine Cache 在性能上的劣势。为了让大家对 Guava Cache 理解起来更容易，我们还是在开篇介绍它的原理：Guava Cache 通过分段(Segment)锁()机制、volatile变量和多种缓存策略实现了性能相对 Caffeine 性能较差的缓存，它的数据结构如上图所示。它会将缓存分成多个段(Segment)去管理，，如果要创建大小为 1000 的缓存，那么实际上会分配 4 个段，每个段的最大容量为 250。
Guava Cache 工具类
dgqvhtlwq472235338的博客
08-29 524
maven依赖 <dependency> <groupId>com.google.guava</groupId> <artifactId>guava</artifactId> <version>23.0</version> </dependency>...
GuavaCacheUtil包
熊浪的博客
05-28 679
package com.book.common.util; import com.google.common.cache.CacheBuilder; import com.google.common.cache.CacheLoader; import com.google.common.cache.LoadingCache; import com.google.common.cache.RemovalListener; import com.google.common.cache.RemovalNoti.
Guava Cache工具类及部分参数解析
Haiyoung
11-25 1061
Guava Cache 最近用到guava的内存缓存，网上找了一些资料，总结了一下，写了个创建缓存的工具类 只涉及到部分参数，更多可以查看引用资料或者其它文档 package com.oyo.bizefficiency.workhours.utils; import com.google.common.cache.CacheBuilder; import com.google.common.ca...
Springboot整合GuavaCache缓存过程解析
08-25
GuavaCacheConfig是一个用于配置GuavaCache的类，用于设置缓存的生命周期、最大缓存数等参数。CacheController是一个业务逻辑类，用于处理业务逻辑中的缓存操作。 GuavaCacheConfig的配置参数： * ...
SpringBoot加入Guava Cache实现本地缓存代码实例
08-25
然后，我们创建一个 CacheServiceImpl 类，实现 CacheService 接口，并使用 Guava Cache 进行缓存： ```java @Service public class CacheServiceImpl implements CacheService { private Cache, Object> common...
google Guava集合工具类（超实用）
11-30
Guava 是一个 Google 的基于java1.6的类库集合的扩展项目，包括 collections, caching, primitives support, concurrency libraries, common annotations, string processing, I/O, 等等. 这些高质量的 API 可以使你...
Guava-Cache本地缓存案例代码
01-19
Guava Cache可以通过CacheBuilder类创建。CacheBuilder提供了丰富的配置选项，如最大容量、过期时间等。例如： ```java LoadingCache, Graph> graphs = CacheBuilder.newBuilder() .maximumSize(1000) ....
使用google guava 实现定时缓存功能
10-23
使用google guava 实现定时缓存功能
Guava 工具类之Cache的使用 本地缓存组件
weixin_56800842的博客
12-15 1302
guava cache是Google guava中提供的一款轻量级的本地缓存组件，其特点是简单、轻便、完善、扩展性强，内存管理机制也相对完善。
Guava LoadingCache详解及工具类
丶自定义
04-16 5505
缓存，在我们日常开发中是必不可少的一种解决性能问题的方法。简单的说，cache 就是为了提升系统性能而开辟的一块内存空间。 　缓存的主要作用是暂时在内存中保存业务系统的数据处理结果，并且等待下次访问使用。在日常开发的很多场合，由于受限于硬盘IO的? 　缓存在很多系统和架构中都用广泛的应用,例如： 　1.CPU缓存 　2.操作系统缓存 　3.本地缓存 　4.分布式缓存 　5.HTTP缓存 　6...
java使用Guava cache做内存缓存
ThinkPet
06-17 819
*** 使用guava需要引入依赖*/ private static Cache < String , Object > cache = CacheBuilder . newBuilder() //5分钟后过期 . expireAfterWrite(5 , TimeUnit . MINUTES) //最大10个缓存 . maximumSize(10) . build();} }
Google Guava学习（9）-Guava Cache缓存工具（一）
Jalen备忘录
10-20 1154
1. 功能：简单实现数据的缓存，提供了一些基本的缓存特性设置（如过期时间等） 2. demo描述：为3张表数据做缓存：公司表、部门表、员工表，使用时通过不同的键值调用此缓存；代码中涉及到多线程访问缓存，可以自己切换线程，更好说明一些； package com.example.google.guava.demo.cache; import com.example.google.guava.de
Java开发利器之Guava Cache的使用教程_Guava 工具类之Cache的使用
yanzirou的博客
02-22 1047
Guava 是一个流行的 Java 工具库，其中的 Cache 工具类提供了一个简单的缓存实现，可以在应用程序中缓存一些数据，避免每次使用时都需要重新获取或计算。创建一个新的缓存实例，指定缓存的最大容量、过期时间等参数。另外，在使用缓存时也需要注意缓存的一致性和正确性，避免出现不一致的情况。方法来获取该键的值，并将其存入缓存中。需要注意的是，如果缓存中的值可能被多个线程同时访问，那么需要使用。对象，该对象可以自动加载缓存项，并在缓存项过期时自动刷新。方法来获取该键的值，并将其存入缓存中。
缓存工具类（基于google guava封装）
文盲青年的博客
12-15 1468
<dependency> <groupId>com.google.guava</groupId> <artifactId>guava</artifactId> <version>30.0-jre</version> </dependency> import com.google.common.cache.Ca...
Guava常用工具# Cache本地缓存
weixin_43996530的博客
09-07 1287
构造 LoadingCache 的关键在于实现 load 方法，也就是在需要访问的缓存项不存在的时候 Cache 会自动调用 load 方法将数据加载到 Cache中，除了实现 load 方法之外还可以配置缓存相关的一些性质，比如过期加载策略、刷新策略。在构建Cache对象的时候我们可以设置可容纳的最大缓存数量，当超过一定最大数量的时候，Cache会淘汰一部分已有的数据，这里采用的是LRU淘汰策略，即访问频率最低的被淘汰。通过get方法当缓存不存在的时候，加载缓存数据到缓存中。：使用弱引用存储值。
guava cache工具类
最新发布
07-22
Guava Cache 是 Google 提供的一个本地缓存工具类，适用于 Java 应用程序，可以用来缓存数据，从而减少重复计算或频繁访问数据库的开销。Guava Cache 提供了多种配置选项，包括最大缓存容量、过期时间以及自动加载...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值