springboot整合缓存redis-cache

版权声明：版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/qq_37465368/article/details/82895419

1、pom添加必要的redis、cache、common依赖

 <!--cache 依赖包-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-cache</artifactId>
        </dependency>

        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
        </dependency>

        <!--redis 依赖包-->
        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <!--redission 依赖包-->
        <dependency>
            <groupId>org.redisson</groupId>
            <artifactId>redisson</artifactId>
            <version>3.5.4</version>
            <exclusions>
                <exclusion>
                    <artifactId>cache-api</artifactId>
                    <groupId>javax.cache</groupId>
                </exclusion>
            </exclusions>
        </dependency>

        <!--aspectj 依赖包-->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
        </dependency>

2、properties添加redis相关配置

#redis配置
#master的ip地址
spring.redis.host=127.0.0.1
#端口号
spring.redis.port=6379
# Redis服务器连接密码（默认为空）
spring.redis.password=
#客户端超时时间单位是毫秒 默认是2000
spring.redis.timeout=30000
#连接池的最大数据库连接数。设为0表示无限制,如果是jedis 2.4以后用redis.maxTotal
spring.redis.lettuce.pool.max-active=50
#最小空闲数
spring.redis.lettuce.pool.min-idle=5
#最大建立连接等待时间。如果超过此时间将接到异常。设为-1表示无限制。
spring.redis.lettuce.pool.max-wait=5000ms
# 连接池最大阻塞等待时间（使用负值表示没有限制）
spring.redis.lettuce.shutdown-timeout=100ms
#最大空闲数
spring.redis.lettuce.pool.max-idle=50
#前缀
spring.redis.prefix=CarryJey

3、启动类编写相关启动bean

添加注解：@EnableCaching

添加必要的启动bean

    @Bean
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<Object, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(redisConnectionFactory);

        // 使用Jackson2JsonRedisSerialize 替换默认序列化
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);

        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);

        jackson2JsonRedisSerializer.setObjectMapper(objectMapper);

        // 设置value的序列化规则和 key的序列化规则
        redisTemplate.setValueSerializer(new StringRedisSerializer());
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashValueSerializer(new StringRedisSerializer());
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }

    @Configuration
    public static class CacheConfig extends CachingConfigurerSupport {
        @Autowired
        private RedisConfig redisConfig;

        @Bean
        public GenericJackson2JsonRedisSerializer jackson2JsonRedisSerializer() {

            GenericJackson2JsonRedisSerializer serializer = new GenericJackson2JsonRedisSerializer();

            try {
                Field mapperField = ReflectionUtils.findField(GenericJackson2JsonRedisSerializer.class, "mapper");
                mapperField.setAccessible(true);

                ObjectMapper objectMapper = (ObjectMapper) mapperField.get(serializer);
                // java8 time
                objectMapper.findAndRegisterModules();
                objectMapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);

                mapperField.setAccessible(false);
            } catch (Exception e) {
                logger.warn("Config object mapper of GenericJackson2JsonRedisSerializer error.", e);
                throw new RuntimeException(e);
            }

            return serializer;
        }

        @Bean
        public RedisCacheConfiguration redisCacheConfiguration() {
            return RedisCacheConfiguration.defaultCacheConfig()
                    .entryTtl(Duration.ofHours(2))
                    .computePrefixWith(cacheName -> redisConfig.prefix + ":" + cacheName + ":")
                    .serializeValuesWith(
                            RedisSerializationContext.SerializationPair.fromSerializer(jackson2JsonRedisSerializer()));
        }
    }

    @Component
    @ConfigurationProperties(prefix = "spring.redis")
    public static class RedisConfig {
        private String prefix = "CarryJey";

        public void setPrefix(String prefix) {
            this.prefix = prefix;
        }

        public String getPrefix() {
            return prefix;
        }

        public String addPrefix(String key) {
            return prefix + ":" + key;
        }
    }

    @Autowired
    private RedisProperties redisProperties;

4、dao层使用相关注解进行缓存的使用，资料链接：https://blog.csdn.net/qq_37465368/article/details/81385395