认识Redis

sql和nosql

SQL和NoSQL是两种不同的数据库管理系统

SQL：（Structured Query Language）即结构化查询语言，主要用于关系型数据库管理系统

  • 结构化、关联的、SQL查询、ACID
  • 磁盘存储，会有大量的磁盘IO，对性能有一定影响
  • 扩展性：关系型数据库集群模式一般是主从，主从数据一致，起到数据备份的作用，称为垂直扩展
  • 使用场景： 数据结构固定，相关业务对数据安全性、一致性要求较高

NoSQL：（Not Only SQL）即非关系型数据库，泛指那些不使用SQL作为查询语言的数据库系统

  • 非结构化
    • 键值类型（Redis）
    • 文档类型（MongDB）
    • 列类型（HBase）
    • Graph类型（Neo4j）
  • 无关联的、非SQL、BASE
  • 内存存储，内存的读写速度会非常快，性能自然会好一些
  • 扩展性：非关系型数据库可以将数据拆分，存储在不同机器上，可以保存海量数据，解决内存大小有限的问题，称为水平扩展
  • 使用场景：数据结构不固定，对数据安全性、一致性要求较不高，对性能有要求

Redis简介

Redis诞生于2009年全称是Remote Dictionary Server 远程词典服务器，是一个基于内存的键值型NoSQL数据库。

特征：

  • 键值（key-value）型，value支持多种不同数据结构，功能丰富
  • 单线程，每个命令具备原子性
  • 低延迟，速度快（基于内存、IO多路复用、良好的编码）。
  • 支持数据持久化，支持主从集群、分片集群，支持多语言客户端

作者：Antirez
Redis的官方网站地址：https://redis.io/

Redis数据结构

Redis是典型的key-value数据库，key一般是字符串，而value包含很多不同的数据类型：
基本类型：

  • String: hello world
  • Hash: {name:“Jack”,age: 21}
  • List: [A -> B -> C -> C]
  • Set: {A, B, C}
  • SortedSet: {A: 1, B: 2, C: 3}

特殊类型：

  • GEO: {A: (120.3, 30.5)}
  • BitMap: 0110110101110101011
  • HyperLog: 0110110101110101011

Redis为了方便我们学习，将操作不同数据类型的命令也做了分组，在官网（ https://redis.io/commands ）可以查看到不同的命令

通用命令

通用指令是部分数据类型的，都可以使用的指令，常见的有：

  • KEYS：查看符合模板的所有key
  • DEL：删除一个指定的key
  • EXISTS：判断key是否存在
  • EXPIRE：给一个key设置有效期，有效期到期时该key会被自动删除
  • TTL：查看一个KEY的剩余有效期

通过help [command] 可以查看一个命令的具体用法，例如：

1
2
3
4
5
6
7
8
# 查看keys命令的帮助信息（windows环境下）：
D:\Redis\Redis-x64-5.0.14.1>redis-cli.exe -p 6379
127.0.0.1:6379> help keys

  KEYS pattern
  summary: Find all keys matching the given pattern
  since: 1.0.0
  group: generic

String类型

String类型，也就是字符串类型，是Redis中最简单的存储类型。
其value是字符串，不过根据字符串的格式不同，又可以分为3类：

  • string：普通字符串
  • int：整数类型，可以做自增、自减操作
  • float：浮点类型，可以做自增、自减操作

不管是哪种格式，底层都是字节数组形式存储，只不过是编码方式不同。字符串类型的最大空间不能超过512m.

String的常见命令

String的常见命令有：

  • SET：添加或者修改已经存在的一个String类型的键值对
  • GET：根据key获取String类型的value
  • MSET：批量添加多个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
项目名: 业务名: 类型: id

这个格式并非固定，也可以根据自己的需求来删除或添加词条。这样以来，我们就可以把不同类型的数据区分开了。从而避免了key的冲突问题。
例如我们的项目名称叫 pumpkin，有user和product两种不同类型的数据，我们可以这样定义key：

  • user相关的key：pumpkin:user:1
  • product相关的key：pumpkin:product:1

如果Value是一个Java对象，例如一个User对象，则可以将对象序列化为JSON字符串后存储：

KEY VALUE
pumpkin:user:1 {“id”:1, “name”: “Jack”, “age”: 21}
pumpkin:product:1 {“id”:1, “name”: “小米11”, “price”: 4999} 
1
2
3
4
5
6
7
8
127.0.0.1:6379> set pumpkin:user:1 '{"id":1, "name":"Jack", "age":21}'
OK
127.0.0.1:6379> set pumpkin:user:2 '{"id":2, "name":"Rose", "age":18}'
OK
127.0.0.1:6379> set pumpkin:product:1 '{"id":1, "name":"Xiaomi14", "price":3999}'
OK
127.0.0.1:6379> set pumpkin:product:2 '{"id":2, "name":"Honor10", "price":2999}'
OK

并且，在Redis的桌面客户端中，还会以相同前缀作为层级结构(pumpkin->user->1)，让数据看起来层次分明，关系清晰（不想存图片啦，自己操作一下看看吧）

Hash类型

Hash类型，也叫散列，其value是一个无序字典，类似于Java中的HashMap结构
String结构是将对象序列化为JSON字符串后存储，当需要修改对象某个字段时很不方便

KEY VALUE
pumpkin:user:1 {“id”:1, “name”: “Jack”, “age”: 21}
pumpkin:product:1 {“id”:1, “name”: “小米11”, “price”: 4999}
Hash结构可以将对象中的每个字段独立存储，可以针对单个字段做CRUD
KEY VALUE
field value
pumpkin:user:1 name Jack
age 21
pumpkin: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不存在，否则不执行
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
# 插入一条数据 并修改年龄
127.0.0.1:6379> Hset pumpkin:user:3 name Lucy
(integer) 1
127.0.0.1:6379> HSET pumpkin:user:3 age 21
(integer) 1
127.0.0.1:6379> HSET pumpkin:user:3 age 17
(integer) 0
# 一次存储多个字段
127.0.0.1:6379> HSET pumpkin:user:4 name Lnnn
(integer) 1
127.0.0.1:6379> HMSET pumpkin:user:4 name Lnnnn age 20 sex girl
(integer) 2
# 获取多个字段
127.0.0.1:6379> HMGET pumpkin:user:4 name age sex
1) "Lnnnn"
2) "20"
3) "girl"
# 获取所有字段
127.0.0.1:6379> HGETALL pumpkin:user:4
1) "name"
2) "Lnnnn"
3) "age"
4) "20"
5) "sex"
6) "girl"

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
1
2
3
4
5
6
7
8
9
10
11
12
13
# 从上到下：3 2 1 4 5 6
127.0.0.1:6379> LPUSH users 1 2 3
(integer) 3
127.0.0.1:6379> RPUSH users 4 5 6
(integer) 6
127.0.0.1:6379> LPOP users
"3"
127.0.0.1:6379> RPOP users
"6"
# 注意角标是从零开始的
127.0.0.1:6379> LRANGE users 1 2
1) "1"
2) "4"

思考：如何利用List结构模拟一个阻塞队列?

  • 入口和出口在不同边（队列）
  • 出队时采用BLPOP或BRPOP

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的交集
  • SDIFF key1 key2 … ：求key1与key2的差集（1有2没有）
  • SUNION key1 key2 … ：求key1与key2的并集（不重复）
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
127.0.0.1:6379> SADD s1 a b c
(integer) 3
127.0.0.1:6379> SMEMBERS s1
1) "b"
2) "c"
3) "a"
127.0.0.1:6379> SRM s1 a
(error) ERR unknown command `SRM`, with args beginning with: `s1`, `a`,
127.0.0.1:6379> SREM s1 a
(integer) 1
127.0.0.1:6379> SISMEMBER s1 b
(integer) 1
127.0.0.1:6379> SISMEMBER s1 a
(integer) 0
127.0.0.1:6379> SCARD s1
(integer) 2

练习时间

  1. 将下列数据用Redis的Set集合来存储：
  • 张三的好友有：李四、王五、赵六
  • 李四的好友有：王五、麻子、二狗
  1. 利用Set的命令实现下列功能：
  • 计算张三的好友有几人
  • 计算张三和李四有哪些共同好友
  • 查询哪些人是张三的好友却不是李四的好友
  • 查询张三和李四的好友总共有哪些人
  • 判断李四是否是张三的好友
  • 判断张三是否是李四的好友
  • 将李四从张三的好友列表中移除
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
127.0.0.1:6379> SADD zs lisi wangwu zhaoliu
(integer) 3
127.0.0.1:6379> SADD ls wangwu mazi ergou
(integer) 3
127.0.0.1:6379> SCARD zs
(integer) 3
127.0.0.1:6379> SINTER zs ls
1) "wangwu"
127.0.0.1:6379> SDIFF zs ls
1) "zhaoliu"
2) "lisi"
127.0.0.1:6379> SUNION zs ls
1) "ergou"
2) "lisi"
3) "wangwu"
4) "zhaoliu"
5) "mazi"
127.0.0.1:6379> SISMEMBER zs lisi
(integer) 1
127.0.0.1:6379> SISMEMBER ls zhangsan
(integer) 0
127.0.0.1:6379> SREM zs 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 中的指定元素的排名（默认升序，加rev为降序：ZREVRANK，其他改为降序与这个类似）
  • 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
并实现下列功能：

  • 删除Tom同学
  • 获取Amy同学的分数
  • 获取Rose同学的排名
  • 查询80分以下有几个学生
  • 给Amy同学加2分
  • 查出成绩前3名的同学
  • 查出成绩80分以下的所有同学
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
127.0.0.1:6379> ZADD stus 85 Jack 89 Lucy 82 Rose 95 Tom 78 Jerry 92 Amy 76 Miles
(integer) 7
127.0.0.1:6379> ZREM stus Tom
(integer) 1
127.0.0.1:6379> ZSCORE stus Amy
"92"
# 其实排第三 但是这里从0开始计算的
127.0.0.1:6379> ZRANK stus Rose
(integer) 2
# 降序排列的排名
127.0.0.1:6379> ZREVRANK stus Rose
(integer) 3
127.0.0.1:6379> ZCOUNT stus 0 80
(integer) 2
127.0.0.1:6379> ZINCRBY stus 2 Amy
"94"
# 倒数后三名
127.0.0.1:6379> ZRANGE stus 0 2
1) "Miles"
2) "Jerry"
3) "Rose"
# 正数前三名
127.0.0.1:6379> ZREVRANGE stus 0 2
1) "Amy"
2) "Lucy"
3) "Jack"
127.0.0.1:6379> ZRANGEBYSCORE stus 0 80
1) "Miles"
2) "Jerry"

Redis的Java客户端

在Redis官网中提供了各种语言的客户端，地址：https://redis.io/docs/clients/
其中Java客户端也包含很多，标记为*的就是推荐使用的java客户端，包括：

  • Jedis和Lettuce：这两个主要是提供了Redis命令对应的API，方便我们操作Redis，而SpringDataRedis又对这两种做了抽象和封装，因此我们后期会直接以SpringDataRedis来学习。
  • Redisson：是在Redis基础上实现了分布式的可伸缩的java数据结构，例如Map、Queue等，而且支持跨进程的同步机制：Lock、Semaphore等待，比较适合用来实现特殊的功能需求。

Jedis客户端

Jedis的官网地址： https://github.com/redis/jedis

快速入门

只需要四步就可以啦（但是我觉得其实就两步嘛）
①引入依赖(根据自己的maven版本选择版本噢)
②创建Jedis对象，建立连接
③使用Jedis，方法名与Redis命令一致
④释放资源

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
<!--jedis-->
<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>5.1.3</version>
</dependency>
<!--单元测试-->
<dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter</artifactId>
    <version>5.10.5</version>
    <scope>test</scope>
</dependency>
<!--Jackson依赖  如果使用springMVC框架就不用手动引入了-->
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
</dependency>
1
2
3
4
5
6
7
8
9
10
11
12
13
public class JedisTest {
    private Jedis jedis;

    @BeforeEach
    void setUp() {
        //1、建立连接
        jedis = new Jedis("127.0.0.1", 6379);
        //2、设置密码(如果redis没有设置密码可以直接注释掉)
        //jedis.auth("123456");
        //3、选择库 默认0号库
        jedis.select(0);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
@Test
void testString() {
    //存入数据
    String result = jedis.set("name", "zhangsan");
    System.out.println("result = " + result);
    //获取数据
    String name = jedis.get("name");
    System.out.println("name = " + name);
}

@Test
void testHash() {
    //插入Hash数据
    jedis.hset("user:1", "name", "lisi");
    jedis.hset("user:1", "age", "18");
    //获取
    Map<String, String> map = jedis.hgetAll("user:1");
    System.out.println("map = " + map);
}
1
2
3
4
5
6
7
@Test
void tearDown() {
    //关闭连接
    if (jedis != null){
        jedis.close();
    }
}

3.1.2.连接池

Jedis自身并不具备线程安全性，并且频繁的创建和销毁连接会有性能损耗，因此推荐使用Jedis连接池代替Jedis的直连方式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class JedisConnectionFactory {
    private static final JedisPool jedispool;

    static{
        //配置连接池
        JedisPoolConfig poolConfig = new JedisPoolConfig();
        // 设置连接池中的最大连接数（包括空闲连接和使用中的连接）
        poolConfig.setMaxTotal(8);
        // 设置连接池中的最大空闲连接数
        poolConfig.setMaxIdle(8);
        // 设置连接池中的最小空闲连接数
        poolConfig.setMinIdle(0);
        // 当没有可用连接时，连接分配的最大等待时间（以毫秒为单位），超过时间会抛出异常
        poolConfig.setMaxWaitMillis(1000);
        //创建连接池对象
        jedispool = new JedisPool(poolConfig,
                "127.0.0.1",6379,1000);
    }
    public static Jedis getJedis(){
        return jedispool.getResource();
    }
}
1
2
3
4
5
6
7
8
9
10
@BeforeEach
    void setUp() {
        //1、建立连接
        //jedis = new Jedis("127.0.0.1", 6379);
        jedis = JedisConnectionFactory.getJedis();
        //2、设置密码(如果redis没有设置密码可以直接注释掉)
        //jedis.auth("123456");
        //3、选择库 默认0号库
        jedis.select(0);
    }

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的支持，使用非常简单
SpringDataRedis的使用步骤：

  • 新建springboot工程，引入spring-boot-starter-data-redis依赖
  • 在application.yml配置Redis信息
  • 注入RedisTemplate
1
2
3
4
5
6
7
8
9
10
<!--Redis依赖-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<!--连接池依赖-->
<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-pool2</artifactId>
</dependency>
1
2
3
4
5
6
7
8
9
10
11
12
13
# 注意springboot3版本 这里要加data
spring:
  data:
    redis:
      host: 127.0.0.1
      port: 6379
      password:
      lettuce:
        pool:
          max-active: 8
          max-idle: 8
          min-idle: 0
          max-wait: 100ms
1
2
3
4
5
6
7
8
9
10
11
12
13
14
@SpringBootTest
class RedisDemoApplicationTests {
    @Resource
    private RedisTemplate redisTemplate;

    @Test
    void testString() {
        //写入一条String数据
        redisTemplate.opsForValue().set("name","pumpkin");
        //获取String数据值
        Object name = redisTemplate.opsForValue().get("name");
        System.out.println("name = " + name);
    }
}

自定义序列化

RedisTemplate可以接收任意Object作为值写入Redis
只不过写入前会把Object序列化为字节形式，默认是采用JDK序列化，得到的结果是这样的：

\xAC\xED\x00\x05t\x00\x04name
\xAC\xED\x00\x05t\x00\x07pumpkin

缺点：

  • 可读性差
  • 内存占用较大

我们可以配置一个Spring类来自定义RedisTemplate的序列化方式，让键和哈希键采用字符串序列化，而值和哈希值则使用JSON序列化。这样Redis就能存储复杂的Java对象，并且这些对象会以JSON格式进行序列化和反序列化。

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
@Configuration
public class RedisConfig {
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
        // 创建RedisTemplate对象，这是一个操作Redis的高级抽象
        RedisTemplate<String, Object> template = new RedisTemplate<>();

        // 设置Redis连接工厂，这是RedisTemplate与Redis服务器建立连接的关键
        template.setConnectionFactory(connectionFactory);

        // 创建JSON序列化工具，用于将Java对象序列化为JSON字符串，以便存储在Redis中。
        GenericJackson2JsonRedisSerializer jsonRedisSerializer = new GenericJackson2JsonRedisSerializer();

        // 设置Key的序列化方式，这里使用字符串序列化器，确保Redis的键是字符串类型
        template.setKeySerializer(RedisSerializer.string());
        // 设置哈希键（Hash Key）的序列化方式，同样使用字符串序列化器
        template.setHashKeySerializer(RedisSerializer.string());

        // 设置Value的序列化方式，使用上面创建的JSON序列化器，以便能够存储和检索Java对象
        template.setValueSerializer(jsonRedisSerializer);
        // 设置哈希值（Hash Value）的序列化方式，同样使用JSON序列化器
        template.setHashValueSerializer(jsonRedisSerializer);

        // 返回配置好的RedisTemplate实例，供应用使用
        return template;
    }
}

1
2
3
4
5
6
7
@Data
@NoArgsConstructor
@AllArgsConstructor
public class User {
    private String name;
    private Integer age;
}
1
2
3
4
5
6
7
8
@Test
void testSaveUser(){
    //写入数据
    redisTemplate.opsForValue().set("user:100",new User("Pumpkin", 18));
    //读取数据
    User user = (User) redisTemplate.opsForValue().get("user:100");
    System.out.println("user = " + user);
}

{
“@class”: “com.ln.pojo.User”,
“name”: “Pumpkin”,
“age”: 18
}

根据运行结果我们可以注意到，此过程中会记录序列化时的类名

“@class”: “com.ln.pojo.User”

以便查询时准确反序列化，但是这会增加一定的内存消耗

StringRedisTemplate

为了节省内存空间，我们可以不使用JSON序列化器来处理value
而是统一使用String序列化器，要求只能存储String类型的key和value
当需要存储Java对象时，手动完成对象的序列化和反序列化
因为存入和读取时的序列化及反序列化都是我们自己实现的，SpringDataRedis就不会将class信息写入Redis了,这种用法比较普遍
因此SpringDataRedis提供了RedisTemplate的子类：StringRedisTemplate，它的key和value的序列化方式默认就是String方式,省去了我们自定义RedisTemplate的序列化方式的步骤，而是直接使用：

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
@SpringBootTest
class RedisDemoApplicationTests {
    @Resource
    private StringRedisTemplate stringRedisTemplate;

    @Test
    void testString() {
        //写入一条String数据
        stringRedisTemplate.opsForValue().set("name","Pumpkins");
        //获取String数据值
        Object name = stringRedisTemplate.opsForValue().get("name");
        System.out.println("name = " + name);
    }

    private static final ObjectMapper mapper = new ObjectMapper();
    @Test
    void testSaveUser() throws JsonProcessingException {
        //创建对象
        User user = new User("pumpkin", 22);
        //手动序列化
        String json = mapper.writeValueAsString(user);
        //写入数据
        stringRedisTemplate.opsForValue().set("user:200",json);
        //获取数据
        String userJson = stringRedisTemplate.opsForValue().get("user:200");
        //手动反序列化
        User user1 = mapper.readValue(userJson, User.class);
        System.out.println("user1 = " + user1);
    }
}

RedisTemplate的两种序列化实践方案：

  • 方案一：
    • 自定义RedisTemplate(会增加一定的内存消耗)
      修改RedisTemplate的序列化器为GenericJackson2JsonRedisSerializer
  • 方案二：
    • 使用StringRedisTemplate（必须手动完成）
      写入Redis时，手动把对象序列化为JSON
      读取Redis时，手动把读取到的JSON反序列化为对象

完结撒花💖

有没有觉得似乎内容很少但好像又很多？
其实根据需求，再查询文档写就可以了
好啦，掰掰