SpringBoot-（七）SpringBoot整合Redis

本文最后更新于：February 13, 2022 pm

SpringBoot框架中有两个非常重要的策略：开箱即用和约定优于配置。其设计目的是用来简化新Spring应用的初始搭建以及开发过程。该框架使用了特定的方式来进行配置，从而使开发人员不再需要定义样板化的配置。

目录

在SpringBoot2.x之后，原来使用的 Jedis被替换为了 Lettuce。

导入依赖

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

配置

1
2
3
4
5
spring:
  redis:
    host: 127.0.0.1
    port: 6379
    database: 0 # 默认为 0 号数据库

测试

预知

操作

1
2
3
4
5
6
7
8
9
10
@Autowired
private RedisTemplate redisTemplate;
@Test
void contextLoads() {
    //opsForValue() 是操作字符串，类似于String
    //opsForList() 是操作list，类似于list，其他的等同使用。
    //常用的操作是直接点的，如：redisTemplate.delete() 。具体其他用法自行尝试查看
    redisTemplate.opsForValue().set("key","value");
    redisTemplate.delete("key");
}

获取连接

1
2
3
4
5
6
7
8
@Autowired
private RedisTemplate redisTemplate;
@Test
void contextLoads() {
    RedisConnection connection = redisTemplate.getConnectionFactory().getConnection();
    connection.flushDb();
    connection.flushAll();
}

测试实例

1
2
3
4
5
6
7
@Autowired
private RedisTemplate redisTemplate;
@Test
void contextLoads() {
    redisTemplate.opsForValue().set("key","value");
    System.out.println(redisTemplate.opsForValue().get("key"));
}

自定义RedisTemplate

在将java对象存入时，需要将对象转换为JSON格式的（如下），否则会报错。

1
2
3
4
5
6
7
8
9
@Autowired
private RedisTemplate redisTemplate;
@Test
void contextLoads() throws JsonProcessingException {
    User user = new User("测试",56);
    String json = new ObjectMapper().writeValueAsString(user); //对象转化为json
    redisTemplate.opsForValue().set("user",json);
    System.out.println(redisTemplate.opsForValue().get("user"));
}

如果不将对象转化为json，则会出错。

如果说，不想转化为json，则需要将对象类序列化。如：

1
2
3
4
public class User implements Serializable{
    private String username;
    private int age;
}

这样就可以不用转换为json，而直接存入对象。而这是默认JDK的序列化，我们可以自己序列化。

序列化模板

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
package com.tothefor.config;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

@Configuration
public class RedisConfig {
    //自定义RedisTemplate
    @Bean
    public RedisTemplate<String,Object> redisTemplate(RedisConnectionFactory factory){
        //一般使用<String,Object>
        RedisTemplate<String,Object> template = new RedisTemplate<>();
        template.setConnectionFactory(factory);

        //Json序列化配置
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);

        //String 序列化
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();

        //key采用String的序列化方式
        template.setKeySerializer(stringRedisSerializer);
        //hash的key采用String的序列化方式
        template.setHashKeySerializer(stringRedisSerializer);
        //value序列化采用jackson
        template.setValueSerializer(jackson2JsonRedisSerializer);
        //hash的value序列化采用jackson
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();

        return template;
    }
}

然后在使用的时候，使用自己的即可：

1
2
3
@Autowired
@Qualifier("redisTemplate")
private RedisTemplate redisTemplate;

然后点左边的叶子，看是否跳到了自己写的 RedisTemplate 里面。