本地缓存之GUAVA

      项目开发中，不少配置数据须要缓存，通常来讲，开发人员都会手动写HashMap，HashSet或者ConcurrentHashMap，ConcurrentHashSet缓存数据，可是这样的缓存每每存在内存泄漏，刷新机制不健全等缺点。实际上有很多第三方组件实现了功能完善的本地缓存，建议你们直接使用成熟的本地缓存组件，这里主要介绍一下google的guava。

      总体来看，guava首次查询数据时使用用户实现的load方法加载数据，以后再次查询该数据就能够直接从内存中获取，没必要走load方法了。固然，guava实现了缓存超时，缓存大小限制等管理机制，使用起来十分方便。废话很少说，直接看代码。

package com.coshaho.learn.guava;

import java.util.concurrent.TimeUnit;

import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;
import com.google.common.cache.Weigher;

/**
 * 
 * BaseCache.java Create on 2017年2月21日 下午9:42:55    
 *    
 * 类功能说明: GUAVA缓存
 *
 * Copyright: Copyright(c) 2013 
 * Company: COSHAHO
 * @Version 1.0
 * @Author coshaho
 */
public abstract class BaseCache<K, V> 
{
	private LoadingCache<K,V> cache;

    public BaseCache()
    {
        cache = CacheBuilder.newBuilder()
        		.maximumSize(10000)
                .build(new CacheLoader<K, V>() {
                    @Override
                    public V load(K k) throws Exception 
                    {
                        return loadData(k);
                    }
                });
    }

    /**
     * 超时缓存：数据写入缓存超过必定时间自动刷新
     * @param duration
     * @param timeUtil
     */
    public BaseCache(long duration, TimeUnit timeUtil)
    {
        cache = CacheBuilder.newBuilder()
                .expireAfterWrite(duration, timeUtil)
                .build(new CacheLoader<K, V>() {
                    @Override
                    public V load(K k) throws Exception 
                    {
                        return loadData(k);
                    }
                });
    }
    
    /**
     * 限容缓存：缓存数据个数不能超过maxSize
     * @param maxSize
     */
    public BaseCache(long maxSize)
    {
        cache = CacheBuilder.newBuilder()
                .maximumSize(maxSize)
                .build(new CacheLoader<K, V>() {
                    @Override
                    public V load(K k) throws Exception 
                    {
                        return loadData(k);
                    }
                });
    }
    
    /**
     * 权重缓存：缓存数据权重和不能超过maxWeight
     * @param maxWeight
     * @param weigher：权重函数类，须要实现计算元素权重的函数
     */
    public BaseCache(long maxWeight, Weigher<K, V> weigher)
    {
        cache = CacheBuilder.newBuilder()
                .maximumWeight(maxWeight)
                .weigher(weigher)
                .build(new CacheLoader<K, V>() {
                    @Override
                    public V load(K k) throws Exception 
                    {
                        return loadData(k);
                    }
                });
    }


    /**
     * 
     * 缓存数据加载方法
     * @author coshaho 
     * @param k
     * @return
     */
    protected abstract V loadData(K k);

    /**
     * 
     * 从缓存获取数据
     * @author coshaho 
     * @param param
     * @return
     */
    public V getCache(K param)
    {
        return cache.getUnchecked(param);
    }

    /**
     * 
     * 清除缓存数据，缓存清除后，数据会从新调用load方法获取
     * @author coshaho 
     * @param k
     */
    public void refresh(K k)
    {
        cache.refresh(k);
    }
    
    /**
     * 
     * 主动设置缓存数据
     * @author coshaho 
     * @param k
     * @param v
     */
    public void put(K k, V v)
    {
        cache.put(k, v);
    }
}