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;
     }

 }