guava cache使用例子

最新推荐文章于 2024-09-07 23:11:32 发布

haozi_ncepu

最新推荐文章于 2024-09-07 23:11:32 发布

阅读量2.3k

点赞数

分类专栏： cache

cache 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

关于介绍请参考:http://blog.csdn.net/liangrui1988/article/details/46120533#

下面是测试代码，下载源码可在github上获取:https://github.com/liangrui1988/guavaTest

[java]view plaincopy 
   
 package org.rui.test;  
   
 import java.util.concurrent.Callable;  
 import java.util.concurrent.ExecutionException;  
   
 import org.junit.Test;  
   
 import com.google.common.cache.Cache;  
 import com.google.common.cache.CacheBuilder;  
 import com.google.common.cache.CacheLoader;  
 import com.google.common.cache.LoadingCache;  
 import com.google.common.cache.Weigher;  
   
 /** 
  * 　Guava Cache有两种创建方式： 
  *  
  * 　　1. cacheLoader 　　2. callable callback 
  *  
  * 　　通过这两种方法创建的cache，和通常用map来缓存的做法比，不同在于，这两种方法都实现了一种逻辑——从缓存中取key 
  * X的值，如果该值已经缓存过了，则返回缓存中的值 
  * ，如果没有缓存过，可以通过某个方法来获取这个值。但不同的在于cacheloader的定义比较宽泛，是针对整个cache定义的 
  * ，可以认为是统一的根据key值load value的方法。而callable的方式较为灵活，允许你在get的时候指定。 
  *  
  * @author liangrui 
  * 
  */  
 public class Tests  
 {  
   
     /** 
      * CacheLoader 
      */  
     @Test  
     public void loadingCache()  
     {  
         LoadingCache<String, String> graphs = CacheBuilder.newBuilder()  
                 .maximumSize(1000).build(new CacheLoader<String, String>()  
                 {  
                     @Override  
                     public String load(String key) throws Exception  
                     {  
                         System.out.println("key:"+key);  
                         if("key".equals(key)){  
                             return "key return result";  
                         }else{  
                             return "get-if-absent-compute";  
                         }  
                           
                           
                     }  
   
                 });  
   
         String resultVal = null;  
         try {  
             resultVal = graphs.get("key");  
         } catch (ExecutionException e) {  
             e.printStackTrace();  
         }  
           
         System.out.println(resultVal);  
     }  
   
     /** 
      *  
      * Callable 
      * 在使用缓存前，首先问自己一个问题：有没有合理的默认方法来加载或计算与键关联的值？如果有的话，你应当使用CacheLoader。如果没有， 
      * 或者你想要覆盖默认的加载运算，同时保留"获取缓存-如果没有-则计算"[get-if-absent-compute]的原子语义， 
      * 你应该在调用get时传入一个Callable实例 
      * 。缓存元素也可以通过Cache.put方法直接插入，但自动加载是首选的，因为它可以更容易地推断所有缓存内容的一致性。 
      */  
     @Test  
     public void callablex() throws ExecutionException  
     {  
   
         Cache<String, String> cache = CacheBuilder.newBuilder()  
                 .maximumSize(1000).build();  
   
         String result = cache.get("key", new Callable<String>()  
         {  
             public String call()  
             {  
                 return "result";  
             }  
         });  
         System.out.println(result);  
     }  
   
     /** 
      * 从LoadingCache查询的正规方式是使用get(K)方法。这个方法要么返回已经缓存的值，要么使用CacheLoader向缓存原子地加载新值。 
      * 由于CacheLoader可能抛出异常，LoadingCache.get(K)也声明为抛出ExecutionException异常。 
      * 如果你定义的CacheLoader没有声明任何检查型异常 
      * ，则可以通过getUnchecked(K)查找缓存；但必须注意，一旦CacheLoader声明了检查型异常 
      * ，就不可以调用getUnchecked(K)。 
      *  
      * @throws ExecutionException 
      */  
     @Test  
     public void capacity()  
     {  
         LoadingCache<String, String> graphs = CacheBuilder.newBuilder()  
                 .maximumWeight(100000).weigher(new Weigher<String, String>()  
                 {  
                     public int weigh(String k, String g)  
                     {  
                         return 100;  
                     }  
                 }).build(new CacheLoader<String, String>()  
                 {  
                     public String load(String key)  
                     { // no checked exception  
                         // return createExpensiveGraph(key);  
                         return "xxxx";  
                     }  
                 });  
   
     }  
 }  

[java]view plaincopy 
   
 package org.rui.test;  
   
 import java.util.concurrent.Callable;  
 import java.util.concurrent.ExecutionException;  
 import java.util.concurrent.TimeUnit;  
   
 import org.junit.Test;  
   
 import com.google.common.cache.Cache;  
 import com.google.common.cache.CacheBuilder;  
 import com.google.common.cache.CacheStats;  
 import com.google.common.cache.RemovalListener;  
 import com.google.common.cache.RemovalNotification;  
 import com.google.common.cache.Weigher;  
   
 /** 
  * cache的参数说明： 
  *  
  * 　　回收的参数： 　　1. 大小的设置：CacheBuilder.maximumSize(long) 
  * CacheBuilder.weigher(Weigher) CacheBuilder.maxumumWeigher(long) 　　2. 
  * 时间：expireAfterAccess(long, TimeUnit) expireAfterWrite(long, TimeUnit) 　　3. 
  * 引用：CacheBuilder.weakKeys() CacheBuilder.weakValues() 
  * CacheBuilder.softValues() 　　4. 明确的删除：invalidate(key) invalidateAll(keys) 
  * invalidateAll() 　　5. 删除监听器：CacheBuilder.removalListener(RemovalListener) 　　 
  *  
  * 　　refresh机制： 　　1. LoadingCache.refresh(K) 在生成新的value的时候，旧的value依然会被使用。 　　2. 
  * CacheLoader.reload(K, V) 生成新的value过程中允许使用旧的value 　　3. 
  * CacheBuilder.refreshAfterWrite(long, TimeUnit) 自动刷新cache 
  * 
  * 
  */  
 public class Eviction  
 {  
   
     /** 
      * 基于容量的回收 
      * 
      * 
      * maximumSize(1) 缓存将尝试回收最近没有使用或总体上很少使用的缓存项 
      *  
      * 不同的缓存项有不同的“权重”（weights）——例如，如果你的缓存值 
      * ，占据完全不同的内存空间，你可以使用CacheBuilder.weigher(Weigher)指定一个权重函数 
      *  
      */  
   
     @Test  
     public void callablex() throws ExecutionException, InterruptedException  
     {  
         // .maximumSize(100)  
         Cache<String, User2> cache = CacheBuilder.newBuilder().maximumWeight(5)  
                 .weigher(new Weigher<String, User2>()  
                 {  
                     @Override  
                     public int weigh(String arg0, User2 user)  
                     {  
                         return 3;  
                     }  
                 }).removalListener(new RemovalListener<String, User2>()  
                 {  
                     @Override  
                     public void onRemoval(RemovalNotification<String, User2> rn)  
                     {  
                         System.out.println(rn.getKey() + "==被移除");  
                     }  
   
                 }).build();  
   
         User2 result = cache.get("key", new Callable<User2>()  
         {  
             public User2 call()  
             {  
                 return new User(1, "liang");  
             }  
         });  
   
         // Thread.sleep(10000);  
   
         User result2 = (User) cache.get("key2", new Callable<User2>()  
         {  
             public User2 call()  
             {  
                 return new User(2, "liang2");  
             }  
         });  
   
         User result3 = (User) cache.get("key3", new Callable<User>()  
         {  
             public User call()  
             {  
                 return new User(3, "liang3");  
             }  
         });  
   
         System.out.println(result);  
         System.out.println(result2);  
         System.out.println(result3);  
         System.out.println(cache.size());  
     }  
   
     /** 
      *  
      *  
      * 定时回收（Timed Eviction） expireAfterAccess(long, 
      * TimeUnit)：缓存项在给定时间内没有被读/写访问，则回收。请注意这种缓存的回收顺序和基于大小回收一样。 
      * expireAfterWrite(long, 
      * TimeUnit)：缓存项在给定时间内没有被写访问（创建或覆盖），则回收。如果认为缓存数据总是在固定时候后变得陈旧不可用，这种回收方式是可取的。 
      *  
      *  
      *  
      * // .expireAfterWrite(5, TimeUnit.SECONDS)//给定时间内没有写访问，则回收。 27 // 
      * .expireAfterAccess(3, TimeUnit.SECONDS)// 缓存过期时间为3秒 
      *  
      * @param args 
      */  
   
     Cache<String, User2> cache2 = CacheBuilder.newBuilder().maximumSize(100)  
             .expireAfterWrite(3, TimeUnit.MILLISECONDS)  
             // .expireAfterAccess(3000, TimeUnit.MILLISECONDS)  
             .removalListener(new RemovalListener<String, User2>()  
             {  
                 @Override  
                 public void onRemoval(RemovalNotification<String, User2> rn)  
                 {  
                     System.out.println("Cause:" + rn.getCause() + " k: "  
                             + rn.getKey() + " v :" + rn.getValue() + "==被移除");  
                 }  
   
             }).build();  
   
     @Test  
     public void timerEvication() throws ExecutionException,  
             InterruptedException  
     {  
   
         User2 user = cache2.get("k1", new Callable<User2>()  
         {  
             @Override  
             public User2 call() throws Exception  
             {  
   
                 return new User(100, "hello");  
             }  
         });  
         Thread.sleep(8000);  
         System.out.println(cache2.size());  
   
         User2 user2 = cache2.get("k2", new Callable<User2>()  
         {  
             @Override  
             public User2 call() throws Exception  
             {  
   
                 return new User(200, "hello2");  
             }  
         });  
         System.out.println(user);  
         Thread.sleep(8000);  
         user = cache2.get("k1", new Callable<User2>()  
         {  
             @Override  
             public User2 call() throws Exception  
             {  
   
                 return new User(10000000, "k1k1k1k1k1k1k1");  
             }  
         });  
   
         System.out.println(cache2.size());  
   
         User2 user3 = cache2.get("k3", new Callable<User2>()  
         {  
             @Override  
             public User2 call() throws Exception  
             {  
   
                 return new User(300, "hello3");  
             }  
         });  
   
         System.out.println(user);  
         System.out.println(user2);  
         System.out.println(user3);  
   
         Thread.sleep(10000);  
         System.out.println(cache2.size());  
         CacheStats status = cache2.stats();  
         status.missCount();  
   
     }  
   
     /** 
      * 显式清除 
      *  
      * 任何时候，你都可以显式地清除缓存项，而不是等到它被回收： 
      *  
      * 个别清除：Cache.invalidate(key) 批量清除：Cache.invalidateAll(keys) 
      * 清除所有缓存项：Cache.invalidateAll() 
      *  
      * @param args 
      */  
   
     Cache<String, User2> cache3 = CacheBuilder.newBuilder().maximumSize(100)  
             .removalListener(new RemovalListener<String, User2>()  
             {  
                 @Override  
                 public void onRemoval(RemovalNotification<String, User2> rn)  
                 {  
                     System.out.println("Cause:" + rn.getCause() + " k: "  
                             + rn.getKey() + " v :" + rn.getValue() + "==被移除");  
                 }  
   
             }).build();  
   
     @Test  
     public void clear() throws ExecutionException  
     {  
   
         User2 u = cache3.get("u1", new Callable<User2>()  
         {  
             @Override  
             public User2 call() throws Exception  
             {  
                 System.out.println("exec call>>>return result");  
                 return new User(500, "world");  
             }  
         });  
   
         System.out.println(u);  
   
         u = cache3.get("u1", new Callable<User2>()  
         {  
             @Override  
             public User2 call() throws Exception  
             {  
                 System.out.println("exec call>>>return result");  
                 return new User(500, "world");  
             }  
         });  
         System.out.println(u);  
         cache3.invalidate("u1");  
         u = cache3.get("u1", new Callable<User2>()  
         {  
             @Override  
             public User2 call() throws Exception  
             {  
                 System.out.println("exec call>>>return result");  
                 return new User(500, "world");  
             }  
         });  
           
           
           
           
     }  
   
 }  

[java]view plaincopy 
   
 package org.rui.test;  
   
 import java.util.concurrent.Callable;  
 import java.util.concurrent.ExecutionException;  
 import java.util.concurrent.Executor;  
 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.util.concurrent.Futures;  
 import com.google.common.util.concurrent.ListenableFuture;  
 import com.google.common.util.concurrent.ListenableFutureTask;  
   
 /** 
  * 刷新和回收不太一样。正如LoadingCache.refresh(K)所声明，刷新表示为键加载新值，这个过程可以是异步的。在刷新操作进行时， 
  * 缓存仍然可以向其他线程返回旧值，而不像回收操作，读缓存的线程必须等待新值加载完成。 
  *  
  * 如果刷新过程抛出异常，缓存将保留旧值，而异常会在记录到日志后被丢弃 
  *  
  * @author lenovo 
  * 
  */  
 public class Refresh  
 {  
   
     static int ixs = 0;  
   
     public static void main(String[] args) throws InterruptedException,  
             ExecutionException  
     {  
   
         LoadingCache<String, String> graphs = CacheBuilder.newBuilder()  
                 .maximumSize(1000).refreshAfterWrite(1, TimeUnit.MICROSECONDS)  
                 .build(new CacheLoader<String, String>()  
                 {  
                     @Override  
                     public ListenableFuture<String> reload(final String key,  
                             String oldValue) throws Exception  
                     {  
                         System.out.println("oldValue:" + oldValue);  
                         ixs++;  
                         if (key.equals("keyx")) {  
                             return Futures.immediateFuture("new Values_" + ixs);  
                         } else {  
   
                             ListenableFutureTask<String> taks = ListenableFutureTask  
                                     .create(new Callable<String>()  
                                     {  
                                         @Override  
                                         public String call() throws Exception  
                                         {  
                                             return key + " xxxxxx_" + ixs;  
                                         }  
                                     });  
                             Executor executor = new ExecutorImple();  
                             executor.execute(taks);  
                             return taks;  
                         }  
   
                     }  
   
                     @Override  
                     public String load(String arg0) throws Exception  
                     {  
                         return "get-if-absent-compute_" + ixs;  
                     }  
   
                 });  
   
         String resultVal = null;  
   
         resultVal = graphs.get("key");  
   
         System.out.println(resultVal);  
         Thread.sleep(2000);  
         resultVal = graphs.get("key");  
         System.out.println(resultVal);  
         Thread.sleep(2000);  
         resultVal = graphs.get("key");  
         System.out.println(resultVal);  
         Thread.sleep(5000);  
         resultVal = graphs.get("key");  
         System.out.println(resultVal);  
     }  
 }  

[java]view plaincopy 
   
 package org.rui.test;  
   
 import java.util.Iterator;  
 import java.util.Set;  
 import java.util.concurrent.Callable;  
 import java.util.concurrent.ExecutionException;  
   
 import org.junit.Test;  
   
 import com.google.common.cache.Cache;  
 import com.google.common.cache.CacheBuilder;  
 import com.google.common.cache.CacheStats;  
   
 /** 
  * 统计 信息 
  *  
  * @author lenovo 
  * 
  */  
 public class RecordStatus  
 {  
     Cache<String, String> cache = CacheBuilder.newBuilder().maximumSize(2)  
             .recordStats().build();  
   
     @Test  
     public void loadCached() throws ExecutionException  
     {  
         String result = cache.get("key", new Callable<String>()  
         {  
             public String call()  
             {  
                 return "result";  
             }  
         });  
   
         String result2 = cache.get("key2", new Callable<String>()  
         {  
             public String call()  
             {  
                 return "result2";  
             }  
         });  
   
         String result3 = cache.get("key3", new Callable<String>()  
         {  
             public String call()  
             {  
                 return "result3";  
             }  
         });  
   
         result = cache.get("key", new Callable<String>()  
         {  
             public String call()  
             {  
                 return "result";  
             }  
         });  
   
         System.out.println(result);  
         System.out.println(result2);  
         System.out.println(result3);  
         System.out.println(cache.getIfPresent("key"));  
   
         //  
         CacheStats cstats = cache.stats();  
         System.out.println("loadCount:" + cstats.loadCount()  
                 + "  loadSuccessCount： " + cstats.loadSuccessCount());  
   
         System.out.println("缓存命中率:" + cstats.hitRate() + " hitCount: "  
                 + cstats.hitCount());// 缓存命中率；  
         System.out.println("加载新值的平均时间:" + cstats.averageLoadPenalty() + " 纳秒");// 加载新值的平均时间，单位为纳秒；  
         System.out.println("缓存项被回收的总数:" + cstats.evictionCount());// 缓存项被回收的总数，不包括显式清除。  
         System.out.println();  
   
         // cache.asMap().entrySet()  
         Set<String> set = cache.asMap().keySet();// 所有健  
         Iterator<String> it = set.iterator();  
         System.out.println("all key====");  
         while (it.hasNext()) {  
   
             System.out.print(it.next() + " \t ");  
         }  
         System.out.println();  
   
     }  
   
 }  

下面是本人自已的想法，还没正实可用性，仅参考

[html]view plaincopy 
   
 package org.rui.utils;  
   
 import java.util.concurrent.Callable;  
 import java.util.concurrent.ExecutionException;  
   
 import com.google.common.cache.Cache;  
   
 /**  
  * guava cached 共公接口  
  *   
  * @author liangrui  
  * @date 2015/6/7  
  * @param <K>  
  * @param <V>  
  */  
 public interface ICached<K, V>  
 {  
     /**  
      * callable 获取cached 方式  
      *   
      * @param key  
      * @param callable  
      * @return  
      * @throws ExecutionException  
      */  
     V getCallable(K key, Callable<V> callable) throws ExecutionException;  
   
     /**  
      * cachedLoader 获取方式  
      *   
      * @param key  
      * @return  
      * @throws ExecutionException  
      */  
     V getLoader(K key) throws ExecutionException;  
   
     /**  
      * 获取某一项的 缓存  
      *   
      * @param Cached  
      * @return  
      */  
     Cache getCache(String Cached);  
   
     /**  
      * 获取所有guava 缓存  
      *   
      * @return  
      */  
     Cache[] getCache();  
   
 }  

[html]view plaincopy 
   
 package org.rui.utils;  
   
 import java.util.concurrent.Callable;  
 import java.util.concurrent.ExecutionException;  
 import java.util.concurrent.TimeUnit;  
   
 import com.google.common.cache.Cache;  
 import com.google.common.cache.CacheBuilder;  
 import com.google.common.cache.CacheLoader;  
 import com.google.common.cache.LoadingCache;  
   
 /**  
  * 方便统一管理缓存 关于配置可根据系统实际情况配置  
  *   
  * @date 2015/6/7  
  * @author liangrui  
  *  
  */  
 public class GuavaCachedImpl implements ICached<String, Object>  
 {  
     /*** cached 缓存最大数量 **/  
     public static final Integer CACHE_MAXIMUMSIZE = 10000;//  
     /** loaderCached 缓存最大数量 **/  
     public static final Integer LOADING_CACHE_MAXIMUMSIZE = 10000;  
     /*** 缓存项在给定时间内没有被写访问（创建或覆盖），则回收 **/  
     public static final Integer EXPIRE_AFTER_WRITE_MILLISECONDS = 1000;  
   
     private Cache<String, Object> cache = CacheBuilder  
             .newBuilder()  
             .maximumSize(CACHE_MAXIMUMSIZE)  
             .expireAfterWrite(EXPIRE_AFTER_WRITE_MILLISECONDS,  
                     TimeUnit.MILLISECONDS).recordStats().build();  
   
     private LoadingCache<String, Object> loadingCached = CacheBuilder  
             .newBuilder()  
             .maximumSize(LOADING_CACHE_MAXIMUMSIZE)  
             .expireAfterWrite(EXPIRE_AFTER_WRITE_MILLISECONDS,  
                     TimeUnit.MILLISECONDS)  
             .build(new CacheLoader<String, Object>()  
             {  
                 @Override  
                 public String load(String key) throws Exception  
                 {  
                     System.out.println("key:" + key);  
                     if ("key".equals(key)) {  
                         return "key return result";  
                     } else {  
                         return "get-if-absent-compute";  
                     }  
   
                 }  
   
             });  
   
     @Override  
     public Object getCallable(String key, Callable<Object> callable)  
             throws ExecutionException  
     {  
         Object value = cache.get(key, callable);  
         return value;  
     }  
   
     @Override  
     public Object getLoader(String key) throws ExecutionException  
     {  
         return loadingCached.get(key);  
     }  
   
     @Override  
     public Cache getCache(String cahced)  
     {  
         if ("cache".equals(cahced)) {  
             return cache;  
         }  
         if ("loadingCached".equals(cahced)) {  
             return loadingCached;  
         } else {  
   
         }  
         return null;  
     }  
   
     @Override  
     public Cache[] getCache()  
     {  
         Cache[] cacheArray = new Cache[]  
         { cache, loadingCached };  
   
         return cacheArray;  
     }  
   
 }  

[html]view plaincopy 
   
 package org.rui.utils;  
   
 import java.util.Iterator;  
 import java.util.Map.Entry;  
 import java.util.Set;  
 import java.util.concurrent.Callable;  
 import java.util.concurrent.ExecutionException;  
   
 import com.google.common.cache.Cache;  
 import com.google.common.cache.CacheStats;  
   
 /**  
  * cache 测试  
  *   
  * @author lenovo  
  *  
  */  
 public class Main  
 {  
   
     public static void main(String[] args) throws ExecutionException  
     {  
         ICached<String, Object> cached = new GuavaCachedImpl();  
   
         Object result = cached.getCallable("key1", new Callable<Object>()  
         {  
             @Override  
             public Object call() throws Exception  
             {  
                 return "|cached value|";  
             }  
         });  
   
         System.out.println(cached.getLoader("key"));  
         System.out.println(result);  
   
         printStats(cached.getCache());  
   
     }  
   
     /**  
      * 打印缓存状态信息  
      *   
      * @param caches  
      */  
     public static void printStats(Cache[] caches)  
     {  
   
         System.out.println("打印缓存状态信息");  
         for (Cache cache : caches) {  
             System.out.println();  
             System.out  
                     .println("start------------------------------------------> ");  
             System.out.println("loadCount:" + cache.stats().loadCount()  
                     + "  loadSsuccessCount： "  
                     + cache.stats().loadSuccessCount());  
   
             System.out.println("缓存命中率:" + cache.stats().hitRate()  
                     + " hitCount: " + cache.stats().hitCount());// 缓存命中率；  
             System.out.println("加载新值的平均时间:"  
                     + cache.stats().averageLoadPenalty() + " 纳秒");// 加载新值的平均时间，单位为纳秒；  
             System.out.println("缓存项被回收的总数:" + cache.stats().evictionCount());// 缓存项被回收的总数，不包括显式清除。  
             System.out.println();  
   
             System.out.println();  
             System.out.println("cached 健和值 ===============");  
   
             Set setEn = cache.asMap().entrySet();  
             Iterator<Object> it = setEn.iterator();  
             System.out.println();  
             System.out.println("all entrySet====>");  
             while (it.hasNext()) {  
                 System.out.print(it.next() + " \t ");  
             }  
   
             System.out.println();  
             System.out.println();  
             Set<String> set = cache.asMap().keySet();// 所有健  
             Iterator<String> it2 = set.iterator();  
             System.out.println("all key====>");  
             while (it2.hasNext()) {  
                 System.out.print(it2.next() + " \t ");  
             }  
             System.out.println();  
             System.out  
                     .println("end------------------------------------------> ");  
         }  
     }  
   
 }  
 
   
 
 
  
  
 