【本地缓存】Java 中的 4 种本地缓存

在Java中，缓存是一种常用的优化手段，用于减少对数据库或远程服务的访问，提高应用程序的性能。尤其是在处理频繁访问的数据时，使用本地缓存是一个非常有效的方法。接下来，我们将介绍Java中的四种常见本地缓存实现，并提供示例代码。

1. 使用HashMap实现简单缓存

最基本的方式是使用HashMap。这种方式简单易用，但需要手动管理缓存的大小和过期策略。

import java.util.HashMap;

public class SimpleCache {
    private HashMap<String, String> cache = new HashMap<>();

    public void put(String key, String value) {
        cache.put(key, value);
    }

    public String get(String key) {
        return cache.get(key);
    }

    public void clear() {
        cache.clear();
    }

    public static void main(String[] args) {
        SimpleCache simpleCache = new SimpleCache();
        simpleCache.put("key1", "value1");
        System.out.println(simpleCache.get("key1")); // 输出: value1
    }
}

2. 使用Guava Cache

Guava是Google推出的一个用于Java开发的工具包，其中提供了强大的缓存机制。Guava Cache支持过期、最大容量等功能，更加灵活且易于使用。

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<String, String> cache = CacheBuilder.newBuilder()
                .expireAfterWrite(10, TimeUnit.SECONDS) // 设置写入后10秒过期
                .maximumSize(100) // 最大缓存条目
                .build(new CacheLoader<String, String>() {
                    public String load(String key) {
                        return "default_" + key; // 缺失值的默认值
                    }
                });

        cache.put("key1", "value1");
        System.out.println(cache.get("key1")); // 输出: value1

        // 等待过期
        try {
            Thread.sleep(11000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(cache.get("key1")); // 输出: default_key1
    }
}

3. Caffeine Cache

Caffeine是一个高性能的缓存库，提供了更高级的缓存功能，支持异步加载、基于重量的驱逐和多种过期策略，性能优于Guava。

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

import java.util.concurrent.TimeUnit;

public class CaffeineCacheExample {
    public static void main(String[] args) {
        Cache<String, String> cache = Caffeine.newBuilder()
                .expireAfterWrite(10, TimeUnit.SECONDS)
                .maximumSize(100)
                .build();

        cache.put("key1", "value1");
        System.out.println(cache.getIfPresent("key1")); // 输出: value1

        // 等待过期
        try {
            Thread.sleep(11000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(cache.getIfPresent("key1")); // 输出: null
    }
}

4. EHCache

EHCache是一个非常著名的开源缓存框架，支持多种缓存策略，并且能方便地与各种框架集成。

import org.ehcache.Cache;
import org.ehcache.CacheManager;
import org.ehcache.config.builders.CacheConfigurationBuilder;
import org.ehcache.config.builders.CacheManagerBuilder;
import org.ehcache.config.builders.ResourcePoolsBuilder;

public class EhCacheExample {
    public static void main(String[] args) {
        CacheManager cacheManager = CacheManagerBuilder.newCacheManagerBuilder()
                .withCache("myCache",
                        CacheConfigurationBuilder.newCacheConfigurationBuilder(String.class, String.class,
                                ResourcePoolsBuilder.heap(100)))
                .build(true);

        Cache<String, String> myCache = cacheManager.getCache("myCache", String.class, String.class);

        myCache.put("key1", "value1");
        System.out.println(myCache.get("key1")); // 输出: value1

        // 关闭缓存管理器
        cacheManager.close();
    }
}

总结

以上介绍了四种不同的本地缓存实现方式。在实际开发中，可以根据需求选择合适的缓存方案。例如，对于简单的缓存需求，可以使用HashMap；如果需要更复杂的过期和大小管理，可以考虑Guava Cache或Caffeine；对于企业级应用，EHCache提供了一套更加完善的解决方案。选择合适的缓存机制，可以显著提高系统的性能和响应速度。