Study nodejs 「4」

Redis#

docker部署#

本地是mac，加上初学不想污染环境，就用docker试试

1
docker pull redis
2
docker run -p 6379:6379 -d - redis-server --appendonly yes
3
docker rename funny_buck redis
4
docker exec -it redis redis-cli
5
//vsc中Database Client可以可视化

字符串命令#

1
SET key value [NX|XX] [EX seconds] [PX milliseconds] [GET]

key：要设置的键名。 value：要设置的值。 NX：可选参数，表示只在键不存在时才设置值。 XX：可选参数，表示只在键已经存在时才设置值。 EX seconds：可选参数，将键的过期时间设置为指定的秒数。 PX milliseconds：可选参数，将键的过期时间设置为指定的毫秒数。 GET：可选参数，返回键的旧值。

比如

SET name zsm NX EX 60

就是在键名name不存在时，设置键名为name的值为zsm，并且设置键名的过期时间为60秒。

SET score 5 XX

在键名score已经存在时，设置键名为score的值为5。

DEL name

删除键名为name的键值对。

集合命令#

1
SADD fruits "apple"
2
SADD fruits "banana"
3
SADD fruits "orange"

SADD命令用于向集合中添加元素。

SADD命令的语法为：SADD key member [member ...]，其中key为集合的名称，member为要添加的元素。

1
SMEMBERS fruits

SMEMBERS命令用于获取集合中的所有元素。

1
SISMEMBER fruits "apple"

SISMEMBER命令用于判断一个元素是否在集合中。

1
SREM fruits "banana"

SREM命令用于从集合中删除一个或多个元素。

1
SCARD fruits

SCARD命令用于获取集合中的元素个数。

1
SRANDMEMBER fruits

SRANDMEMBER命令用于从集合中随机获取一个元素。

1
SUNION fruits vegetables

SUNION命令用于将多个集合进行并集操作。

1
SINTER fruits vegetables

SINTER命令用于将多个集合进行交集操作。

1
SDIFF fruits vegetables

SDIFF命令用于将多个集合进行差集操作。

哈希表命令#

1
HSET obj name "John"
2
HSET obj age 25
3
HSET obj email "john@example.com"

HSET命令用于向哈希表中添加键值对。

HSET命令的语法为：HSET key field value [field value ...]，其中key为哈希表的名称，field为键名，value为键值。

1
HGET obj name

HGET命令用于获取哈希表中指定键的值。

1
HMSET obj name "John" age 25 email "john@example.com"

HMSET命令用于向哈希表中添加多个键值对。

1
HMGET obj name age email

HMGET命令用于获取哈希表中指定键的值。

1
HGETALL obj

HGETALL命令用于获取哈希表中的所有键值对。

1
HDEL obj age email

HDEL命令用于删除哈希表中的指定键。

1
HEXISTS obj name

HEXISTS命令用于判断哈希表中是否存在指定键。

1
HKEYS obj

HKEYS命令用于获取哈希表中的所有键。

1
HVALS obj

HVALS命令用于获取哈希表中的所有值。

1
HLEN obj

HLEN命令用于获取哈希表中的键值对个数。

列表命令#

1
RPUSH key element1 element2 element3
2
LPUSH key element1 element2 element3

RPUSH命令用于将元素从右侧插入列表。 LPUSH命令用于将元素从左侧插入列表。 RPUSH&LPUSH命令的语法为：RPUSH key element [element ...]，其中key为列表的名称，element为要插入的元素。

1
LINDEX key index
2
LRANGE key start stop

LINDEX命令用于获取列表中指定索引位置的元素。 LRANGE命令用于获取列表中指定范围内的元素。

1
LSET key index newValue

LSET命令用于修改列表中指定索引位置的元素的值。

1
LPOP key
2
RPOP key
3
LREM key count value

LPOP命令用于从列表的左侧移除并返回第一个元素。 RPOP命令用于从列表的右侧移除并返回最后一个元素。 LREM命令用于从列表中删除指定数量的指定值元素。

1
LLEN key

LLEN命令用于获取列表的长度。

持久化#

RDB（Redis Database）持久化：RDB是一种快照的形式，它会将内存中的数据定期保存到磁盘上。可以通过配置Redis服务器，设置自动触发RDB快照的条件，比如在指定的时间间隔内，或者在指定的写操作次数达到一定阈值时进行快照保存。RDB持久化生成的快照文件是一个二进制文件，包含了Redis数据的完整状态。在恢复数据时，可以通过加载快照文件将数据重新加载到内存中。
AOF（Append-Only File）持久化：AOF持久化记录了Redis服务器执行的所有写操作命令，在文件中以追加的方式保存。当Redis需要重启时，可以重新执行AOF文件中保存的命令，以重新构建数据集。相比于RDB持久化，AOF持久化提供了更好的数据恢复保证，因为它记录了每个写操作，而不是快照的形式。然而，AOF文件相对于RDB文件更大，恢复数据的速度可能会比较慢。

启动docker的时候- redis-server —appendonly yes就是打开了rdb

1
docker exec -it redis bash
2
root@4f92f5f4b595:/data# ls
3
appendonlydir  dump.rdb

如果想通过配置文件修改，可以通过下载tar包或者是编写dockerfile

订阅&事务#

订阅#

监听命令 subscribe

推送命令 publish

整体效果

1
127.0.0.1:6379> subscribe zsm
2
1) "subscribe"
3
2) "zsm"
4
3) (integer) 1
5
1) "message"
6
2) "zsm"
7
3) "200"
8

9
127.0.0.1:6379> publish zsm 200
10
(integer) 1

其实就是redis多个实例之间进行通讯，但是不能持久化

事务#

不能回滚，保证原子的一致性

打开 multi 关闭 discard

1
127.0.0.1:6379> set A 100
2
OK
3
127.0.0.1:6379> set B 100
4
OK
5
127.0.0.1:6379> multi
6
OK
7
127.0.0.1:6379(TX)> set A 0
8
QUEUED
9
127.0.0.1:6379(TX)> set B 200
10
QUEUED
11
127.0.0.1:6379(TX)> exec
12
1) OK
13
2) OK

有点类似于队列，可以写入一堆东西，然后一块执行，那如果可以定时，就是理想的使用方法了

主从复制#

docker实现也不算麻烦

主

1
mkdir -p /home/docker/redis6379/conf
2
mkdir -p /home/docker/redis6379/data
3
vi /home/docker/redis6379/conf/redis.conf
4

5
# 服务端口 默认6379
6
port 6379
7
# 关闭保护模式，允许远程连接
8
protected-mode no
9
# 密码
10
requirepass 123456

从

1
mkdir -p /home/docker/redis6380/conf
2
mkdir -p /home/docker/redis6380/data
3
vi /home/docker/redis6380/conf/redis.conf
4

5
# 服务端口 默认6379
6
port 6380
7
# 关闭保护模式，允许远程连接
8
protected-mode no
9
# 密码
10
requirepass 123456
11
# 主节点密码
12
masterauth 123456
13
# 主从复制
14
replicaof 172.16.8.186 6379

启动主

1
docker run -d \
2
-p 6379:6379 \
3
--name redis6379 \
4
--restart always \
5
--privileged=true \
6
-v /home/docker/redis6379/conf/redis.conf:/etc/redis/redis.conf \
7
-v /home/docker/redis6379/data:/data \
8
redis:latest \
9
redis-server /etc/redis/redis.conf

从

1
docker run -d \
2
-p 6381:6381 \
3
--name redis6381 \
4
--restart always \
5
--privileged=true \
6
-v /home/docker/redis6381/conf/redis.conf:/etc/redis/redis.conf \
7
-v /home/docker/redis6381/data:/data \
8
redis:latest \
9
redis-server /etc/redis/redis.conf

redis&nodejs联动#

npm i ioredis

1
import Redis from "ioredis";
2
//命令行=>面向对象
3
const redis = new Redis({
4
    host: "127.0.0.1",
5
    port: 6379,
6
})
7

8
// redis.set("name", "zhangsan")
9
// redis.get("name").then((res) => {
10
//     console.log(res)
11
// })
12

13
//redis.setex("age",5, 18)//设置过期时间
14

15
//redis.sadd("set", "a", "b", "c")
16
// redis.smembers("set").then((res) => {
17
//     console.log(res)
18
// })
19

20
// redis.srem("set", "a", "b", "c")
21

22
// redis.hset("hash", "name", "zhangsan", "age", 18)
23

24
//redis.hdel("hash", "name")
25
redis.hgetall("hash").then((res) => {
26
    console.log(res)
27
})

和数据库的prisma那边不一样，这边感觉就是吧命令直接变成代码了

lua&redis&nodejs#

实现一个简单的限流阀，就是比如腾讯游戏抽奖每次只能在有限时间点有限次数的那种

index.html

1
<!DOCTYPE html>
2
<html lang="en">
3

4
<head>
5
    <meta charset="UTF-8">
6
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
7
    <title>Document</title>
8
</head>
9

10
<body>
11
    <button id="btn">抽奖</button>
12
    <script>
13
        const btn = document.getElementById('btn');
14
        btn.onclick = function () {
15
            fetch('http://localhost:3000/lottery').then(res => {
16
                return res.text()
17
            }).then(data => {
18
                console.log(data)
19
                alert(data)
20
            })
21
        }
22
    </script>
23
</body>
24

25
</html>

index.js

1
import express from 'express';
2
import Redis from 'ioredis';
3
import fs from 'node:fs';
4

5
const lua = fs.readFileSync('./index.lua', 'utf-8');
6
const redis = new Redis();
7
const app = express();
8

9
//限流阀
10
const KEY = 'lottery';
11
const TIME = 30
12
const LIMIT = 5
13

14
// 设置 CORS
15
app.all('*', (req, res, next) => {
16
    res.header('Access-Control-Allow-Origin', '*');
17
    res.header('Access-Control-Allow-Methods', 'GET,POST,PUT,DELETE,OPTIONS');
18
    res.header('Access-Control-Allow-Headers', 'Content-Type');
19
    next();
20
});
21

22
app.get('/lottery', (req, res) => {
23
    redis.eval(lua, 1, KEY, TIME, LIMIT, (err, result) => {
24
        if (err) {
25
            console.log(err)
26
            return res.status(500).json({ error: err.message });
27
        }
28
        if (result == 1) {
29
            res.send('抽奖成功')
30
        } else {
31
            res.send('请稍后再试')
32
        }
33
    })
34
})
35

36
app.listen(3000, () => {
37
    console.log('Server is running on port 3000');
38
})

index.lua

1
local key = KEYS[1]
2
local inerval = tonumber(ARGV[1])
3
local count = tonumber(ARGV[2])
4

5
local limit = tonumber(redis.call("get", key) or "0")
6

7
if limit + 1 >= count then
8
    return 0
9
else
10
    redis.call("incr", key)
11
    redis.call("expire", key, inerval)
12
    return 1
13
end

只得注意的问题在于跨域处理，感觉lua的语法还是比较简单的，注意和js的交互处理

a ctfer on the load