本地缓存-应用级缓存之Guava Cache

参考：

1.http://blog.csdn.net/kobejayandy/article/details/13277035

2.http://www.cnblogs.com/peida/p/Guava_Cache.html

 

一.Guava简介：

1.Google Guava库是一个非常优秀的包含很多Java工具类集的库，使用Google Guava来编写优雅的代码

 

2.与现有的Apache Commons相比：同样出色，并且目前发展比Apache Commons系列更为迅速的Google Guava库。

3.内容：Guava本身是Google内部的核心Java基础库，其涵盖的内容包含集合、缓存、基础类型、并发处理、常用注解、字符串处理、I/O、网络、数学运算、反射、范围(Range)等方面。

4.为什么要使用Guava：Guava的开发活跃度和良好的质量保证是我更愿意转而使用Guava的的原因之一。Guava几年发展下来各界发表的各类文章和其自身良好的文档风格也极大的帮助了该库的传播使用
注：从上面的Stackoverflow的讨论来看，google的java开发主管带领的小组负责该库的主要维护工作

5.Guava相关文档和资源
首先推荐访问Guava的知识库和API文档
Guava官方网站也给出非常有用的学习资源的地址:
Presentation slides focusing on base, primitives, and io
Presentation slides focusing on cache
Presentation slides focusing on util.concurrent
A nice collection of other helpful links

6.使用Guava
如果你是使用Maven作为项目管理和集成工具的话，那么只需要拷贝下面一段代码到项目的pom.xml中即可。
<dependency>
     <groupId>com.google.guava</groupId>
     <artifactId>guava</artifactId>
     <version>14.0-rc3</version>
</dependency>

 

 

二.Guava cache

 

1.关于缓存

缓存：在我们日常开发中是必不可少的一种解决性能问题的方法。简单的说，cache 就是为了提升系统性能而开辟的一块内存空间。

主要作用：是暂时在内存中保存业务系统的数据处理结果，并且等待下次访问使用。在日常开发的很多场合，由于受限于硬盘IO的性能或者我们自身业务系统的数据处理和获取可能非常费时，当我们发现我们的系统这个数据请求量很大的时候，频繁的IO和频繁的逻辑处理会导致硬盘和CPU资源的瓶颈出现。缓存的作用就是将这些来自不易的数据保存在内存中，当有其他线程或者客户端需要查询相同的数据资源时，直接从缓存的内存块中返回数据，这样不但可以提高系统的响应时间，同时也可以节省对这些数据的处理流程的资源消耗，整体上来说，系统性能会有大大的提升。

缓存在很多系统和架构中都用广泛的应用,例如：
1.CPU缓存 2.操作系统缓存 3.本地缓存 4.分布式缓存 5.HTTP缓存 6.数据库缓存等等，
可以说在计算机和网络领域，缓存无处不在。可以这么说，只要有硬件性能不对等，涉及到网络传输的地方都会有缓存的身影。

 

2.Guava Cache

Guava Cache是一个全内存的本地缓存实现，它提供了线程安全的实现机制。整体上来说Guava cache 是本地缓存的不二之选，简单易用，性能好。

 

3.Guava Cache有两种创建方式

第一个： cacheLoader
第二个： callable callback

这两种方法和通常用map来缓存的做法比
相同点：这两种方法都实现了一种逻辑——从缓存中取key-X的值，如果该值已经缓存过了，则返回缓存中的值，如果没有缓存过，可以通过某个方法来获取这个值：
不同点：

cacheloader 的定义比较宽泛，是针对整个cache定义的，可以认为是统一的根据key值loadvalue的方法。

callable 的方式较为灵活，允许你在get的时候指定

 

cacheLoader方式实现实例

 

GuavaCacheUtil.java
@Test
    public void TestLoadingCache() throws Exception{
        LoadingCache<String,String> cahceBuilder=CacheBuilder
        .newBuilder()
        .build(new CacheLoader<String, String>(){
            @Override
            public String load(String key) throws Exception {       
                String strProValue="hello "+key+"!";               
                return strProValue;
            }
           
        });       
       
        System.out.println("jerry value:"+cahceBuilder.apply("jerry"));
        System.out.println("jerry value:"+cahceBuilder.get("jerry"));
        System.out.println("peida value:"+cahceBuilder.get("peida"));
        System.out.println("peida value:"+cahceBuilder.apply("peida"));
        System.out.println("lisa value:"+cahceBuilder.apply("lisa"));
        cahceBuilder.put("harry", "ssdded");
        System.out.println("harry value:"+cahceBuilder.get("harry"));
    }

 

  

输出：
jerry value:hello jerry!
jerry value:hello jerry!
peida value:hello peida!
peida value:hello peida!
lisa value:hello lisa!
harry value:ssdded  

 
callable callback的实现：

 

 

GuavaCacheUtil.java
@Test
    public void testcallableCache()throws Exception{
        Cache<String, String> cache = CacheBuilder.newBuilder().maximumSize(1000).build(); 
        String resultVal = cache.get("jerry", new Callable<String>() { 
            public String call() { 
                String strProValue="hello "+"jerry"+"!";               
                return strProValue;
            } 
        }); 
        System.out.println("jerry value : " + resultVal);
       
        resultVal = cache.get("peida", new Callable<String>() { 
            public String call() { 
                String strProValue="hello "+"peida"+"!";               
                return strProValue;
            } 
        }); 
        System.out.println("peida value : " + resultVal); 
    }

 

输出：
jerry value : hello jerry!
peida value : hello peida!

 
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


基于泛型的实现：

/**
     * 不需要延迟处理(泛型的方式封装)
     * @return
     */
    public  <K , V> LoadingCache<K , V> cached(CacheLoader<K , V> cacheLoader) {
          LoadingCache<K , V> cache = CacheBuilder
          .newBuilder()
          .maximumSize(2)
          .weakKeys()
          .softValues()
          .refreshAfterWrite(120, TimeUnit.SECONDS)
          .expireAfterWrite(10, TimeUnit.MINUTES)       
          .removalListener(new RemovalListener<K, V>(){
            @Override
            public void onRemoval(RemovalNotification<K, V> rn) {
                System.out.println(rn.getKey()+"被移除"); 
               
            }})
          .build(cacheLoader);
          return cache;
    }
   
    /**
     * 通过key获取value
     * 调用方式 commonCache.get(key) ; return String
     * @param key
     * @return
     * @throws Exception
     */
 
    public  LoadingCache<String , String> commonCache(final String key) throws Exception{
        LoadingCache<String , String> commonCache= cached(new CacheLoader<String , String>(){
                @Override
                public String load(String key) throws Exception {
                    return "hello "+key+"!";   
                }
          });
        return commonCache;
    }
   
    @Test
    public void testCache() throws Exception{
        LoadingCache<String , String> commonCache=commonCache("peida");
        System.out.println("peida:"+commonCache.get("peida"));
        commonCache.apply("harry");
        System.out.println("harry:"+commonCache.get("harry"));
        commonCache.apply("lisa");
        System.out.println("lisa:"+commonCache.get("lisa"));
    }

 
   
基于泛型的Callable Cache实现：

private static Cache<String, String> cacheFormCallable = null;

   
    /**
     * 对需要延迟处理的可以采用这个机制；(泛型的方式封装)
     * @param <K>
     * @param <V>
     * @param key
     * @param callable
     * @return V
     * @throws Exception
     */
    public static <K,V> Cache<K , V> callableCached() throws Exception {
          Cache<K, V> cache = CacheBuilder
          .newBuilder()
          .maximumSize(10000)
          .expireAfterWrite(10, TimeUnit.MINUTES)
          .build();
          return cache;
    }

   
    private String getCallableCache(final String userName) {
           try {
             //Callable只有在缓存值不存在时，才会调用
             return cacheFormCallable.get(userName, new Callable<String>() {
                @Override
                public String call() throws Exception {
                    System.out.println(userName+" from db");
                    return "hello "+userName+"!";
               }
              });
           } catch (ExecutionException e) {
              e.printStackTrace();
              return null;
            }
    }
   
    @Test
    public void testCallableCache() throws Exception{
         final String u1name = "peida";
         final String u2name = "jerry";
         final String u3name = "lisa";
         cacheFormCallable=callableCached();
         System.out.println("peida:"+getCallableCache(u1name));
         System.out.println("jerry:"+getCallableCache(u2name));
         System.out.println("lisa:"+getCallableCache(u3name));
         System.out.println("peida:"+getCallableCache(u1name));
        
    }

 
说明：Callable只有在缓存值不存在时，才会调用，比如第二次调用getCallableCache(u1name)直接返回缓存中的值

 

 

4.guava Cache数据移除

被动移除和主动移除两种

 

被动移除数据的三种方式
1.基于大小的移除

理解：看字面意思就知道就是按照缓存的大小来移除，如果即将到达指定的大小，那就会把不常用的键值对从cache中移除。
定义的方式：

一般常用： CacheBuilder.maximumSize(long)，

不常用的：还有一种一种可以算权重的方法，个人认为实际使用中不太用到。
就这个常用的来看有几个注意点，
(1) 这个size指的是cache中的条目数，不是内存大小或是其他；
(2) 并不是完全到了指定的size系统才开始移除不常用的数据的，而是接近这个size的时候系统就会开始做移除的动作；
(3) 如果一个键值对已经从缓存中被移除了，你再次请求访问的时候，如果cachebuild是使用cacheloader方式的，那依然还是会从cacheloader中再取一次值，如果这样还没有，就会抛出异常
　　
2.基于时间的移除

理解：guava提供了两个基于时间移除的方法

expireAfterAccess(long, TimeUnit)  

这个方法是根据某个键值对最后一次访问之后多少时间后移除

expireAfterWrite(long, TimeUnit)  

这个方法是根据某个键值对被创建或值被替换后多少时间移除
　　
3.基于引用的移除
理解：这种移除方式主要是基于java的垃圾回收机制，根据键或者值的引用关系决定移除
　　

主动移除数据方式，主动移除有三种方式
1.单独移除用 Cache.invalidate(key)
2.批量移除用 Cache.invalidateAll(keys)
3.移除所有用 Cache.invalidateAll()

 

如果需要在移除数据的时候有所动作还可以定义Removal Listener，但是有点需要注意的是默认Removal Listener中的行为是和移除动作同步执行的，如果需要改成异步形式，可以考虑使用RemovalListeners.asynchronous(RemovalListener, Executor)


方法对比：
get(K)：这个方法要么返回已经缓存的值，要么使用CacheLoader向缓存原子地loading新值(就是上面说的当缓存没有值的时候执行Load方法)
put(key, value)：这个方法可以直接显示地向缓存中插入值，这会直接覆盖掉已有键之前映射的值。

缓存回收:
CacheBuilder.maximumSize(long)：这个方法规定缓存项的数目不超过固定值(其实你可以理解为一个Map的最大容量)，尝试回收最近没有使用或总体上很少使用的缓存项

定时回收（Timed Eviction）:
expireAfterAccess(long, TimeUnit)：缓存项在给定时间内没有被读/写访问，则回收。请注意这种缓存的回收顺序和基于大小回收一样。
expireAfterWrite(long, TimeUnit)：缓存项在给定时间内没有被写访问（创建或覆盖），则回收。如果认为缓存数据总是在固定时候后变得陈旧不可用，这种回收方式是可取的。














‘