java如何使用缓存
缓存的基本概念
缓存是一种临时存储数据的机制，用于提高系统性能，减少对数据库或外部服务的频繁访问。Java中可以通过多种方式实现缓存，包括内置缓存框架、第三方库或自定义实现。
使用Java内置缓存
Java提供了简单的缓存机制，例如使用HashMap或ConcurrentHashMap实现内存缓存。
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
public class SimpleCache<K, V> {
private final Map<K, V> cache = new ConcurrentHashMap<>();
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库提供了强大的缓存功能，支持过期策略、最大容量限制等。
添加Maven依赖：
<dependency>
<groupId>com.google.guava</groupId>
<artifactId>guava</artifactId>
<version>31.1-jre</version>
</dependency>示例代码：
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) // 写入后10分钟过期
.build();
cache.put("key1", "value1");
String value = cache.getIfPresent("key1");
System.out.println(value);
}
}使用Caffeine Cache
Caffeine是高性能的Java缓存库，比Guava Cache更高效。
添加Maven依赖：
<dependency>
<groupId>com.github.ben-manes.caffeine</groupId>
<artifactId>caffeine</artifactId>
<version>3.1.8</version>
</dependency>示例代码：
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()
.maximumSize(100)
.expireAfterWrite(10, TimeUnit.MINUTES)
.build();
cache.put("key1", "value1");
String value = cache.getIfPresent("key1");
System.out.println(value);
}
}使用Ehcache
Ehcache是一个成熟的Java缓存框架，支持分布式缓存和持久化。
添加Maven依赖：
<dependency>
<groupId>org.ehcache</groupId>
<artifactId>ehcache</artifactId>
<version>3.10.8</version>
</dependency>示例代码：
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> cache = cacheManager.createCache("myCache",
CacheConfigurationBuilder.newCacheConfigurationBuilder(
String.class, String.class,
ResourcePoolsBuilder.heap(100)));
cache.put("key1", "value1");
String value = cache.get("key1");
System.out.println(value);
cacheManager.close();
}
}使用Spring Cache
Spring框架提供了缓存抽象，支持多种缓存实现（如Caffeine、Ehcache、Redis）。
添加Maven依赖（以Spring Boot为例）：
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-cache</artifactId>
</dependency>启用缓存并配置：
@SpringBootApplication
@EnableCaching
public class MyApp {
public static void main(String[] args) {
SpringApplication.run(MyApp.class, args);
}
}使用缓存注解：
@Service
public class UserService {
@Cacheable(value = "users", key = "#id")
public User getUserById(Long id) {
// 模拟数据库查询
return userRepository.findById(id);
}
@CacheEvict(value = "users", key = "#id")
public void deleteUser(Long id) {
userRepository.deleteById(id);
}
}分布式缓存（Redis）
对于分布式系统，可以使用Redis作为缓存。
添加Maven依赖：
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>配置Redis连接：
spring:
redis:
host: localhost
port: 6379使用RedisTemplate：
@Autowired
private RedisTemplate<String, String> redisTemplate;
public void setValue(String key, String value) {
redisTemplate.opsForValue().set(key, value);
}
public String getValue(String key) {
return redisTemplate.opsForValue().get(key);
}缓存策略选择
- 内存缓存：适用于单机应用，如Guava、Caffeine。
- 分布式缓存：适用于微服务或集群，如Redis、Ehcache分布式模式。
- Spring Cache：提供统一的缓存抽象，便于切换实现。
通过合理选择缓存框架和策略，可以显著提升Java应用的性能。
