Redis 基础入门(介绍、安装、数据类型)

一、Redis简介

1.1 简介

Redis (Remote Dictionary Server)是完全开源的,遵守 BSD 协议,是一个高性能的 key-value 数据库。

Redis 与其他 key - value 缓存产品有以下三个特点:

  • Redis支持数据的持久化,可以将内存中的数据保存在磁盘中,重启的时候可以再次加载进行使用。
  • Redis不仅仅支持简单的key-value类型的数据,同时还提供list,set,zset,hash等数据结构的存储。
  • Redis支持数据的备份,即master-slave模式的数据备份。

1.2 特性

  • 键值(key-value)型,value支持多种不同数据结构,功能丰富

  • 单线程,每个命令具备原子性

  • 低延迟,速度快(基于内存、IO多路复用、良好的编码)。

  • 支持数据持久化

  • 支持主从集群、分片集群

  • 支持多语言客户端

1.3 使用场景

  • 登录会话存储:存储在redis中,与memcached相比,数据不会丢失。
  • 排行版/计数器:比如一些秀场类的项目,经常会有一些前多少名的主播排名。还有一些文章阅读量的技术,或者新浪微博的点赞数等。
  • 作为消息队列:比如celery就是使用redis作为中间人。
  • 当前在线人数:还是之前的秀场例子,会显示当前系统有多少在线人数。
  • 一些常用的数据缓存:比如我们的BBS论坛,板块不会经常变化的,但是每次访问首页都要从mysql中获取,可以在redis中缓存起来,不用每次请求数据库。
  • 把前200篇文章缓存或者评论缓存:一般用户浏览网站,只会浏览前面一部分文章或者评论,那么可以把前面200篇文章和对应的评论缓存起来。用户访问超过的,就访问数据库,并且以后文章超过200篇,则把之前的文章删除。
  • 好友关系:微博的好友关系使用redis实现。
  • 发布和订阅功能:可以用来做聊天软件。

1.4 安装

  • 默认安装

    # centos8 ,采用默认安装方式使用的是redis 5 版本
    yum install redis
    
  • 源码安装

    下载地址 http://redis.io/download,下载最新稳定版本。

    注意源码安装时,检查本地是否又gcc编译器,因为redis使用C语言实现,需要使用gcc编译器进行编译。

    [root@centos8-106 redis-6.0.8]# gcc --version
    gcc (GCC) 8.5.0 20210514 (Red Hat 8.5.0-4)
    Copyright (C) 2018 Free Software Foundation, Inc.
    
    # 如果没有gcc
    yum install gcc -y
    

    源码安装redis

    # wget http://download.redis.io/releases/redis-6.0.8.tar.gz
    # tar xzf redis-6.0.8.tar.gz
    # cd redis-6.0.8
    # make
    

    安装后查看信息

    [root@centos8-106 software]# redis-cli --version
    redis-cli 6.0.8
    

1.5 配置

redis 默认的安装路径是在 /usr/local/bin/ 目录下,会产生几个redis开头的可执行文件,称之为redis-shell
在这里插入图片描述

可执行文件作用
redis-cliRedis 命令行客户端文件
redis-server启动 Redis
redis-benchmarkRedis 基准测试工具
redis-check-aofRedis AOF持久化文件检测和修复工具
redis-check-dumpRedis RDB 持久化文件检测和修复工具
redis-sentinel启动 Redis Sentinel

1.6 Redis 启动&停止

(1)默认配置启动

采用默认的配置文件启动redis ,启动之后可以看见redis的相关信息,包括端口号,版本等。

这种启动属于前台启动,会阻塞整个会话窗口,窗口关闭或者按下CTRL + C则Redis停止。不推荐使用。

[root@centos8-106 src]# redis-server
87816:C 19 Mar 2022 15:43:30.326 # oO0OoO0OoO0Oo Redis is starting oO0OoO0OoO0Oo
87816:C 19 Mar 2022 15:43:30.326 # Redis version=6.0.8, bits=64, commit=00000000, modified=0, pid=87816, just started
87816:C 19 Mar 2022 15:43:30.326 # Warning: no config file specified, using the default config. In order to specify a config file use redis-server /path/to/redis.conf
87816:M 19 Mar 2022 15:43:30.327 * Increased maximum number of open files to 10032 (it was originally set to 1024).
                _._                                                  
           _.-``__ ''-._                                             
      _.-``    `.  `_.  ''-._           Redis 6.0.8 (00000000/0) 64 bit
  .-`` .-```.  ```\/    _.,_ ''-._                                   
 (    '      ,       .-`  | `,    )     Running in standalone mode
 |`-._`-...-` __...-.``-._|'` _.-'|     Port: 6379
 |    `-._   `._    /     _.-'    |     PID: 87816
  `-._    `-._  `-./  _.-'    _.-'                                   
 |`-._`-._    `-.__.-'    _.-'_.-'|                                  
 |    `-._`-._        _.-'_.-'    |           http://redis.io        
  `-._    `-._`-.__.-'_.-'    _.-'                                   
 |`-._`-._    `-.__.-'    _.-'_.-'|                                  
 |    `-._`-._        _.-'_.-'    |                                  
  `-._    `-._`-.__.-'_.-'    _.-'                                   
      `-._    `-.__.-'    _.-'                                       
          `-._        _.-'                                           
              `-.__.-'                                               

(2)配置文件启动(后台启动)

如果要让Redis以后台方式启动,则必须修改Redis配置文件,就在我们之前解压的redis安装包下,名字叫redis.conf

我们先将这个配置文件备份一份:

cd /home/software/redis-6.0.8/

cp redis.conf redis.conf.bck

然后修改redis.conf文件中的一些配置:

# 允许访问的地址,默认是127.0.0.1,会导致只能在本地访问。修改为0.0.0.0则可以在任意IP访问,生产环境不要设置为0.0.0.0
bind 0.0.0.0
# 守护进程,修改为yes后即可后台运行
daemonize yes 
# 密码,设置后访问Redis必须输入密码
requirepass 123321

Redis的其它常见配置:

# 监听的端口
port 6379
# 工作目录,默认是当前目录,也就是运行redis-server时的命令,日志、持久化等文件会保存在这个目录
dir .
# 数据库数量,设置为1,代表只使用1个库,默认有16个库,编号0~15
databases 1
# 设置redis能够使用的最大内存
maxmemory 512mb
# 日志文件,默认为空,不记录日志,可以指定日志文件名
logfile "redis.log"

启动Redis:

[root@centos8-106 redis-6.0.8]# redis-server redis.conf
[root@centos8-106 redis-6.0.8]# ps -aux | grep redis
root       87848  0.1  0.9 271948  9648 ?        Ssl  15:52   0:00 redis-server 127.0.0.1:6379
root       87854  0.0  0.1 221924  1044 pts/1    R+   15:52   0:00 grep --color=auto redis

注意:

redis目录下都会有一个redis.conf 文件,里面就是redis的默认配置文件,是redis配置模板文件

(3)运行启动

通过在redis-server 加上要修改的参数和值(可以是多对),没有设置的配置将采用默认参数 ,这种启动方式不建议使用。

redis-server --configKey1 configValue1 --configKey2 configValue2
[root@centos8-106 redis-6.0.8]# redis-server --port 9999

(4)停止 Redis服务

# 1. 利用redis-cli来执行 shutdown 命令,即可停止 Redis 服务,
redis-cli shutdown

# 2. 如果之前配置了密码,因此需要通过 -u 来指定密码
redis-cli -u 123321 shutdown

redis 关闭的过程:

  1. 断开与客户端的连接
  2. 持久化文件生成

这时一种相对优雅的关闭方式,我们还可以使用kill 关闭进程,如果使用kill -9 PID 强制杀死redis服务,则 不会做持久化操作,还会造成缓冲区等资源不能优雅的关闭,极端情况可以会造成AOF和复制丢失数据的情况。

1.7 Redis 开机自启

  • 定义配置文件实现开机自启

    首先,新建一个系统服务文件:

    vim /etc/systemd/system/redis.service
    

    内容如下:

    [Unit]
    Description=redis-server
    After=network.target
    
    [Service]
    Type=forking
    ExecStart=/usr/local/bin/redis-server /home/software/redis-6.0.8/redis.conf
    PrivateTmp=true
    
    [Install]
    WantedBy=multi-user.target
    

    然后重载系统服务:

    systemctl daemon-reload
    
  • 通过systemctl 实现开机自启

    # 开机自启
    systemctl enable redis
    
    # 关闭开机自启
    systemctl disable redis
    

    systemctl 操作 redis

    # 启动
    systemctl start redis
    # 停止
    systemctl stop redis
    # 重启
    systemctl restart redis
    # 查看状态
    systemctl status redis
    

1.8 Redis 客户端

在启动redis-server 服务端后,我们使用redis-cli连接redis ,可以通过2种方式连接redis服务器

  • 交互式方式

    redis-cli -h {host} -p {port} 
    

    若不填写host 则使用 127.0.0.1 ,port 则使用 6379

    [root@centos8-106 redis-6.0.8]# redis-cli
    127.0.0.1:6379> 
    
  • 命令方式

    redis-cli -h {host} -p {port} {command}
    

    执行后可以得到命令的返回结果

    [root@centos8-106 redis-6.0.8]# redis-cli -h 127.0.0.1 -p 6379 set hello world
    OK
    

二、数据结构

2.1 通用命令

在学习数据结构之前我们先了解redis的一些全局命令和内部编码

  • 查看所有键

    keys *
    

    如果数据库中的key很多,最好不要使用keys * ,该操作可能会操作阻塞

  • 键总数

    # 返回当前数据库中键的总数
    dbsize
    
  • 键是否存在

    # 如果键存在则返回 1, 不存在则返回 0
    exists key
    
  • 删除键

    # 删除一个key 或者多个key
    # 删除成功则返回删除的个数,若删除的key不存在则返回 0
    del key [key ...]
    
  • 键过期

    # 设置键的过期时间,单位为秒,前提是key必须存在
    expire key seconds		 设置键多少秒后过期
    expireat  key timestamp  设置键的秒级过期时间戳
    
    pexpire key milliseconds 键在毫秒后过期
    pexpireat key milliseconds 键在毫秒级时间戳 timestamp 后过期   (Redis 内部最终使用的都是pexpireat)
    

    通过 ttl 查看键的剩余过期时间情况,它有三种返回值:

    • 大于等于0的整数:键剩余的过期时间
    • -1 :键没有设置过期时间
    • -2 :键不存在
    127.0.0.1:6379> set k1 v1
    OK
    127.0.0.1:6379> expire k1 10
    (integer) 1
    127.0.0.1:6379> ttl k1
    (integer) -2
    127.0.0.1:6379> set k1 v1
    OK
    127.0.0.1:6379> expire k1 10
    (integer) 1
    127.0.0.1:6379> ttl k1
    (integer) 6
    127.0.0.1:6379> ttl k1
    (integer) -2
    127.0.0.1:6379> get k1
    (nil)
    
  • 查看数据结构内部编码

    可以通过 object encoding key 来查看key的内部编码方式

    127.0.0.1:6379> object encoding k66
    "raw"
    
  • 键重命名

    rename key newKey
    # 如果rename之前,键已经存在,则它的值也将被覆盖
    

    为了防止被出现键相同被修改的情况,Redis提供了renamenx命令,确保只有newKey不存在时,才能被覆盖过去。如当我给newKey = python时,却发现python键已经存在,所以重命名会失败。

  • 随机返回一个键

    randomkey
    
  • 迁移键

    • move

      move key db
      用于在redis内部进行数据迁移,把指定的键从源数据库迁移到目标数据库,不过不建议在生产环境使用
      
    • dump + restore

      dump key
      restore key ttl value
      

      可以实现在不同redis实例之间进行数据迁移的功能

    • migrate

      migrate host port key|"" destination-db timeout [copy] [replace] [keys key [key ...]]
      
  • 数据库管理操作

    • 清除数据库

      • flushdb

        清除当前数据库中的全部数据

      • flushall

        清除所有数据库中的数据

    • 切换数据库

      • select dbindex

2.2 数据结构类型及编码

Redis是一个key-value的数据库,key一般是String类型,不过value的类型多种多样

Redis支持五种数据类型:string(字符串),hash(哈希),list(列表),set(集合)及zset(sorted set:有序集合)。

在这里插入图片描述

Redis 数据结构和内部编码
在这里插入图片描述

2.3 字符串(String)

2.3.1 简介

string 是 redis 最基本的类型,一个 key 对应一个 value。注意键都是字符串类型。

string 类型是二进制安全的。意思是 redis 的 string 可以包含任何数据。比如jpg图片或者序列化的对象。

string 类型是 Redis 最基本的数据类型,string 类型的值最大能存储 512MB。

2.3.2 方法

  • 设置值

      set key value [ex seconds] [px milliseconds] [nx|xx]
    # 设置 键  值     过期时间(秒) 过期时间(毫秒)     键是否存在
    
    # nx : 键必须不存在,才可以设置成功,即创建操作
    # xx : 键不存在,才可以设置成功,用于更新
    

    setnx | setex 命令

    setnx key value
    	键必须不存在,才可以设置,如果有多个客户端同时执行setnx key value ,则只有一个可以设置成功。依据这个特性,setnx可以作为分布式锁的一种实现方案
    	
    setex key seconds value
    	设置键的过期时间
    
  • 获取值

    get key
    # 存在则返回值,不存在则返回空(nil)
    
  • 批量设置值

    mset key value [key1 value1 ...]
    
    127.0.0.1:6379> mset k1 v1 k2 v2 k3 v3
    OK
    
  • 批量获取值

    mget key [key ...]
    
    127.0.0.1:6379> mget k1 k2 k3
    1) "v1"
    2) "v2"
    3) "v3"
    

    注意:

    ​ 批量操作值可以有效提高开发效率

    ​ 例如执行n次get命令:

    ​ n次get 需要耗时:n次get 时间 = n次网络时间 + n次命令时间

    ​ mget需要耗时:mget时间 = 一次网络时间 + n次命令时间

    批量操作不是无限制的,如果一次性执行的命令过多,则会造成Redis阻塞或者网络阻塞

  • 计数

    incr key					# 自增
    decr key					# 自减
    incrby key number			# 自增指定的数
    decrby key number			# 自减自定的数 
    incrbyfloat key floatnumber # 自增自定的浮点数
    

    用于对值做自增操作,结果分为三种情况

    • 值不是整数,返回错误

    • 值是整数,返回自增后的结果

    • 键不存在,按照值为0自增,返回的结果是1

      127.0.0.1:6379> mset k1 10 k2 v2   # 设置 k1 ,k2
      OK
      127.0.0.1:6379> incr k1			# k1的值自增1
      (integer) 11
      127.0.0.1:6379> incr k2			# k2的值自增报错
      (error) ERR value is not an integer or out of range
      127.0.0.1:6379> incr k100		# 自增不存在的key,会自动创建该key,并给key设置默认值为0且自增1
      (integer) 1
      127.0.0.1:6379> get k100		
      "1"
      127.0.0.1:6379> keys *			
      1) "k100"
      2) "k1"
      3) "k2"
      
      127.0.0.1:6379> incrby k1 100	# 自增100
      (integer) 111
      127.0.0.1:6379> decrby k1 11	
      (integer) 100
      127.0.0.1:6379> incrbyfloat k1 10.00	# 自增浮点数
      "110"
      127.0.0.1:6379> decrbyfloat k1 10.00	# 没有自减浮点数
      (error) ERR unknown command `decrbyfloat`, with args beginning with: `k1`, `10.00`, 
      
  • 追加值

    append key value
    

    先字符串尾部追加值,不管value是数值还是字符都为转为字符内容进行追加

  • 字符长度

    strlen key
    
  • 设置并返回原值

    getset key value
    
    127.0.0.1:6379> getset k66 v66
    (nil)
    127.0.0.1:6379> getset k66 v6666
    "v66"
    
  • 设置指定位置的字符

    setrange key offset value
    
    127.0.0.1:6379> get k66
    "v6666"
    127.0.0.1:6379> setrange k66 4 7
    (integer) 5
    127.0.0.1:6379> get k66
    "v6667"
    
  • 获取部分字符串

    getrange key start end
    
    127.0.0.1:6379> getrange k66 1 4
    "6667"
    

2.3.3 String 内部编码

编码说明
int8个字节的长整型
embstr小于等于39个字节的字符串
raw大于39个字节的字符串

2.4 哈希(hash)

2.4.1 简介

Redis hash 是一个键值(key=>value)对集合。

Redis hash 是一个 string 类型的 field 和 value 的映射表,hash 特别适合用于存储对象。

格式诸如:key = {{field1,value1},{field2,value2},{field3,value3}}

每个 hash 可以存储 2^32 -1 键值对(40多亿)

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Tall5vTC-1653664183927)(D:\SoftFileLocalSave\Typora图片文件库\image-20220527165327590.png)]

2.4.2 方法

  • 设置值

    hset key field value
    

    hsetnx 命令与setnx 一样,不过前者针对field,后缀针对键

  • 获取键

    hget key field
    
  • 删除field

    hdel key field [field ...]
    
  • 计算field个数

    hlen key
    
  • 批量设置或获取field-value

    hmset key field value [field value ...]
    hmget key field [field ...]
    
  • 判断field是否存在

    hexists key field
    
  • 获取所有field

    hkeys key
    
  • 获取所有value

    hvals key
    
  • 获取所有的field-value

    hgetall key
    

    在使用hgetall 如果hash元素的个数比较多,会存在阻塞redis的可能。如果一定要获取全部的field-value,建议使用hscan命令,该命令会渐进式遍历hash类型

  • value自增

    hincrby
    hincrbyfloat
    
    127.0.0.1:6379> hgetall user:1
    1) "name"
    2) "rion"
    3) "age"
    4) "18"
    5) "addr"
    6) "changsha"
    127.0.0.1:6379> hincrby user:1 age 10
    (integer) 28
    127.0.0.1:6379> hget user:1 age
    "28"
    
  • 计算value的长度

    hstrlen key field
    
    127.0.0.1:6379> hstrlen user:1 name
    (integer) 4
    

2.4.3 hash 内部编码

  • ziplist

    压缩列表,当hash类型元素个数小于hash-max-ziplist-entries 配置(512个),同时所有的value都小于hash-max-ziplist-value配置(默认64字节)时,Redis会使用ziplist作为hash内部实现。

  • hashtable

    当hash无法满足ziplist的条件时,会转为hashtable编码,随着hash元素增多时,ziplist的读写效率会下降

2.5 列表(list)

2.5.1 简介

Redis 列表是简单的字符串列表,按照插入顺序排序。你可以添加一个元素到列表的头部(左边)或者尾部(右边)

列表最多可存储 2^32 - 1 元素 (4294967295, 每个列表可存储40多亿)。

2.5.2 方法

在这里插入图片描述

  • 添加操作

    • 从右边插入元素

      rpush key value [value]
      
    • 从左边插入元素

      lpush key value [value]
      
    • 向某个元素前或者后插入元素

      linsert key before | after pivot value
      # 插入   key 前     | 后    元素值 新元素
      
      127.0.0.1:6379> rpush list:1 a b c d
      (integer) 4
      127.0.0.1:6379> linsert list:1 after b bbb
      (integer) 5
      127.0.0.1:6379> lrange list:1 0 -1		# 查询列表所有数据的意思
      1) "a"
      2) "b"
      3) "bbb"
      4) "c"
      5) "d"
      
  • 查找

    • 获取指定范围的元素

      lrange key start end
      
      # start : 表示起始位置
      # end   : 表示结束位置
      

      注意:lrange 中的end包含了自身,即 lrange list:key 0 2 表示list:key 中的第0个、第1个、第2个元素。

      127.0.0.1:6379> lrange list:1 0 2
      1) "a"
      2) "b"
      3) "bbb"
      
    • 获取列表指定索引下标的元素

      lindex key index
      
    • 获取列表元素长度

      llen key
      
  • 删除

    • 从列表左侧弹出元素

      lpop key
      
    • 从列表右侧弹出元素

      rpop key
      
    • 删除指定元素

      lrem key count value
      

      lrem 会从列表中删除等于value的元素,根据count的值的不同分为三种方式:

      • count > 0 :从左往右,删除最多count个元素
      • count < 0 : 从右到左, 删除最多count绝对值个元素
      • count = 0 : 删除所有元素
      127.0.0.1:6379> lrange list:1 0 -1		
      1) "a"
      2) "b"
      3) "bbb"
      4) "c"
      5) "d"
      127.0.0.1:6379> lrem list:1 1 a			# 从左往右删除1个元素a
      (integer) 1
      127.0.0.1:6379> lrange list:1 0 -1
      1) "b"
      2) "bbb"
      3) "c"
      4) "d"
      127.0.0.1:6379> lrem list:1 -2 b		# # 从右往左删除最多2个元素b
      (integer) 1
      127.0.0.1:6379> lrange list:1 0 -1
      1) "bbb"
      2) "c"
      3) "d"
      
    • 按照索引范围修剪列表

      这类似于python 中列表的索引取值 l[1:10]

      ltrim key start end
      

      注意:修改时包含end的值

      127.0.0.1:6379> lrange list:1 0 -1
      1) "bbb"
      2) "c"
      3) "d"
      4) "e"
      5) "f"
      6) "g"
      127.0.0.1:6379> ltrim list:1 1 3
      OK
      127.0.0.1:6379> lrange list:1 0 -1
      1) "c"
      2) "d"
      3) "e"
      
  • 修改

    lset key index newValue
    
  • 阻塞操作

    blpop key [key ...] timeout
    brpop key [key ...] timeout
    # blpop/brpop 弹出元素的方向不同
    # key 列表的键
    # 阻塞时长(单位秒)
    
    • 列表为空

      • timeout = 3 ,那么客户端需要等3秒后获取结果,

      • timeout = 0 ,那么客户端一直阻塞下去

        127.0.0.1:6379> blpop list:test 3
        (nil)
        (3.04s)
        127.0.0.1:6379> blpop list:test 0
        ...阻塞...
        	# 一旦列表中有值了,客户端会立即返回
        
        
    • 列表不为空

      • brpop list:test 0 ,客户端会立即返回

      • brpop list:1 3 ,客户端会立即返回

        127.0.0.1:6379> brpop list:1 3
        1) "list:1"				# key
        2) "e"					# 弹出的元素
        
    • 注意

      • 如果是多个键,brpop 会从左至右遍历键,一旦有一个键可以弹出元素,客户端就会立即返回。

        redis-cli1> brpop list:1 list:2 list:3 0
        ... 阻塞 ...
        
        redis-cli2> lpush list:2 jack 
        redis-cli3> lpush list:2 tom
        
        redis-cli1> brpop list:1 list:2 list:3 0
        1) "list:2"
        2) "jack"
        
      • 如果多个客户端对同一个list执行brpop,那么最先执行brpop 命令的客户端可以获取到值

        redis-cli1> brpop list:100 0
        redis-cli2> brpop list:100 0
        redis-cli3> brpop list:100 0
        ... 阻塞 ...
        
        redis-cli4> lpush list:100 alex
        
        redis-cli1> brpop list:100 0
        1) "list:100"
        2) "alex"
        

2.5.3 list 内部编码

  • ziplist

  • linkedlist(链表)

    不满足ziplist条件时,Redis会将list内部以linedlist作为内部编码

  • quicklist

    结合了ziplist、linkedlist 两者的优势,一种更为优秀的内部编码

2.5.4 使用场景

  • 消息队列

    lpush + brpop 命令组合可以实现阻塞队列

    • lpush : 客户端从列表左侧插入元素

    • brpop :多个消费者客户端阻塞式的 “抢” 列表尾部元素,多个客户端保证了消费的负载均衡和高可用性。

    lpush + lpop = Stack(栈)

    lpush + rpop = Queue(队列)

    lpush + ltrim = Capped Collection(有限集合)

2.6 集合(set)

2.6.1 简介

Redis 的 Set 是 string 类型的无序集合,不能通过索引下标来取值。

集合是通过哈希表实现的,所以添加,删除,查找的复杂度都是 O(1)。

集合中不允许出现重复的元素,

2.6.2 方法

  • 集合内操作

    • 添加元素

      sadd key element [element ...]
      
    • 删除元素

      srem key element [element ...]
      
    • 计算元素个数

      scard key
      # scard 不会遍历集合中的所有元素,而是用redis内部的变量,所以时间复杂度是 O(1)
      
    • 判断元素是否在集合中

      sismember key elemeny
      
    • 随机从集合中返回指定个数的元素

      srandmember key [count]
      # count 默认为1,可以不写
      
    • 从集合中随机弹出一个元素

      spop key [count]
      # count 弹出元素个数,redis 3.2 之后支持
      

      spop 和 srandmember 区别

      ​ spop 执行后,集合中的元素也会删除

      ​ srandmember 执行后,集合中的元素不会删除

    • 获取所有元素

      smembers key
      
  • 集合间操作
    在这里插入图片描述

    • 多个集合的交集(sinter)

      
      sinter key [key ...]
      
    • 多个集合的并集(sunion)

      sunion key [key ...]
      
    • 多个集合的差集(sdiff)

      sdiff key [key ...]
      
    • 将交集、并集、差集的结果进行保存

      sinterstore	desctination key [key ...]
      sunionstore	desctination key [key ...]
      sdiffstore	desctination key [key ...]
      
      sinterstore	user:1_2:inter user:1 user:2
      

2.6.3 内部编码

  • intset(整数集合)

    集合中的元素都为整数,且元素个数小于512个时所采用的内部编码方式。

  • hashtable(哈希表)

2.6.4 使用场景

  • 标签

2.7 有序集合(zset : sorted set)

2.7.1 简介

Redis zsetset 一样也是string类型元素的集合,且不允许重复的成员。

不同的是每个元素都会关联一个double类型的分数。redis正是通过分数(score)来为集合中的成员进行从小到大的排序。

zset的成员是唯一的,但分数(score)却可以重复。可以理解为班级同学学号不能重复,但是同学成绩可以重复。

在这里插入图片描述

2.7.2 方法

  • 集合内

    • 添加成员

      zadd key [nx|xx] [ch] [incr] score member [score member ...] 
      # nx : member 必须不存在才能添加成功
      # xx : member 必须存在才能添加成功
      # ch : 返回此次操作后,有序集合元素和分数发生的变化的个数
      # incr : 对score做增加
      
    • 计算成员个数

      zcard key
      
    • 获取某个成员分数

      zscore key member
      
    • 计算成员排名

      zrank key member
      zrevrank key member
      # zrank 分数从低到高排序(升序),输出成员的排名
      # zrevrank 分数从高到低进行排序(降序),输出成员的排名
      
    • 删除成员

      zrem key member
      
    • 增加成员的分数

      zincrby key increment member
      
      127.0.0.1:6379> zincrby s1 100 1002
      "192"
      
    • 返回指定排名范围的成员

      zrange key start end [withscores] 
      zrevrank key start end [withscores] 
      # 如果加上withscores参数,则会返回成员的分数
      
      127.0.0.1:6379> zrange s1 0 1 withscores
      1) "1001"
      2) "100"
      3) "1002"
      4) "192"
      
    • 返回指定分数范围的成员

      zrangebyscore key min max [withscores] [limit offset count]
      zrevrangebyscore key min max [withscores] [limit offset count]
      # zrangebyscore : 按分数从低到高返回,zrevrangebyscore 反之
      # min、max 支持开区间(小括号)和闭区间(中括号),-inf 和 +inf 分别代表无穷小和无穷大
      # 如果加上withscores参数,则会返回成员的分数
      # [limit offset count] 可以限制输出的其实位置和个数
      
      127.0.0.1:6379> zrangebyscore s1 (180 +inf withscores 		# 有序集合分数大于180的成员同时输出成员分数
      1) "1002"
      2) "192"
      3) "1003"
      4) "201"
      5) "1004"
      6) "300"
      
    • 返回指定分数范围成员的个数

      zcount key min max
      # min、max 支持开区间(小括号)和闭区间(中括号),-inf 和 +inf 分别代表无穷小和无穷大
      
    • 删除指定排名内的元素

      zremrangebyrank key start end
      
    • 删除指定分数范围的成员

      zremrangebyscore key min max
      # min、max 支持开区间(小括号)和闭区间(中括号),-inf 和 +inf 分别代表无穷小和无穷大
      
  • 有序集合间的操作

    • 交集

      zinterstore destination numkeys key [keys ...] [weights weight [weight ...]] [aggregate sum|min|max]
      # destination : 交集计算结果要保存的键
      # numkeys : 需要做交集计算键的个数
      # key [key ...] : 需要做交集计算的键
      # weights weight [weight ...] : 每个键的权重
      # aggregate sum|min|max : 计算成员交集后,分值可以安装 sum、min、max 做汇总,默认是sum
      

在这里插入图片描述

```
127.0.0.1:6379> zinterstore user:ranking:1_inter_2 2 user:ranking:1 user:ranking:2
127.0.0.1:6379> zrange user:ranking:1_inter_2 0 -1 withscores
1) "mike"
2) "168"
3) "martin"
4) "875"
5) "tom"
6) "1139"
```

- 并集

    ```
    zunionstore destination numkeys key [keys ...] [weights weight [weight ...]] [aggregate sum|min|max]
    ```

2.7.3 内部编码

  • ziplist
  • skiplist(跳表)

2.7.4 使用场景

  • 排行榜
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值