SpringBoot如何使用Redis缓存

# SpringBoot如何使用Redis缓存 ## 1. Redis缓存概述 ### 1.1 什么是Redis Redis（Remote Dictionary Server）是一个开源的、基于内存的数据结构存储系统，可以用作数据库、缓存和消息中间件。它支持多种数据结构，包括字符串（strings）、哈希（hashes）、列表（lists）、集合（sets）、有序集合（sorted sets）等。 Redis的主要特点： - 高性能：基于内存操作，读写速度极快 - 持久化：支持RDB和AOF两种持久化方式 - 丰富的数据结构：支持多种高级数据结构 - 原子性：所有操作都是原子性的 - 发布/订阅：支持消息发布订阅模式 ### 1.2 为什么选择Redis作为缓存 在SpringBoot应用中使用Redis作为缓存有诸多优势： 1. **性能提升**：相比直接访问数据库，Redis的响应时间通常在微秒级别 2. **减轻数据库压力**：高频访问数据可以从缓存获取，减少数据库查询 3. **分布式支持**：Redis天然支持分布式，适合微服务架构 4. **丰富的数据结构**：可以灵活处理各种缓存场景 5. **过期策略**：支持设置缓存过期时间，自动清理旧数据 ### 1.3 Spring缓存抽象 Spring框架提供了缓存抽象，通过注解的方式简化缓存操作。主要注解包括： - `@EnableCaching`：启用缓存支持 - `@Cacheable`：在方法执行前检查缓存 - `@CachePut`：将方法返回值放入缓存 - `@CacheEvict`：清除缓存 - `@Caching`：组合多个缓存操作 - `@CacheConfig`：类级别的共享缓存配置 ## 2. 环境准备与配置 ### 2.1 安装Redis #### Windows安装 1. 下载Redis for Windows：https://github.com/microsoftarchive/redis/releases 2. 解压zip包 3. 运行redis-server.exe启动服务 4. 使用redis-cli.exe连接测试 #### Linux安装 ```bash # Ubuntu/Debian sudo apt update sudo apt install redis-server # CentOS/RHEL sudo yum install epel-release sudo yum install redis sudo systemctl start redis sudo systemctl enable redis 

Docker运行Redis

docker run --name my-redis -p 6379:6379 -d redis 

2.2 SpringBoot项目创建

使用Spring Initializr创建项目，添加以下依赖：

• Spring Web
• Spring Data Redis
• Lombok（可选）

或手动添加Maven依赖：

<dependencies> <!-- Spring Boot Starter Web --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <!-- Spring Data Redis --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency> <!-- Lombok --> <dependency> <groupId>org.projectlombok</groupId> <artifactId>lombok</artifactId> <optional>true</optional> </dependency> <!-- 测试依赖 --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-test</artifactId> <scope>test</scope> </dependency> </dependencies> 

2.3 基本配置

在application.properties或application.yml中配置Redis连接：

# application.properties spring.redis.host=localhost spring.redis.port=6379 spring.redis.password= spring.redis.database=0 # 连接池配置 spring.redis.lettuce.pool.max-active=8 spring.redis.lettuce.pool.max-idle=8 spring.redis.lettuce.pool.min-idle=0 spring.redis.lettuce.pool.max-wait=-1ms 

或YAML格式：

# application.yml spring: redis: host: localhost port: 6379 password: database: 0 lettuce: pool: max-active: 8 max-idle: 8 min-idle: 0 max-wait: -1ms 

3. 基本缓存操作

3.1 启用缓存支持

在主应用类上添加@EnableCaching注解：

@SpringBootApplication @EnableCaching public class RedisCacheApplication { public static void main(String[] args) { SpringApplication.run(RedisCacheApplication.class, args); } } 

3.2 缓存注解使用

@Cacheable

@Service public class ProductService { @Cacheable(value = "products", key = "#id") public Product getProductById(Long id) { // 模拟数据库查询 System.out.println("Fetching product from database..."); return new Product(id, "Product " + id, 100.00); } } 

@CachePut

@CachePut(value = "products", key = "#product.id") public Product updateProduct(Product product) { // 更新数据库逻辑 System.out.println("Updating product in database..."); return product; } 

@CacheEvict

@CacheEvict(value = "products", key = "#id") public void deleteProduct(Long id) { // 删除数据库记录 System.out.println("Deleting product from database..."); } // 清除所有缓存 @CacheEvict(value = "products", allEntries = true) public void clearAllCache() { System.out.println("Clearing all products cache..."); } 

@Caching

@Caching( cacheable = { @Cacheable(value = "products", key = "#name") }, put = { @CachePut(value = "products", key = "#result.id") } ) public Product getProductByName(String name) { // 查询逻辑 return productRepository.findByName(name); } 

3.3 自定义Key生成器

@Configuration public class RedisConfig { @Bean public KeyGenerator customKeyGenerator() { return (target, method, params) -> { StringBuilder sb = new StringBuilder(); sb.append(target.getClass().getSimpleName()); sb.append(":"); sb.append(method.getName()); sb.append(":"); for (Object obj : params) { sb.append(obj.toString()); } return sb.toString(); }; } } // 使用自定义Key生成器 @Cacheable(value = "products", keyGenerator = "customKeyGenerator") public Product getProduct(Long id) { // ... } 

4. 高级缓存配置

4.1 自定义RedisTemplate

@Configuration public class RedisConfig { @Bean public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) { RedisTemplate<String, Object> template = new RedisTemplate<>(); template.setConnectionFactory(factory); // 使用Jackson2JsonRedisSerializer序列化value Jackson2JsonRedisSerializer<Object> serializer = new Jackson2JsonRedisSerializer<>(Object.class); ObjectMapper mapper = new ObjectMapper(); mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY); mapper.activateDefaultTyping( mapper.getPolymorphicTypeValidator(), ObjectMapper.DefaultTyping.NON_FINAL ); serializer.setObjectMapper(mapper); // 设置key和value的序列化规则 template.setKeySerializer(new StringRedisSerializer()); template.setValueSerializer(serializer); template.setHashKeySerializer(new StringRedisSerializer()); template.setHashValueSerializer(serializer); template.afterPropertiesSet(); return template; } } 

4.2 自定义缓存管理器

@Configuration @EnableCaching public class RedisCacheConfig { @Bean public CacheManager cacheManager(RedisConnectionFactory factory) { RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig() .entryTtl(Duration.ofMinutes(30)) // 默认过期时间30分钟 .disableCachingNullValues() // 不缓存null值 .serializeKeysWith(RedisSerializationContext.SerializationPair .fromSerializer(new StringRedisSerializer())) .serializeValuesWith(RedisSerializationContext.SerializationPair .fromSerializer(new GenericJackson2JsonRedisSerializer())); // 针对不同cacheName设置不同的过期时间 Map<String, RedisCacheConfiguration> cacheConfigurations = new HashMap<>(); cacheConfigurations.put("products", config.entryTtl(Duration.ofHours(1))); cacheConfigurations.put("users", config.entryTtl(Duration.ofMinutes(10))); return RedisCacheManager.builder(factory) .cacheDefaults(config) .withInitialCacheConfigurations(cacheConfigurations) .transactionAware() .build(); } } 

4.3 多级缓存策略

实现本地缓存(Caffeine)与Redis的多级缓存：

@Configuration @EnableCaching public class MultiLevelCacheConfig { @Bean @Primary public CacheManager cacheManager() { CaffeineCacheManager caffeineCacheManager = new CaffeineCacheManager(); caffeineCacheManager.setCaffeine(Caffeine.newBuilder() .expireAfterWrite(Duration.ofMinutes(10)) .maximumSize(1000)); return caffeineCacheManager; } @Bean public CacheManager redisCacheManager(RedisConnectionFactory factory) { RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig() .entryTtl(Duration.ofHours(1)); return RedisCacheManager.builder(factory) .cacheDefaults(config) .build(); } @Bean public CacheManager multiLevelCacheManager( @Qualifier("cacheManager") CacheManager localCacheManager, @Qualifier("redisCacheManager") CacheManager redisCacheManager) { return new MultiLevelCacheManager(localCacheManager, redisCacheManager); } } public class MultiLevelCacheManager implements CacheManager { private final CacheManager localCacheManager; private final CacheManager redisCacheManager; public MultiLevelCacheManager(CacheManager localCacheManager, CacheManager redisCacheManager) { this.localCacheManager = localCacheManager; this.redisCacheManager = redisCacheManager; } @Override public Cache getCache(String name) { return new MultiLevelCache( localCacheManager.getCache(name), redisCacheManager.getCache(name) ); } @Override public Collection<String> getCacheNames() { return redisCacheManager.getCacheNames(); } } public class MultiLevelCache implements Cache { private final Cache localCache; private final Cache redisCache; public MultiLevelCache(Cache localCache, Cache redisCache) { this.localCache = localCache; this.redisCache = redisCache; } @Override public String getName() { return redisCache.getName(); } @Override public Object getNativeCache() { return redisCache.getNativeCache(); } @Override public ValueWrapper get(Object key) { // 先从本地缓存获取 ValueWrapper value = localCache.get(key); if (value != null) { return value; } // 本地缓存没有，从Redis获取 value = redisCache.get(key); if (value != null) { // 将Redis中的数据放入本地缓存 localCache.put(key, value.get()); } return value; } // 实现其他Cache接口方法... } 

5. 实战应用场景

5.1 商品信息缓存

@Service public class ProductServiceImpl implements ProductService { @Autowired private ProductRepository productRepository; @Override @Cacheable(value = "products", key = "#id", unless = "#result == null") public Product getProductById(Long id) { return productRepository.findById(id).orElse(null); } @Override @CachePut(value = "products", key = "#product.id") public Product updateProduct(Product product) { return productRepository.save(product); } @Override @CacheEvict(value = "products", key = "#id") public void deleteProduct(Long id) { productRepository.deleteById(id); } @Override @Cacheable(value = "products", key = "'list:' + #pageable.pageNumber") public Page<Product> listProducts(Pageable pageable) { return productRepository.findAll(pageable); } } 

5.2 用户会话管理

@Service public class SessionService { @Autowired private RedisTemplate<String, Object> redisTemplate; private static final String SESSION_PREFIX = "session:"; public void createSession(User user, String sessionId) { String key = SESSION_PREFIX + sessionId; redisTemplate.opsForValue().set(key, user, Duration.ofHours(2)); } public User getSession(String sessionId) { String key = SESSION_PREFIX + sessionId; return (User) redisTemplate.opsForValue().get(key); } public void refreshSession(String sessionId) { String key = SESSION_PREFIX + sessionId; redisTemplate.expire(key, Duration.ofHours(2)); } public void deleteSession(String sessionId) { String key = SESSION_PREFIX + sessionId; redisTemplate.delete(key); } } 

5.3 热点数据缓存

@Service public class HotDataService { @Autowired private RedisTemplate<String, Object> redisTemplate; private static final String HOT_PRODUCTS_KEY = "hot:products"; private static final String TOP_SEARCHES_KEY = "top:searches"; public void incrementProductView(Long productId) { String key = "product:views:" + productId; redisTemplate.opsForValue().increment(key); // 添加到热门商品ZSET redisTemplate.opsForZSet().incrementScore(HOT_PRODUCTS_KEY, productId.toString(), 1); } public List<Long> getHotProducts(int limit) { Set<Object> productIds = redisTemplate.opsForZSet() .reverseRange(HOT_PRODUCTS_KEY, 0, limit - 1); return productIds.stream() .map(id -> Long.parseLong(id.toString())) .collect(Collectors.toList()); } public void recordSearch(String keyword) { redisTemplate.opsForZSet().incrementScore(TOP_SEARCHES_KEY, keyword, 1); } public List<String> getTopSearches(int limit) { Set<Object> keywords = redisTemplate.opsForZSet() .reverseRange(TOP_SEARCHES_KEY, 0, limit - 1); return keywords.stream() .map(Object::toString) .collect(Collectors.toList()); } } 

6. 性能优化与最佳实践

6.1 缓存穿透解决方案

问题：大量请求查询不存在的key，导致请求直接打到数据库

解决方案：

1. 缓存空对象：

@Cacheable(value = "products", key = "#id", unless = "#result == null") public Product getProductById(Long id) { Product product = productRepository.findById(id).orElse(null); if (product == null) { // 缓存一个空对象，设置较短过期时间 return new Product(); // 空对象 } return product; } 

1. 布隆过滤器：

@Service public class BloomFilterService { @Autowired private RedisTemplate<String, Object> redisTemplate; private static final String BLOOM_FILTER_KEY = "product:bloom:filter"; public void initBloomFilter(List<Long> productIds) { for (Long id : productIds) { addToBloomFilter(id); } } public void addToBloomFilter(Long productId) { // 使用多个hash函数计算位位置 int[] positions = getHashPositions(productId.toString()); for (int pos : positions) { redisTemplate.opsForValue().setBit(BLOOM_FILTER_KEY, pos, true); } } public boolean mightContain(Long productId) { int[] positions = getHashPositions(productId.toString()); for (int pos : positions) { if (!redisTemplate.opsForValue().getBit(BLOOM_FILTER_KEY, pos)) { return false; } } return true; } private int[] getHashPositions(String value) { // 使用多个hash函数计算位置 // 实际实现可以使用Guava的BloomFilter或Redisson的RBloomFilter return new int[]{/* 计算出的位置数组 */}; } } 

6.2 缓存雪崩解决方案

问题：大量缓存同时失效，导致所有请求直接访问数据库

解决方案：

1. 设置不同的过期时间：

@Bean public CacheManager cacheManager(RedisConnectionFactory factory) { RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig() .entryTtl(Duration.ofMinutes(30 + new Random().nextInt(15))) // 30-45分钟随机 .disableCachingNullValues(); // ... } 

1. 永不过期+后台更新：

@Service public class ProductService { @Cacheable(value = "products", key = "#id") public Product getProductById(Long id) { return loadFromDb(id); } // 后台定时任务更新缓存 @Scheduled(fixedRate = 3600000) // 每小时更新一次 public void refreshCache() { List<Product> products = productRepository.findAll(); products.forEach(p -> updateProduct(p)); } } 

6.3 缓存一致性保障

问题：数据库更新后，缓存数据不一致

解决方案：

1. 双写模式：

”`java @Transactional public Product updateProduct(Product product) { // 先更新数据库 Product updated = productRepository.save(product); // 再更新缓存 redisTemplate.ops