34-redis缓存服务(一)

2020-05-26  本文已影响0人  Liang_JC

本章内容

◆ 缓存介绍
◆ redis 部署与使用
◆ redis 高可用与集群
◆ memcached

一、 缓存概念

1.1： 系统缓存

1.1.1： buffer 与 cache

1.1.2： cache 的保存位置

1.1.3： cache 的特性

1.2： 用户层缓存

1.2.1： DNS 缓存
默认为 60 秒，即 60 秒之内在访问同一个域名就不在进行 DNS 解析：
查看 chrome 浏览器的 DNS 缓存：
chrome://net-internals/#dns

image.png

1.2.2：火狐浏览器缓存

地址栏：about:cache

image.png

1.2.3： 浏览器缓存过期机制

1.2.3.1： 最后修改时间
系统调用会获取文件的最后修改时间，如果没有发生变化就返回给浏览器 304 的状态码，表示没有发生变化，然后浏览器就使用的本地的缓存展示资源

image.png image.png

1.2.3.2： Etag 标记
基于 Etag 标记是否一致做判断页面是否发生过变化，比如基于 Nginx 的 etag on 来实现

image.png

1.2.3.3： 过期时间

image.png
1.3： CDN 缓存

1.3.1： 什么是 CND

1.3.2： 用户请求 CDN 流程：

1.3.3： CDN 主要优势：

1.4： 应用层缓存
1.5： 其他层面缓存
二、 redis 部署与使用
2.1： redis 基础

官网地址： https://redis.io/
Redis 和 Memcached 是非关系型数据库也称为 NoSQL 数据库，MySQL、Mariadb、SQL Server、PostgreSQL、Oracle 数据库属于关系型数据(RDBMS, Relational Database Management System)

2.1.1： redis 简介

Redis(Remote Dictionary Server)在 2009 年发布， 开发者 Salvatore Sanfilippo 是意大利开发者， 他本想为自己的公司开发一个用于替换 MySQL 的产品 Redis， 但是没有想到他把 Redis 开源后大受欢迎，短短几年， Redis 就有了很大的用户群体，目前国内外使用的公司有知乎网、新浪微博、 GitHub 等
redis 是一个开源的、遵循 BSD 协议的、基于内存的而且目前比较流行的键值数据库(key-value database)，是一个非关系型数据库， redis 提供将内存通过网络远程共享的一种服务，提供类似功能的还有memcache，但相比 memcache， redis 还提供了易扩展、高性能、 具备数据持久性等功能。
Redis 在高并发、低延迟环境要求比较高的环境使用量非常广泛， 目前 redis 在 DB-Engine 月排行榜https://db-engines.com/en/ranking 中一直比较靠前，而且一直是键值型存储类的首位。

2.1.2： redis 对比 memcached

2.1.3： redis 典型应用场景

2.2： Redis 安装及使用

2.2.1： yum 安装 redis

2.2.2：编译安装 redis

2.2.2.1： 编译安装命令

官方的安装命令： https://redis.io/download

cd /usr/local/src
tar xf redis-5.0.3.tar.gz
cd redis-5.0.3
make PREFIX=/usr/local/redis install
ll /usr/local/redis/
total 0
drwxr-xr-x 2 root root 134 Dec 13 09:21 bin
mkdir /usr/local/redis/etc
cp redis.conf /usr/local/redis/etc/

2.2.2.2： 前台启动 redis

/usr/local/redis/bin/redis-server /usr/local/redis/etc/redis.conf

2.2.2.3：解决当前的警告提示

2.2.2.3.1： tcp-backlog

The backlog argument defines the maximum length to which the queue of pending connections
for sockfd may grow. If a connection request arrives when the queue is full, the client may receive an error
with an indication of ECONNREFUSED or, if the underlying protocol supports retransmission, the request may
be ignored so that a later reattempt at connection succeeds.

backlog 参数控制的是三次握手的时候 server 端收到 client ack 确认号之后的队列值。

net.core.somaxconn = 512

2.2.2.3.2： vm.overcommit_memory

0、表示内核将检查是否有足够的可用内存供应用进程使用；如果有足够的可用内存，内存申请允许；
否则，内存申请失败，并把错误返回给应用进程。
1、表示内核允许分配所有的物理内存，而不管当前的内存状态如何。
2、表示内核允许分配超过所有物理内存和交换空间总和的内存

vm.overcommit_memory = 1

2.2.2.3.3： transparent hugepage
开启大页内存动态分配，需要关闭让 redis 负责内存管理。

echo never > /sys/kernel/mm/transparent_hugepage/enabled

2.2.2.3.4： 再次启动 redis
将以上配置同步到其他 redis 服务器。

2.2.2.4：编辑 redis 服务启动脚本

[root@s1 ~]# cat /usr/lib/systemd/system/redis.service
[Unit]
Description=Redis persistent key-value database
After=network.target
After=network-online.target
Wants=network-online.target
[Service]
#ExecStart=/usr/bin/redis-server /etc/redis.conf --supervised systemd
ExecStart=/apps/redis/bin/redis-server /apps/redis/etc/redis.conf --supervised systemd
ExecReload=/bin/kill -s HUP $MAINPID
ExecStop=/bin/kill -s QUIT $MAINPID
Type=notify
User=root
Group=root
RuntimeDirectory=redis
RuntimeDirectoryMode=0755
[Install]
WantedBy=multi-user.target

2.2.2.5：创建 redis 用户和数据目录

groupadd -g 1000 redis && useradd -u 1000 -g 1000 redis -s /sbin/nologin
mkdir -pv /usr/local/redis/{etc,logs,data,run}
chown redis.redis -R /usr/local/redis/

2.2.2.6： 验证 redis 启动

useradd redis -s /sbin/nologin
chown redis.redis /usr/local/redis/ -R
chown redis.redis /usr/local/redis/ -R #注意目录权限

2.2.2.7： 使用客户端连接 redis

/usr/local/redis/bin/redis-cli -h IP/HOSTNAME -p PORT -a PASSWORD

2.2.2.8： 创建命令软连接

ln -sv /usr/local/redis/bin/redis-* /usr/bin/
'/usr/bin/redis-benchmark' -> '/usr/local/redis/bin/redis-benchmark'
'/usr/bin/redis-check-aof' -> '/usr/local/redis/bin/redis-check-aof'
'/usr/bin/redis-check-rdb' -> '/usr/local/redis/bin/redis-check-rdb'
'/usr/bin/redis-cli' -> '/usr/local/redis/bin/redis-cli'
'/usr/bin/redis-sentinel' -> '/usr/local/redis/bin/redis-sentinel'
'/usr/bin/redis-server' -> '/usr/local/redis/bin/redis-server'

2.2.2.9： 编译安装后的命令

[root@redis-s1 ~]# ll /usr/local/redis/bin/
total 32656
-rwxr-xr-x 1 redis redis 4365488 Dec 13 09:21 redis-benchmark #redis 性能测试工具
-rwxr-xr-x 1 redis redis 8088920 Dec 13 09:21 redis-check-aof #AOF 文件检查工具
-rwxr-xr-x 1 redis redis 8088920 Dec 13 09:21 redis-check-rdb #RDB 文件检查工具
-rwxr-xr-x 1 redis redis 4800752 Dec 13 09:21 redis-cli #redis #客户端工具
lrwxrwxrwx 1 redis redis 12 Dec 13 09:21 redis-sentinel -> redis-server #哨兵， 软连接到server
-rwxr-xr-x 1 redis redis 8088920 Dec 13 09:21 #redis-server #redis 服务端

2.2.3： windows 安装 redis：

2.2.4： 连接到 Redis：

#!/bin/env python
#Author: ZhangJie
import redis
import time
pool = redis.ConnectionPool(host="192.168.7.101",
port=6379,password="")
r = redis.Redis(connection_pool=pool)
for i in range(100):
r.set("k%d" % i,"v%d" % i)
time.sleep(1)
data=r.get("k%d" % i)
print(data)

小笔记：redis安装启动

yum install redis -y    #epel
systemctl start redis
#测试
redis-cli
ping

#源码编译安装
useradd redis -s /sbin/nologin -r
cd /usr/local/src
tar xf redis-5.0.3.tar.gz
cd redis-5.0.3
make PREFIX=/apps/redis install
mkdir /apps/redis/etc
cp redis.conf /apps/redis/etc/
chown -R redis.redis /apps/redis

#创建服务启动文件
vim /usr/lib/systemd/system/redis.service
    [Unit]
    Description=Redis persistent key-value database
    After=network.target
    After=network-online.target
    Wants=network-online.target
    [Service]
    ExecStart=/apps/redis/bin/redis-server /apps/redis/etc/redis.conf --supervised systemd
    ExecReload=/bin/kill -s HUP $MAINPID
    ExecStop=/bin/kill -s QUIT $MAINPID
    Type=notify
    User=root
    Group=root
    RuntimeDirectory=redis
    RuntimeDirectoryMode=0755
    [Install]
    WantedBy=multi-user.target

systemctl start redis
/apps/redis/bin/redis-cli

#解决启动时的警告
vim /etc/sysctl.conf
    net.core.somaxconn = 512        # WARNING: The TCP backlog setting of 511
    vm.overcommit_memory = 1        # WARNING overcommit_memory is set to 0!
sysctl -p
#WARNING you have Transparent Huge Pages (THP) support enabled in your kernel
echo never > /sys/kernel/mm/transparent_hugepage/enabled    #开启大页内存动态分配，需要关闭让 redis 负责内存管理
echo 'echo never > /sys/kernel/mm/transparent_hugepage/enabled' > /etc/rc.d/rc.local
chmod +x /etc/rc.d/rc.local
systemctl restart redis
2.3： redis 配置文件

2.3.1： redis 主要配置项

#监听地址， 可以用空格隔开后多个监听 IP
bind 0.0.0.0
#redis3.2 之后加入的新特性， 在没有设置 bind IP 和密码的时候只允许访问
protected-mode yes 
127.0.0.1:6379
#监听端口
port 6379 
#三次握手的时候 server 端收到 client ack 确认号之后的队列值。
tcp-backlog 511 
#客户端和 Redis 服务端的连接超时时间，默认是 0，表示永不超时。
timeout 0 
#tcp 会话保持时间
tcp-keepalive 300 
#认情况下 redis 不是作为守护进程运行的，如果你想让它在后台运行，你就把它改成yes,当 redis 作为守护进程运行的时候，它会写一个 pid 到 /var/run/redis.pid 文件里面
daemonize no 
#和操作系统相关参数， 可以设置通过 upstart 和 systemd 管理 Redis 守护进程， centos 7以后都使用 systemd
supervised no 
#pid 文件路径
pidfile /var/run/redis_6379.pid 
#日志级别
loglevel notice 
#日志路径
logfile "" 
 #设置 db 库数量，默认 16 个库
databases 16
#在启动 redis 时是否显示 logo
always-show-logo yes 
#在 900 秒内有一个键内容发生更改就出就快照机制
save 900 1 
save 300 10
save 60 10000
#快照出错时是否禁止 redis 写入操作
stop-writes-on-bgsave-error no 
#持久化到 RDB 文件时，是否压缩， "yes"为压缩， "no"则反之
rdbcompression yes 
#是否开启 RC64 校验，默认是开启
rdbchecksum yes 
#快照文件名
dbfilename dump.rdb 
#快照文件保存路径
dir ./ 

#当从库同主库失去连接或者复制正在进行，从机库有两种运行方式： 1) 如果 replica-serve-stale-data 设置为 yes(默认设置)，从库会继续响应客户端的读请求。 2) 如果 replicaserve-stale-data 设置为 no，除去指定的命令之外的任何请求都会返回一个错误"SYNC with mprogress"。
replica-serve-stale-data yes 
#是否设置从库只读
replica-read-only yes 
#是否使用 socket 方式复制数据， 目前 redis 复制提供两种方式， disk 和 socket， 如果新的 slave 连上来或者重连的 slave 无法部分同步，就会执行全量同步， master 会生成 rdb 文件， 有2 种方式： disk 方式是 master 创建一个新的进程把 rdb 文件保存到磁盘，再把磁盘上的 rdb 文件传递给 slave， socket 是 master 创建一个新的进程，直接把 rdb 文件以 socket 的方式发给 slave， disk 方式的时候，当一个 rdb 保存的过程中，多个 slave 都能共享这个 rdb 文件， socket 的方式就是一个个 slave顺序复制， 只有在磁盘速度缓慢但是网络相对较快的情况下才使用 socket 方式， 否则使用默认的 disk方式
repl-diskless-sync no 
#diskless 复制的延迟时间， 设置 0 为关闭， 一旦复制开始还没有结束之前，master 节点不会再接收新 slave 的复制请求， 直到下一次开始
repl-diskless-sync-delay 30 
#slave 根据 master 指定的时间进行周期性的 PING 监测
repl-ping-slave-period 10 
#复制链接超时时间，需要大于 repl-ping-slave-period， 否则会经常报超时
repl-timeout 60 
#在 socket 模式下是否在 slave 套接字发送 SYNC 之后禁用 TCP_NODELAY，如果你选择“yes”Redis 将使用更少的 TCP 包和带宽来向 slaves 发送数据。但是这将使数据传输到 slave上有延迟， Linux 内核的默认配置会达到 40 毫秒， 如果你选择了 "no" 数据传输到 salve 的延迟将会减少但要使用更多的带宽
repl-disable-tcp-nodelay no 
#复制缓冲区大小， 只有在 slave 连接之后才分配内存。
repl-backlog-size 1mb 
#多次时间 master 没有 slave 连接，就清空 backlog 缓冲区。
repl-backlog-ttl 3600 
#当 master 不可用， Sentinel 会根据 slave 的优先级选举一个 master。最低的优先级的 slave，当选 master。而配置成 0，永远不会被选举。requirepass foobared #设置 redis 连接密码
replica-priority 100 
 #重命名一些高危命令
rename-command
#最大连接客户端
maxclients 10000 
#最大内存，单位为 bytes 字节，8G 内存的计算方式 8(G)*1024(MB)*1024(KB)*1024(Kbyte)，需要注意的是 slave 的输出缓冲区是不计算在 maxmemory 内。
maxmemory 
#是否开启 AOF 日志记录， 默认 redis 使用的是 rdb 方式持久化，这种方式在许多应用中已经足够用了。但是 redis 如果中途宕机，会导致可能有几分钟的数据丢失，根据 save 来策略进行持久化，Append Only File 是另一种持久化方式，可以提供更好的持久化特性。 Redis 会把每次写入的数据在接收后都写入 appendonly.aof 文件，每次启动时 Redis 都会先把这个文件的数据读入内存里，先忽略 RDB 文件。
appendonly no 
#AOF 文件名
appendfilename "appendonly.aof" 
 #aof 持久化策略的配置,no 表示不执行 fsync,由操作系统保证数据同步到磁盘,always 表示每次写入都执行 fsync，以保证数据同步到磁盘,everysec 表示每秒执行一次 fsync，可能会导致丢失这 1s 数据。no-appendfsync-on-rewrite no 在 aof rewrite 期间,是否对 aof 新记录的 append 暂缓使用文件同步策略,主要考虑磁盘 IO 开支和请求阻塞时间。默认为 no,表示"不暂缓",新的 aof 记录仍然会被立即同步，Linux 的默认 fsync 策略是 30 秒，如果为 yes 可能丢失 30 秒数据， 但由于 yes 性能较好而且会避免出现阻塞因此比较推荐。
appendfsync everysec
# 当 Aof log 增长超过指定百分比例时，重写 log file， 设置为 0 表示不自动重写 Aof 日志，重写是为了使 aof 体积保持最小，而确保保存最完整的数据。
auto-aof-rewrite-percentage 100 
#触发 aof rewrite 的最小文件大小
auto-aof-rewrite-min-size 64mb 
#是否加载由于其他原因导致的末尾异常的 AOF 文件(主进程被 kill/断电等)
aof-load-truncated yes 
#redis4.0 新增 RDB-AOF 混合持久化格式，在开启了这个功能之后， AOF 重写产生的文件将同时包含 RDB 格式的内容和 AOF 格式的内容，其中 RDB 格式的内容用于记录已有的数据，而 AOF 格式的内存则用于记录最近发生了变化的数据，这样 Redis 就可以同时兼有 RDB 持久化和AOF 持久化的优点（既能够快速地生成重写文件，也能够在出现问题时，快速地载入数据）。
aof-use-rdb-preamble yes 
#lua 脚本的最大执行时间， 单位为毫秒
lua-time-limit 5000 
#是否开启集群模式，默认是单机模式
cluster-enabled yes 
#由 node 节点自动生成的集群配置文件
cluster-config-file nodes-6379.conf 
#集群中 node 节点连接超时时间
cluster-node-timeout 15000 
#在执行故障转移的时候可能有些节点和 master 断开一段时间数据比较旧， 这些节点就不适用于选举为 master， 超过这个时间的就不会被进行故障转移
cluster-replica-validity-factor 10 
#一个主节点拥有的至少正常工作的从节点， 即如果主节点的 slave 节点故障后会将多余的从节点分配到当前主节点成为其新的从节点。cluster-require-full-coverage no #集群槽位覆盖， 如果一个主库宕机且没有备库就会出现集群槽位不全， 那么 yes 情况下 redis 集群槽位验证不全就不再对外提供服务，而 no 则可以继续使用但是会出现查询数据查不到的情况(因为有数据丢失)。
cluster-migration-barrier 1 

#Slow log 是 Redis 用来记录查询执行时间的日志系统， slow log 保存在内存里面，读写速度非常快，因此你可以放心地使用它，不必担心因为开启 slow log 而损害 Redis 的速度。

#以微秒为单位的慢日志记录， 为负数会禁用慢日志， 为 0 会记录每个命令操作。
slowlog-log-slower-than 10000 

#记录多少条慢日志保存在队列，超出后会删除最早的， 以此滚动删除
slowlog-max-len 128 

127.0.0.1:6379> slowlog len
(integer) 14
127.0.0.1:6379> slowlog get
1) 1) (integer) 14
    2) (integer) 1544690617
    3) (integer) 4
    4) 1) "slowlog"
127.0.0.1:6379> SLOWLOG reset
OK

小笔记：配置文件

vim /apps/redis/etc/redis.conf
bind 127.0.0.1 192.168.37.7
protected-mode yes
port 6379
tcp-backlog 511
timeout 0
tcp-keepalive 300   #单位:秒
daemonize yes       #是否已守护进程运行
supervised systemd  #管理redis守护进程
pidfile /apps/redis/run/redis-6379.pid
loglevel notice     #日志级别
logfile "/apps/redis/logs/redis-6379.log"   #日志路径
databases 16        #设置 db 库数量，默认 16 个库
always-show-logo yes #在启动 redis 时是否显示 logo

#快照
save 900 1 #在 900 秒内有一个键内容发生更改就出就快照机制
save 300 10
save 60 10000
stop-writes-on-bgsave-error no  #快照出错时是否禁止 redis 写入操作
rdbcompression yes          #持久化到 RDB 文件时，是否压缩， "yes"为压缩， "no"则反之
rdbchecksum yes             #是否开启 RC64 校验，默认是开启
dbfilename dump.rdb         #快照文件名
dir /apps/redis/data        #快照文件保存路径

#主从配置
replica-serve-stale-data yes
replica-read-only yes
repl-diskless-sync no
repl-diskless-sync-delay 30
repl-ping-slave-period 10       #检测存活
repl-timeout 60
repl-disable-tcp-nodelay no
repl-backlog-size 1mb       #复制缓冲区大小， 只有在 slave 连接之后才分配内存
repl-backlog-ttl 3600       #多次时间 master 没有 slave 连接，就清空 backlog 缓冲区
replica-priority 100

#安全
requirepass 123456          #设置 redis 连接密码
rename-command              #重命名一些高危命令，如flushdb,flushall

#连接并发
maxclients 10000            #最大连接客户端
maxmemory 4294967296        #最大内存，单位为 bytes 字节

#AOF
appendonly yes
appendfilename "appendonly.aof"
appendfsync everysec
no-appendfsync-on-rewrite no
auto-aof-rewrite-percentage 100
auto-aof-rewrite-min-size 64mb
aof-load-truncated yes
aof-use-rdb-preamble yes

#其他
lua-time-limit 5000     #lua 脚本的最大执行时间， 单位为毫秒

#创建集群后自动添加
cluster-enabled yes
cluster-config-file nodes-6379.conf
cluster-node-timeout 15000
cluster-replica-validity-factor 10
cluster-migration-barrier 1
cluster-require-full-coverage no

#慢日志
slowlog-log-slower-than 10000       #以微秒为单位的慢日志记录，为负数会禁用慢日志， 为 0 会记录每个命令操作
slowlog-max-len 128         #记录多少条慢日志保存在队列，超出后会删除最早的， 以此滚动删除
:wq

slowlog len
slowlog get
1) 1) (integer) 14
    2) (integer) 1544690617
    3) (integer) 4
    4) 1) "slowlog"
SLOWLOG reset

#修复命令
redis-check-aof --fix /apps/redis/data/appendonly.aof
redis-check-rdb

2.3.2： redis 持久化

2.3.2.1： RDB 模式

2.3.2.2： RDB 模式的优缺点

2.3.2.3： AOF 模式

2.3.2.4： AOF 模式优缺点

2.4： redis 数据类型：

2.4.1： 字符串(string)

字符串是所有编程语言中最常见的和最常用的数据类型，而且也是 redis 最基本的数据类型之一，而且 redis 中所有的 key 的类型都是字符串。

2.4.1.1： 添加一个 key：
127.0.0.1:6379> set key1 value1
OK
127.0.0.1:6379> get key1
"value1"
127.0.0.1:6379> TYPE key1
string
127.0.0.1:6379> SET name2 jack2 ex 3 #设置自动过期时间
OK

2.4.1.2： 获取一个 key 的内容
127.0.0.1:6379> get key1
"value1

2.4.1.3： 删除一个 key
127.0.0.1:6379> DEL key1
(integer)

2.4.1.4：批量设置多个 key
127.0.0.1:6379> MSET key1 value1 key2 value2
OK

2.4.1.5： 批量获取多个 key
127.0.0.1:6379> MGET key1 key2
OK

2.4.1.6：追加数据
127.0.0.1:6379> APPEND key1 append
(integer) 12
127.0.0.1:6379> get key1
"value1append

2.4.1.7： 数值递增
127.0.0.1:6379> set num 10
OK
127.0.0.1:6379> INCR num
(integer) 11
127.0.0.1:6379> get num
"11

2.4.1.8： 数值递减
127.0.0.1:6379> set num 10
OK
127.0.0.1:6379> DECR num
(integer) 9
127.0.0.1:6379> get num
"9"

2.4.1.9：返回字符串 key 长度
127.0.0.1:6379> STRLEN key1
(integer) 12

2.4.2： 列表(list)

2.4.2.1：生成列表并插入数据

LPUSH列表写入从右往左，类似list1[0]=jhon,list1[1]=tom,list1[2]=jack

127.0.0.1:6379> LPUSH list1 jack tom jhon
(integer) 3
127.0.0.1:6379> TYPE list1
list

2.4.2.2：向列表追加数据
127.0.0.1:6379> LPUSH list1 tom
(integer) 2
127.0.0.1:6379> RPUSH list1 jack
(integer) 3

2.4.2.3： 获取列表长度
127.0.0.1:6379> LLEN list1

2.4.2.4：获取列表指定位置数据：
127.0.0.1:6379> RPUSH list1 zhang wang li zhao
(integer) 4
127.0.0.1:6379> LRANGE list1 1 2 #指定范围

  1. "wang"
  2. "li"
    127.0.0.1:6379> LRANGE list1 2 2 #指定位置
  3. "li"

2.4.2.5：移除列表数据：
127.0.0.1:6379> RPOP list1 #最后一个
"jack"
127.0.0.1:6379> LPOP list1 #第一个
"tom"

2.4.3： 集合(set)

2.4.3.1：生成集合 key
127.0.0.1:6379> SADD set1 v1
(integer) 1
127.0.0.1:6379> SADD set2 v2 v4
(integer) 2
127.0.0.1:6379> TYPE set1
set
127.0.0.1:6379> TYPE set2
set

2.4.3.2： 追加数值：
追加的时候不能追加已经存在的数值
127.0.0.1:6379> SADD set1 v2 v3 v4
(integer) 3
127.0.0.1:6379> SADD set1 v2 #没有追加成功
(integer) 0
127.0.0.1:6379> TYPE set1
set
127.0.0.1:6379> TYPE set2
set

2.4.3.3： 查看集合的所有数据：
127.0.0.1:6379> SMEMBERS set1

  1. "v4"
  2. "v1"
  3. "v3"
  4. "v2"
    127.0.0.1:6379> SMEMBERS set2
  5. "v4"
  6. "v2

2.4.3.4： 获取集合的差集：
差集： 已属于 A 而不属于 B 的元素称为 A 与 B 的差（集）
127.0.0.1:6379> SDIFF set1 set2

  1. "v1"
  2. "v3"

2.4.3.5： 获取集合的交集：
交集： 已属于 A 且属于 B 的元素称为 A 与 B 的交（集）
127.0.0.1:6379> SINTER set1 set2

  1. "v4"
  2. "v2

2.4.3.6： 获取集合的并集：
并集：已属于 A 或属于 B 的元素为称为 A 与 B 的并（集）
127.0.0.1:6379> SUNION set1 set2

  1. "v2"
  2. "v4"
  3. "v1"
  4. "v3"
2.4.4： sorted set(有序集合):

2.4.4.1：生成有序集合：
127.0.0.1:6379> ZADD zset1 1 v1
(integer) 1
127.0.0.1:6379> ZADD zset1 2 v2
(integer) 1
127.0.0.1:6379> ZADD zset1 2 v3
(integer) 1
127.0.0.1:6379> ZADD zset1 3 v4
(integer) 1
127.0.0.1:6379> TYPE zset1
zset
127.0.0.1:6379> TYPE zset2
zset

排行案例：
192.168.7.104:6379> ZADD paihangbang 10 key1 20 key2 30 key3
(integer) 3
192.168.7.104:6379> ZREVRANGE paihangbang 0 -1 withscores #显示指定集合内所有 key 和得分情况

  1. "key3"
  2. "30"
  3. "key2"
  4. "20"
  5. "key1"
  6. "10"

2.4.4.2：批量添加多个数值：
127.0.0.1:6379> ZADD zset2 1 v1 2 v2 4 v3 5 v5
(integer) 4
2.4.4.3： 获取集合的长度数：
127.0.0.1:6379> ZCARD zset1
(integer) 4
127.0.0.1:6379> ZCARD zset2
(integer) 4
2.4.4.4：基于索引返回数值：
127.0.0.1:6379> ZRANGE zset1 1 3

  1. "v2"
  2. "v3"
  3. "v4"
    127.0.0.1:6379> ZRANGE zset1 0 2
  4. "v1"
  5. "v2"
  6. "v3"
    127.0.0.1:6379> ZRANGE zset1 2 2
  7. "v3

2.4.4.5：返回某个数值的索引：
127.0.0.1:6379> ZRANK zset1 v2
(integer) 1
127.0.0.1:6379> ZRANK zset1 v3
(integer) 2

2.4.5：哈希(hash)：

2.4.5.1：生成 hash key

127.0.0.1:6379> HSET hset1 name tom age 18
(integer) 1
127.0.0.1:6379> TYPE hset1
hash

2.4.5.2： 获取 hash key 字段值

127.0.0.1:6379> HGET hset1 name
"tom"
127.0.0.1:6379> HGET hset1 age
"18"

2.4.5.3： 删除一个 hash key 的字段

127.0.0.1:6379> HDEL hset1 age
(integer) 1

2.4.5.4：获取所有 hash 表中的字段

127.0.0.1:6379> HSET hset1 name tom age 19
(integer) 1
127.0.0.1:6379> HKEYS hset1

  1. "name"
  2. "age

2.5： 消息队列

2.5.1： 生产者消费者模式

2.5.1.1： 模式介绍

2.5.1.2：队列介绍

2.5.1.3： 生产者发布消息

[root@redis-s4 ~]# redis-cli
127.0.0.1:6379> AUTH 123456
OK
127.0.0.1:6379> LPUSH channel1 msg1 #从管道的左侧写入
(integer) 1
127.0.0.1:6379> LPUSH channel1 msg2
(integer) 2
127.0.0.1:6379> LPUSH channel1 msg3
(integer) 3
127.0.0.1:6379> LPUSH channel1 msg4
(integer) 4
127.0.0.1:6379> LPUSH channel1 msg5
(integer) 5

2.5.1.4：查看队列所有消息

127.0.0.1:6379> LRANGE channel1 0 -1

  1. "msg5"
  2. "msg4"
  3. "msg3"
  4. "msg2"
  5. "msg1"

2.5.1.5： 消费者消费消息

127.0.0.1:6379> RPOP channel1 #从管道的右侧消费
"msg1"
127.0.0.1:6379> RPOP channel1
"msg2"
127.0.0.1:6379> RPOP channel1
"msg3"
127.0.0.1:6379> RPOP channel1
"msg4"
127.0.0.1:6379> RPOP channel1
"msg5"
127.0.0.1:6379> RPOP channel1
(nil)

2.5.1.6： 再次验证队列消息
127.0.0.1:6379> LRANGE channel1 0 -1
(empty list or set) #队列中的消息已经被已全部消费完毕

2.5.2： 发布者订阅模式

2.5.2.1： 模式简介

image.png

2.5.2.2：订阅者监听频道

[root@redis-s4 ~]# redis-cli
127.0.0.1:6379> AUTH 123456
OK
127.0.0.1:6379> SUBSCRIBE channel1 #订阅者订阅指定的频道
Reading messages... (press Ctrl-C to quit)

  1. "subscribe"
  2. "channel1"
  3. (integer) 1

2.5.2.3： 发布者发布消息

127.0.0.1:6379> PUBLISH channel1 test1 #发布者发布消息
(integer) 2
127.0.0.1:6379> PUBLISH channel1 test2
(integer) 2
127.0.0.1:6379>

2.5.2.4：各订阅者验证消息

127.0.0.1:6379> SUBSCRIBE channel1

2.5.2.5： 订阅多个频道
订阅指定的多个频道
> SUBSCRIBE channel1 channel2

2.5.2.6： 订阅所有频道
127.0.0.1:6379> PSUBSCRIBE *

2.7.2.7： 订阅匹配的频道
> PSUBSCRIBE chann* #匹配订阅多个频道

2.6： redis 其他命令

2.6.1： CONFIG
config 命令用于查看当前 redis 配置、以及不重启更改 redis 配置等

2.6.1.1： 更改最大内存
127.0.0.1:6379> CONFIG set maxmemory 8589934592
OK
127.0.0.1:6379> CONFIG get maxmemory

  1. "maxmemory"
  2. "8589934592"

2.6.1.2： 设置连接密码
127.0.0.1:6379> CONFIG SET requirepass 123456 #临时修改密码
OK

2.5.1.3： 或当前配置
CONFIG GET *

2.6.2： info
显示当前节点 redis 运行状态信息

2.6.3： SELECT 切换数据库
select 1

2.6.4： keys
查看当前库下的所有 key
key *

2.6.5： BGSAVE
手动在后台执行 RDB 持久化操作

2.6.6： DBSIZE
返回当前库下的所有 key 数量

2.6.7： FLUSHDB
强制清空当前库中的所有 key

2.6.8： FLUSHALL
强制清空当前 redis 服务器所有数据库中的所有 key， 即删除所有数据

上一篇 下一篇

猜你喜欢

热点阅读