[Java 缓存] Java Cache之 Guava Cache的简单应用.

前言

今天第一次使用MarkDown的形式发博客. 准备记录一下自己对Guava Cache的认识及项目中的实际使用经验.

一: 什么是Guava

Guava工程包含了若干被Google的 Java项目广泛依赖 的核心库，例如：集合 [collections] 、缓存 [caching] 、原生类型支持 [primitives support] 、并发库 [concurrency libraries] 、通用注解 [common annotations] 、字符串处理 [string processing] 、I/O 等等。 所有这些工具每天都在被Google的工程师应用在产品服务中。

//Guava Cache的使用
LoadingCache<Key, Graph> graphs = CacheBuilder.newBuilder()
        .expireAfterAccess(10, TimeUnit.MINUTES)
        .build(
            new CacheLoader<Key, Graph>() {
                public Graph load(Key key) { // no checked exception
                    return createExpensiveGraph(key);
                }
            });

...
return graphs.getUnchecked(key);

二: 使用场景

当我们使用一种新工具的时候 我们总要先弄清楚它到底适用于什么样的场景.

• 你愿意消耗一些内存空间来提升速度。
• 你预料到某些键会被查询一次以上。
• 缓存中存放的数据总量不会超出内存容量。（Guava Cache是单个应用运行时的本地缓存。它不把数据存放到文件或外部服务器。如果这不符合你的需求，请尝试Memcached这类工具）

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

三: 核心类图

四: 使用实例

前面说了这么多, 都不如如何使用来的实在. 现在直接贴出来使用的实例, 具体实现的逻辑大家可以看下源码, 这里也会有一些实际的讲解.

在pom文件中引入Guava Cache的坐标:

<dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
</dependency>

下面拿我们实际项目中使用的一个GuavaCache来举例:

public abstract class BaseCacheService<K,V> {
    private LoadingCache<K,V> cache;

    public BaseCacheService(){
        cache = CacheBuilder.newBuilder()
                .expireAfterWrite(30, TimeUnit.MINUTES)
                .build(new CacheLoader<K, V>() {
                    @Override
                    public V load(K k) throws Exception {
                        return loadData(k);
                    }
                });
    }

    public BaseCacheService(long duration){
        cache = CacheBuilder.newBuilder()
                .expireAfterWrite(duration, TimeUnit.MINUTES)
                .build(new CacheLoader<K, V>() {
                    @Override
                    public V load(K k) throws Exception {
                        return loadData(k);
                    }
                });
    }

    protected abstract V loadData(K k);

    public V getCache(K param){
        return cache.getUnchecked(param);
    }

    //更新缓存中数据
    public void refresh(K k){
        cache.refresh(k);
    }
}

这里我是抽象出来了一个BaseCacheService, 当我们使用时则可以继承这个抽象类:
如果我们第一次请求, 那么这会执行这里面的load方法去数据库中查询相应的值, 当第二次请求时这会从缓存中直接返回了.

@Service
public class MaterialInfoCacheService extends BaseCacheService<Long, List<MaterialInfoDto>> {

    @Override
    protected List<MaterialInfoDto> loadData(Long key) {
        //具体的查询数据库得到数据的逻辑.

        return materialInfoDtos;
    }
}

这里面有关于缓存的回收(expireAfterWrite), 有关于缓存的刷新(refresh)等, 这些东西会一一来介绍.

缓存的回收:

1, 基于容量的回收（size-based eviction）
如果要规定缓存项的数目不超过固定值，只需使用CacheBuilder.maximumSize(long)。缓存将尝试回收最近没有使用或总体上很少使用的缓存项。——警告：在缓存项的数目达到限定值之前，缓存就可能进行回收操作——通常来说，这种情况发生在缓存项的数目逼近限定值时。

另外，不同的缓存项有不同的“权重”（weights）——例如，如果你的缓存值，占据完全不同的内存空间，你可以使用CacheBuilder.weigher(Weigher)指定一个权重函数，并且用CacheBuilder.maximumWeight(long)指定最大总重。在权重限定场景中，除了要注意回收也是在重量逼近限定值时就进行了，还要知道重量是在缓存创建时计算的，因此要考虑重量计算的复杂度。

LoadingCache<Key, Graph> graphs = CacheBuilder.newBuilder()
        .maximumWeight(100000)
        .weigher(new Weigher<Key, Graph>() {
            public int weigh(Key k, Graph g) {
                return g.vertices().size();
            }
        })
        .build(
            new CacheLoader<Key, Graph>() {
                public Graph load(Key key) { // no checked exception
                    return createExpensiveGraph(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比较值。

其实这里使用最多的还是基于时间的定时回收, 其他的两种回收方式大家可以根据自己的项目而定.

缓存的显示刷新和清除:

(任何时候，你都可以显式地清除缓存项，而不是等到它被回收)
这里需要说明下刷新(refresh)和清除(invalidate)的区别:
刷新和回收不太一样。正如LoadingCache.refresh(K)所声明，刷新表示为键加载新值，这个过程可以是异步的。在刷新操作进行时，
缓存仍然可以向其他线程返回旧值，而不像回收操作，读缓存的线程必须等待新值加载完成。
如果刷新过程抛出异常，缓存将保留旧值，而异常会在记录到日志后被丢弃 .

• 刷新: Cache.refresh(K k)
• 个别清除：Cache.invalidate(key)
• 批量清除：Cache.invalidateAll(keys)
• 清除所有缓存项：Cache.invalidateAll()

三: 使用实例

这里更新下我在项目中常用的guava cache的实例. 更新于2016年12月14日.

LoadingCache<String, Map<Long, CarAttentionDTO>> cache = CacheBuilder.newBuilder()
            .expireAfterAccess(30, TimeUnit.MINUTES)
            .build(new CacheLoader<String, Map<Long, CarAttentionDTO>>() {
                public Map<Long, CarAttentionDTO> load(String key) { // no checked exception
                    LOGGER.info("loading car week attention data......");
                    long startTime = System.currentTimeMillis();
                    List<String> groupBy = Lists.newArrayList();
                    groupBy.add("key2");

                    Map<String, String> where = Maps.newHashMap();
                    where.put("group_name", String.valueOf(CommonConstants.CounterGroup.ATTENTION));
                    where.put("key1", String.valueOf(CommonConstants.DataType.CAR));

                    Calendar cal = Calendar.getInstance();
                    Date dateTo = DateUtils.addDays(cal.getTime(), -1);
                    Date dateFrom = DateUtils.addDays(cal.getTime(), -8);

                    int dayTo = Integer.valueOf(DateFormatUtils.format(dateTo, "yyyyMMdd"));
                    int dayFrom = Integer.valueOf(DateFormatUtils.format(dateFrom, "yyyyMMdd"));
                    List<CountDayUvEntity> list = uvEntityDao.countByParams(groupBy, where, dayFrom, dayTo);

                    int multiple = configReader.getInt(CommonConstants.SystemConfigKey.ATTENTION_MULTIPLE, 53);
                    Map<Long, CarAttentionDTO> tempMap = Maps.newHashMap();
                    for (CountDayUvEntity uvEntity : list) {
                        CarAttentionDTO attentionDTO = new CarAttentionDTO();
                        attentionDTO.setCarId(Long.valueOf(uvEntity.getKey2()));
                        attentionDTO.setAttention(uvEntity.getCount() * multiple + RandomUtils.nextInt(0, 10));
                        tempMap.put(attentionDTO.getCarId(), attentionDTO);
                    }

                    LOGGER.info("load car week attention finished. useTime=" + (System.currentTimeMillis() - startTime));
                    return tempMap;
                }
            });

private Cache<String, Object> carIndexCache = CacheBuilder.newBuilder().expireAfterAccess(20, TimeUnit.MINUTES).build();

public Map<Long, Long> getCarAttentions() throws ExecutionException {
        String key = "getCarAttentions";
        return (Map<Long, Long>) carIndexCache.get(key, new Callable<Map<Long, Long>>() {
            @Override
            public Map<Long, Long> call() throws Exception {
                List<CarIndexEntity> carIndexs = carIndexEntityDao.findAll(
                        CarIndexEntity.Fields.type.eq(CommonConstants.CarIndexStatus.ATTENTION));
                Map<Long, Long> data = Maps.newHashMapWithExpectedSize(carIndexs.size());
                for (CarIndexEntity carIndex : carIndexs) {
                    data.put(carIndex.getCarId(), carIndex.getCount());
                }
                return data;
            }
        });
    }

public Map<Long, Long> getCarSales() throws ExecutionException {
        String key = "getCarSales";
        return (Map<Long, Long>) carIndexCache.get(key, new Callable<Map<Long, Long>>() {
            @Override
            public Map<Long, Long> call() throws Exception {
                List<CarIndexEntity> carIndexs = carIndexEntityDao.findAll(
                        CarIndexEntity.Fields.type.eq(CommonConstants.CarIndexStatus.SALES));
                Map<Long, Long> data = Maps.newHashMapWithExpectedSize(carIndexs.size());
                for (CarIndexEntity carIndex : carIndexs) {
                    data.put(carIndex.getCarId(), carIndex.getCount());
                }

                return data;
            }
        });
    }

其实两种情况都是一样的, 第二个是使用场景是一个service有多个方法都需要用到guava cache.

好了 知道了这些就可以在项目中直接使用了, 更多的内容请看Guava Cache官方文档(翻译版):http://ifeve.com/google-guava-cachesexplained/