使用Caffeine库的Java本地缓存详解

在Java编程语言中，Caffeine是一个开源的缓存库，用于提供高性能的本地缓存实现。它支持在应用程序中轻松管理缓存，并提供了许多灵活的配置选项。以下是使用Caffeine库的一些常见方法的详解：

引言

在Java编程语言中，Caffeine是一个强大的缓存库，为应用程序提供了高性能的本地缓存实现。通过使用Caffeine，开发者可以轻松管理应用程序中的缓存，并通过灵活的配置选项满足不同场景下的需求。本博客将详细介绍Caffeine库的一些常见用法。

1. 引入Caffeine库

首先，我们需要将Caffeine库添加到项目的依赖项中。这可以通过Maven或Gradle等构建工具完成。以下是一个Maven的依赖配置示例：

<dependency>
    <groupId>com.github.ben-manes.caffeine</groupId>
    <artifactId>caffeine</artifactId>
    <version>2.9.0</version>
</dependency>

2. 创建Caffeine缓存

使用Caffeine类创建缓存对象，并配置一些基本参数，如初始容量、最大容量和过期时间。

import com.github.benmanes.caffeine.cache.Caffeine;

// 创建缓存
Caffeine<Object, Object> caffeine = Caffeine.newBuilder()
    .initialCapacity(100)
    .maximumSize(1000)
    .expireAfterWrite(10, TimeUnit.MINUTES);

// 构建缓存实例
com.github.benmanes.caffeine.cache.Cache<Object, Object> cache = caffeine.build();

3. 存储和获取数据

使用put方法将数据放入缓存，使用get方法从缓存中获取数据。

// 存储数据
cache.put("key", "value");

// 获取数据
String result = cache.get("key", k -> "default");

4. 异步加载

Caffeine支持异步加载缓存项，以便在需要时异步加载数据。

CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> "async value");
String result = cache.get("key", k -> future);

5. 监听器

可以添加监听器以便在缓存项被创建、更新、删除或过期时执行自定义逻辑。

cache
    .writer(new CacheWriter<Object, Object>() {
        @Override
        public void write(Object key, Object value) {
            // 缓存项写入时的逻辑
        }

        @Override
        public void delete(Object key, Object value, RemovalCause cause) {
            // 缓存项删除时的逻辑
        }
    });

Caffeine是线程安全的，支持高并发环境。它使用细粒度的锁来提高并发性能，确保在多线程环境中安全地访问缓存。

11. 配置选项

Caffeine提供了众多的配置选项，包括缓存大小、过期时间、自动加载、并发级别等。根据具体需求进行适当的配置。

Caffeine<Object, Object> caffeine = Caffeine.newBuilder()
    .maximumSize(1000)
    .expireAfterWrite(10, TimeUnit.MINUTES)
    .concurrencyLevel(4);  // 设置并发级别

12. 统计信息

Caffeine提供了获取缓存统计信息的方法，如命中率、加载次数等。

CacheStats stats = cache.stats();
System.out.println("Hit Rate: " + stats.hitRate());
System.out.println("Miss Rate: " + stats.missRate());

13. 高级功能：手动加载

除了异步加载外，Caffeine还支持手动加载缓存项，这对于某些特殊场景可能更为适用。

// 手动加载
String result = cache.get("key", k -> fetchDataFromDatabase(k));

14. 使用缓存的最佳实践

在实际应用中，为了充分利用Caffeine的性能和功能，一些最佳实践值得注意：

  • 合理配置缓存大小： 根据应用程序的内存限制和性能需求，合理配置缓存的大小，以防止内存溢出或低效率的缓存。
  • 选择合适的失效策略： 根据数据的更新频率和访问模式，选择合适的失效策略，例如基于时间的失效、定时刷新或手动失效。
  • 使用监听器进行日志或清理操作： 通过添加监听器，可以在缓存项被创建、更新、删除或过期时执行自定义的日志记录或清理操作。
  • 考虑并发性： Caffeine已经实现了高效的并发性，但在高并发场景下，仍需注意线程安全性和性能。

15. 避免缓存击穿

缓存击穿是指在缓存中不存在但数据库中存在的数据，每次请求都要到数据库中查询，导致数据库负载过大。为避免缓存击穿，可以考虑使用CacheLoader的loadAll方法一次性加载多个缓存项。

cache.getAll(keys, keys -> fetchDataFromDatabase(keys));

16. 分布式缓存集成

在某些场景下，需要将缓存扩展到多个应用程序实例或服务之间，以确保共享的状态和数据的一致性。Caffeine本身是一种本地缓存，但可以与其他分布式缓存系统集成，如Redis或Memcached。

// 示例：使用Caffeine作为本地缓存，与Redis进行集成
Caffeine<Object, Object> caffeine = Caffeine.newBuilder()
    .maximumSize(1000)
    .expireAfterWrite(10, TimeUnit.MINUTES);

Cache<Object, Object> localCache = caffeine.build();
Cache<Object, Object> distributedCache = RedisCacheIntegration.withCaffeine(localCache);

17. 处理缓存穿透

缓存穿透是指查询一个一定不存在的数据，由于缓存没有命中，请求直接访问数据库，导致数据库查询负载过大。为了防止缓存穿透，可以考虑使用布隆过滤器或在缓存中存储空对象来标记缓存中不存在的数据。

// 使用布隆过滤器进行缓存穿透防护
BloomFilter<Object> bloomFilter = BloomFilter.create(Funnels.stringFunnel(Charset.defaultCharset()), 1000, 0.01);
cache = Caffeine.newBuilder()
    .maximumSize(1000)
    .expireAfterWrite(10, TimeUnit.MINUTES)
    .writer(new CacheWriter<Object, Object>() {
        @Override
        public void write(Object key, Object value) {
            // 写入缓存时更新布隆过滤器
            bloomFilter.put(key);
        }

        @Override
        public void delete(Object key, Object value, RemovalCause cause) {
            // 删除缓存时更新布隆过滤器
            bloomFilter.put(key);
        }
    })
    .build();

// 在查询前使用布隆过滤器判断是否存在
String key = "nonExistentKey";
if (bloomFilter.mightContain(key) && cache.get(key, k -> fetchDataFromDatabase(k)) == null) {
    // 数据不存在，避免缓存穿透
}

18. 适用于Spring Boot的注解驱动缓存

对于使用Spring Boot的开发者，可以使用@Caching、@Cacheable、@CachePut等注解来简化缓存的使用，而底层的缓存实现可以选择集成Caffeine。

codeimport org.springframework.cache.annotation.Cacheable;

// 使用Caffeine作为缓存提供者
@Cacheable(value = "myCache", cacheManager = "caffeineCacheManager")
public String getData(String key) {
    // 如果缓存中有数据，直接返回；否则执行下面的逻辑并将结果存入缓存
    return fetchDataFromDatabase(key);
}

举例

例子1

假设我们有一个简单的应用程序，该应用程序需要存储和获取用户信息。为了提高性能，我们决定使用Caffeine作为本地缓存。以下是一个具体的例子：

import com.github.benmanes.caffeine.cache.Cache;
import com.github.benmanes.caffeine.cache.Caffeine;

import java.util.concurrent.TimeUnit;

public class UserCacheExample {

    // 创建Caffeine缓存
    private static Cache<Long, User> userCache = Caffeine.newBuilder()
            .expireAfterWrite(10, TimeUnit.MINUTES)
            .maximumSize(1000)
            .build();

    public static void main(String[] args) {
        // 获取用户信息，如果缓存中不存在，则从数据库中查询
        long userId = 123;
        User user = getUser(userId);
        System.out.println("User: " + user);
    }

    private static User getUser(long userId) {
        // 先尝试从缓存中获取用户信息
        User cachedUser = userCache.getIfPresent(userId);

        if (cachedUser != null) {
            System.out.println("User found in cache!");
            return cachedUser;
        } else {
            // 如果缓存中不存在，从数据库中查询用户信息
            User dbUser = fetchUserFromDatabase(userId);

            // 将查询到的用户信息放入缓存
            if (dbUser != null) {
                userCache.put(userId, dbUser);
            }

            return dbUser;
        }
    }

    private static User fetchUserFromDatabase(long userId) {
        // 模拟从数据库中查询用户信息的逻辑
        System.out.println("Fetching user from database...");
        return new User(userId, "John Doe");
    }

    static class User {
        private long userId;
        private String username;

        public User(long userId, String username) {
            this.userId = userId;
            this.username = username;
        }

        @Override
        public String toString() {
            return "User{" +
                    "userId=" + userId +
                    ", username='" + username + '\'' +
                    '}';
        }
    }
}

在这个例子中，我们使用了Caffeine缓存来存储用户信息。当需要获取用户信息时，首先尝试从缓存中获取，如果缓存中不存在，则从数据库中查询，并将查询结果放入缓存中。这样，在接下来的一段时间内，相同的查询将直接从缓存中获取，提高了应用程序的性能。

例子2

假设我们有一个在线电商应用，用户可以浏览商品并将商品加入购物车。我们希望使用Caffeine缓存来存储商品信息，以提高对商品的频繁访问性能。以下是一个具体的例子：

import com.github.benmanes.caffeine.cache.Cache;
import com.github.benmanes.caffeine.cache.Caffeine;

import java.util.concurrent.TimeUnit;

public class ProductCacheExample {

    // 创建Caffeine缓存
    private static Cache<Long, Product> productCache = Caffeine.newBuilder()
            .expireAfterWrite(30, TimeUnit.MINUTES)
            .maximumSize(1000)
            .build();

    public static void main(String[] args) {
        // 模拟用户浏览商品
        long productId = 1;
        Product product = getProduct(productId);
        System.out.println("Product: " + product);

        // 用户加入购物车，更新商品库存
        addToShoppingCart(product);

        // 再次浏览同一商品，此时应从缓存中获取，而不是再次查询数据库
        Product cachedProduct = getProduct(productId);
        System.out.println("Cached Product: " + cachedProduct);
    }

    private static Product getProduct(long productId) {
        // 先尝试从缓存中获取商品信息
        Product cachedProduct = productCache.getIfPresent(productId);

        if (cachedProduct != null) {
            System.out.println("Product found in cache!");
            return cachedProduct;
        } else {
            // 如果缓存中不存在，从数据库中查询商品信息
            Product dbProduct = fetchProductFromDatabase(productId);

            // 将查询到的商品信息放入缓存
            if (dbProduct != null) {
                productCache.put(productId, dbProduct);
            }

            return dbProduct;
        }
    }

    private static void addToShoppingCart(Product product) {
        // 模拟用户将商品加入购物车的操作，更新商品库存等
        System.out.println("Adding product to shopping cart: " + product);
    }

    private static Product fetchProductFromDatabase(long productId) {
        // 模拟从数据库中查询商品信息的逻辑
        System.out.println("Fetching product from database...");
        return new Product(productId, "Laptop", 999.99);
    }

    static class Product {
        private long productId;
        private String name;
        private double price;

        public Product(long productId, String name, double price) {
            this.productId = productId;
            this.name = name;
            this.price = price;
        }

        @Override
        public String toString() {
            return "Product{" +
                    "productId=" + productId +
                    ", name='" + name + '\'' +
                    ", price=" + price +
                    '}';
        }
    }
}

在这个例子中，我们使用Caffeine缓存来存储商品信息。当用户浏览商品时，首先尝试从缓存中获取，如果缓存中不存在，则从数据库中查询，并将查询结果放入缓存中。这样，用户在浏览相同商品时，将直接从缓存中获取，提高了应用程序对商品信息的访问性能。

# java # 缓存 # 开发语言
Logo
GitCode 开源社区

旨在为数千万中国开发者提供一个无缝且高效的云端环境，以支持学习、使用和贡献开源项目。

更多推荐

cover

GitTalk | 使用面向业务的狮偶编程语言提升开发效率

avatar GitCode 开源社区
cover

GitTalk | DevUI Suits 场景解决方案

avatar GitCode 开源社区
cover

GitTalk | DevUI Admin 前端项目构建

avatar GitCode 开源社区