当前位置：首页 > Java

java如何实现缓存

2026-03-04 00:26:28Java

Java实现缓存的常见方法

使用HashMap实现简单缓存

利用Java集合框架中的HashMap可以快速实现一个简单的内存缓存。这种方式适合小型应用或临时缓存需求。

import java.util.HashMap;
import java.util.Map;

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

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

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

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

使用Guava Cache

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

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

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

        cache.put("key1", "value1");
        String value = cache.getIfPresent("key1");
    }
}

使用Caffeine缓存

Caffeine是高性能的Java缓存库，比Guava Cache有更好的性能表现。

java如何实现缓存

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

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

        cache.put("key1", "value1");
        String value = cache.getIfPresent("key1");
    }
}

使用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 {
    public static void main(String[] args) {
        CacheManager cacheManager = CacheManagerBuilder.newCacheManagerBuilder().build();
        cacheManager.init();

        Cache<String, String> myCache = cacheManager.createCache("myCache",
            CacheConfigurationBuilder.newCacheConfigurationBuilder(
                String.class, String.class,
                ResourcePoolsBuilder.heap(100)));

        myCache.put("key", "value");
        String value = myCache.get("key");
    }
}

使用Spring Cache抽象

Spring框架提供了缓存抽象层，可以方便地与各种缓存实现集成。

java如何实现缓存

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

@Service
public class BookService {
    @Cacheable("books")
    public Book findBook(String isbn) {
        // 模拟耗时操作
        return lookupBookInDatabase(isbn);
    }
}

配置Spring Cache（以Caffeine为例）：

@Configuration
@EnableCaching
public class CacheConfig {
    @Bean
    public CacheManager cacheManager() {
        CaffeineCacheManager cacheManager = new CaffeineCacheManager();
        cacheManager.setCaffeine(Caffeine.newBuilder()
            .expireAfterWrite(10, TimeUnit.MINUTES)
            .maximumSize(1000));
        return cacheManager;
    }
}

使用Redis实现分布式缓存

对于分布式系统，可以使用Redis作为缓存服务器。

import org.springframework.data.redis.core.RedisTemplate;

@Service
public class RedisCacheService {
    private final RedisTemplate<String, Object> redisTemplate;

    public void setValue(String key, Object value) {
        redisTemplate.opsForValue().set(key, value);
    }

    public Object getValue(String key) {
        return redisTemplate.opsForValue().get(key);
    }
}

配置Redis连接：

@Configuration
public class RedisConfig {
    @Bean
    public RedisConnectionFactory redisConnectionFactory() {
        return new LettuceConnectionFactory();
    }

    @Bean
    public RedisTemplate<String, Object> redisTemplate() {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(redisConnectionFactory());
        return template;
    }
}