Guva是google开源的一个公共java库，相似于Apache Commons，它提供了集合，反射，缓存，科学计算，xml，io等一些工具类库。
cache只是其中的一个模块。使用Guva cache可以方便快速的构建本地缓存。
[TOC]html
首先须要在maven项目中加入guava依赖
<dependency>
<groupId>com.google.guava</groupId>
<artifactId>guava</artifactId>
<version>25.0-jre</version>
</dependency>
使用Guava建立一个缓存
// 经过CacheBuilder构建一个缓存实例
Cache<String, String> cache = CacheBuilder.newBuilder()
.maximumSize(100) // 设置缓存的最大容量
.expireAfterWrite(1, TimeUnit.MINUTES) // 设置缓存在写入一分钟后失效
.concurrencyLevel(10) // 设置并发级别为10
.recordStats() // 开启缓存统计
.build();
// 放入缓存
cache.put("key", "value");
// 获取缓存
String value = cache.getIfPresent("key");
expireAfterWrite 缓存必定时间内直接失效
expireAfterAccess 缓存被访问后,必定时间后失效
getIfPresent 不存在就返回null
代码演示了使用Guava建立了一个基于内存的本地缓存，并指定了一些缓存的参数，如缓存容量、缓存过时时间、并发级别等，随后经过put方法放入一个缓存并使用getIfPresent来获取它。
Cache是经过CacheBuilder的build()方法构建，它是Gauva提供的最基本的缓存接口，而且它提供了一些经常使用的缓存api：
Cache<Object, Object> cache = CacheBuilder.newBuilder().build();
// 放入/覆盖一个缓存
cache.put("k1", "v1");
// 获取一个缓存，若是该缓存不存在则返回一个null值
Object value = cache.getIfPresent("k1");
// 获取缓存，当缓存不存在时，则通Callable进行加载并返回。该操做是原子
Object getValue = cache.get("k1", new Callable<Object>() {
@Override
public Object call() throws Exception {
return null;
}
});
LoadingCache继承自Cache，在构建LoadingCache时，须要经过CacheBuilder的build(CacheLoader<? super K1, V1> loader)方法构建
CacheBuilder.newBuilder()
.build(new CacheLoader<String, String>() {
@Override
public String load(String key) throws Exception {
// 缓存加载逻辑
...
}
});
它可以经过CacheLoader自发的加载缓存
LoadingCache<Object, Object> loadingCache = CacheBuilder.newBuilder().build(new CacheLoader<Object, Object>() {
@Override
public Object load(Object key) throws Exception {
return null;
}
});
// 获取缓存，当缓存不存在时，会经过CacheLoader自动加载，该方法会抛出ExecutionException异常
loadingCache.get("k1");
// 以不安全的方式获取缓存，当缓存不存在时，会经过CacheLoader自动加载，该方法不会抛出异常
loadingCache.getUnchecked("k1");
Guava提供了设置并发级别的api，使得缓存支持并发的写入和读取。同ConcurrentHashMap相似Guava cache的并发也是经过分离锁实现。在通常状况下，将并发级别设置为服务器cpu核心数是一个比较不错的选择。
CacheBuilder.newBuilder()
// 设置并发级别为cpu核心数
.concurrencyLevel(Runtime.getRuntime().availableProcessors())
.build();
咱们在构建缓存时能够为缓存设置一个合理大小初始容量，因为Guava的缓存使用了分离锁的机制，扩容的代价很是昂贵。因此合理的初始容量可以减小缓存容器的扩容次数。
CacheBuilder.newBuilder()
// 设置初始容量为100
.initialCapacity(100)
.build();
使用基于最大容量的的回收策略时，咱们须要设置2个必要参数：
这里咱们例举一个key和value都是String类型缓存：
CacheBuilder.newBuilder()
.maximumWeight(1024 * 1024 * 1024) // 设置最大容量为 1M
// 设置用来计算缓存容量的Weigher
.weigher(new Weigher<String, String>() {
@Override
public int weigh(String key, String value) {
return key.getBytes().length + value.getBytes().length;
}
}).build();
当缓存的最大数量/容量逼近或超过咱们所设置的最大值时，Guava就会使用LRU算法对以前的缓存进行回收。
基于引用的回收策略，是java中独有的。在java中有对象自动回收机制，依据程序员建立对象的方式不一样，将对象由强到弱分为强引用、软引用、弱引用、虚引用。对于这几种引用他们有如下区别
强引用java
强引用是使用最广泛的引用。若是一个对象具备强引用，那垃圾回收器毫不会回收它。
Object o=new Object(); // 强引用
当内存空间不足，垃圾回收器不会自动回收一个被引用的强引用对象，而是会直接抛出OutOfMemoryError错误，使程序异常终止。
软引用程序员
相对于强引用，软引用是一种不稳定的引用方式，若是一个对象具备软引用，当内存充足时，GC不会主动回收软引用对象，而当内存不足时软引用对象就会被回收。
SoftReference<Object> softRef=new SoftReference<Object>(new Object()); // 软引用 Object object = softRef.get(); // 获取软引用
使用软引用能防止内存泄露，加强程序的健壮性。可是必定要作好null检测。
弱引用算法
弱引用是一种比软引用更不稳定的引用方式，由于不管内存是否充足，弱引用对象都有可能被回收。
WeakReference<Object> weakRef = new WeakReference<Object>(new Object()); // 弱引用 Object obj = weakRef.get(); // 获取弱引用
虚引用api
而虚引用这种引用方式就是形同虚设，由于若是一个对象仅持有虚引用，那么它就和没有任何引用同样。在实践中也几乎没有使用。在Guava cache中支持，软/弱引用的缓存回收方式。使用这种方式可以极大的提升内存的利用率，而且不会出现内存溢出的异常。缓存
CacheBuilder.newBuilder()
.weakKeys() // 使用弱引用存储键。当键没有其它（强或软）引用时，该缓存可能会被回收。
.weakValues() // 使用弱引用存储值。当值没有其它（强或软）引用时，该缓存可能会被回收。
.softValues() // 使用软引用存储值。当内存不足而且该值其它强引用引用时，该缓存就会被回收
.build();
经过软/弱引用的回收方式，至关于将缓存回收任务交给了GC，使得缓存的命中率变得十分的不稳定，在非必要的状况下，仍是推荐基于数量和容量的回收。
在缓存构建完毕后，咱们能够经过Cache提供的接口，显式的对缓存进行回收，例如：
// 构建一个缓存
Cache<String, String> cache = CacheBuilder.newBuilder().build();
// 回收key为k1的缓存
cache.invalidate("k1");
// 批量回收key为k一、k2的缓存
List<String> needInvalidateKeys = new ArrayList<>();
needInvalidateKeys.add("k1");
needInvalidateKeys.add("k2");
cache.invalidateAll(needInvalidateKeys);
// 回收全部缓存
cache.invalidateAll();
Guava也提供了缓存的过时策略和刷新策略。
缓存的过时策略分为固定时间和相对时间。固定时间通常是指写入后多长时间过时，例如咱们构建一个写入10分钟后过时的缓存：安全
CacheBuilder.newBuilder()
.expireAfterWrite(10, TimeUnit.MINUTES) // 写入10分钟后过时
.build();
// java8后可使用Duration设置
CacheBuilder.newBuilder()
.expireAfterWrite(Duration.ofMinutes(10))
.build();
相对时间通常是相对于访问时间，也就是每次访问后，会从新刷新该缓存的过时时间，这有点相似于servlet中的session过时时间，例如构建一个在10分钟内未访问则过时的缓存：
CacheBuilder.newBuilder()
.expireAfterAccess(10, TimeUnit.MINUTES) //在10分钟内未访问则过时
.build();
// java8后可使用Duration设置
CacheBuilder.newBuilder()
.expireAfterAccess(Duration.ofMinutes(10))
.build();
在Guava cache中支持定时刷新和显式刷新两种方式，其中只有LoadingCache可以进行定时刷新。
定时刷新服务器
在进行缓存定时刷新时，咱们须要指定缓存的刷新间隔，和一个用来加载缓存的CacheLoader，当达到刷新时间间隔后，下一次获取缓存时，会调用CacheLoader的load方法刷新缓存。例如构建个刷新频率为10分钟的缓存:
CacheBuilder.newBuilder()
// 设置缓存在写入10分钟后，经过CacheLoader的load方法进行刷新
.refreshAfterWrite(10, TimeUnit.SECONDS)
// jdk8之后可使用 Duration
// .refreshAfterWrite(Duration.ofMinutes(10))
.build(new CacheLoader<String, String>() {
@Override
public String load(String key) throws Exception {
// 缓存加载逻辑
...
}
});
显式刷新session
在缓存构建完毕后，咱们能够经过Cache提供的一些借口方法，显式的对缓存进行刷新覆盖，例如：
// 构建一个缓存
Cache<String, String> cache = CacheBuilder.newBuilder().build();
// 使用put进行覆盖刷新
cache.put("k1", "v1");
// 使用Map的put方法进行覆盖刷新
cache.asMap().put("k1", "v1");
// 使用Map的putAll方法进行批量覆盖刷新
Map<String,String> needRefreshs = new HashMap<>();
needRefreshs.put("k1", "v1");
cache.asMap().putAll(needRefreshs);
// 使用ConcurrentMap的replace方法进行覆盖刷新
cache.asMap().replace("k1", "v1");
对于LoadingCache，因为它可以自动的加载缓存，因此在进行刷新时，不须要显式的传入缓存的值：
LoadingCache<String, String> loadingCache = CacheBuilder
.newBuilder()
.build(new CacheLoader<String, String>() {
@Override
public String load(String key) throws Exception {
// 缓存加载逻辑
return null;
}
});
// loadingCache 在进行刷新时无需显式的传入 value
loadingCache.refresh("k1");