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

最新推荐文章于 2024-03-06 16:59:50 发布

weixin_34198797

最新推荐文章于 2024-03-06 16:59:50 发布

阅读量118

点赞数

文章标签： java 数据库 markdown

前言

今天第一次使用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就适合你。

三: 核心类图

file-list

四: 使用实例

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

在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/