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

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 抛出 InterruptedExceptionCache.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 缓存工具

点  赞 (0) 打  赏
分享到: