Redis作为分布式缓存提供持久化和高并发支持，而Caffeine作为本地缓存提供更快的读取速度。Redis和Caffeine实现二级缓存可以有效的提高应用的性能，下面我们就来看看如何在SpringBoot项目中通过整合二者来实现二级缓。

引入依赖

要想使用相关的操作，就必须要引入对应的依赖，如下所示。

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

添加Redis配置

由于Caffeine是本地缓存，所以不需要配置，我们只需要配置Redis依赖即可，如下所示。

spring:
  cache:
    type: redis
  redis:
    host: localhost
    port: 6379

配置 Caffeine

我们可以通过本地配置类的方式来对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.KeyGenerator;
import org.springframework.cache.interceptor.SimpleKeyGenerator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.Arrays;
import java.util.concurrent.TimeUnit;

@Configuration
@EnableCaching
public class CacheConfig {

    @Bean
    public Caffeine<Object, Object> caffeineConfig() {
        return Caffeine.newBuilder()
                .expireAfterWrite(10, TimeUnit.MINUTES)
                .maximumSize(1000);
    }

    @Bean
    public CacheManager caffeineCacheManager(Caffeine<Object, Object> caffeine) {
        CaffeineCacheManager cacheManager = new CaffeineCacheManager();
        cacheManager.setCaffeine(caffeine);
        return cacheManager;
    }

    @Bean
    public KeyGenerator keyGenerator() {
        return new SimpleKeyGenerator();
    }
}

配置 Redis 和 Caffeine 的组合

上面我们将二者单独配置好之后，接下来需要做的事情就是如何将两个缓存整合到一起，然后实现二级缓存，如下所示。通过自定义缓存管理器来组合 Redis 和 Caffeine 缓存

import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cache.concurrent.ConcurrentMapCacheManager;
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.cache.RedisCacheWriter;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import java.time.Duration;
import java.util.Arrays;

@Configuration
@EnableCaching
public class CacheConfig {

    @Bean
    public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
        RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig()
                .entryTtl(Duration.ofMinutes(10))
                .disableCachingNullValues()
                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer()))
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(RedisSerializer.json()));

        RedisCacheManager redisCacheManager = RedisCacheManager.RedisCacheManagerBuilder
                .fromCacheWriter(RedisCacheWriter.nonLockingRedisCacheWriter(redisConnectionFactory))
                .cacheDefaults(redisCacheConfiguration).build();

        CaffeineCacheManager caffeineCacheManager = new CaffeineCacheManager();
        caffeineCacheManager.setCaffeine(Caffeine.newBuilder()
                .expireAfterWrite(10, TimeUnit.MINUTES)
                .maximumSize(1000));

        return new CompositeCacheManager(redisCacheManager, caffeineCacheManager);
    }

    @Bean
    public CacheErrorHandler errorHandler() {
        return new SimpleCacheErrorHandler();
    }
}

使用缓存注解

配置完缓存管理器之后，接下来就是在Service中使用缓存注解来使用配置的缓存操作。如下所示。

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

@Service
public class MyService {

    @Cacheable(value = "myCache", key = "#id")
    public String getDataById(Long id) {
        // 你的数据库查询或者复杂计算逻辑
        return "data";
    }
}

启动项目之后，我们可以对缓存进行验证，可以通过相关的日志来监听Redis和Caffeine是否工作。来确认二级缓存实现机制是否起作用。

总结

在上面的实现中我们利用了Caffeine提供快速的本地缓存，以及Redis提供的持久化的分布式缓存，从极大程度上提升了系统的访问性能，当然在实际的实现过程中，可能面对的是分布式环境，所以在实现的过程中可能还需要考虑到可扩展性、容错性、数据一致性等问题。