使用 Redis + Caffeine 实现二级缓存可以有效提升应用的性能和缓存的命中率。Caffeine 是一个高效的 Java 本地缓存库，而 Redis 是一个分布式缓存解决方案。通过将两者结合，Caffeine 作为一级缓存用于快速访问常用数据，Redis 作为二级缓存用于持久化存储和共享。

下面是一个实现热门文章二级缓存的示例步骤：

1. 添加依赖

在 pom.xml 中添加所需的依赖：

<dependencies><!-- Spring Boot dependencies --><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-redis</artifactId></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-cache</artifactId></dependency><dependency><groupId>com.github.ben-manes.caffeine</groupId><artifactId>caffeine</artifactId></dependency>
</dependencies>

2. 配置 Redis

在 application.properties 文件中配置 Redis：

spring.redis.host=localhost
spring.redis.port=6379

3. 配置缓存管理器

在 Spring Boot 应用中配置 Caffeine 和 Redis 的缓存管理器，并创建一个组合缓存管理器。

import com.github.benmanes.caffeine.cache.Caffeine;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cache.caffeine.CaffeineCache;
import org.springframework.cache.caffeine.CaffeineCacheManager;
import org.springframework.cache.interceptor.CacheErrorHandler;
import org.springframework.cache.interceptor.SimpleCacheErrorHandler;
import org.springframework.cache.redis.RedisCacheManager;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.StringRedisSerializer;import java.time.Duration;
import java.util.Arrays;@Configuration
@EnableCaching
public class CacheConfig {@Beanpublic Caffeine<Object, Object> caffeineConfig() {return Caffeine.newBuilder().initialCapacity(100).maximumSize(500).expireAfterWrite(Duration.ofMinutes(10));}@Beanpublic CaffeineCacheManager caffeineCacheManager(Caffeine<Object, Object> caffeine) {CaffeineCacheManager cacheManager = new CaffeineCacheManager();cacheManager.setCaffeine(caffeine);return cacheManager;}@Beanpublic RedisCacheConfiguration redisCacheConfiguration() {return RedisCacheConfiguration.defaultCacheConfig().serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer())).serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(new GenericJackson2JsonRedisSerializer())).entryTtl(Duration.ofHours(1));}@Beanpublic RedisCacheManager redisCacheManager(RedisConnectionFactory redisConnectionFactory, RedisCacheConfiguration redisCacheConfiguration) {return RedisCacheManager.builder(redisConnectionFactory).cacheDefaults(redisCacheConfiguration).build();}@Beanpublic CacheManager cacheManager(CaffeineCacheManager caffeineCacheManager, RedisCacheManager redisCacheManager) {return new CompositeCacheManager(caffeineCacheManager, redisCacheManager);}@Beanpublic CacheErrorHandler errorHandler() {return new SimpleCacheErrorHandler();}
}

4. 创建服务类

创建一个服务类来处理热门文章的缓存逻辑：

import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;import java.util.List;@Service
public class ArticleService {@Cacheable(value = "hotArticles", key = "'hotArticles'")public List<Article> getHotArticles() {// 这里应从数据库中获取热门文章return fetchHotArticlesFromDatabase();}private List<Article> fetchHotArticlesFromDatabase() {// 模拟数据库查询// 实际实现中应从数据库或其他数据源获取热门文章return List.of(new Article(1, "Title1", "Content1"),new Article(2, "Title2", "Content2"),new Article(3, "Title3", "Content3"));}
}

5. 创建文章类

创建一个简单的 Article 类：

public class Article {private int id;private String title;private String content;// Constructors, getters and setterspublic Article(int id, String title, String content) {this.id = id;this.title = title;this.content = content;}public int getId() {return id;}public void setId(int id) {this.id = id;}public String getTitle() {return title;}public void setTitle(String title) {this.title = title;}public String getContent() {return content;}public void setContent(String content) {this.content = content;}
}

6. 启用缓存

在主应用类中启用缓存：

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;@SpringBootApplication
public class DemoApplication {public static void main(String[] args) {SpringApplication.run(DemoApplication.class, args);}
}

7. 测试缓存功能

创建一个简单的控制器来测试缓存功能：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;import java.util.List;@RestController
public class ArticleController {@Autowiredprivate ArticleService articleService;@GetMapping("/hot-articles")public List<Article> getHotArticles() {return articleService.getHotArticles();}
}

8. 启动应用

启动 Spring Boot 应用，并访问 http://localhost:8080/hot-articles 来测试缓存功能。第一次访问会从数据库获取数据，并缓存到 Caffeine 和 Redis。随后的访问会从 Caffeine 缓存中获取数据，直到 Caffeine 缓存过期后再从 Redis 缓存中获取数据。

通过这种方式，实现 Redis 和 Caffeine 的二级缓存，既提高了数据访问速度，又保证了数据的持久化和一致性。