当前位置: article > 正文

Spring Cache结合redis使用_spring cache整合redis

作者：煮酒与君饮 | 2024-08-02 20:18:01

踩

spring cache整合redis

SpringCache结合redis使用

springCache使用redis作为缓存使用步骤：

1、添加依赖

      <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
        <version>2.7.2</version>
      </dependency>
      <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-cache</artifactId>
        <version>2.7.2</version>
      </dependency>
1
2
3
4
5
6
7
8
9
10

2、添加properties配置文件

spring.redis.host=127.0.0.1

spring.redis.port=6379

spring.redis.password=

spring.redis.pool.max-active=8

spring.redis.pool.max-wait=-1

spring.redis.pool.max-idle=8

spring.redis.pool.min-idle=0

spring.redis.timeout=30000
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

3、cache配置文件

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.jsontype.impl.LaissezFaireSubTypeValidator;
import org.springframework.cache.annotation.EnableCaching;
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.RedisCacheManager;
import org.springframework.data.redis.cache.RedisCacheWriter;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;

import java.time.Duration;
import java.util.HashMap;
import java.util.Map;

/**
 * SpringCache中配置 RedisCache
 *
 * @author xlwang55
 */
@EnableCaching
@Configuration
public class CacheConfig {
    /**
     * 测试缓存key
     */
    public static final String STUDENT_CACHE = "studentCache";
    public static final String MESSAGE_CACHE = "messageCache";

    /**
     * 设置SpringCache缓存时间:默认策略和自定义指定key策略的超时时间
     */
    @Bean
    public RedisCacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
        return new RedisCacheManager(
                RedisCacheWriter.nonLockingRedisCacheWriter(redisConnectionFactory),
                this.getRedisCacheConfigurationWithTtl(60),
                this.getRedisCacheConfigurationMap());
    }

    /**
     * 自定义指定key策略的超时时间
     *
     * @author xlwang55
     * @date 2022/12/12
     */
    private Map<String, RedisCacheConfiguration> getRedisCacheConfigurationMap() {

        Map<String, RedisCacheConfiguration> redisCacheConfigurationMap = new HashMap<>(2);
        //SsoCache和BasicDataCache进行过期时间配置
        redisCacheConfigurationMap.put(MESSAGE_CACHE, this.getRedisCacheConfigurationWithTtl(30 * 60));
        //自定义设置缓存时间
        redisCacheConfigurationMap.put(STUDENT_CACHE, this.getRedisCacheConfigurationWithTtl(60));
        return redisCacheConfigurationMap;
    }

    /**
     * 初始化缓存序列化配置和过期时间
     *
     * @param seconds 缓存时间
     * @author xlwang55
     * @date 2022/12/12
     */
    private RedisCacheConfiguration getRedisCacheConfigurationWithTtl(Integer seconds) {
        Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.activateDefaultTyping(LaissezFaireSubTypeValidator.instance, ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig();
        return redisCacheConfiguration.serializeValuesWith(RedisSerializationContext
                .SerializationPair
                .fromSerializer(jackson2JsonRedisSerializer)).entryTtl(Duration.ofSeconds(seconds));
    }

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

@EnableCaching开启缓存
@Configuration 标记当前类为配置类，确保springboot能够扫描到此配置类。

4、controller 和service

5、测试

5.1 @Cacheable案例

在这里插入图片描述

缓存key为方法参数测试

userName参数为 “小明”
第一次访问，会查询数据库并将缓存存入redis中
在这里插入图片描述

第二次访问，直接命中缓存返回结果

缓存key为方法名测试

在这里插入图片描述

5.2 @CachePut

使用@CachePut修改缓存信息，当我们对数据库修改时，为了保持缓存数据一致性需要对缓存信息修改。但是思考了一下，我们在实际使用的时候采用修改缓存的方式并不能完全保证一致性。比如上述queryAllUser案例中，查询全部用户也做了缓存，要想修改缓存并不是件容易的事情。所以建议使用@CacheEvict将缓存清除。
在这里插入图片描述
缓存结果