• [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就适合你。

    三: 核心类图

    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/

  • 相关阅读:
    day89
    day88
    day87
    day86
    day85
    day84
    day83
    Maven仓库汇总
    [转载]AngularJS入门教程04:双向绑定
    [转载]AngularJS入门教程03:迭代器
  • 原文地址:https://www.cnblogs.com/wang-meng/p/6130471.html
走看看 - 开发者的网上家园