Redis基础
初识Redis
Redis是一种键值型的NoSQL数据库，这里有两个关键字
- 键值型
- NoSQL
其中键值型是指Redis中存储的数据都是以Key-Value键值对的形式存储，而Value的形式多种多样，可以使字符串、数值甚至Json
而NoSQL则是相对于传统关系型数据库而言，有很大差异的一种数据库
认识NoSQL
NoSql可以翻译做Not Only Sql（不仅仅是SQL），或者是No Sql（非Sql的）数据库。是相对于传统关系型数据库而言，有很大差异的一种特殊的数据库，因此也称之为非关系型数据库。
结构化与非结构化
传统关系型数据库是结构化数据，每张表在创建的时候都有严格的约束信息，如字段名、字段数据类型、字段约束等，插入的数据必须遵循这些约束
而NoSQL则对数据库格式没有约束，可以是键值型，也可以是文档型，甚至是图格式
关联与非关联
传统数据库的表与表之间往往存在关联，例如外键约束
而非关系型数据库不存在关联关系，要维护关系要么靠代码中的业务逻辑，要么靠数据之间的耦合
1 | { |
例如此处要维护张三与两个手机订单的关系，不得不冗余的将这两个商品保存在张三的订单文档中，不够优雅，所以建议使用业务逻辑来维护关联关系
查询方式
传统关系型数据库会基于Sql语句做查询，语法有统一的标准
1 | SELECT id, age FROM tb_user WHERE id = 1 |
而不同的非关系型数据库查询语法差异极大
1 | Redis: get user:1 |
事务
传统关系型数据库能满足事务的ACID原则(原子性、一致性、独立性及持久性)
而非关系型数据库汪汪不支持事务，或者不能要个保证ACID的特性，只能实现计本的一致性
总结
| SQL | NoSQL | |
|---|---|---|
| 数据结构 | 结构化(Structured) | 非结构化 |
| 数据关联 | 关联的(Relational) | 无关联的 |
| 查询方式 | SQL查询 | 非SQL |
| 事务特性 | ACID | BASE |
| 存储方式 | 磁盘 | 内存 |
| 扩展性 | 垂直 | 水平 |
| 使用场景 | 1）数据结构固定 2)对一致性、安全性要求不高 | 1)数据结构不固定 2)相关业务对数据安全性、一致性要求较高 3）对性能要求 |
存储方式
- 关系型数据库基于磁盘进行存储，会有大量的磁盘IO，对性能有一定影响
- 非关系型数据库，他们的操作更多的是依赖于内存来操作，内存的读写速度会非常快，性能自然会好一些
扩展性
- 关系型数据库集群模式一般是主从，主从数据一致，起到数据备份的作用，称为垂直扩展。
- 非关系型数据库可以将数据拆分，存储在不同机器上，可以保存海量数据，解决内存大小有限的问题。称为水平扩展。
- 关系型数据库因为表之间存在关联关系，如果做水平扩展会给数据查询带来很多麻烦
认识Redis
Redis诞生于2009年，全称是Remote Dictionary Server远程词典服务器，是一个基于内存的键值型NoSQL数据库。
特征：
- 键值(Key-Value)型，Value支持多种不同的数据结构，功能丰富
- 单线程，每个命令具有原子性
- 低延迟，速度快(基于内存、IO多路复用、良好的编码)
- 支持数据持久化
- 支持主从集群、分片集群
- 支持多语言客户端
作者：Antirez
Redis官网：https://redis.io/
安装Redis
关于Redis的安装，我在之前的这篇文章做过详细的说明，这里就不赘述了
Redis入门
https://cyborg2077.github.io/2022/10/17/ReggieRedis/
Redis桌面客户端
安装完成Redis，我们就可以操作Redis，实现数据的CRUD了。这需要用到Redis客户端，包括：
- 命令行客户端
- 图形化桌面客户端
- 编程客户端
Redis命令行客户端
Redis安装完成后就自带了命令行客户端：redis-cli，使用方式如下：
1 | redis-cli [options] [commonds] |
其中常见的options有：
-h 127.0.0.1：指定要连接的redis节点的IP地址，默认是127.0.0.1-p 6379：指定要连接的redis节点的端口，默认是6379-a 123321：指定redis的访问密码
其中的commonds就是Redis的操作命令，例如：
ping：与redis服务端做心跳测试，服务端正常会返回`pong
图形化桌面客户端
安装包：https://github.com/lework/RedisDesktopManager-Windows/releases
Redis默认有16个仓库，编号从0至15. 通过配置文件可以设置仓库数量，但是不超过16，并且不能自定义仓库名称。
如果是基于redis-cli连接Redis服务，可以通过select命令来选择数据库：
1 | # 选择0号数据库 |
Redis常用命令
Redis是典型的key-value数据库，key一般是字符串，而value包含很多不同的数据类型
Redis通用命令
常用的通用命令有以下几个
| 命令 | 描述 |
|---|---|
| KEYs pattern | 查找所有符合给定模式(pattern)的key |
| EXISTs key | 检查给定key是否存在 |
| TYPE key | 返回key所储存的值的类型 |
| TTL key | 返回给定key的剩余生存时间(TTL, time to live)，以秒为单位 |
| DEL key | 该命令用于在key存在是删除key |
```
KEYS1
2
3
4
5
6
7
：查看符合模板的所有key
- 不建议在生产环境设备上使用，因为Redis是单线程的，执行查询的时候会阻塞其他命令，当数据量很大的时候，使用KEYS进行模糊查询，效率很差
- ```
DEL：删除一个指定的key
- 也可以删除多个key，
DEL name age，会将name和age都删掉
- 也可以删除多个key，
```
EXISTS1
2
3
4
5
6
7
：判断key是否存在
- `EXISTS name`，如果存在返回1，不存在返回0
- ```
EXPIRE：给一个key设置有效期，有效期到期时该key会被自动删除
EXPIRE name 20，给name设置20秒有效期，到期自动删除
```
TTL1
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
：查看一个key的剩余有效期(Time-To-Live)
- `TTL name`，查看name的剩余有效期，如果未设置有效期，则返回-1
## String类型
String类型，也就是字符串类型，是Redis中最简单的存储类型
其value是字符串，不过根据字符串的格式不同，又可以分为3类
- `string`：普通字符串
- `int`：整数类型，可以做自增、自减操作
- `float`：浮点类型，可以做自增、自减操作
不管是哪种格式，底层都是字节数组形式存储，只不过是编码方式不同，字符串类型的最大空间不能超过512M
### String的常用命令
String的常用命令有
| 命令 | 描述 |
| :---------: | :----------------------------------------------------------: |
| SET | 添加或者修改一个已经存在的String类型的键值对 |
| GET | 根据key获取String类型的value |
| MEST | 批量添加多个String类型的键值对 |
| MGET | 根据多个key获取多个String类型的value |
| INCR | 让一个整形的key自增1 |
| INCRBY | 让一个整形的key自增并指定步长值，例如：incrby num 2，让num值自增2 |
| INCRBYFLOAT | 让一个浮点类型的数字自增并指定步长值 |
| SETNX | 添加一个String类型的键值对，前提是这个key不存在，否则不执行，可以理解为真正的`新`增 |
| SETEX | 添加一个String类型的键值对，并指定有效期 |
### Key结构
- Redis没有类似MySQL中Table的概念，那么我们该如何区分不同类型的Key呢？
- 例如：需要存储用户、商品信息到Redis，有一个用户的id是1，有一个商品的id恰好也是1，如果此时使用id作为key，那么就回冲突，该怎么办？
- 我们可以通过给key添加前缀加以区分，不过这个前缀不是随便加的，有一定的规范
- Redis的key允许有多个单词形成层级结构，多个单词之间用:
1
2
3
隔开，格式如下PLAINTEXT
项目名:业务名:类型:id1
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
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
- 这个格式也并非是固定的，可以根据自己的需求来删除/添加词条，这样我们就可以把不同数据类型的数据区分开了，从而避免了key的冲突问题
- 例如我们的项目名叫reggie，有user和dish两种不同类型的数据，我们可以这样定义key
- user相关的key：`reggie:user:1`
- dish相关的key：`reggie:dish:1`
- 如果value是一个Java对象，例如一个User对象，则可以将对象序列化为JSON字符串后存储
| KEY | VALUE |
| :-----------: | :-----------------------------------------: |
| reggie:user:1 | {“id”:1, “name”: “Jack”, “age”: 21} |
| reggie:dish:1 | {“id”:1, “name”: “鲟鱼火锅”, “price”: 4999} |
- 并且在Redis的桌面客户端中，也会以相同前缀作为层次结构，让数据看起来层次分明，关系清晰
## Hash类型
- Hash类型，也叫散列，其中value是一个无序字典，类似于Java中的HashMap结构
- String结构是将对象序列化为JSON字符串后存储，当我们要修改对象的某个属性值的时候很不方便
| KEY | VALUE |
| :-----------: | :-----------------------------------------: |
| reggie:user:1 | {“id”:1, “name”: “Jack”, “age”: 21} |
| reggie:dish:1 | {“id”:1, “name”: “鲟鱼火锅”, “price”: 4999} |
- Hash结构可以将对象中的每个字段独立存储，可以针对单个字段做CRUD
| KEY | VALUE | |
| ------------- | ----- | ---- |
| field | value | |
| reggie:user:1 | name | Jack |
| age | 21 | |
| reggie:user:2 | name | Rose |
| age | 18 | |
- Hash的常用命令有
| 命令 | 描述 |
| :------------------: | :----------------------------------------------------------: |
| HSET key field value | 添加或者修改hash类型key的field的值 |
| HGET key field | 获取一个hash类型key的field的值 |
| HMSET | 批量添加多个hash类型key的field的值 |
| HMGET | 批量获取多个hash类型key的field的值 |
| HGETALL | 获取一个hash类型的key中的所有的field和value |
| HKEYS | 获取一个hash类型的key中的所有的field |
| HINCRBY | 让一个hash类型key的字段值自增并指定步长 |
| HSETNX | 添加一个hash类型的key的field值，前提是这个field不存在，否则不执行 |
## List类型
- Redis中的List类型与Java中的LinkedList类似，可以看做是一个双向链表结构。既可以支持正向检索和也可以支持反向检索。
- 特征也与LinkedList类似：
- 有序
- 元素可以重复
- 插入和删除快
- 查询速度一般
- 常用来存储一个有序数据，例如：朋友圈点赞列表，评论列表等。
- List的常见命令有：
| 命令 | 描述 |
| :-----------------: | :----------------------------------------------------------: |
| LPUSH key element … | 向列表左侧插入一个或多个元素 |
| LPOP key | 移除并返回列表左侧的第一个元素，没有则返回nil |
| RPUSH key element … | 向列表右侧插入一个或多个元素 |
| RPOP key | 移除并返回列表右侧的第一个元素 |
| LRANGE key star end | 返回一段角标范围内的所有元素 |
| BLPOP和BRPOP | 与LPOP和RPOP类似，只不过在没有元素时等待指定时间，而不是直接返回nil |
## Set类型
- Redis的Set结构与Java中的HashSet类似，可以看做是一个value为null的HashMap。因为也是一个hash表，因此具备与HashSet类似的特征：
- 无序
- 元素不可重复
- 查找快
- 支持交集、并集、差集等功能
- Set的常见命令有：
| 命令 | 描述 |
| :------------------: | :-------------------------: |
| SADD key member … | 向set中添加一个或多个元素 |
| SREM key member … | 移除set中的指定元素 |
| SCARD key | 返回set中元素的个数 |
| SISMEMBER key member | 判断一个元素是否存在于set中 |
| SMEMBERS | 获取set中的所有元素 |
| SINTER key1 key2 … | 求key1与key2的交集 |
| SUNION key1 key2 … | 求key1与key2的并集 |
| SDIFF key1 key2 … | 求key1与key2的差集 |
练习题：
1. 将下列数据用Redis的Set集合来存储：
- 张三的好友有：李四、王五、赵六
```BASH
127.0.0.1:6379> sadd zhangsan lisi wangwu zhaoliu
(integer) 3李四的好友有：王五、麻子、二狗
1
2127.0.0.1:6379> sadd lisi wangwu mazi ergou
(integer) 3
利用Set的命令实现下列功能：
计算张三的好友有几人
1
2127.0.0.1:6379> scard zhangsan
(integer) 3计算张三和李四有哪些共同好友
1
2127.0.0.1:6379> sinter zhangsan lisi
1) "wangwu"查询哪些人是张三的好友却不是李四的好友
1
2
3127.0.0.1:6379> sdiff zhangsan lisi
1) "zhaoliu"
2) "lisi"查询张三和李四的好友总共有哪些人
1
2
3
4
5
6127.0.0.1:6379> sunion zhangsan lisi
1) "wangwu"
2) "zhaoliu"
3) "ergou"
4) "lisi"
5) "mazi"判断李四是否是张三的好友
1
2127.0.0.1:6379> sismember zhangsan lisi
(integer) 1判断张三是否是李四的好友
1
2127.0.0.1:6379> sismember lisi zhangsan
(integer) 0将李四从张三的好友列表中移除
1
2127.0.0.1:6379> srem zhangsan lisi
(integer) 1
SortedSet类型
- Redis的SortedSet是一个可排序的set集合，与Java中的TreeSet有些类似，但底层数据结构却差别很大。SortedSet中的每一个元素都带有一个score属性，可以基于score属性对元素排序，底层的实现是一个跳表（SkipList）加 hash表。
- SortedSet具备下列特性：
- 可排序
- 元素不重复
- 查询速度快
- 因为SortedSet的可排序特性，经常被用来实现排行榜这样的功能。
- SortedSet的常见命令有：
| 命令 | 描述 |
|---|---|
| ZADD key score member | 添加一个或多个元素到sorted set ，如果已经存在则更新其score值 |
| ZREM key member | 删除sorted set中的一个指定元素 |
| ZSCORE key member | 获取sorted set中的指定元素的score值 |
| ZRANK key member | 获取sorted set 中的指定元素的排名 |
| ZCARD key | 获取sorted set中的元素个数 |
| ZCOUNT key min max | 统计score值在给定范围内的所有元素的个数 |
| ZINCRBY key increment member | 让sorted set中的指定元素自增，步长为指定的increment值 |
| ZRANGE key min max | 按照score排序后，获取指定排名范围内的元素 |
| ZRANGEBYSCORE key min max | 按照score排序后，获取指定score范围内的元素 |
| ZDIFF、ZINTER、ZUNION | 求差集、交集、并集 |
注意：所有的排名默认都是升序，如果要降序则在命令的Z后面添加REV即可，例如：
升序获取sorted set 中的指定元素的排名：ZRANK key member降序获取sorted set 中的指定元素的排名：ZREVRANK key memeber练习题：
将班级的下列学生得分存入Redis的SortedSet中：
Jack 85, Lucy 89, Rose 82, Tom 95, Jerry 78, Amy 92, Miles 76
1
2127.0.0.1:6379> zadd stu 85 Jack 89 Lucy 82 Rose 95 Tom 78 Jerry 92 Amy 76 Miles
(integer) 7并实现下列功能：
删除Tom同学
1
2127.0.0.1:6379> zrem stu Tom
(integer) 1获取Amy同学的分数
1
2127.0.0.1:6379> zscore stu Amy
"92"获取Rose同学的排名
1
2127.0.0.1:6379> zrank stu Rose
(integer) 2查询80分以下有几个学生
1
2127.0.0.1:6379> zcount stu 0 80
(integer) 2给Amy同学加2分
1
2127.0.0.1:6379> zincrby stu 2 Amy
"94"查出成绩前3名的同学
1
2
3
4127.0.0.1:6379> zrange stu 0 2
1) "Miles"
2) "Jerry"
3) "Rose"查出成绩80分以下的所有同学
1
2
3127.0.0.1:6379> zrangebyscore stu 0 80
1) "Miles"
2) "Jerry"
Redis的Java客户端
- 目前主流的Redis的Java客户端有三种
- Jedis和Lettuce：这两个主要是提供了Redis命令对应的API，方便我们操作Redis，而SpringDataRedis又对这两种做了抽象和封装，因此我们后期会直接以SpringDataRedis来学习。
- Redisson：是在Redis基础上实现了分布式的可伸缩的java数据结构，例如Map、Queue等，而且支持跨进程的同步机制：Lock、Semaphore等待，比较适合用来实现特殊的功能需求。
Jedis客户端
快速入门
使用Jedis的步骤
导入Jedis的maven坐标
1
2
3
4
5
6
7
8
9
10
11
12
13<!--jedis-->
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>3.7.0</version>
</dependency>
<!--单元测试-->
<dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter</artifactId>
<version>5.7.0</version>
<scope>test</scope>
</dependency>建立连接
新建一个单元测试类
1
2
3
4
5
6
7
8
9
10
11private Jedis jedis;
void setUp() {
//1. 建立连接
jedis = new Jedis("101.42.225.160", 6379);
//2. 设置密码
jedis.auth("root");
//3. 选择库
jedis.select(0);
}测试
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
void testString(){
jedis.set("name","Kyle");
String name = jedis.get("name");
System.out.println("name = " + name);
}
void testHash(){
jedis.hset("reggie:user:1","name","Jack");
jedis.hset("reggie:user:2","name","Rose");
jedis.hset("reggie:user:1","age","21");
jedis.hset("reggie:user:2","age","18");
Map<String, String> map = jedis.hgetAll("reggie:user:1");
System.out.println(map);
}释放资源
1
2
3
4
5
6
void tearDown(){
if (jedis != null){
jedis.close();
}
}
连接池
Jedis本身是线程不安全的，并且频繁的创建和销毁连接会有性能损耗，因此我们推荐大家使用Jedis连接池代替Jedis的直连方式。新建一个
com.blog.util，用于存放我们编写的工具类但后面我们使用
1
SpringDataRedis
的时候，可以直接在
1
yml
配置文件里配置这些内容
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19public class JedisConnectionFactory {
private static JedisPool jedisPool;
static {
// 配置连接池
JedisPoolConfig poolConfig = new JedisPoolConfig();
poolConfig.setMaxTotal(8);
poolConfig.setMaxIdle(8);
poolConfig.setMinIdle(0);
poolConfig.setMaxWaitMillis(1000);
// 创建连接池对象，参数：连接池配置、服务端ip、服务端端口、超时时间、密码
jedisPool = new JedisPool(poolConfig, "101.42.225.160", 6379, 1000, "root");
}
public static Jedis getJedis(){
return jedisPool.getResource();
}
}之后我们的测试类就可以修改为如下
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
class RedisTestApplicationTests {
private Jedis jedis = JedisConnectionFactory.getJedis();
void testString(){
jedis.set("name","Kyle");
String name = jedis.get("name");
System.out.println("name = " + name);
}
void testHash(){
jedis.hset("reggie:user:1","name","Jack");
jedis.hset("reggie:user:2","name","Rose");
jedis.hset("reggie:user:3","name","Kyle");
jedis.hset("reggie:user:1","age","21");
jedis.hset("reggie:user:2","age","18");
jedis.hset("reggie:user:3","age","18");
Map<String, String> map = jedis.hgetAll("reggie:user:1");
System.out.println(map);
}
void tearDown(){
if (jedis != null){
jedis.close();
}
}
}
SpringDataRedis客户端
- SpringData是Spring中数据操作的模块，包含对各种数据库的集成，其中对Redis的集成模块就叫做SpringDataRedis
- 官网地址：https://spring.io/projects/spring-data-redis
- 提供了对不同Redis客户端的整合（Lettuce和Jedis）
- 提供了RedisTemplate统一API来操作Redis
- 支持Redis的发布订阅模型
- 支持Redis哨兵和Redis集群
- 支持基于Lettuce的响应式编程
- 支持基于JDK、JSON、字符串、Spring对象的数据序列化及反序列化
- 支持基于Redis的JDKCollection实现
- SpringDataRedis中提供了RedisTemplate工具类，其中封装了各种对Redis的操作。并且将不同数据类型的操作API封装到了不同的类型中：
| API | 返回值类型 | 说明 |
|---|---|---|
| redisTemplate.opsForValue() | ValueOperations | 操作String类型数据 |
| redisTemplate.opsForHash() | HashOperations | 操作Hash类型数据 |
| redisTemplate.opsForList() | ListOperations | 操作List类型数据 |
| redisTemplate.opsForSet() | SetOperations | 操作Set类型数据 |
| redisTemplate.opsForzSet() | ZSetOperations | 操作SortedSet类型数据 |
| redisTemplate | 通用的命令 |
快速入门
SpringBoot已经提供了对SpringDataRedis的支持，使用起来非常简单
导入依赖，
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<!--redis依赖-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<!--common-pool-->
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-pool2</artifactId>
</dependency>
<!--Jackson依赖-->
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
</dependency>
<!--lombok-->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<optional>true</optional>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>配置Redis
1
2
3
4
5
6
7
8
9
10
11spring:
redis:
host: 101.42.225.160
port: 6379
password: root
lettuce:
pool:
max-active: 8
max-idle: 8
min-idle: 0
max-wait: 100ms注入RedisTemplate
因为有了SpringBoot的自动装配，我们可以拿来就用1
2
private RedisTemplate redisTemplate;编写测试方法
1
2
3
4
5
6
void stringTest(){
redisTemplate.opsForValue().set("username","David");
String username = (String) redisTemplate.opsForValue().get("username");
System.out.println(username);
}
自定义序列化
RedisTemplate可以接收任意Object作为值写入Redis
只不过写入前会把Object序列化为字节形式，默认是采用JDK序列化，得到的结果是这样的
\xAC\xED\x00\x05t\x00\x06\xE5\xBC\xA0\xE4\xB8\x89
缺点：
- 可读性差
- 内存占用较大
我们可以自定义RedisTemplate的序列化方式，代码如下
在com.blog.config包下编写对应的配置类1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class RedisConfig {
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
// 创建RedisTemplate对象
RedisTemplate<String, Object> template = new RedisTemplate<>();
// 设置连接工厂
template.setConnectionFactory(connectionFactory);
// 创建JSON序列化工具
GenericJackson2JsonRedisSerializer jsonRedisSerializer =
new GenericJackson2JsonRedisSerializer();
// 设置Key的序列化
template.setKeySerializer(RedisSerializer.string());
template.setHashKeySerializer(RedisSerializer.string());
// 设置Value的序列化
template.setValueSerializer(jsonRedisSerializer);
template.setHashValueSerializer(jsonRedisSerializer);
// 返回
return template;
}
}我们编写一个User类，并尝试将其创建的对象存入Redis，看看是什么效果
1
2
3
4
5
6
7
public class User {
private String name;
private Integer age;
}测试方法
1
2
3
4
void stringTest(){
redisTemplate.opsForValue().set("userdata",new User("张三",18));
}这里采用了JSON序列化来代替默认的JDK序列化方式。最终结果如下：
1
2
3
4
5{
"@class": "com.blog.entity.User",
"name": "张三",
"age": 18
}整体可读性有了很大提升，并且能将Java对象自动的序列化为JSON字符串，并且查询时能自动把JSON反序列化为Java对象。不过，其中记录了序列化时对应的class名称，目的是为了查询时实现自动反序列化。这会带来额外的内存开销。
所以肯定会有更好的方法
StringRedisTemplate
为了节省内存空间，我们可以不使用JSON序列化器来处理value，而是统一使用String序列化器，要求只能存储String类型的key和value。当需要存储Java对象时，手动完成对象的序列化和反序列化。
因为存入和读取时的序列化及反序列化都是我们自己实现的，SpringDataRedis就不会将class信息写入Redis了
这种用法比较普遍，因此SpringDataRedis就提供了RedisTemplate的子类：StringRedisTemplate，它的key和value的序列化方式默认就是String方式。源码如下
1
2
3
4
5
6
7public class StringRedisTemplate extends RedisTemplate<String, String> {
public StringRedisTemplate() {
this.setKeySerializer(RedisSerializer.string());
this.setValueSerializer(RedisSerializer.string());
this.setHashKeySerializer(RedisSerializer.string());
this.setHashValueSerializer(RedisSerializer.string());
}省去了我们自定义RedisTemplate的序列化方式的步骤（可以将之前配置的RedisConfig删除掉），而是直接使用：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
void stringTest() throws JsonProcessingException {
//创建对象
User user = new User("张三", 18);
//手动序列化
String json = mapper.writeValueAsString(user);
//写入数据
stringRedisTemplate.opsForValue().set("userdata", json);
//获取数据
String userdata = stringRedisTemplate.opsForValue().get("userdata");
//手动反序列化
User readValue = mapper.readValue(userdata, User.class);
System.out.println(readValue);
}存入Redis中是这样的
1
2
3
4{
"name": "张三",
"age": 18
}
相关推荐
评论