Guava自動加載緩存LoadingCache使用實戰(zhàn)詳解

更新時間：2023年12月22日 09:05:50 作者：S

這篇文章主要為大家介紹了Guava自動加載緩存LoadingCache使用實戰(zhàn)詳解,有需要的朋友可以借鑒參考下,希望能夠有所幫助,祝大家多多進步,早日升職加薪

第1章：引言

今天我們來聊聊緩存。在Java世界里，高效的緩存機制對于提升應用性能、降低數據庫負擔至關重要。想象一下，如果每次數據請求都要跑到數據庫里取，那服務器豈不是要累趴了？這時候，緩存就顯得尤為重要了。

那么，怎么實現一個既高效又好用的緩存呢？別急，咱們今天的主角——Guava的LoadingCache就是這樣一個神器。LoadingCache，顧名思義，就是能夠自動加載緩存的工具。它不僅能自動載入數據，還能按需刷新，簡直是懶人救星！接下來，小黑就帶大家一起深入探究Guava的這個強大功能。

第2章：Guava簡介

Guava是Google開源的一款Java庫，提供了一堆好用的工具類，從集合操作、緩存機制到函數式編程，應有盡有。使用Guava，咱們可以寫出更簡潔、更高效、更優(yōu)雅的Java代碼。今天，小黑重點要聊的是Guava中的緩存部分。

首先，讓我們來看看Guava緩存的一個基本概念：LoadingCache。LoadingCache是Guava中一個提供自動加載功能的緩存接口。它允許咱們通過一個CacheLoader來指定如何加載緩存。這就意味著，當咱們嘗試從緩存中讀取一個值，如果這個值不存在，LoadingCache就會自動調用預定義的加載機制去獲取數據，然后將其加入到緩存中，非常智能。

來，小黑先給大家展示一個簡單的LoadingCache創(chuàng)建示例：

import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;
public class LoadingCacheExample {
    public static void main(String[] args) {
        LoadingCache<String, String> cache = CacheBuilder.newBuilder()
                .maximumSize(100) // 最大緩存項數
                .build(new CacheLoader<String, String>() {
                    @Override
                    public String load(String key) throws Exception {
                        return "Hello, " + key; // 定義緩存加載的方式
                    }
                });
        System.out.println(cache.getUnchecked("Guava")); // 輸出：Hello, Guava
    }
}

在這個例子里，小黑創(chuàng)建了一個簡單的LoadingCache實例。當咱們嘗試通過getUnchecked方法獲取一個緩存項時，如果這個項不存在，CacheLoader會自動加載一個新值。在這里，它就是簡單地返回一個字符串。

第3章：LoadingCache基礎

什么是LoadingCache呢？簡單來說，它是Guava提供的一個緩存接口，能夠自動加載緩存。當你嘗試從緩存中讀取一個值時，如果這個值不存在，LoadingCache會自動調用預定義的加載邏輯來獲取這個值，然后存儲到緩存中。這個過程完全自動化，省去了很多手動管理緩存的麻煩。

那么，LoadingCache的核心特性是什么呢？首先，它提供了自動的緩存加載機制，這意味著咱們不需要自己去寫代碼判斷緩存是否存在或者過期。其次，它支持多種緩存過期策略，比如基于時間的過期、大小限制等，確保緩存的有效性。再者，LoadingCache還提供了緩存統(tǒng)計和監(jiān)聽的功能，方便咱們監(jiān)控和調優(yōu)緩存的使用。

來，讓小黑用一個例子來展示一下LoadingCache的基本用法：

import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;
import java.util.concurrent.ExecutionException;
public class LoadingCacheDemo {
    public static void main(String[] args) throws ExecutionException {
        // 創(chuàng)建一個CacheLoader
        CacheLoader<String, String> loader = new CacheLoader<String, String>() {
            @Override
            public String load(String key) {
                return key.toUpperCase(); // 模擬加載數據的過程
            }
        };
        // 使用CacheBuilder構建一個LoadingCache
        LoadingCache<String, String> cache = CacheBuilder.newBuilder()
                .maximumSize(100) // 設置最大緩存數為100
                .build(loader);
        // 使用緩存
        System.out.println(cache.get("hello")); // 輸出: HELLO
        System.out.println(cache.get("guava")); // 輸出: GUAVA
    }
}

在這個例子中，小黑創(chuàng)建了一個CacheLoader來定義加載數據的邏輯，這里就是簡單地將字符串轉換為大寫。然后，使用CacheBuilder來構建一個LoadingCache實例，設置了最大緩存數為100。當調用get方法時，如果緩存中不存在對應的鍵值，LoadingCache會自動調用CacheLoader來加載數據，并將結果存入緩存。

第4章：創(chuàng)建LoadingCache

創(chuàng)建一個LoadingCache最關鍵的就是定義一個CacheLoader。這個CacheLoader指定了如何加載緩存。它就像是個工廠，當咱們請求的數據在緩存中不存在時，它就會生產出所需的數據。

那么，怎么定義這個CacheLoader呢？讓小黑給你看個例子：

import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;
public class UserCache {
    // 假設有一個用戶服務，用于獲取用戶信息
    private static UserService userService = new UserService();
    public static void main(String[] args) throws Exception {
        // 創(chuàng)建CacheLoader
        CacheLoader<String, User> loader = new CacheLoader<String, User>() {
            @Override
            public User load(String userId) {
                // 從用戶服務獲取用戶信息
                return userService.getUserById(userId);
            }
        };
        // 創(chuàng)建LoadingCache
        LoadingCache<String, User> cache = CacheBuilder.newBuilder()
                .maximumSize(100) // 設置最大緩存數
                .build(loader);
        // 使用緩存獲取用戶信息
        User user = cache.get("123"); // 如果緩存中沒有，會調用load方法加載數據
        System.out.println(user);
    }
}

在這個例子中，小黑創(chuàng)建了一個CacheLoader來從用戶服務中獲取用戶信息。然后，使用CacheBuilder來構建一個LoadingCache，并設置了最大緩存數量為100。當咱們通過get方法獲取用戶信息時，如果緩存中沒有相應的數據，CacheLoader就會自動加載數據。

這個過程聽起來是不是很神奇？實際上，這背后是一種非常有效的數據管理策略。通過這種方式，咱們可以減少對數據庫或遠程服務的直接訪問，提高了應用的響應速度和效率。

第5章：LoadingCache的高級特性

自動加載和刷新機制

首先，LoadingCache的一個很棒的功能就是自動加載和刷新。這意味著當咱們請求某個鍵的值時，如果這個值不存在或者需要刷新，LoadingCache會自動調用CacheLoader去加載或刷新數據。

import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;
import java.util.concurrent.TimeUnit;
public class AutoRefreshCache {
    public static void main(String[] args) throws Exception {
        LoadingCache<String, String> cache = CacheBuilder.newBuilder()
                .refreshAfterWrite(1, TimeUnit.MINUTES) // 設置1分鐘后刷新
                .build(new CacheLoader<String, String>() {
                    @Override
                    public String load(String key) {
                        return fetchDataFromDatabase(key); // 模擬從數據庫加載數據
                    }
                });
        // 使用緩存
        System.out.println(cache.get("key1")); // 第一次加載
        // 1分鐘后，嘗試再次獲取，將觸發(fā)刷新操作
    }
    private static String fetchDataFromDatabase(String key) {
        // 模擬數據庫操作
        return "Data for " + key;
    }
}

在這個例子中，咱們設置了refreshAfterWrite，這意味著每當一個鍵值對寫入一分鐘后，它就會被自動刷新。

處理異常值

有時候，加載數據可能會出現異常。LoadingCache提供了優(yōu)雅的處理異常的機制。

public class ExceptionHandlingCache {
    public static void main(String[] args) throws Exception {
        LoadingCache<String, String> cache = CacheBuilder.newBuilder()
                .build(new CacheLoader<String, String>() {
                    @Override
                    public String load(String key) throws Exception {
                        if ("errorKey".equals(key)) {
                            throw new Exception("Loading error");
                        }
                        return "Data for " + key;
                    }
                });

        try {
            System.out.println(cache.get("errorKey"));
        } catch (Exception e) {
            System.out.println("Error during cache load: " + e.getMessage());
        }
    }
}

這里，如果加載過程中出現異常，咱們可以捕獲這個異常，并做適當的處理。

統(tǒng)計和監(jiān)聽功能

LoadingCache還提供了緩存統(tǒng)計和監(jiān)聽功能，這對于監(jiān)控緩存性能和行為非常有用。

import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;
import com.google.common.cache.RemovalListener;
import com.google.common.cache.RemovalNotification;
public class CacheMonitoring {
    public static void main(String[] args) throws Exception {
        RemovalListener<String, String> removalListener = new RemovalListener<String, String>() {
            @Override
            public void onRemoval(RemovalNotification<String, String> notification) {
                System.out.println("Removed: " + notification.getKey() + ", Cause: " + notification.getCause());
            }
        };
        LoadingCache<String, String> cache = CacheBuilder.newBuilder()
                .maximumSize(100)
                .removalListener(removalListener)
                .build(new CacheLoader<String, String>() {
                    // ...
                });
        // 使用緩存
        // ...
    }
}

在這個例子中，小黑設置了一個RemovalListener，用于監(jiān)聽緩存項的移除事件。

第6章：LoadingCache的最佳實踐

配置緩存大小

合理配置緩存大小非常關鍵。如果緩存太小，就會頻繁地加載數據，影響性能；如果太大，又可能消耗過多內存。

LoadingCache<String, String> cache = CacheBuilder.newBuilder()
        .maximumSize(1000) // 設置最大緩存項為1000
        .build(new CacheLoader<String, String>() {
            // ...
        });

在這個例子中，小黑設置了最大緩存項為1000。這個值需要根據實際情況和資源限制來調整。

設置合適的過期策略

LoadingCache支持基于時間的過期策略，比如訪問后過期和寫入后過期。

LoadingCache<String, String> cache = CacheBuilder.newBuilder()
        .expireAfterWrite(10, TimeUnit.MINUTES) // 寫入后10分鐘過期
        .expireAfterAccess(5, TimeUnit.MINUTES) // 訪問后5分鐘過期
        .build(new CacheLoader<String, String>() {
            // ...
        });

選擇合適的過期策略可以確保緩存中的數據既不會過時，又能有效利用內存。

異常處理策略

在加載數據時可能會遇到各種異常。咱們可以設置一個合理的異常處理策略，比如記錄日志、返回默認值或者重新拋出異常。

LoadingCache<String, String> cache = CacheBuilder.newBuilder()
        .build(new CacheLoader<String, String>() {
            @Override
            public String load(String key) throws Exception {
                try {
                    return fetchData(key);
                } catch (Exception e) {
                    // 處理異常
                }
            }
        });

使用軟引用或弱引用

為了防止緩存占用過多內存，可以使用軟引用或弱引用。

LoadingCache<String, String> cache = CacheBuilder.newBuilder()
        .softValues() // 使用軟引用存儲值
        .weakKeys() // 使用弱引用存儲鍵
        .build(new CacheLoader<String, String>() {
            // ...
        });

使用軟引用和弱引用可以幫助Java垃圾收集器在需要時回收緩存項，防止內存泄露。

監(jiān)聽移除通知

設置移除監(jiān)聽器可以幫助咱們了解緩存的行為，比如為什么某個項被移除。

LoadingCache<String, String> cache = CacheBuilder.newBuilder()
        .removalListener(notification -> {
            // 處理移除通知
        })
        .build(new CacheLoader<String, String>() {
            // ...
        });

通過這些最佳實踐，咱們可以確保LoadingCache的高效運行，同時避免一些常見的問題。這樣，咱們的Java應用就能更加穩(wěn)定和高效地運行啦！

第7章：LoadingCache與Java 8的結合

好的，咱們接下來聊聊怎樣把LoadingCache和Java 8的特性結合起來，用起來更順手。

Java 8引入了很多強大的新特性，像Lambda表達式、Stream API等，這些都可以和LoadingCache搭配使用，讓代碼更簡潔、更易讀。

使用Lambda表達式簡化CacheLoader

首先，咱們可以用Lambda表達式來簡化CacheLoader的創(chuàng)建。這樣代碼看起來更干凈，更直觀。

LoadingCache<String, String> cache = CacheBuilder.newBuilder()
        .build(key -> fetchDataFromDatabase(key)); // 使用Lambda表達式
private static String fetchDataFromDatabase(String key) {
    // 數據庫操作
    return "Data for " + key;
}

在這個例子里，小黑用Lambda表達式替代了傳統(tǒng)的匿名內部類，使代碼更加簡潔。

結合Stream API處理緩存數據

接下來，咱們看看如何用Java 8的Stream API來處理LoadingCache中的數據。

LoadingCache<String, User> userCache = //... 緩存初始化
List<String> userIds = //... 用戶ID列表
// 使用Stream API獲取用戶信息列表
List<User> users = userIds.stream()
        .map(userId -> userCache.getUnchecked(userId))
        .collect(Collectors.toList());

在這個例子中，小黑用Stream API來處理一系列用戶ID，然后用map方法從緩存中獲取對應的用戶信息。

利用Optional處理緩存返回值

最后，Java 8引入的Optional也可以用來優(yōu)雅地處理可能為空的緩存返回值。

public Optional&lt;User&gt; getUser(String userId) {
    try {
        return Optional.ofNullable(userCache.get(userId));
    } catch (Exception e) {
        return Optional.empty();
    }
}

在這里，小黑用Optional包裝了緩存的返回值。這樣一來，就能優(yōu)雅地處理緩存可能返回的空值情況。

通過這些方式，結合Java 8的特性，咱們可以讓LoadingCache的使用更加高效和優(yōu)雅。這不僅提高了代碼的可讀性，還讓咱們的編程體驗更加流暢。

實戰(zhàn)案例

小黑將通過一個具體的例子，展示如何在實際項目中使用LoadingCache。這個例子會模擬一個簡單的場景，比如說，使用LoadingCache來緩存用戶的登錄次數。

假設咱們有一個應用，需要跟蹤用戶的登錄次數。每次用戶登錄時，程序會增加其登錄次數。為了提高性能，咱們用LoadingCache來緩存這些數據，避免每次都查詢數據庫。

首先，小黑定義了一個模擬的用戶登錄服務：

public class UserService {
    private final Map&lt;String, Integer&gt; loginCount = new ConcurrentHashMap&lt;&gt;();

    public int addLoginCount(String userId) {
        return loginCount.merge(userId, 1, Integer::sum);
    }
}

UserService userService = new UserService();

這個UserService類有一個addLoginCount方法，用于增加特定用戶的登錄次數。

接下來，小黑將展示如何使用LoadingCache來緩存登錄次數：

LoadingCache<String, Integer> loginCache = CacheBuilder.newBuilder()
        .expireAfterAccess(30, TimeUnit.MINUTES) // 設置緩存30分鐘后過期
        .build(new CacheLoader<String, Integer>() {
            @Override
            public Integer load(String userId) {
                return userService.addLoginCount(userId);
            }
        });

public void userLogin(String userId) {
    int count = loginCache.getUnchecked(userId);
    System.out.println("User " + userId + " login count: " + count);
}

在這個例子中，每當有用戶登錄，userLogin方法就會被調用。這個方法會從loginCache中獲取用戶的登錄次數，如果緩存中沒有，CacheLoader會調用UserService的addLoginCount來獲取最新的計數，然后將其存儲在緩存中。

總結

通過這些章節(jié)，咱們了解了LoadingCache的基本原理和用法，包括如何創(chuàng)建和配置緩存，以及如何結合Java 8的特性來優(yōu)化代碼。LoadingCache不僅提供了自動加載和刷新的強大功能，還有異常處理、緩存統(tǒng)計和監(jiān)聽等高級特性。

實戰(zhàn)案例給咱們展示了LoadingCache在現實場景中的應用。不管是緩存用戶信息還是統(tǒng)計數據，LoadingCache都能大大提高性能和用戶體驗。

技術總是在不斷進步的，學習和掌握這些工具，能讓咱們更好地適應未來的技術挑戰(zhàn)。希望這些內容能激發(fā)你對Guava以及Java編程的更多探索！

以上就是Guava自加載緩存LoadingCache使用實戰(zhàn)詳解的詳細內容，更多關于Guava自加載緩存LoadingCache的資料請關注腳本之家其它相關文章！

您可能感興趣的文章:

Springboot @Value使用代碼實例
這篇文章主要介紹了Springboot @Value使用代碼實例,文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值,需要的朋友可以參考下
2019-11-11
Java數組優(yōu)點和缺點_動力節(jié)點Java學院整理
本文給大家簡單介紹下java數組的優(yōu)點和缺點知識，需要的的朋友參考下吧
2017-04-04
Java網絡編程之入門篇
這篇文章主要介紹了Java網絡編程入門，本文給大家介紹的非常詳細，對大家的學習或工作具有一定的參考借鑒價值，需要的朋友可以參考下
2021-09-09
在SpringBoot中通過jasypt進行加密解密的方法
今天小編就為大家分享一篇關于在SpringBoot中通過jasypt進行加密解密的方法，小編覺得內容挺不錯的，現在分享給大家，具有很好的參考價值，需要的朋友一起跟隨小編來看看吧
2019-01-01
Java單例模式簡單介紹
這篇文章主要為大家詳細介紹了Java單例模式簡單的相關資料，具有一定的參考價值，感興趣的小伙伴們可以參考一下
2017-10-10
在SpringBoot中使用@Value注解來設置默認值的方法
Spring Boot提供了一種使用注解設置默認值的方式,即使用 @Value 注解,下面這篇文章主要給大家介紹了關于如何在SpringBoot中使用@Value注解來設置默認值的相關資料,需要的朋友可以參考下
2023-10-10
Springcloud Config支持本地配置文件的方法示例
這篇文章主要介紹了Springcloud Config支持本地配置文件的方法示例，文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值，需要的朋友們下面隨著小編來一起學習學習吧
2020-02-02
Java如何讀取配置文件并賦值靜態(tài)變量
這篇文章主要介紹了Java如何讀取配置文件并賦值靜態(tài)變量,文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值,需要的朋友可以參考下
2020-10-10
Spring?Security實現添加圖片驗證功能
這篇文章主要為大家介紹了Spring?Security實現添加圖片驗證功能詳解，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進步，早日升職加薪
2023-01-01
Java 線程池的作用以及該如何使用
這篇文章主要介紹了Java 線程池的作用以及該如何使用，幫助大家更好的理解和學習Java的相關知識，感興趣的朋友可以了解下
2021-01-01