SpringBoot中SpringCache整合redis实现_rediscachemanager cachekeyprefix

结合上一篇博客来看：
SpringBoot整合Redis

开始整合 SpringCache，这里只演示如何整合：

添加 maven 依赖：

<!--redis操作-->
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.6.7</version>
        </dependency>

        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>2.9.0</version>
        </dependency>
1
2
3
4
5
6
7
8
9
10
11
12

在 RedisConfig 的配置中添加代码：

@Override
    public KeyGenerator keyGenerator() {
        return new KeyGenerator() {
            @Override
            public Object generate(Object o, Method method, Object... objects) {
                StringBuilder sb = new StringBuilder();
                sb.append(o.getClass().getName()).append(".");
                sb.append(method.getName()).append(".");
                for (Object obj : objects) {
                    sb.append(obj.toString());
                }
                System.out.println("keyGenerator=" + sb.toString());
                return sb.toString();
            }
        };
    }
    @Bean
    public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
        //初始化一个RedisCacheWriter
        RedisCacheWriter redisCacheWriter = RedisCacheWriter.nonLockingRedisCacheWriter(redisConnectionFactory);
        //自定义key前缀
        CacheKeyPrefix cacheKeyPrefix = new CacheKeyPrefix() {
            @Override
            public String compute(String cacheName) {
                return cacheName+":";
            }
        };
        //设置CacheManager的值序列化方式为json序列化
        RedisSerializer<Object> jsonSerializer = new GenericJackson2JsonRedisSerializer();
        RedisSerializationContext.SerializationPair<Object> pair = RedisSerializationContext.SerializationPair
                .fromSerializer(jsonSerializer);
        //生成RedisCacheConfiguration配置
        RedisCacheConfiguration defaultCacheConfig = RedisCacheConfiguration.defaultCacheConfig()
                .computePrefixWith(cacheKeyPrefix)
                .serializeValuesWith(pair);
        //设置默认超过期时间是30秒
        defaultCacheConfig.entryTtl(Duration.ofSeconds(DEFAULT_TTL));
        //初始化RedisCacheManager
        return new RedisCacheManager(redisCacheWriter, defaultCacheConfig);
    }
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

编写 service，mapper 层：这里举一个例子：

controller 层：

@RequestMapping("test")
    public ResultJson selectUser() {
        System.out.println("===========第一次调用=======");
        ResultJson resultJson2 = demoService.selectUser();
        System.out.println("===========第二次调用=======");
        ResultJson resultJson1 = demoService.selectUser();
        System.out.println(resultJson1);
        System.out.println("===========");
        System.out.println(resultJson2);
        return null;
    }
1
2
3
4
5
6
7
8
9
10
11

service 层接口：

public interface DemoService {
    ResultJson selectUser();
}

1
2
3
4

service 层实现类，这里需要使用 @Cacheable 注解，同时在类上添加@CacheConfig(cacheNames = {“demoService”})

 @Override
    @Cacheable
    public ResultJson selectUser() {
        return ResultJson.success(demoMapper.selectUser());
    }

1
2
3
4
5
6

mapper 层接口：

public interface DemoMapper {
    List<SysUser> selectUser();
}

1
2
3
4

xml：

<mapper namespace="com.community.mapper.DemoMapper">
    <select id="selectUser" resultType="com.community.entity.SysUser">
        select *
        from sys_user
    </select>
</mapper>
1
2
3
4
5
6

运行程序，查看访问结果

很明显的看出，第一次调用去 mysql 查找了数据，而第二次没有去 mysql，而是去了 redis，去 redis 数据库查看，会有数据：

再次执行程序，查看结果

由于 redis 中存在数据，所以都去 redis 查看结果了

闭环测试结束，解释 SpringCache 几个注解的作用：

@Cacheable 触发缓存入口
@CacheEvict 触发移除缓存
@CacahePut 更新缓存
@Caching 将多种缓存操作分组
@CacheConfig 类级别的缓存注解，允许共享缓存名称

CacheConfig 该注解是可以将缓存分类，它是类级别的注解方式。

@CacheConfig

@Cacheable

一般用于查询操作，根据key查询缓存.

@CachePut

@CachePut 一般用于更新和插入操作，每次都会请求db
通过key去redis中进行操作。

1. 如果key存在，更新内容
2. 如果key不存在，插入内容。

@CacheEvict

根据key删除缓存中的数据。allEntries=true表示删除缓存中的所有数据。

结束闭环测试