SpringDataRedis#

SpringData是Spring中数据操作的模块，包含对各种数据库的集成，其中对Redis的集成模块就叫做SpringDataRedis

提供了对不同Redis客户端的整合(Lettuce和Jedis)
提供了RedisTemplate统一API来操作Redis
支持Redis的发布订阅模型
支持Redis哨兵和Redis集群
支持基于Lettuce的响应式编程
支持基于JDK、JSON、字符串、Spring对象的数据序列化及反序列化
支持基于Redis的JDKCollection实现

SpringDataRedis快速入门#

API	返回值类型	说明
redisTemplate.opsForValue()	ValueOperations	操作String数据类型
redisTemplate.opsForHash()	HashOperations	操作Hash类型数据
redisTemplate.opsForList()	ListOperations	操作List类型数据
redisTemplate.opsForSet()	SetOperations	操作Set类型数据
redisTemplate.opsForZSet()	ZSetOperations	操作SortedSet类型数据
redisTemplate		通用的命令

使用(基于SpringBoot)#

1.引入依赖

1
<!-- Redis依赖 -->
2
<dependency>
3
    <groupId>org.springframework.boot</groupId>
4
    <artifactId>spring-boot-starter-data-redis</artifactId>
5
</dependency>
6
<!-- 连接池依赖 -->
7
<dependency>
8
    <groupId>org.apache.commons</groupId>
9
    <artifactId>commons-pool2</artifactId>
10
</dependency>

2.配置文件

1
spring:
2
  redis:
3
    host: 192.168.72.128
4
    port: 6379
5
    password: 123456
6
    lettuce:
7
      pool:
8
        max-active: 8 # 最大连接
9
        max-idle: 8 # 最大空闲连接
10
        min-idle: 0 # 最小空闲连接
11
        max-wait: 100 # 连接等待时间

3.注入RedisTemplate

1
@Autowired
2
private RedisTemplate redisTemplate;

4.编写测试

1
@SpringBootTest
2
public class RedisTest {
3
    @Autowired
4
    private RedisTemplate redisTemplate;
5

6
    @Test
7
    void testString() {
8
        //插入一条String类型数据
9
        redisTemplate.opsForValue().set("name", "李四");
10
        //读取一条String数据
11
        Object name = redisTemplate.opsForValue().get("name");
12
        System.out.println("name = " + name);
13
    }
14

15
    @Test
16
    void testSaveUser() {
17
        //写入数据
18
        redisTemplate.opsForValue().set("user:100", new User("Wang", 21));
19
        //获取数据
20
        User o = (User) redisTemplate.opsForValue().get("user:100");
21
        System.out.println("o = " + o);
22
    }
23
}

插入数据出现了问题，序列化出现了问题，变成了字节

缺点：可读性差且占用内存大

改进(自己定义序列化和反序列化)

1
public class RedisConfig {
2

3
    @Bean
4
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
5
        //创建RedisTemplate对象
6
        RedisTemplate<String, Object> template = new RedisTemplate<>();
7
        //设置连接工厂
8
        template.setConnectionFactory(connectionFactory);
9
        //创建JSON序列化工具
10
        GenericJackson2JsonRedisSerializer jsonRedisSerializer = new GenericJackson2JsonRedisSerializer();
11
        //设置Key的序列化
12
        template.setKeySerializer(RedisSerializer.string());
13
        template.setHashKeySerializer(RedisSerializer.string());
14
        //设置Value的序列化
15
        template.setValueSerializer(jsonRedisSerializer);
16
        template.setHashValueSerializer(jsonRedisSerializer);
17
        //返回
18
        return template;
19
    }
20
}

为了在反序列化时知道对象的类型，JSON序列化器会将类的class类型写入json结果中，存入Redis，会带来额外的内存开销。

为了节省内存空间，我们并不会使用JSON序列化器来处理value，而是统一使用String序列化器，要求只能存储String类型的key和value。当需要存储Java对象时，手动完成对象的序列化和反序列化。

Spring默认提供了一个StringRedisTemplate类，它的key和value的序列化方式默认就是String方式。省去了我们自定义RedisTemplate的过程:

使用StringRedisTemplate和手动序列化和反序列化

1
@SpringBootTest
2
class RedisStringTests {
3

4
    @Autowired
5
    private StringRedisTemplate stringRedisTemplate;
6

7
    @Test
8
    void testString() {
9
        //插入一条String类型数据
10
        stringRedisTemplate.opsForValue().set("name", "string测试");
11
        //读取一条String数据
12
        Object name = stringRedisTemplate.opsForValue().get("name");
13
        System.out.println("name = " + name);//插入一条String类型数据
14
    }
15

16
    private static final ObjectMapper mapper = new ObjectMapper();
17

18
    @Test
19
    void testSaveUser() throws JsonProcessingException {
20
        //创建对象
21
        User user = new User("Wang-nine", 9);
22
        //手动序列化
23
        String json = mapper.writeValueAsString(user);
24
        //写入数据
25
        stringRedisTemplate.opsForValue().set("user:200", json);
26

27
        //获取数据
28
        String jsonUser = stringRedisTemplate.opsForValue().get("user:200");
29
        //手动反序列化
30
        User user1 = mapper.readValue(jsonUser, User.class);
31
        System.out.println("user1 = " + user1);
32
    }
33

34
}

==RedisTemplate的两种序列化实践方案:==

方案一: 1.自定义RedisTemplate 2.修改RedisTemplate的序列化器为GenericJackson2JsonRedisSerializer
方案二: 1.使用StringRedisTemplate 2.写入Redis时，手动把对象序列化为JSON 3.读取Redis时，手动把读取到的JSON反序列化为对象

注意：有关于Hash数据结构的存取

1
@Test
2
void TestHash() {
3
    stringRedisTemplate.opsForHash().put("user:400", "测试300", "300");
4
    stringRedisTemplate.opsForHash().put("user:400", "测试400", "400");
5

6
    Map<Object, Object> entries = stringRedisTemplate.opsForHash().entries("user:400");
7
    System.out.println(entries);
8
}