当前位置：首页 > Java

java如何实现缓存

2026-02-05 13:11:44Java

缓存实现方法

在Java中实现缓存可以通过多种方式，包括使用内置库、第三方框架或自定义实现。以下是几种常见的缓存实现方法：

使用Java内置缓存

Java提供了java.util.concurrent.ConcurrentHashMap作为线程安全的缓存容器基础。可以结合ConcurrentHashMap和SoftReference或WeakReference实现简单的内存缓存。

import java.util.concurrent.ConcurrentHashMap;

public class SimpleCache<K, V> {
    private final ConcurrentHashMap<K, V> cache = new ConcurrentHashMap<>();

    public V get(K key) {
        return cache.get(key);
    }

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

    public void remove(K key) {
        cache.remove(key);
    }
}

使用Guava Cache

Google的Guava库提供了强大的缓存实现CacheBuilder，支持过期策略、最大容量限制等功能。

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

public class GuavaCacheExample {
    private static final Cache<String, String> cache = CacheBuilder.newBuilder()
            .maximumSize(100)
            .expireAfterWrite(10, TimeUnit.MINUTES)
            .build();

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

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

使用Caffeine Cache

Caffeine是高性能的Java缓存库，比Guava Cache更高效，适合高并发场景。

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

public class CaffeineCacheExample {
    private static final Cache<String, String> cache = Caffeine.newBuilder()
            .maximumSize(100)
            .expireAfterWrite(10, TimeUnit.MINUTES)
            .build();

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

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

使用Ehcache

Ehcache是成熟的Java缓存框架，支持磁盘持久化和分布式缓存。

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 {
    private static CacheManager cacheManager = CacheManagerBuilder.newCacheManagerBuilder()
            .withCache("preConfigured",
                    CacheConfigurationBuilder.newCacheConfigurationBuilder(
                            String.class, String.class,
                            ResourcePoolsBuilder.heap(100)))
            .build(true);

    private static Cache<String, String> cache = cacheManager.getCache("preConfigured", String.class, String.class);

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

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

使用Spring Cache

Spring框架提供了声明式缓存支持，可以轻松集成多种缓存实现。

import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;

@Service
public class BookService {
    @Cacheable("books")
    public String getBook(String isbn) {
        return findBookInDatabase(isbn);
    }

    private String findBookInDatabase(String isbn) {
        // Database query logic
        return "Book Details";
    }
}