java

关注公众号 jb51net

关闭
首页 > 软件编程 > java > java本地缓存GuavaCache

java中的本地缓存GuavaCache使用方法和示例教程

作者：呀哈哈kk

GuavaCache是Google提供的高效本地缓存工具,支持线程安全、自动加载、过期策略及内存回收,适用于高并发场景,可提升系统性能,减少数据库访问压力

在现代互联网应用中，高并发场景是每个开发者都可能遇到的挑战。为了提高系统的响应速度和吞吐量，缓存技术成为了一个不可或缺的部分。Google Guava库提供了一个强大的本地缓存实现——GuavaCache，它不仅简单易用，而且性能优秀，非常适合处理高并发场景。

 GuavaCache简介

GuavaCache是Google Guava库中的一个组件，用于实现内存中的缓存。它支持多种配置选项，如设置缓存大小、过期策略等，并且提供了线程安全的操作方法，使得在多线程环境中使用更加方便。

主要特性

线程安全

GuavaCache的所有操作都是线程安全的，这使得它在高并发环境下能够稳定运行，无需额外的同步控制。

自动加载

可以通过LoadingCache接口实现数据的自动加载，当缓存中没有找到对应的键时，会自动调用指定的方法来加载数据。

过期策略

支持基于时间的过期策略，包括创建后过期（expire after write）和访问后过期（expire after access）。

内存回收

GuavaCache可以根据内存情况自动回收不常用的条目，避免内存溢出。

使用示例

基本使用

首先，需要添加Guava库到项目中，如果使用Maven，可以在pom.xml中添加如下依赖：

<dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>31.0.1-jre</version>
</dependency>

接下来，创建一个简单的缓存实例：

import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;

public class GuavaCacheExample {
    public static void main(String[] args) throws ExecutionException {
        // 创建一个LoadingCache实例
        LoadingCache<String, String> cache = CacheBuilder.newBuilder()
                .maximumSize(100) // 设置缓存的最大容量
                .expireAfterWrite(10, TimeUnit.MINUTES) // 设置过期时间为10分钟
                .build(new CacheLoader<String, String>() { // 定义默认的数据加载机制
                    @Override
                    public String load(String key) throws Exception {
                        return "value-" + key;
                    }
                });

        // 访问缓存
        String value = cache.get("key1");
        System.out.println(value); // 输出: value-key1
    }
}

异常处理

在实际应用中，数据加载可能会抛出异常。GuavaCache允许你定义如何处理这些异常：

try {
    String value = cache.get("key2");
} catch (ExecutionException e) {
    // 处理异常
    System.err.println("Failed to load value for key2: " + e.getCause());
}

手动加载和删除

除了自动加载外，还可以手动将数据放入缓存或从缓存中删除数据：

// 手动加载
cache.put("key3", "value3");

// 手动删除
cache.invalidate("key3");

性能优化

并发级别

通过设置concurrencyLevel参数可以调整缓存的并发性能，这个值表示预计同时访问缓存的线程数。通常情况下，默认值已经足够好，但在特定场景下适当调整可以提升性能。

软引用与弱引用

对于内存敏感的应用，可以考虑使用软引用或弱引用来存储缓存项，这样当系统内存不足时，JVM会自动回收这些对象。

CacheBuilder.newBuilder()
    .softValues() // 使用软引用
    .weakKeys() // 使用弱引用
    .build();

GuavaCache是一个强大而灵活的缓存工具，特别适合于需要高性能和低延迟的应用。通过合理配置，可以有效应对高并发场景下的各种挑战。这篇文章介绍了GuavaCache的基本概念、主要特性和使用方法，以及一些性能优化的技巧，适合对缓存技术感兴趣的开发者阅读。Guava Cache 是一个非常高效的本地缓存库，特别适合处理高并发场景。下面是一个使用 Guava Cache 的示例代码，假设我们有一个需要频繁查询用户信息的应用场景。

场景描述

假设我们有一个用户服务，需要频繁地从数据库中查询用户信息。为了减少数据库的访问压力，我们可以使用 Guava Cache 来缓存用户信息。

依赖引入

首先，确保你的项目中已经引入了 Guava 库。如果你使用的是 Maven，可以在 pom.xml 中添加以下依赖：

<dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>31.0.1-jre</version>
</dependency>

示例代码

import com.google.common.cache.Cache;
import com.google.common.cache.CacheBuilder;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;

public class UserCacheService {

    // 创建一个 Guava Cache 实例
    private final Cache<String, User> userCache;

    public UserCacheService() {
        // 配置缓存
        this.userCache = CacheBuilder.newBuilder()
                .maximumSize(1000) // 最大缓存条目数
                .expireAfterWrite(10, TimeUnit.MINUTES) // 缓存条目在写入后 10 分钟过期
                .recordStats() // 记录缓存统计信息
                .build();
    }

    // 获取用户信息
    public User getUser(String userId) {
        try {
            return userCache.get(userId, () -> loadUserFromDatabase(userId));
        } catch (ExecutionException e) {
            throw new RuntimeException("Failed to load user from cache", e);
        }
    }

    // 从数据库加载用户信息
    private User loadUserFromDatabase(String userId) {
        // 模拟从数据库加载用户信息
        System.out.println("Loading user " + userId + " from database");
        return new User(userId, "User Name " + userId);
    }

    public static void main(String[] args) {
        UserCacheService service = new UserCacheService();

        // 模拟高并发请求
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                User user = service.getUser("12345");
                System.out.println("User: " + user);
            }).start();
        }
    }
}

class User {
    private String id;
    private String name;

    public User(String id, String name) {
        this.id = id;
        this.name = name;
    }

    @Override
    public String toString() {
        return "User{id='" + id + "', name='" + name + "'}";
    }
}

代码解释

  1. 缓存配置：
  1. 获取用户信息：
  1. 从数据库加载用户信息：
  1. 模拟高并发请求：

备注

1. 基本概念

2. 创建Guava Cache

创建一个简单的GuavaCache可以通过CacheBuilder来完成。以下是一个基本的例子：

import com.google.common.cache.Cache;
import com.google.common.cache.CacheBuilder;

import java.util.concurrent.TimeUnit;

public class GuavaCacheExample {
    public static void main(String[] args) {
        // 创建一个最大容量为100，超过容量后使用LRU算法移除最近最少使用的条目，
        // 并且设置10分钟后过期的缓存
        Cache<String, String> cache = CacheBuilder.newBuilder()
                .maximumSize(100)
                .expireAfterWrite(10, TimeUnit.MINUTES)
                .removalListener(notification -> System.out.println("Removed: " + notification.getKey()))
                .build();

        // 向缓存中添加数据
        cache.put("key1", "value1");

        // 从缓存中获取数据
        String value = cache.getIfPresent("key1");
        System.out.println(value); // 输出: value1
    }
}

3. 使用LoadingCache

LoadingCache可以在缓存未命中时自动加载数据，这通常通过实现CacheLoader来完成：

import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;

public class LoadingCacheExample {
    public static void main(String[] args) throws ExecutionException {
        LoadingCache<String, String> cache = CacheBuilder.newBuilder()
                .maximumSize(100)
                .expireAfterWrite(10, TimeUnit.MINUTES)
                .build(new CacheLoader<String, String>() {
                    @Override
                    public String load(String key) throws Exception {
                        return fetchFromDatabase(key);
                    }
                });

        // 获取数据，如果缓存中没有，会自动调用load方法加载
        String value = cache.get("key1");
        System.out.println(value); // 输出: 从数据库获取的数据
    }

    private static String fetchFromDatabase(String key) {
        // 模拟从数据库查询
        return "从数据库获取的数据";
    }
}

4. 高级特性

5. 注意事项

总结

通过使用 Guava Cache，我们可以有效地减少对数据库的访问次数，提高系统的性能和响应速度。特别是在高并发场景下，缓存的作用更加明显。希望这个示例对你有所帮助！在处理高并发场景时，缓存是提高系统性能和响应速度的重要手段之一。Google Guava库提供了一个非常强大的本地缓存实现——GuavaCache，它不仅提供了基本的缓存功能，还支持多种高级特性，如过期策略、大小限制、统计信息等，非常适合在高并发环境下使用。

到此这篇关于java中的本地缓存GuavaCache使用方法和示例教程的文章就介绍到这了,更多相关java本地缓存GuavaCache内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:
阅读全文