程序喵

择善人而交，择善书而读
择善言而听，择善行而从
当前位置：首页 > Java开发 > Google Guava 快速入门 —— Cache 缓存工具 大屏阅读

Google Guava 快速入门 —— Cache 缓存工具

7年前 (2019-02-26) 分类：Java开发 阅读(5831) 评论(0)

Google Guava 快速入门.jpg

Guava Cache 缓存工具

Guava 通过接口 LoadingCache 提供了一个非常强大的基于内存的 LoadingCache<K，V>。在缓存中自动加载值，它提供了许多实用的方法，在有缓存需求时非常有用。

一、接口声明

以下是 com.google.common.cache.LoadingCache<K，V> 接口的声明：

@GwtCompatible
public interface LoadingCache<K, V> extends Cache<K, V>, Function<K, V> {

二、接口方法

官方文档：https://google.github.io/guava/releases/27.0.1-jre/api/docs/src-html/com/google/common/cache/Cache.html

修饰符和类型方法描述
ConcurrentMap<K,V>asMap() 
返回存储在此缓存中的条目视图作为线程安全映射.
voidcleanUp() 
执行缓存所需的任何挂起的维护操作.
Vget(K key, Callable<? extends V> loader) 
返回与此缓存中的键关联的值，必要时从加载器获取该值.
ImmutableMap<K,V>getAllPresent(Iterable<?> keys) 
返回与此缓存中的键关联的值的map映射.
VgetIfPresent(Object key) 
返回与此高速缓存中的键关联的值，如果没有key的高速缓存值，则返回null。
voidinvalidate(Object key) 
废弃缓存中当前key对应的所有value值。
voidinvalidateAll() 
废弃缓存中所有的value值。
voidinvalidateAll(Iterable<?> keys) 
废弃传入key集合中对应的所有缓存中的value值。
voidput(K key, V value) 
将值与此缓存中的键关联.
voidputAll(Map<? extends K,? extends V> m) 
将指定映射中的所有映射复制到缓存.
longsize() 
返回此缓存中的条目数.
CacheStatsstats() 
返回此缓存的累积统计信息的当前快照，如果缓存未记录统计信息，则返回一组默认值.

三、Guava Cache 适用性

缓存在很多场景下都是相当有用的。例如，计算或检索一个值的代价很高，并且对同样的输入需要不止一次获取值的时候，就应当考虑使用缓存。

Guava Cache 与 ConcurrentMap 很相似，但也不完全一样。最基本的区别是 ConcurrentMap 会一直保存所有添加的元素，直到显式地移除。相对地，Guava Cache为了限制内存占用，通常都设定为自动回收元素。在某些场景下，尽管 LoadingCache 不回收元素，它也是很有用的，因为它会自动加载缓存。

通常来说，Guava Cache适用于：

  • 你愿意消耗一些内存空间来提升速度。

  • 你预料到某些键会被查询一次以上。

  • 缓存中存放的数据总量不会超出内存容量。（Guava Cache是单个应用运行时的本地缓存。它不把数据存放到文件或外部服务器。）

如果你的场景符合上述的每一条，Guava Cache就适合你。

四、创建 Cache 范例

LoadingCache<String, Object> employeeCache = CacheBuilder.newBuilder()
        .maximumSize(100) // 最多可以缓存100条记录
        .expireAfterAccess(30, TimeUnit.MINUTES) // 缓存将在访问30分钟后过期
        .build(new CacheLoader<String, Object>() {
            @Override
            public Object load(String key) throws Exception {
                // 数据库加载
                return getFromDatabase(key);
            }
        });

Cache 实例通过 CacheBuilder 生成器模式获取。

五、加载

在使用缓存前，首先问自己一个问题：有没有合理的默认方法来加载或计算与键关联的值？如果有的话，你应当使用 CacheLoader。如果没有，或者你想要覆盖默认的加载运算，同时保留 "获取缓存-如果没有-则计算 [get-if-absent-compute]" 的原子语义，你应该在调用 get 时传入一个 Callable 实例。缓存元素也可以通过 Cache.put 方法直接插入，但自动加载是首选的，因为它可以更容易地推断所有缓存内容的一致性。

任何缓存都应该提供 get-if-absent-compute 这一基础原子语义，具体含义如下：

  1. 从缓存中取。

  2. 缓存中存在该数据，直接返回；

  3. 缓存中不存在该数据，从数据源中取。

  4. 数据源中存在该数据，放入缓存，并返回；

  5. 数据源中不存在该数据，返回空。

1、CacheLoader

LoadingCache 是附带 CacheLoader 构建而成的缓存实现。创建自己的 CacheLoader 通常只需要简单地实现 V load(K key) throws Exception 方法。如下示例。

// 根据员工ID为员工创建缓存
LoadingCache<String, Object> employeeCache = CacheBuilder.newBuilder()
        .maximumSize(100) // 最多可以缓存100条记录
        .expireAfterAccess(30, TimeUnit.MINUTES) // 缓存将在访问30分钟后过期
        .build(new CacheLoader<String, Object>() {

            // 一般重载 load 方法即可
            @Override
            public Object load(String key) throws Exception {
                // 数据库加载
                return getFromDatabase(key);
            }

            @Override
            public ListenableFuture<Object> reload(String key, Object oldValue) throws Exception {
                return super.reload(key, oldValue);
            }

            @Override
            public Map<String, Object> loadAll(Iterable<? extends String> keys) throws Exception {
                return super.loadAll(keys);
            }
        });

2、get 方法

从 LoadingCache 查询的正规方式是使用 get(K) 方法。这个方法要么返回已经缓存的值，要么使用 CacheLoader 向缓存原子地加载新值。由于 CacheLoader 可能抛出异常，LoadingCache.get(K) 也声明为抛出 ExecutionException 异常。如果你定义的 CacheLoader 没有声明任何检查型异常，则可以通过 getUnchecked(K) 查找缓存；

3、getAll 方法

getAll(Iterable<? extends K>) 方法用来执行批量查询。默认情况下，对每个不在缓存中的键 getAll 方法会单独调用 CacheLoader.load 来加载缓存项。如果批量的加载比多个单独加载更高效，你可以重载 CacheLoader.loadAll 来利用这一点。getAll(Iterable) 的性能也会相应提升。

注：CacheLoader.loadAll 的实现可以为没有明确请求的键加载缓存值。例如，为某组中的任意键计算值时，能够获取该组中的所有键值，loadAll方法就可以实现为在同一时间获取该组的其他键值。

try {
    System.out.println("\n执行 getAll");
    ImmutableMap<String, Object> cacheAll = employeeCache.getAll(Lists.newArrayList("100", "103", "110"));
    cacheAll.forEach((k, v) -> System.out.println("K：" + k + "，V：" + v));

} catch (ExecutionException e) {
    e.printStackTrace();
}

4、Callable 回调

所有类型的 Guava Cache，不管有没有自动加载功能，都支持 get(K, Callable<V>) 方法。这个方法返回缓存中相应的值，或者用给定的 Callable 运算并把结果加入到缓存中。在整个加载方法完成前，缓存项相关的可观察状态都不会更改。这个方法简便地实现了模式："如果有缓存则返回；否则运算、缓存、然后返回"。

String key = "001";
System.out.println(employeeCache.get(key, new Callable<Employee>() {
    @Override
    public Employee call() throws Exception {
        return getFromDatabase(key);
    }
}));

// lambda写法
System.out.println(employeeCache.get(key, (Callable<Employee>) () -> getFromDatabase(key)));

六、显式插入

使用 cache.put(key, value) 方法可以直接向缓存中插入值，这会直接覆盖掉给定键之前映射的值。使用 Cache.asMap() 视图提供的任何方法也能修改缓存。

但请注意，asMap 视图的任何方法都不能保证缓存项被原子地加载到缓存中。进一步说，asMap 视图的原子运算在 Guava Cache 的原子加载范畴之外，所以相比于 Cache.asMap().putIfAbsent(K, V)，Cache.get(K, Callable<V>) 应该总是优先使用。

// 显示插入
employeeCache.put("001","听风");
System.out.println(employeeCache.get("001"));

// 更改asMap视图内容，同步更改缓存内容
ConcurrentMap<String, Object> asMap = employeeCache.asMap();
asMap.put("100","程序喵");
employeeCache.getAll(Lists.newArrayList("100", "103", "110")).forEach((k, v) -> System.out.println("K：" + k + "，V：" + v));

七、缓存回收

一个残酷的现实是，我们几乎一定没有足够的内存缓存所有数据。你你必须决定：什么时候某个缓存项就不值得保留了？Guava Cache提供了三种基本的缓存回收方式：基于容量回收、定时回收 和 基于引用回收。

1、基于容量的回收（size-based eviction）

如果要规定缓存项的数目不超过固定值，只需使用 CacheBuilder.maximumSize(long)。缓存将尝试回收最近没有使用或总体上很少使用的缓存项。通常来说，这种情况发生在缓存项的数目逼近限定值时。

另外，不同的缓存项有不同的“权重”（weights），例如，如果你的缓存值，占据完全不同的内存空间，你可以使用 CacheBuilder.weigher(Weigher) 指定一个权重函数，并且用 CacheBuilder.maximumWeight(long) 指定最大总重。

在权重限定场景中，除了要注意回收也是在重量逼近限定值时就进行了，还要知道重量是在缓存创建时计算的，因此要考虑重量计算的复杂度。

LoadingCache<String, Employee> employeeCache2 = CacheBuilder.newBuilder()
        .maximumSize(100) // 最多可以缓存100条记录
        .expireAfterAccess(30, TimeUnit.MINUTES) // 缓存将在访问30分钟后过期
        .maximumWeight(100)  // 最大权重总量
        .weigher(new Weigher<String, Employee>() {
            @Override
            public int weigh(String key, Employee value) {
                return value.dept.length();
            }
        })
        .build(new CacheLoader<String, Employee>() {
            @Override
            public Employee load(String key) throws Exception {
                // 数据库加载
                return getFromDatabase(key);
            }
        });

2、定时回收（Timed Eviction）

CacheBuilder提供两种定时回收的方法：

  • expireAfterAccess(long, TimeUnit)：缓存项在给定时间内没有被读/写访问，则回收。请注意这种缓存的回收顺序和基于大小回收一样。

  • expireAfterWrite(long, TimeUnit)：缓存项在给定时间内没有被写访问（创建或覆盖），则回收。如果认为缓存数据总是在固定时候后变得陈旧不可用，这种回收方式是可取的。

3、基于引用的回收（Reference-based Eviction）

通过使用弱引用的键、或弱引用的值、或软引用的值，Guava Cache可以把缓存设置为允许垃圾回收：

  • CacheBuilder.weakKeys()：使用弱引用存储键。当键没有其它（强或软）引用时，缓存项可以被垃圾回收。因为垃圾回收仅依赖恒等式（==），使用弱引用键的缓存用==而不是equals比较键。

  • CacheBuilder.weakValues()：使用弱引用存储值。当值没有其它（强或软）引用时，缓存项可以被垃圾回收。因为垃圾回收仅依赖恒等式（==），使用弱引用值的缓存用==而不是equals比较值。

  • CacheBuilder.softValues()：使用软引用存储值。软引用只有在响应内存需要时，才按照全局最近最少使用的顺序回收。考虑到使用软引用的性能影响，我们通常建议使用更有性能预测性的缓存大小限定（见上文，基于容量回收）。使用软引用值的缓存同样用==而不是equals比较值。

八、显式清除缓存

任何时候，你都可以显式地清除缓存项，而不是等到它被回收：

  • 个别清除：Cache.invalidate(key)

  • 批量清除：Cache.invalidateAll(keys)

  • 清除所有缓存项：Cache.invalidateAll()

九、移除监听器

通过 CacheBuilder.removalListener(RemovalListener)，你可以声明一个监听器，以便缓存项被移除时做一些额外操作。缓存项被移除时，RemovalListener 会获取移除通知[RemovalNotification]，其中包含移除原因[RemovalCause]、键和值。

请注意，RemovalListener 抛出的任何异常都会在记录到日志后被丢弃[swallowed]。

// 根据员工ID为员工创建缓存
LoadingCache<String, Object> employeeCache = CacheBuilder.newBuilder()
        .maximumSize(100) // 最多可以缓存100条记录
        .expireAfterAccess(30, TimeUnit.MINUTES) // 缓存将在访问30分钟后过期
        .removalListener(new RemovalListener<String, Object>() {    // 移除监听器
            @Override
            public void onRemoval(RemovalNotification<String, Object> notification) {
                System.out.println("notification："+notification);
            }
        })
        .build(new CacheLoader<String, Object>() {
            @Override
            public Object load(String key) throws Exception {
                // 数据库加载
                return getFromDatabase(key);
            }
        });

// lambda 表达方式
CacheBuilder.removalListener((RemovalListener<String, Object>) notification -> System.out.println("notification："+notification))

默认情况下，监听器方法是在移除缓存时同步调用的。因为缓存的维护和请求响应通常是同时进行的，代价高昂的监听器方法在同步模式下会拖慢正常的缓存请求。在这种情况下，你可以使用 RemovalListeners.asynchronous(RemovalListener, Executor) 把监听器装饰为异步操作。

RemovalListeners.asynchronous(
    new RemovalListener<Object, Object>() {
        @Override
        public void onRemoval(RemovalNotification<Object, Object> notification) {

        }
    }, new Executor() {
        @Override
        public void execute(Runnable command) {

        }
});

十、清理什么时候发生？

使用 CacheBuilder 构建的缓存不会"自动"执行清理和回收工作，也不会在某个缓存项过期后马上清理，也没有诸如此类的清理机制。相反，它会在写操作时顺带做少量的维护工作，或者偶尔在读操作时做——如果写操作实在太少的话。

这样做的原因在于：如果要自动地持续清理缓存，就必须有一个线程，这个线程会和用户操作竞争共享锁。此外，某些环境下线程创建可能受限制，这样 CacheBuilder 就不可用了。

相反，Guava把选择权交到你手里。如果你的缓存是高吞吐的，那就无需担心缓存的维护和清理等工作。如果你的缓存只会偶尔有写操作，而你又不想清理工作阻碍了读操作，那么可以创建自己的维护线程，以固定的时间间隔调用 Cache.cleanUp()，ScheduledExecutorService可以帮助你很好地实现这样的定时调度。

十一、刷新

刷新和回收不太一样。正如 LoadingCache.refresh(K) 所声明，刷新表示为键加载新值，这个过程可以是异步的。在刷新操作进行时，缓存仍然可以向其他线程返回旧值，而不像回收操作，读缓存的线程必须等待新值加载完成。

如果刷新过程抛出异常，缓存将保留旧值，而异常会在记录到日志后被丢弃[swallowed]。

重载 CacheLoader.reload(K, V) 可以扩展刷新时的行为，这个方法允许开发者在计算新值时使用旧的值。

CacheBuilder.refreshAfterWrite(long, TimeUnit) 可以为缓存增加自动定时刷新功能让缓存项保持可用，但请注意：缓存项只有在被检索时才会真正刷新（如果 CacheLoader.refresh 实现为异步，那么检索不会被刷新拖慢）。因此，如果你在缓存上同时声明 expireAfterWrite和refreshAfterWrite，缓存并不会因为刷新盲目地定时重置，如果缓存项没有被检索，那刷新就不会真的发生，缓存项在过期时间后也变得可以回收。

十二、其他特性

1、统计

CacheBuilder.recordStats() 用来开启 Guava Cache 的统计功能。统计打开后，Cache.stats() 方法会返回 CacheStats 对象以提供如下统计信息：

  • hitRate()：缓存命中率；

  • averageLoadPenalty()：加载新值的平均时间，单位为纳秒；

  • evictionCount()：缓存项被回收的总数，不包括显式清除。

此外，还有其他很多统计信息。这些统计信息对于调整缓存设置是至关重要的，在性能要求高的应用中我们建议密切关注这些数据。

2、asMap视图

asMap 视图提供了缓存的 ConcurrentMap 形式，但 asMap 视图与缓存的交互需要注意：

  • cache.asMap() 包含当前所有加载到缓存的项。因此相应地，cache.asMap().keySet()包含当前所有已加载键;

  • asMap().get(key) 实质上等同于 cache.getIfPresent(key)，而且不会引起缓存项的加载。这和Map的语义约定一致。

  • 所有读写操作都会重置相关缓存项的访问时间，包括 Cache.asMap().get(Object) 方法和 Cache.asMap().put(K, V)方法，但不包括 Cache.asMap().containsKey(Object) 方法，也不包括在 Cache.asMap() 的集合视图上的操作。比如，遍历 Cache.asMap().entrySet() 不会重置缓存项的读取时间。

3、中断

缓存加载方法（如 Cache.get）不会抛出中断异常 InterruptedException。我们也可以让这些方法支持 InterruptedException，但这种支持注定是不完备的，并且会增加所有使用者的成本，而只有少数使用者实际获益。详情请继续阅读。

Cache.get 请求到未缓存的值时会遇到两种情况：当前线程加载值；或等待另一个正在加载值的线程。这两种情况下的中断是不一样的。等待另一个正在加载值的线程属于较简单的情况：使用可中断的等待就实现了中断支持；但当前线程加载值的情况就比较复杂了：因为加载值的 CacheLoader 是由用户提供的，如果它是可中断的，那我们也可以实现支持中断，否则我们也无能为力。

如果用户提供的 CacheLoader 是可中断的，为什么不让 Cache.get 也支持中断？从某种意义上说，其实是支持的：如果 CacheLoader 抛出 InterruptedException，Cache.get将立刻返回（就和其他异常情况一样）；此外，在加载缓存值的线程中，Cache.get捕捉到 InterruptedException 后将恢复中断，而其他线程中 InterruptedException 则被包装成了 ExecutionException。

原则上，我们可以拆除包装，把 ExecutionException 变为 InterruptedException，但这会让所有的 LoadingCache 使用者都要处理中断异常，即使他们提供的 CacheLoader 不是可中断的。如果你考虑到所有非加载线程的等待仍可以被中断，这种做法也许是值得的。但许多缓存只在单线程中使用，它们的用户仍然必须捕捉不可能抛出的 InterruptedException 异常。即使是那些跨线程共享缓存的用户，也只是有时候能中断他们的 get 调用，取决于那个线程先发出请求。

对于这个决定，我们的指导原则是让缓存始终表现得好像是在当前线程加载值。这个原则让使用缓存或每次都计算值可以简单地相互切换。如果老代码（加载值的代码）是不可中断的，那么新代码（使用缓存加载值的代码）多半也应该是不可中断的。

如上所述，Guava Cache 在某种意义上支持中断。另一个意义上说，Guava Cache 不支持中断，这使得 LoadingCache 成了一个有漏洞的抽象：当加载过程被中断了，就当作其他异常一样处理，这在大多数情况下是可以的；但如果多个线程在等待加载同一个缓存项，即使加载线程被中断了，它也不应该让其他线程都失败（捕获到包装在 ExecutionException 里的 InterruptedException），正确的行为是让剩余的某个线程重试加载。为此，我们记录了一个 bug。然而，与其冒着风险修复这个bug，我们可能会花更多的精力去实现另一个建议 AsyncLoadingCache，这个实现会返回一个有正确中断行为的 Future对象。

十三、完整示例

一个获取员工信息的示例

package com.example.guava.cache;

import com.google.common.base.MoreObjects;

public class Employee {
    String name;
    String dept;
    String emplD;

    public Employee(String name, String dept, String empID){
        this.name = name;
        this.dept = dept;
        this.emplD = empID;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getDept() {
        return dept;
    }
    public void setDept(String dept) {
        this.dept = dept;
    }
    public String getEmplD() {
        return emplD;
    }
    public void setEmplD(String emplD) {
        this.emplD = emplD;
    }

    @Override
    public String toString() {
        return MoreObjects.toStringHelper(Employee.class)
                .add("Name", name)
                .add("Department", dept)
                .add("Emp Id", emplD).toString();
    }
}

测试类

package com.example.guava.cache;

import com.google.common.cache.*;
import com.google.common.collect.ImmutableMap;
import com.google.common.util.concurrent.ListenableFuture;
import junit.framework.TestCase;
import org.assertj.core.util.Lists;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.*;

/**
 * 缓存测试
 */
public class CacheTest extends TestCase {

    public void test1() {
        // 根据员工ID为员工创建缓存
        // 移除监听器
        LoadingCache<String, Object> employeeCache = CacheBuilder.newBuilder()
                .maximumSize(100) // 最多可以缓存100条记录
                .expireAfterAccess(30, TimeUnit.MINUTES) // 缓存将在访问30分钟后过期
                .removalListener((RemovalListener<String, Object>) notification -> System.out.println("notification："+notification))
                .build(new CacheLoader<String, Object>() {

                    // 通常重写一个 load 方法即可
                    @Override
                    public Object load(String key) throws Exception {
                        // 数据库加载
                        return getFromDatabase(key);
                    }

                    @Override
                    public ListenableFuture<Object> reload(String key, Object oldValue) throws Exception {
                        return super.reload(key, oldValue);
                    }
                });


        // 1、单个查询
        System.out.println("1、单个查询");
        try {
            // 在第一次调用时，缓存将填充相应的员工记录
            System.out.println("调用 #1");
            System.out.println(employeeCache.get("100"));
            System.out.println(employeeCache.get("103"));
            System.out.println(employeeCache.get("110"));

            // 第二次调用时，将从缓存中返回数据
            System.out.println("\n调用 #2");
            System.out.println(employeeCache.get("100"));
            System.out.println(employeeCache.get("103"));
            System.out.println(employeeCache.get("110"));

        } catch (ExecutionException e) {
            e.printStackTrace();
        }

        // 第三次调用时 getUnchecked 不执行检查
        System.out.println("\n调用 #3");
        System.out.println(employeeCache.getUnchecked("100"));
        System.out.println(employeeCache.getUnchecked("103"));
        System.out.println(employeeCache.getUnchecked("110"));

        // 2、批量查询
        try {
            System.out.println("\n2、批量查询");
            ImmutableMap<String, Object> cacheAll = employeeCache.getAll(Lists.newArrayList("100", "103", "110"));
            cacheAll.forEach((k, v) -> System.out.println("K：" + k + "，V：" + v));

            // 3、具有回调的查询
            System.out.println("\n3、具有回调的查询");
            String key = "001";
            System.out.println(employeeCache.get(key, new Callable<Employee>() {
                @Override
                public Employee call() throws Exception {
                    return getFromDatabase(key);
                }
            }));

            // lambda写法
            System.out.println(employeeCache.get(key, (Callable<Employee>) () -> getFromDatabase(key)));

            // 4、显示插入 put
            System.out.println("\n4、显示插入");
            employeeCache.put("001","听风");
            System.out.println(employeeCache.get("001"));

            // 5、更改视图
            ConcurrentMap<String, Object> asMap = employeeCache.asMap();
            asMap.put("100","程序喵");
            employeeCache.getAll(Lists.newArrayList("100", "103", "110")).forEach((k, v) -> System.out.println("K：" + k + "，V：" + v));

        } catch (ExecutionException e) {
            e.printStackTrace();
        }

        // 6、清除所有缓存
        System.out.println("\n6、清除所有缓存，调用移除监听器");
        employeeCache.invalidateAll();
    }

    private static Employee getFromDatabase(String empId) {
        Map<String, Employee> database = new HashMap();
        database.put("100", new Employee("Mahesh", "Finance", "100"));
        database.put("103", new Employee("Rohan", "IT", "103"));
        database.put("110", new Employee("Sohan", "Admin", "110"));

        database.put("001", new Employee("Tingfeng", "Admin", "001"));
        System.out.println("数据库命中" + empId);
        return database.get(empId);
    }

}

执行结果

1、单个查询
调用 #1
数据库命中100
Employee{Name=Mahesh, Department=Finance, Emp Id=100}
数据库命中103
Employee{Name=Rohan, Department=IT, Emp Id=103}
数据库命中110
Employee{Name=Sohan, Department=Admin, Emp Id=110}

调用 #2
Employee{Name=Mahesh, Department=Finance, Emp Id=100}
Employee{Name=Rohan, Department=IT, Emp Id=103}
Employee{Name=Sohan, Department=Admin, Emp Id=110}

调用 #3
Employee{Name=Mahesh, Department=Finance, Emp Id=100}
Employee{Name=Rohan, Department=IT, Emp Id=103}
Employee{Name=Sohan, Department=Admin, Emp Id=110}

2、批量查询
K：100，V：Employee{Name=Mahesh, Department=Finance, Emp Id=100}
K：103，V：Employee{Name=Rohan, Department=IT, Emp Id=103}
K：110，V：Employee{Name=Sohan, Department=Admin, Emp Id=110}

3、具有回调的查询
数据库命中001
Employee{Name=Tingfeng, Department=Admin, Emp Id=001}
Employee{Name=Tingfeng, Department=Admin, Emp Id=001}

4、显示插入
notification：001=Employee{Name=Tingfeng, Department=Admin, Emp Id=001}
听风
notification：100=Employee{Name=Mahesh, Department=Finance, Emp Id=100}
K：100，V：程序喵
K：103，V：Employee{Name=Rohan, Department=IT, Emp Id=103}
K：110，V：Employee{Name=Sohan, Department=Admin, Emp Id=110}

6、清除所有缓存，调用移除监听器
notification：001=听风
notification：103=Employee{Name=Rohan, Department=IT, Emp Id=103}
notification：110=Employee{Name=Sohan, Department=Admin, Emp Id=110}
notification：100=程序喵

十四、相关文章


未经允许请勿转载：程序喵 » Google Guava 快速入门 —— Cache 缓存工具

点  赞 (1) 打  赏
分享到：
标签：