本地声明式缓存

怼烎@ 2024-02-05 16:23 40阅读 0赞

SpringBoot+Caffeine+Redis声明式缓存

最近接到一个项目，里面同时整合了Caffeine和Redis。

对于像验证码，或者对用户操作做一些限制的缓存，还有分布式锁等等操作就利用redis来缓存，

对于一些热点数据，为了降低数据库查询频率，就使用Caffeine本地缓存来实现。

至于为什么这么做？这个问题问得好！下次别问了！

记录一个项目中同时整合了Caffeine和Redis时，怎么使用@Cacheable这样的注解，优雅地实现缓存。

**相关知识**  
对相关原理和注解@Cacheable/@CachePut/@CacheEvit不熟练的同学请移步相关文章，能很好地理解。

代码实践】  
废话不多讲，直接开撸。

引入组件  
先创建一个springboot项目，再pom文件中导入以下依赖：

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

配置文件  
接下来就是针对两个缓存组件的配置

在application.yml中，需要对redis的连接信息做一些基础配置，Caffeine不用。

spring:
       redis:
        # Redis服务器地址
        host: 127.0.0.1
        # Redis数据库索引（默认为0）
        database: 1
        # Redis服务器连接端口
        port: 6379
        # Redis服务器连接密码（默认为空）
        password: pas
        jedis:
          pool:
            # 连接池最大连接数（使用负值表示没有限制）
            max-active: 8
            # 连接池最大阻塞等待时间（使用负值表示没有限制）
            max-wait: -1ms
            # 连接池中的最大空闲连接
            max-idle: 8
            # 连接池中的最小空闲连接
            min-idle: 0
        # 连接超时时间（毫秒）
        timeout: 3000ms

配置类  
CacheConfig 配置类：

import com.github.benmanes.caffeine.cache.Caffeine;
    import org.springframework.cache.Cache;
    import org.springframework.cache.CacheManager;
    import org.springframework.cache.caffeine.CaffeineCache;
    import org.springframework.cache.support.SimpleCacheManager;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.context.annotation.Primary;
    import org.springframework.data.redis.cache.RedisCacheConfiguration;
    import org.springframework.data.redis.cache.RedisCacheManager;
    import org.springframework.data.redis.connection.RedisConnectionFactory;
    import org.springframework.data.redis.serializer.RedisSerializationContext;
    import org.springframework.data.redis.serializer.RedisSerializer;
     
    import java.time.Duration;
    import java.util.ArrayList;
    import java.util.concurrent.TimeUnit;
     
     
    @Configuration
    public class CacheConfig {
        
        @Bean("caffeineCacheManager")
        @Primary
        public CacheManager cacheManager(){
        
            SimpleCacheManager simpleCacheManager = new SimpleCacheManager();
            ArrayList<Cache> caches = new ArrayList<>();
            caches.add(new CaffeineCache("test1",
                    Caffeine.newBuilder()
                            .expireAfterWrite(100, TimeUnit.SECONDS)
                            .recordStats()
                            .maximumSize(Integer.MAX_VALUE)
                            .removalListener((key, value, cause) -> {
        
                                System.out.println("");
                            }).build()));
     
            caches.add(new CaffeineCache("test2",
                    Caffeine.newBuilder()
                            .expireAfterWrite(100, TimeUnit.SECONDS)
                            .recordStats()
                            .maximumSize(Integer.MAX_VALUE)
                            .removalListener((key, value, cause) -> {
        
                                System.out.println("");
                            }).build()));
            simpleCacheManager.setCaches(caches);
            return simpleCacheManager;
        }
     
     
        @Bean("redisCacheManager")
        public CacheManager redisCacheManager(RedisConnectionFactory factory){
        
            RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
                    // 设置缓存的默认过期时间
                    .entryTtl(Duration.ofSeconds(180))
                    .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(RedisSerializer.string()))
                    .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(RedisSerializer.json()))
                    // 不缓存空值
                    .disableCachingNullValues();
     
            return RedisCacheManager
                    .builder(factory)
                    .cacheDefaults(config)
                    .transactionAware()
                    .build();
        }
    }

之所以要配置两个Manager的原因简单说一下。

我们在使用@Cacheable注解时，在Caffeine中，Spring底层是通过@Cacheable的cacheManager属性的值去找对应的CacheManger中名为value属性值的缓存容器实例；

而在Redist中又不一样，整个Redis就是一个缓存容器，所以是通过CacheManager的属性值去调用对应的Redis缓存容器实例，而此时的value属性值和key属性的值，一起组成了redis的key。

启动类  
启动类上添加注解@EnableCaching开启自动缓存支持。

import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.cache.annotation.EnableCaching;
    import org.springframework.scheduling.annotation.EnableAsync;
    import org.springframework.transaction.annotation.EnableTransactionManagement;
     
    @SpringBootApplication
    @EnableCaching  //开启自动缓存
    @EnableAsync	//开启异步支持
    @EnableTransactionManagement // 开启事务支持
    public class ProjectApplication {
        
    	public static void main(String[] args) {
        
    		SpringApplication.run(ProjectApplication.class, args);
    	}
    }

基本上就算是配置结束了，下面可以直接使用了。

实体类

import lombok.Data;
    import lombok.experimental.Accessors;
     
    import java.io.Serializable;
    import java.util.Date;
     
    /**
     * @version 1.0.0
     * @Author DG
     * @Date 2022/1/6 15:13
     */
    @Data
    @Accessors(chain = true) // 链式编程
    public class Person implements Serializable {
        
        private Long id;
     
        private String name;
     
        private int age;
     
        private String[] hobby;
     
        private String address;
     
        private Date createTime;
    }

控制层

import com.xxx.xxx.entity.Person;
    import com.xxx.xxx.service.base.CacheService;
    import com.xxx.xxx.service.base.CacheTestService;
    import io.swagger.annotations.Api;
    import io.swagger.annotations.ApiImplicitParam;
    import io.swagger.annotations.ApiOperation;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.context.ApplicationContext;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.data.redis.support.atomic.RedisAtomicLong;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.RestController;
     
    import javax.annotation.Resource;
    import java.text.SimpleDateFormat;
    import java.util.Date;
    import java.util.Objects;
    import java.util.concurrent.TimeUnit;
     
    /**
     * @version 1.0.0
     * @Author DG
     * @Date 2022/1/6 15:23
     */
    @RestController
    @Api(value = "测试功能", tags = "功能测试")
    public class CacheController {
        
        @Resource
        private CacheTestService cacheTestService;
       
     
        @GetMapping("/get")
        @ApiOperation(value = "这是测试一级缓存和二级缓存同时使用的控制器", tags = "如果入参为奇数走redis，如果入参为偶数走caffeine")
        @ApiImplicitParam(name = "id", value = "对象ID，就是一个标记而已", dataType = "Long", dataTypeClass = Long.class, defaultValue = "0", example = "0")
        public List<Person> selectPerson(Long id){
        
            Person cache1;
            Person cache2;
            if (id % 2 == 0) {
        
                cache1 = cacheTestService.testCaffeineCache1(id);
                cache2 = cacheTestService.testRedisCache1(id);
            } else {
        
                cache1 = cacheTestService.testCaffeineCache2(id);
                cache2 = cacheTestService.testRedisCache2(id);
            }
            return Arrays.asList(cache1, cache2);
        }
    }

业务层  
CacheTestService 接口：

import com.xxx.xxx.entity.Person;
     
    public interface CacheTestService {
        
     
        /**
         * 测试caffeine缓存1
         * @return
         */
        Person testCaffeineCache1(Long id);
     
        /**
         * 测试caffeine缓存2
         * @return
         */
        Person testCaffeineCache2(Long id);
     
        /**
         * 测试redis缓存1
         * @return
         */
        Person testRedisCache1(Long id);
     
        /**
         * 测试redis缓存2
         * @return
         */
        Person testRedisCache2(Long id);
    }

CacheTestServiceImpl 实现类

import com.xxx.xxx.entity.Person;
    import com.xxx.xxx.service.base.CacheTestService;
    import org.springframework.cache.annotation.Cacheable;
    import org.springframework.stereotype.Service;
     
    import java.util.Date;
     
    @Service
    public class CacheTestServiceImpl implements CacheTestService {
        
     
        @Override
        @Cacheable(value = "test1", key = "#id", cacheManager = "caffeineCacheManager")
        public Person testCaffeineCache1(Long id) {
        
            // 模拟数据库查询并返回
            return new Person()
                    .setId(id)
                    .setAge(18)
                    .setHobby(new String[]{
        "java"})
                    .setAddress("松下问童子")
                    .setName("caffeineCache1")
                    .setCreateTime(new Date());
        }
     
        @Override
        @Cacheable(value = "test2", key = "#id", cacheManager = "caffeineCacheManager")
        public Person testCaffeineCache2(Long id) {
        
            // 模拟数据库查询并返回
            return new Person()
                    .setId(id)
                    .setAge(19)
                    .setHobby(new String[]{
        "C#"})
                    .setAddress("言师采药去")
                    .setName("caffeineCache2")
                    .setCreateTime(new Date());
        }
     
        @Override
        @Cacheable(value = "test1", key = "#id", cacheManager = "redisCacheManager")
        public Person testRedisCache1(Long id) {
        
            // 模拟数据库查询并返回
            return new Person()
                    .setId(id)
                    .setAge(20)
                    .setHobby(new String[]{
        "Python"})
                    .setAddress("只在此山中")
                    .setName("redisCache1")
                    .setCreateTime(new Date());
        }
     
        @Override
        @Cacheable(value = "test2", key = "#id", cacheManager = "redisCacheManager")
        public Person testRedisCache2(Long id) {
        
            // 模拟数据库查询并返回
            return new Person()
                    .setId(id)
                    .setAge(21)
                    .setHobby(new String[]{
        "Go"})
                    .setAddress("云深不知处")
                    .setName("redisCache2")
                    .setCreateTime(new Date());
        }
     
    }