层级模式：

 redis 的 java 客户端：

 重点：

 序列化：https://www.cnblogs.com/xiaobaibailongma/p/17111314.html

 序列化：https://www.cnblogs.com/xiaobaibailongma/p/17111329.html——重点

SpringDataRedis 中提供了 RedisTemplate 工具类，其中封装了各种对 Redis 的操作。并且将不同数据类型的操作 API 封装到不同类型中

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

缺点：

• 可读性差

• 内存占用较大

我们可以指定别的序列化不使用 JDK 默认序列化

pom 导入依赖

<!--        redis 启动类-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
<!--        redis 连接池-->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
        </dependency>
​
​
        <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>

设置 RedisTemplate

package com.sofwin.redis;
​
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.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializer;
​
import javax.annotation.Resource;
​
/**
 * @packageName: com.sofwin.redis
 * @author: winter
 * @date: 2023/4/6 19:14
 * @version: 1.0
 * @email 1660420659@qq.com
 * @description: TODO
 */
@Configuration
public class RedisConfig {
​
​
    @Bean
    @Resource
    public RedisTemplate<String,Object> getRedisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        //设置连接工厂
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        GenericJackson2JsonRedisSerializer genericJackson2JsonRedisSerializer =
                new GenericJackson2JsonRedisSerializer();
        //key      RedisSerializer.string() 返回值 -->  StringRedisSerializer.UTF_8
        redisTemplate.setKeySerializer(RedisSerializer.string());
        //hash  key
        redisTemplate.setHashKeySerializer(RedisSerializer.string());
        //value
        redisTemplate.setValueSerializer(genericJackson2JsonRedisSerializer);
        //hash value
        redisTemplate.setHashValueSerializer(genericJackson2JsonRedisSerializer);
        return  redisTemplate;
    }
}

  @Autowired
    private StringRedisTemplate stringRedisTemplate;
    //json 工具
    private static  final ObjectMapper mapper = new ObjectMapper();
​
    @Test
    public void test03() throws JsonProcessingException {
        User user = new User("虎哥",33);
        //序列化为字符串
        String userString = mapper.writeValueAsString(user);
        stringRedisTemplate.opsForValue().set("strRedisUser:1",userString);
        String obj = stringRedisTemplate.opsForValue().get("strRedisUser:1");
        User user1 = mapper.readValue(obj, User.class);
        System.out.println("user1 =" + user1);}

https://cyborg2077.github.io/2022/10/21/RedisBasic/  ——参考笔记

初识 Redis

Redis 是一种键值型的 NoSQL 数据库，这里有两个关键字

• 键值型
• NoSQL

其中键值型是指 Redis 中存储的数据都是以 Key-Value 键值对的形式存储，而 Value 的形式多种多样，可以使字符串、数值甚至 Json

而 NoSQL 则是相对于传统关系型数据库而言，有很大差异的一种数据库

认识 NoSQL

NoSql可以翻译做 Not Only Sql（不仅仅是 SQL），或者是 No Sql（非 Sql 的）数据库。是相对于传统关系型数据库而言，有很大差异的一种特殊的数据库，因此也称之为非关系型数据库。

结构化与非结构化

传统关系型数据库是结构化数据，每张表在创建的时候都有严格的约束信息，如字段名、字段数据类型、字段约束等，插入的数据必须遵循这些约束

而 NoSQL 则对数据库格式没有约束，可以是键值型，也可以是文档型，甚至是图格式

关联与非关联

传统数据库的表与表之间往往存在关联，例如外键约束
而非关系型数据库不存在关联关系，要维护关系要么靠代码中的业务逻辑，要么靠数据之间的耦合

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

{
  id: 1,
  name: "张三",
  orders: [
    {
       id: 1,
       item: {
	 id: 10, title: "荣耀 6", price: 4999
       }
    },
    {
       id: 2,
       item: {
	 id: 20, title: "小米 11", price: 3999
       }
    }
  ]
}

例如此处要维护张三与两个手机订单的关系，不得不冗余的将这两个商品保存在张三的订单文档中，不够优雅，所以建议使用业务逻辑来维护关联关系

查询方式

传统关系型数据库会基于 Sql 语句做查询，语法有统一的标准

1

SELECT id, age FROM tb_user WHERE id = 1

而不同的非关系型数据库查询语法差异极大

1
2
3

Redis:  get user:1
MongoDB: db.user.find({_id: 1})
elasticsearch:  GET http://localhost:9200/users/1

事务

传统关系型数据库能满足事务的 ACID 原则 (原子性、一致性、独立性及持久性)
而非关系型数据库汪汪不支持事务，或者不能要个保证 ACID 的特性，只能实现计本的一致性

总结

• 存储方式
  • 关系型数据库基于磁盘进行存储，会有大量的磁盘 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
2

## 选择 0 号数据库
select 0

Redis 常用命令

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

Redis 通用命令

常用的通用命令有以下几个

• KEYS：查看符合模板的所有 key
  • 不建议在生产环境设备上使用，因为 Redis 是单线程的，执行查询的时候会阻塞其他命令，当数据量很大的时候，使用 KEYS 进行模糊查询，效率很差
• DEL：删除一个指定的 key
  • 也可以删除多个 key，DEL name age，会将 name 和 age 都删掉
• EXISTS：判断 key 是否存在
  • EXISTS name，如果存在返回 1，不存在返回 0
• EXPIRE：给一个 key 设置有效期，有效期到期时该 key 会被自动删除
  • EXPIRE name 20，给 name 设置 20 秒有效期，到期自动删除
• TTL：查看一个 key 的剩余有效期 (Time-To-Live)
  • TTL name，查看 name 的剩余有效期，如果未设置有效期，则返回 -1

String 类型

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

• string：普通字符串
• int：整数类型，可以做自增、自减操作
• float：浮点类型，可以做自增、自减操作
  不管是哪种格式，底层都是字节数组形式存储，只不过是编码方式不同，字符串类型的最大空间不能超过 512M

String 的常用命令

String 的常用命令有

Key 结构

• Redis 没有类似 MySQL 中 Table 的概念，那么我们该如何区分不同类型的 Key 呢？
• 例如：需要存储用户、商品信息到 Redis，有一个用户的 id 是 1，有一个商品的 id 恰好也是 1，如果此时使用 id 作为 key，那么就回冲突，该怎么办？
• 我们可以通过给 key 添加前缀加以区分，不过这个前缀不是随便加的，有一定的规范
  • Redis 的 key 允许有多个单词形成层级结构，多个单词之间用:隔开，格式如下
  PLAINTEXT

  1	项目名: 业务名: 类型:id

  • 这个格式也并非是固定的，可以根据自己的需求来删除 / 添加词条，这样我们就可以把不同数据类型的数据区分开了，从而避免了 key 的冲突问题
  • 例如我们的项目名叫 reggie，有 user 和 dish 两种不同类型的数据，我们可以这样定义 key
    • user 相关的 key：reggie:user:1
    • dish 相关的 key：reggie:dish:1
• 如果 value 是一个 Java 对象，例如一个 User 对象，则可以将对象序列化为 JSON 字符串后存储

• 并且在 Redis 的桌面客户端中，也会以相同前缀作为层次结构，让数据看起来层次分明，关系清晰

Hash 类型

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

• Hash 结构可以将对象中的每个字段独立存储，可以针对单个字段做 CRUD

• Hash 的常用命令有

List 类型

• Redis 中的 List 类型与 Java 中的 LinkedList 类似，可以看做是一个双向链表结构。既可以支持正向检索和也可以支持反向检索。

• 特征也与 LinkedList 类似：

  • 有序
  • 元素可以重复
  • 插入和删除快
  • 查询速度一般

• 常用来存储一个有序数据，例如：朋友圈点赞列表，评论列表等。

• List 的常见命令有：

Set 类型

• Redis 的 Set 结构与 Java 中的 HashSet 类似，可以看做是一个 value 为 null 的 HashMap。因为也是一个 hash 表，因此具备与 HashSet 类似的特征：
  • 无序
  • 元素不可重复
  • 查找快
  • 支持交集、并集、差集等功能
• Set 的常见命令有：

1
2

127.0.0.1:6379> sadd zhangsan lisi wangwu zhaoliu
(integer) 3

1
2

127.0.0.1:6379> sadd lisi wangwu mazi ergou
(integer) 3

1
2

127.0.0.1:6379> scard zhangsan
(integer) 3

1
2

127.0.0.1:6379> sinter zhangsan lisi
1) "wangwu"

1
2
3

127.0.0.1:6379> sdiff zhangsan lisi
1) "zhaoliu"
2) "lisi"

1
2
3
4
5
6

127.0.0.1:6379> sunion zhangsan lisi
1) "wangwu"
2) "zhaoliu"
3) "ergou"
4) "lisi"
5) "mazi"

1
2

127.0.0.1:6379> sismember zhangsan lisi
(integer) 1

1
2

127.0.0.1:6379> sismember lisi zhangsan
(integer) 0

1
2

127.0.0.1:6379> srem zhangsan lisi
(integer) 1

SortedSet 类型

• Redis 的 SortedSet 是一个可排序的 set 集合，与 Java 中的 TreeSet 有些类似，但底层数据结构却差别很大。SortedSet 中的每一个元素都带有一个 score 属性，可以基于 score 属性对元素排序，底层的实现是一个跳表（SkipList）加 hash 表。
• SortedSet 具备下列特性：
  • 可排序
  • 元素不重复
  • 查询速度快
• 因为 SortedSet 的可排序特性，经常被用来实现排行榜这样的功能。
• SortedSet 的常见命令有：

Redis 的 Java 客户端

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

Jedis 客户端

快速入门

• 使用 Jedis 的步骤
  1. 导入 Jedis 的 maven 坐标
  XML

  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>

  2. 建立连接
     新建一个单元测试类
  JAVA

  1 2 3 4 5 6 7 8 9 10 11

  private Jedis jedis; @BeforeEach void setUp() { //1. 建立连接 jedis = new Jedis("101.42.225.160", 6379); //2. 设置密码 jedis.auth("root"); //3. 选择库 jedis.select(0); }

  3. 测试
  JAVA

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

  @Test void testString(){ jedis.set("name","Kyle"); String name = jedis.get("name"); System.out.println("name =" + name); } @Test 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); }

  4. 释放资源
  JAVA

  1 2 3 4 5 6

  @AfterEach void tearDown(){ if (jedis != null){ jedis.close(); } }

连接池

• Jedis本身是线程不安全的，并且频繁的创建和销毁连接会有性能损耗，因此我们推荐大家使用 Jedis 连接池代替 Jedis 的直连方式。
• 新建一个com.blog.util，用于存放我们编写的工具类
• 但后面我们使用SpringDataRedis的时候，可以直接在yml配置文件里配置这些内容

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

public 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

@SpringBootTest
class RedisTestApplicationTests {

    private Jedis jedis = JedisConnectionFactory.getJedis();

    @Test
    void testString(){
        jedis.set("name","Kyle");
        String name = jedis.get("name");
        System.out.println("name =" + name);
    }

    @Test
    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);
    }

    @AfterEach
    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 封装到了不同的类型中：

快速入门

SpringBoot 已经提供了对 SpringDataRedis 的支持，使用起来非常简单

1. 导入依赖，

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>

2. 配置 Redis

1
2
3
4
5
6
7
8
9
10
11

spring:
  redis:
    host: 101.42.225.160
    port: 6379
    password: root
    lettuce:
      pool:
        max-active: 8
        max-idle: 8
        min-idle: 0
        max-wait: 100ms

3. 注入 RedisTemplate
   因为有了 SpringBoot 的自动装配，我们可以拿来就用

1
2

@Autowired
private RedisTemplate redisTemplate;

4. 编写测试方法

1
2
3
4
5
6

@Test
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

@Configuration
public class RedisConfig {

    @Bean
    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

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
    private String name;
    private Integer age;
}

• 测试方法

1
2
3
4

@Test
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
7

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());
    }

• 省去了我们自定义 RedisTemplate 的序列化方式的步骤（可以将之前配置的 RedisConfig 删除掉），而是直接使用：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

@Test
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
}