摘要：下面對的用法進行詳細的介紹。也可以同時用和方法指定過期時間，這時只要對象滿足兩者中的一個條件就會被自動過期刪除。當調用的方法時，如果緩存不存在對應的記錄，則中的方法會被自動調用從外存加載數據，方法的返回值會作為對應的存儲到中，并從方法返回。
Guava Cache是在內存中緩存數據，相比較于數據庫或redis存儲，訪問內存中的數據會更加高效。Guava官網介紹，下面的這幾種情況可以考慮使用Guava Cache：
愿意消耗一些內存空間來提升速度。
預料到某些鍵會被多次查詢。
緩存中存放的數據總量不會超出內存容量。
所以，可以將程序頻繁用到的少量數據存儲到Guava Cache中，以改善程序性能。下面對Guava Cache的用法進行詳細的介紹。
構建緩存對象
接口Cache代表一塊緩存，它有如下方法：
public interface Cache {
V get(K key, Callable valueLoader) throws ExecutionException;
ImmutableMap getAllPresent(Iterable keys);
void put(K key, V value);
void putAll(Map m);
void invalidate(Object key);
void invalidateAll(Iterable keys);
void invalidateAll();
long size();
CacheStats stats();
ConcurrentMap asMap();
void cleanUp();
}
可以通過CacheBuilder類構建一個緩存對象，CacheBuilder類采用builder設計模式，它的每個方法都返回CacheBuilder本身，直到build方法被調用。構建一個緩存對象代碼如下。
public class StudyGuavaCache {
public static void main(String[] args) {
Cache cache = CacheBuilder.newBuilder().build();
cache.put("word","Hello Guava Cache");
System.out.println(cache.getIfPresent("word"));
}
}
上面的代碼通過CacheBuilder.newBuilder().build()這句代碼創建了一個Cache緩存對象，并在緩存對象中存儲了key為word，value為Hello Guava Cache的一條記錄。可以看到Cache非常類似于JDK中的Map，但是相比于Map，Guava Cache提供了很多更強大的功能。
設置最大存儲
Guava Cache可以在構建緩存對象時指定緩存所能夠存儲的最大記錄數量。當Cache中的記錄數量達到最大值后再調用put方法向其中添加對象，Guava會先從當前緩存的對象記錄中選擇一條刪除掉，騰出空間后再將新的對象存儲到Cache中。
public class StudyGuavaCache {
public static void main(String[] args) {
Cache cache = CacheBuilder.newBuilder()
.maximumSize(2)
.build();
cache.put("key1","value1");
cache.put("key2","value2");
cache.put("key3","value3");
System.out.println("第一個值：" + cache.getIfPresent("key1"));
System.out.println("第二個值：" + cache.getIfPresent("key2"));
System.out.println("第三個值：" + cache.getIfPresent("key3"));
}
}
上面代碼在構造緩存對象時，通過CacheBuilder類的maximumSize方法指定Cache最多可以存儲兩個對象，然后調用Cache的put方法向其中添加了三個對象。程序執行結果如下圖所示，可以看到第三條對象記錄的插入，導致了第一條對象記錄被刪除。
設置過期時間
在構建Cache對象時，可以通過CacheBuilder類的expireAfterAccess和expireAfterWrite兩個方法為緩存中的對象指定過期時間，過期的對象將會被緩存自動刪除。其中，expireAfterWrite方法指定對象被寫入到緩存后多久過期，expireAfterAccess指定對象多久沒有被訪問后過期。
public class StudyGuavaCache {
public static void main(String[] args) throws InterruptedException {
Cache cache = CacheBuilder.newBuilder()
.maximumSize(2)
.expireAfterWrite(3,TimeUnit.SECONDS)
.build();
cache.put("key1","value1");
int time = 1;
while(true) {
System.out.println("第" + time++ + "次取到key1的值為：" + cache.getIfPresent("key1"));
Thread.sleep(1000);
}
}
}
上面的代碼在構造Cache對象時，通過CacheBuilder的expireAfterWrite方法指定put到Cache中的對象在3秒后會過期。在Cache對象中存儲一條對象記錄后，每隔1秒讀取一次這條記錄。程序運行結果如下圖所示，可以看到，前三秒可以從Cache中獲取到對象，超過三秒后，對象從Cache中被自動刪除。
下面代碼是expireAfterAccess的例子。
public class StudyGuavaCache {
public static void main(String[] args) throws InterruptedException {
Cache cache = CacheBuilder.newBuilder()
.maximumSize(2)
.expireAfterAccess(3,TimeUnit.SECONDS)
.build();
cache.put("key1","value1");
int time = 1;
while(true) {
Thread.sleep(time*1000);
System.out.println("睡眠" + time++ + "秒后取到key1的值為：" + cache.getIfPresent("key1"));
}
}
}
通過CacheBuilder的expireAfterAccess方法指定Cache中存儲的對象如果超過3秒沒有被訪問就會過期。while中的代碼每sleep一段時間就會訪問一次Cache中存儲的對象key1，每次訪問key1之后下次sleep的時間會加長一秒。程序運行結果如下圖所示，從結果中可以看出，當超過3秒沒有讀取key1對象之后，該對象會自動被Cache刪除。
也可以同時用expireAfterAccess和expireAfterWrite方法指定過期時間，這時只要對象滿足兩者中的一個條件就會被自動過期刪除。
弱引用
可以通過weakKeys和weakValues方法指定Cache只保存對緩存記錄key和value的弱引用。這樣當沒有其他強引用指向key和value時，key和value對象就會被垃圾回收器回收。
public class StudyGuavaCache {
public static void main(String[] args) throws InterruptedException {
Cache cache = CacheBuilder.newBuilder()
.maximumSize(2)
.weakValues()
.build();
Object value = new Object();
cache.put("key1",value);
value = new Object();//原對象不再有強引用
System.gc();
System.out.println(cache.getIfPresent("key1"));
}
}
上面代碼的打印結果是null。構建Cache時通過weakValues方法指定Cache只保存記錄值的一個弱引用。當給value引用賦值一個新的對象之后，就不再有任何一個強引用指向原對象。System.gc()觸發垃圾回收后，原對象就被清除了。
顯示清除
可以調用Cache的invalidateAll或invalidate方法顯示刪除Cache中的記錄。invalidate方法一次只能刪除Cache中一個記錄，接收的參數是要刪除記錄的key。invalidateAll方法可以批量刪除Cache中的記錄，當沒有傳任何參數時，invalidateAll方法將清除Cache中的全部記錄。invalidateAll也可以接收一個Iterable類型的參數，參數中包含要刪除記錄的所有key值。下面代碼對此做了示例。
public class StudyGuavaCache {
public static void main(String[] args) throws InterruptedException {
Cache cache = CacheBuilder.newBuilder().build();
Object value = new Object();
cache.put("key1","value1");
cache.put("key2","value2");
cache.put("key3","value3");
List list = new ArrayList();
list.add("key1");
list.add("key2");
cache.invalidateAll(list);//批量清除list中全部key對應的記錄
System.out.println(cache.getIfPresent("key1"));
System.out.println(cache.getIfPresent("key2"));
System.out.println(cache.getIfPresent("key3"));
}
}
代碼中構造了一個集合list用于保存要刪除記錄的key值，然后調用invalidateAll方法批量刪除key1和key2對應的記錄，只剩下key3對應的記錄沒有被刪除。
移除監聽器
可以為Cache對象添加一個移除監聽器，這樣當有記錄被刪除時可以感知到這個事件。
public class StudyGuavaCache {
public static void main(String[] args) throws InterruptedException {
RemovalListener listener = new RemovalListener() {
public void onRemoval(RemovalNotification notification) {
System.out.println("[" + notification.getKey() + ":" + notification.getValue() + "] is removed!");
}
};
Cache cache = CacheBuilder.newBuilder()
.maximumSize(3)
.removalListener(listener)
.build();
Object value = new Object();
cache.put("key1","value1");
cache.put("key2","value2");
cache.put("key3","value3");
cache.put("key4","value3");
cache.put("key5","value3");
cache.put("key6","value3");
cache.put("key7","value3");
cache.put("key8","value3");
}
}
removalListener方法為Cache指定了一個移除監聽器，這樣當有記錄從Cache中被刪除時，監聽器listener就會感知到這個事件。程序運行結果如下圖所示。
自動加載
Cache的get方法有兩個參數，第一個參數是要從Cache中獲取記錄的key，第二個記錄是一個Callable對象。當緩存中已經存在key對應的記錄時，get方法直接返回key對應的記錄。如果緩存中不包含key對應的記錄，Guava會啟動一個線程執行Callable對象中的call方法，call方法的返回值會作為key對應的值被存儲到緩存中，并且被get方法返回。下面是一個多線程的例子：
public class StudyGuavaCache {
private static Cache cache = CacheBuilder.newBuilder()
.maximumSize(3)
.build();
public static void main(String[] args) throws InterruptedException {
new Thread(new Runnable() {
public void run() {
System.out.println("thread1");
try {
String value = cache.get("key", new Callable() {
public String call() throws Exception {
System.out.println("load1"); //加載數據線程執行標志
Thread.sleep(1000); //模擬加載時間
return "auto load by Callable";
}
});
System.out.println("thread1 " + value);
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}).start();
new Thread(new Runnable() {
public void run() {
System.out.println("thread2");
try {
String value = cache.get("key", new Callable() {
public String call() throws Exception {
System.out.println("load2"); //加載數據線程執行標志
Thread.sleep(1000); //模擬加載時間
return "auto load by Callable";
}
});
System.out.println("thread2 " + value);
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}).start();
}
}
這段代碼中有兩個線程共享同一個Cache對象，兩個線程同時調用get方法獲取同一個key對應的記錄。由于key對應的記錄不存在，所以兩個線程都在get方法處阻塞。此處在call方法中調用Thread.sleep(1000)模擬程序從外存加載數據的時間消耗。代碼的執行結果如下圖：
從結果中可以看出，雖然是兩個線程同時調用get方法，但只有一個get方法中的Callable會被執行(沒有打印出load2)。Guava可以保證當有多個線程同時訪問Cache中的一個key時，如果key對應的記錄不存在，Guava只會啟動一個線程執行get方法中Callable參數對應的任務加載數據存到緩存。當加載完數據后，任何線程中的get方法都會獲取到key對應的值。
統計信息
可以對Cache的命中率、加載數據時間等信息進行統計。在構建Cache對象時，可以通過CacheBuilder的recordStats方法開啟統計信息的開關。開關開啟后Cache會自動對緩存的各種操作進行統計，調用Cache的stats方法可以查看統計后的信息。
public class StudyGuavaCache {
public static void main(String[] args) throws InterruptedException {
Cache cache = CacheBuilder.newBuilder()
.maximumSize(3)
.recordStats() //開啟統計信息開關
.build();
cache.put("key1","value1");
cache.put("key2","value2");
cache.put("key3","value3");
cache.put("key4","value4");
cache.getIfPresent("key1");
cache.getIfPresent("key2");
cache.getIfPresent("key3");
cache.getIfPresent("key4");
cache.getIfPresent("key5");
cache.getIfPresent("key6");
System.out.println(cache.stats()); //獲取統計信息
}
}
程序執行結果如下圖所示：
這些統計信息對于調整緩存設置是至關重要的，在性能要求高的應用中應該密切關注這些數據
LoadingCache
LoadingCache是Cache的子接口，相比較于Cache，當從LoadingCache中讀取一個指定key的記錄時，如果該記錄不存在，則LoadingCache可以自動執行加載數據到緩存的操作。LoadingCache接口的定義如下：
public interface LoadingCache extends Cache, Function {
V get(K key) throws ExecutionException;
V getUnchecked(K key);
ImmutableMap getAll(Iterable keys) throws ExecutionException;
V apply(K key);
void refresh(K key);
@Override
ConcurrentMap asMap();
}
與構建Cache類型的對象類似，LoadingCache類型的對象也是通過CacheBuilder進行構建，不同的是，在調用CacheBuilder的build方法時，必須傳遞一個CacheLoader類型的參數，CacheLoader的load方法需要我們提供實現。當調用LoadingCache的get方法時，如果緩存不存在對應key的記錄，則CacheLoader中的load方法會被自動調用從外存加載數據，load方法的返回值會作為key對應的value存儲到LoadingCache中，并從get方法返回。
public class StudyGuavaCache {
public static void main(String[] args) throws ExecutionException {
CacheLoader loader = new CacheLoader () {
public String load(String key) throws Exception {
Thread.sleep(1000); //休眠1s，模擬加載數據
System.out.println(key + " is loaded from a cacheLoader!");
return key + ""s value";
}
};
LoadingCache loadingCache = CacheBuilder.newBuilder()
.maximumSize(3)
.build(loader);//在構建時指定自動加載器
loadingCache.get("key1");
loadingCache.get("key2");
loadingCache.get("key3");
}
}
程序執行結果如下圖所示：
文章版權歸作者所有，未經允許請勿轉載,若此文章存在違規行為，您可以聯系管理員刪除。
轉載請注明本文地址：http://specialneedsforspecialkids.com/yun/70410.html
