Guava cache 示例

pom.xml

        <!-- guava -->
        <dependency>
            <groupId>com.google.guava</groupId>
            <artifactId>guava</artifactId>
            <version>19.0</version>
        </dependency>

code sample:

package com.ctrip.arch.antibot.cepwriter.data.cache;


import com.ctrip.arch.antibot.cepwriter.constant.CommonConstant;
import com.ctrip.arch.antibot.cepwriter.data.entity.BwgResponseEntity;
import com.ctrip.arch.antibot.cepwriter.util.Config;
import com.google.common.cache.*;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.ListeningExecutorService;
import com.google.common.util.concurrent.MoreExecutors;
import org.apache.commons.lang.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;


public class CacheFactory {
    private static final Logger logger = LoggerFactory.getLogger(CacheFactory.class);
    private static class CacheFactorySingletonHolder {
        private static final CacheFactory instance = new CacheFactory();
    }
    private LoadingCache<String, BwgResponseEntity> bwgCache;
    private long maximumSize = 100;
    private long refreshAfterWriteSecond = 30;
    private long expireAfterWriteMinute = 2;
    // guava线程池,用来产生ListenableFuture
    private ListeningExecutorService service = MoreExecutors.listeningDecorator(Executors.newFixedThreadPool(10));



    //========= Private Constructor =========
    private CacheFactory(){
        try{
            init();
            bwgCache = buildBwgCache();
        }catch(Exception e){
            logger.error("CacheFactory(): constructor error!", e);
        }
        logger.info("CacheFactory(): init over ...");
    }

    //init with config parameter
    public void init(){
        Config config = Config.getInstance();
        String maximumSize_str = config.getParamValue(CommonConstant.CACHE_MAXIMUM_SIZE);
        if(StringUtils.isNotBlank(maximumSize_str)){
            try{
                maximumSize = Long.parseLong(maximumSize_str);
            }catch(Exception e){
                logger.error("init(): parameter '" + CommonConstant.CACHE_MAXIMUM_SIZE + "' parse error! it must be an integer.");
            }
        }
        logger.info("init(): maximumSize=[" + maximumSize + "]");

        String refreshAfterWrite_str = config.getParamValue(CommonConstant.CACHE_REFRESH_AFTER_WRITE_SECOND);
        if(StringUtils.isNotBlank(refreshAfterWrite_str)){
            try{
                refreshAfterWriteSecond = Long.parseLong(refreshAfterWrite_str);
            }catch(Exception e){
                logger.error("init(): parameter '" + CommonConstant.CACHE_REFRESH_AFTER_WRITE_SECOND + "' parse error! it must be an integer.");
            }
        }
        logger.info("init(): refreshAfterWriteSecond=[" + refreshAfterWriteSecond + "]");

        String expireAfterWrite_str = config.getParamValue(CommonConstant.CACHE_EXPIRE_AFTER_WRITE_MINUTE);
        if(StringUtils.isNotBlank(expireAfterWrite_str)){
            try{
                expireAfterWriteMinute = Long.parseLong(expireAfterWrite_str);
            }catch(Exception e){
                logger.error("init(): parameter '" + CommonConstant.CACHE_EXPIRE_AFTER_WRITE_MINUTE + "' parse error! it must be an integer.");
            }
        }
        logger.info("init(): expireAfterWriteMinute=[" + expireAfterWriteMinute + "]");
    }

    //Expose method
    public static CacheFactory getInstance(){
        return CacheFactorySingletonHolder.instance;
    }

    //setter/getter
    public LoadingCache<String, BwgResponseEntity> getBwgCache() {
        return bwgCache;
    }


    //========= biz method =========
    /**
     * LoadCache - 不需要延迟处理(泛型的方式封装)
     * @return
     */
    private <K, V> LoadingCache<K, V> initBasicCache(CacheLoader<K, V> cacheLoader) {
        LoadingCache<K, V> cache = CacheBuilder
                .newBuilder()
                .maximumSize(maximumSize)
                .refreshAfterWrite(refreshAfterWriteSecond, TimeUnit.SECONDS)
                .expireAfterWrite(expireAfterWriteMinute, TimeUnit.MINUTES)
                .recordStats()      //设置要统计缓存的命中率
                .removalListener(new RemovalListener<K, V>(){
                    @Override
                    public void onRemoval(RemovalNotification<K, V> rn) {
                        logger.debug("initBasicCache() -> onRemoval(): key=" + rn.getKey() + " is removed ...");
                    }})
                .build(cacheLoader);
        return cache;
    }
    
    /**
     * 获取 bwg cache
     *
     * @return bwgCache
     * @throws Exception
     */  
    private LoadingCache<String, BwgResponseEntity> buildBwgCache() throws Exception {
        LoadingCache<String, BwgResponseEntity> bwgCache = initBasicCache(new CacheLoader<String, BwgResponseEntity>(){
                @Override
                public BwgResponseEntity load(String appId) throws Exception {
                    logger.debug("buildBwgCache() -> load(): load data from db, appId=" + appId);
                    BwgCallable callable = new BwgCallable(appId);
                    return (BwgResponseEntity) callable.call();
                }

                //refresh data synchronously
                @Override
                public ListenableFuture<BwgResponseEntity> reload(String key, BwgResponseEntity oldValue) throws Exception {
                    logger.debug("buildBwgCache() -> reload(): ......后台线程池异步刷新: " + key);
                    BwgCallable callable = new BwgCallable(key);
                    return service.submit(callable);
                }
        });
        return bwgCache;
    }



}