书成

再这样堕落下去就给我去死啊你这混蛋！！！

0%

SpringBoot整合Redis

发表于 更新于 分类于

Spring Boot 整合 Redis

Spring Boot 整合 Redis 十分方便，引入 redis 依赖自后配置 Redis 相关参数即可：

1
2
3
4
<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>

默认的 Redis 连接驱动是 Lettuce，Lettuce 是基于 NIO 编写的，性能与效果相比较 Jedis 更优秀。

Spring 根据配置生成一个 RedisConnectionFactory 接口实现类，通过它可以生成一个 RedisConnection 接口对象来对 Redis 进行操作。

为了更进一步简化开发流程，Spring 提供了 RedisTemplate 类，它会自动从 RedisConnectionFactory 中获取连接，然后执行 Redis 命令，之后自动关闭 Redis 连接。

示例

创建一个 Spring Boot 项目，引入 Redis 依赖后在配置文件中配置 Redis 相关信息：

1
2
3
4
spring.redis.host=127.0.0.1
spring.redis.database=0
spring.redis.port=6379
spring.redis.password=123456

然后新建一个 HelloController 内容如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
@RestController
public class HelloController {
    @Autowired
    StringRedisTemplate stringRedisTemplate;

    @GetMapping("/set")
    public void set(){
        ValueOperations<String, String> ops = stringRedisTemplate.opsForValue();
        ops.set("name", "helloRedis");
    }

    @GetMapping("/get")
    public void get(){
        ValueOperations<String, String> ops = stringRedisTemplate.opsForValue();
        System.out.println(ops.get("name"));
    }
}

启动项目后可以访问对应 url 测试 Redis 是否成功应用。

上面代码中的 StringRedisTemplate 是 RedisTemplate 的子类，因为 RedisTemplate 默认序列化器是 JdkSerializationRedisSerializer，存入的是类对象序列化后的二进制字符串，使用体验很不好。 StringRedisTemplate 使用了 StringRedisSerializer 序列化器，这样能将数据从二进制字符串编码为简单字符串。但是 StringRedisTemplate 只提供了字符串序列化操作，对于复杂的 Java 对象需要自己实现 RedisSerializer 接口处理。

StringRedisTemplate 部分源码如下：

1
2
3
4
5
6
7
8
9
10
11
12
public class StringRedisTemplate extends RedisTemplate<String, String> {
    public StringRedisTemplate() {
        // 设置键序列化器
        this.setKeySerializer(RedisSerializer.string());
        // 设置值序列化器
        this.setValueSerializer(RedisSerializer.string());
        // 设置散列结构的键序列化器
        this.setHashKeySerializer(RedisSerializer.string());
        // 设置散列结构的值序列化器
        this.setHashValueSerializer(RedisSerializer.string());
    }
}

Spring封装的数据类型操作

Redis 支持7种数据类型，Spring 针对每一种都提供了操作接口：

接口 获取接口 作用
GeoOperations redisTemplate.opsForGeo() 地理位置数据类型操作
HashOperations redisTemplate.opsForHash() 散列数据类型操作
HyperLogLogOperations redisTemplate.opsForHyperLogLog() 基数操作
ListOperations redisTemplate.opsForList() 列表数据类型操作
SetOperations redisTemplate.opsForSet() 集合数据类型操作
ZSetOperations redisTemplate.opsForZSet() 有序集合数据类型操作
ValuerOperations redisTemplate.opsForValue() 字符串数据类型操作

在之前的例子中，使用了字符串数据类型的操作，如果需要操作其它数据类型，通过 API 获得相应接口即可。

Spring Cache 整合 Redis

Spring 提供了缓存注解，进一步简化 Redis 的使用。

Spring 支持多种缓存的使用，提供了 CacheManager 接口与之相关的类，当使用 Redis 作为缓存时，主要使用 RedisCacheManager 管理缓存。

在配置文件中加入缓存配置：

1
2
3
4
5
6
7
8
9
10
# 缓存名字
spring.cache.cache-names=testCache
# 是否允许缓存空值
spring.cache.redis.cache-null-values=true
# 缓存key的前缀
spring.cache.redis.key-prefix= keyPrefixTest
# 缓存超时时间戳，设置为0则永不过期，单位毫秒
spring.cache.redis.time-to-live=60000
# 默认情况下会自动探测
spring.cache.type=redis

基本使用

在启动文件上加入注解@EnableCaching，之后新建一个 User 类如下：

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
public class User implements Serializable {
    String name;
    int id;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", id=" + id +
                '}';
    }
}

然后新建一个 UserService 如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
@Service
// 配置文件中配置的cacheNames
@CacheConfig(cacheNames = "testCache")
public class UserService {

    @Cacheable
    public User getUserById(int id){
        System.out.println(">>>>>>>插入方法调用");
        User user = new User();
        user.setId(id);
        return user;
    }

    @CacheEvict
    public void deleteUserById(int id){
        System.out.println(">>>>>>>>删除方法调用");
    }

    @CachePut
    public User updateUser(User user){
        System.out.println(">>>>>>>>>>更新方法调用");
        return user;
    }
}

在单元测试中测试 getUserById 方法：

1
2
3
4
5
6
7
8
9
10
11
12
@SpringBootTest
class RedisdemoApplicationTests {

    @Autowired
    UserService userService;
    @Test
    void contextLoads() {
        userService.getUserById(1);
        userService.getUserById(1);
        userService.getUserById(1);
    }
}

运行结果显示只调用了一次 getUserById 方法，在 Redis 中查找存入的缓存结果：

从缓存结果可以看出，查询结果确实被放入缓存了，缓存名字冒号前面是配置文件中配置的前缀和 cacheNames 的拼接，冒号后面是参数的值(默认，可修改)。

接着测试 deleteUserById 方法：

1
2
3
4
@Test
    void testDelete(){
        userService.deleteUserById(1);
    }

运行测试后可以查看 Redis 中缓存是否被删除。接着测试 updateUser 方法。

1
2
3
4
5
6
@Test
    void testUpdate(){
        User user = new User();
        user.setId(1);
        userService.updateUser(user);
    }

方法运行后查看 Redis 缓存如下：

发现结果与预想有出入，更新的缓存应该与查找的缓存名字一样，对 updateUser 方法做如下修改：

1
2
3
4
5
6
// 表示取参数 user 的 id 属性做缓存名字
@CachePut(key = "#user.id")
    public User updateUser(User user){
        System.out.println(">>>>>>>>>>更新方法调用");
        return user;
    }

修改之后再次运行单元测试后查看缓存结果便正确了：

自定义 KeyGenerator

新建一个 MyKeyGenerator 类如下：

1
2
3
4
5
6
7
@Component
public class MyKeyGenerator implements KeyGenerator {
    @Override
    public Object generate(Object o, Method method, Object... objects) {
        return method.getName();
    }
}

修改 UserService 类如下：

1
2
3
4
5
6
@Service
// 引入自定义的 KeyGenerator
@CacheConfig(cacheNames = "testCache",keyGenerator = "myKeyGenerator")
public class UserService {
    // 省略其它代码...
}

之后重新在单元测试中测试 getUserById 方法后，查看 Redis 中的内容如下，可以发现缓存的 key 已经按照自定义的设置生成了。

缓存注解总结

注解 作用
@EnableCaching 开启缓存注解
@CacheConfig 可以配置cacheNames，keyGenerator，cacheManager，cacheResolver
@Cacheable 先从缓存中查询结果，查询不到再执行方法，然后将方法结果放入缓存
@CachePut 将方法返回值放入缓存
@CacheEvict 移除缓存