NoSQL：Redis基础

一、使用准备

　　Redis全程Remote Dictionary Server（远程字典服务器），用ANSI C编写而成，开源。少量数据存储、高速读写访问，是Redis的最主要应用场景。

　　在读写响应性能上，传统关系型数据库最一般，MongoDB类似的基于磁盘读写的NoSQL数据库较好，基于内存存储的Redis数据库最好（单服务器每秒插入处理速度可以超过8万条）。

　　但是传统关系型数据库应用业务范围最广、MongoDB主要应用于基于互联网的web应用，Redis只能解决Internet应用环境下的特定应用业务。

1、了解Redis

　　Redis作为数据库，也可以用于缓存（Cache）处理和消息（Message）传递处理，支持的数据结构包括字符串（String）、列表（List）、散列表（Hash）、集合（Set）、带范围查询的有序集合（Sorted set）、位图（Bitmap）、Hyperloglog和带半径查询的地理空间（Geospatial）索引。

　　Redis提供了内置复制、Lua脚本、LRU驱动事件、事务和不同级别的磁盘持久化功能，并通过哨兵（Sentinel）和集群自动分区（Partitioning）功能实现高可用。

　　Redis还提供了原子操作功能，如增加字符串内容，在散列表中增减值操作，在列表里增加一个元素成员，进行集合的交、并、差等运算，或者从有序集合获得排名最高的成员等。

　　Redis主要在内存中实现对各类数据的运算，以提高数据处理速度。但Redis也提供了隔一段时间转存到磁盘，或通过命令附加到日志持久化数据。当然，为了提高处理速度，也可以完全禁用持久性功能。

　　Redis支持的操作系统包括Linux、Unix、OS X、Windows四大系列，但是Windows版本是微软开源团队自行维护，在功能实现上有所差异。

　　为了完整体现Redis功能，建议采用Linux操作系统环境来安装Redis。

2、Redis安装

A、如果是Windows操作系统，必须满足系统和CPU都支持64位，而不是32位，否则安装存在问题。

在64位Windows操作系统下安装Docker（操作系统虚拟层应用容器软件）

  • 下载Docker

　　地址：https://github.com/docker/docker/releases/tag/v17.03.0-ce

  • 安装Docker

 　　点击安装Docker安装包执行安装，安装后运行Docker。为了使Docker与Redis Cluster兼容，需要使用Docker的主机联网模式，通过--net=host选项实现，其设置详见https://docs.docker.com/engine/userguide/networking/

　　Windows下docker仅支持cmd运行　　

　　 

 　　Windows下docker 命令帮助　　

  1 C:\Users\bjp-dt-wuzh\Desktop\docker-17.03.0-ce\docker>docker
  2 
  3 Usage:  docker COMMAND
  4 
  5 A self-sufficient runtime for containers
  6 
  7 Options:
  8       --config string      Location of client config files (default "C:\Users\bjp-dt-wuzh\.docker")
  9   -D, --debug              Enable debug mode
 10       --help               Print usage
 11   -H, --host list          Daemon socket(s) to connect to (default [])
 12   -l, --log-level string   Set the logging level ("debug", "info", "warn", "error", "fatal") (default "info")
 13       --tls                Use TLS; implied by --tlsverify
 14       --tlscacert string   Trust certs signed only by this CA (default "C:\Users\bjp-dt-wuzh\.docker\ca.pem")
 15       --tlscert string     Path to TLS certificate file (default "C:\Users\bjp-dt-wuzh\.docker\cert.pem")
 16       --tlskey string      Path to TLS key file (default "C:\Users\bjp-dt-wuzh\.docker\key.pem")
 17       --tlsverify          Use TLS and verify the remote
 18   -v, --version            Print version information and quit
 19 
 20 Management Commands:
 21   container   Manage containers
 22   image       Manage images
 23   network     Manage networks
 24   node        Manage Swarm nodes
 25   plugin      Manage plugins
 26   secret      Manage Docker secrets
 27   service     Manage services
 28   stack       Manage Docker stacks
 29   swarm       Manage Swarm
 30   system      Manage Docker
 31   volume      Manage volumes
 32 
 33 Commands:
 34   attach      Attach to a running container
 35   build       Build an image from a Dockerfile
 36   commit      Create a new image from a container's changes
 37   cp          Copy files/folders between a container and the local filesystem
 38   create      Create a new container
 39   diff        Inspect changes to files or directories on a container's filesystem
 40   events      Get real time events from the server
 41   exec        Run a command in a running container
 42   export      Export a container's filesystem as a tar archive
 43   history     Show the history of an image
 44   images      List images
 45   import      Import the contents from a tarball to create a filesystem image
 46   info        Display system-wide information
 47   inspect     Return low-level information on Docker objects
 48   kill        Kill one or more running containers
 49   load        Load an image from a tar archive or STDIN
 50   login       Log in to a Docker registry
 51   logout      Log out from a Docker registry
 52   logs        Fetch the logs of a container
 53   pause       Pause all processes within one or more containers
 54   port        List port mappings or a specific mapping for the container
 55   ps          List containers
 56   pull        Pull an image or a repository from a registry
 57   push        Push an image or a repository to a registry
 58   rename      Rename a container
 59   restart     Restart one or more containers
 60   rm          Remove one or more containers
 61   rmi         Remove one or more images
 62   run         Run a command in a new container
 63   save        Save one or more images to a tar archive (streamed to STDOUT by default)
 64   search      Search the Docker Hub for images
 65   start       Start one or more stopped containers
 66   stats       Display a live stream of container(s) resource usage statistics
 67   stop        Stop one or more running containers
 68   tag         Create a tag TARGET_IMAGE that refers to SOURCE_IMAGE
 69   top         Display the running processes of a container
 70   unpause     Unpause all processes within one or more containers
 71   update      Update configuration of one or more containers
 72   version     Show the Docker version information
 73   wait        Block until one or more containers stop, then print their exit codes
 74 
 75 Run 'docker COMMAND --help' for more information on a command.
 76 
 77 C:\Users\bjp-dt-wuzh\Desktop\docker-17.03.0-ce\docker>docker COMMAND --help
 78 
 79 Usage:  docker COMMAND
 80 
 81 A self-sufficient runtime for containers
 82 
 83 Options:
 84       --config string      Location of client config files (default "C:\Users\bjp-dt-wuzh\.docker")
 85   -D, --debug              Enable debug mode
 86       --help               Print usage
 87   -H, --host list          Daemon socket(s) to connect to (default [])
 88   -l, --log-level string   Set the logging level ("debug", "info", "warn", "error", "fatal") (default "info")
 89       --tls                Use TLS; implied by --tlsverify
 90       --tlscacert string   Trust certs signed only by this CA (default "C:\Users\bjp-dt-wuzh\.docker\ca.pem")
 91       --tlscert string     Path to TLS certificate file (default "C:\Users\bjp-dt-wuzh\.docker\cert.pem")
 92       --tlskey string      Path to TLS key file (default "C:\Users\bjp-dt-wuzh\.docker\key.pem")
 93       --tlsverify          Use TLS and verify the remote
 94   -v, --version            Print version information and quit
 95 
 96 Management Commands:
 97   container   Manage containers
 98   image       Manage images
 99   network     Manage networks
100   node        Manage Swarm nodes
101   plugin      Manage plugins
102   secret      Manage Docker secrets
103   service     Manage services
104   stack       Manage Docker stacks
105   swarm       Manage Swarm
106   system      Manage Docker
107   volume      Manage volumes
108 
109 Commands:
110   attach      Attach to a running container
111   build       Build an image from a Dockerfile
112   commit      Create a new image from a container's changes
113   cp          Copy files/folders between a container and the local filesystem
114   create      Create a new container
115   diff        Inspect changes to files or directories on a container's filesystem
116   events      Get real time events from the server
117   exec        Run a command in a running container
118   export      Export a container's filesystem as a tar archive
119   history     Show the history of an image
120   images      List images
121   import      Import the contents from a tarball to create a filesystem image
122   info        Display system-wide information
123   inspect     Return low-level information on Docker objects
124   kill        Kill one or more running containers
125   load        Load an image from a tar archive or STDIN
126   login       Log in to a Docker registry
127   logout      Log out from a Docker registry
128   logs        Fetch the logs of a container
129   pause       Pause all processes within one or more containers
130   port        List port mappings or a specific mapping for the container
131   ps          List containers
132   pull        Pull an image or a repository from a registry
133   push        Push an image or a repository to a registry
134   rename      Rename a container
135   restart     Restart one or more containers
136   rm          Remove one or more containers
137   rmi         Remove one or more images
138   run         Run a command in a new container
139   save        Save one or more images to a tar archive (streamed to STDOUT by default)
140   search      Search the Docker Hub for images
141   start       Start one or more stopped containers
142   stats       Display a live stream of container(s) resource usage statistics
143   stop        Stop one or more running containers
144   tag         Create a tag TARGET_IMAGE that refers to SOURCE_IMAGE
145   top         Display the running processes of a container
146   unpause     Unpause all processes within one or more containers
147   update      Update configuration of one or more containers
148   version     Show the Docker version information
149   wait        Block until one or more containers stop, then print their exit codes
150 
151 Run 'docker COMMAND --help' for more information on a command.
152 
153 C:\Users\bjp-dt-wuzh\Desktop\docker-17.03.0-ce\docker>
docker COMMAND --help
  • 安装Linux

　　接着在Docker里安装Linux（安装过程忽略，可以是RedHat、Debian、Ubuntu等）

B、安装Redis

  • 下载Redis

　　在Redis官网上下载最新版本的Redis，下载地址为http://www.redis.cn/download.html，下载稳定版

 

 

  •  安装Redis

在Linux环境中解压Redis安装包，然后执行Make命令对Redis解压后的文件进行编译。（Linux解压具体操作见https://www.cnblogs.com/wzh313/articles/12080651.html）

[root@dream ~]# mkdir /Redis //新建目录，并将安装包上传到该目录
[root@dream ~]# cd /Redis
[root@dream Redis]# tar -zxvf redis-5.0.5.tar.gz  ///解压文件
[root@dream Redis]# cd redis-5.0.5
[root@dream redis-5.0.5]# make //编译Redis源代码文件为可执行文件
[root@dream redis-5.0.5]# cd src
[root@dream src]# make install //安装Redis文件
[root@dream src]#

　　编译完成后，可以看到解压文件redis-3.2.9中会有src、conf等文件夹。同Windows下安装解压的文件一样，大部分安装包都会有对应的类文件、配置文件和一些命令文件。

　　编译成功后，进入src文件夹，执行make install进行Redis安装。

3、部署Redis

安装完成Redis后，需要进一步对相关内容进行部署配置，方便数据库的使用。先将配置文件和常用命令文件放到新指定的文件夹下，在Linux环境下执行如下命令：

[root@dream ~]mkdir -p /usr/local/redis/bin
[root@dream ~]mkdir -p /usr/local/redis/etc
[root@dream ~]mv /Redis/redis-5.0.5/redis.conf  /usr/local/redis/etc
[root@dream ~]cd /Redis/redis-5.0.5/src
[root@dream ~]mv mkreleasdhdr.sh redis-benchmark redis-check-aof redis-check- dump redis-cli redis-server /usr/local/redis/bin  (执行不了）
[root@dream ~]cd etc/
[root@dream ~]vi redis.conf  //修改conf配置

在conf文件里将daemonize属性改为yes（意味启动Linux时自动启动Redis）

[root@dream ~]redis-server /usr/local/redis/etc/redis.conf

　　Redis服务端启动界面如下：

 

　　Redis在服务器端安装完成并启动后，才可以在Linux下执行Redis-cli。

　　Redis-cli为客户端执行命令操作平台，是经常要用的命令操作平台，所以需要先了解该平台的基本用法。

4、Redis-cli

　　Redis-cli是Redis客户端命令操作的简易工具，类似MongoDB的Shell工具，为Redis提供两方面的命令操作支持功能。

　　一方面，提供Redis数据操作的基本功能，如实现对字符串、列表、集合、散列、有序集合、位图、超文本、地理空间索引等数据结构的建立和操作。

　　另一方面，提供Redis服务器运行情况，例如：

    • 连续远程监控Redis服务器运行情况；
    • 扫描Redis数据库，以发现特殊的巨大建（Very Large Keys）情况，巨大建存在，会影响Redis数据库的执行效率；
    • 基于模式匹配的键空间扫描；
    • 为信息订阅渠道提供发布、订阅操作终端；
    • 监控在Redis数据库中命令执行情况；
    • 检查不同应用方式下的Redis服务延迟情况；
    • 检查本计算机的调度延误情况；
    • 将远程数据库备份到本地；
    • 在客户端展现Redis从数据库的情况；
    • 模拟LRU工作负载，显示键热点击统计情况；
    • 实现对Lua的客户端操作。

　　A、Redis-cli两种使用方式

第一种为带参数方式，举例如下：

[root@dream ~]redis-cli -h 127.0.0.1 -p 6379 ping
PONG
以参数形式指出Redis-cli链接的Redis数据库，同时执行ping命令。
这里指向IP地址为127.0.0.1，端口为6379的本机Redis数据库。
显然，通过改变IP地址和端口号，Redis-cli也可以链接其他服务器上的Redis数据库。
ping的结果如果返回的是PONG，说明Redis-cli跟Redis数据库连接成功。当连接失败时，会返回以ERR开头的连接失败信息。

第二种为交互式，举例如下：　　

[root@dream ~]redis-cli //在Linux提示符下执行上述命令，进入Redis客户端交互操作界面：
redis 127.0.0.1:6379>

　　B、试用Redis命令

检查Redis-cli与Redis数据库连接状态，代码如下：

[root@dream ~]# redis-cli
127.0.0.1:6379> ping
PONG
127.0.0.1:6379>

　　注意：

    • Redis数据库对命令大小写不敏感
    • Redis数据库对变量大小写不敏感
    • 执行Redis-cli客户端工具钳，Redis数据库必须正常启动状态，否则无法执行数据库命令。

　　C、Redis存储模式

　　Redis数据库存储模式，基于键值（Key-Value）基本存储原理的基础上，进行细化分类，构建了具体自身特点的数结构类型。

    • 字符串String：
      • 可存储数字、文本、图片、视频等
      • 键名不要过长（会影响执行效率）
      • 值最大长度不超过512M
      • 键可以用IT:Bookid方式在呢个价键的提示信息
    • 列表List
      • 允许值重复出现
      • 由于列表采用链表技术实现，所有在链表头插入新字符串，速度非常快
      • 列表可以用于聊天记录、博客评论等无需调整字符串顺序，而又需要快速响应的应用场景
      • List的有序排序，指按照插入顺序排列，而不一定按照值本身的ASCII排序排列。
    • 集合Set（不重复且无序的字符串元素组成）
      • 集合里的所有字符串都是唯一的。这是与列表的区别之一；
      • 无序意味着所有字符串值的读写可以是任意的，不存在列表一定要从两头操作的问题，结合对字符串地址的统一管理原理，决定了字符串值之间是无序的，这是与列表的有一个区别。
      • 一个集合内的字符串不能重复
      • 一个集合内的字符串值不能排序
    • 散列Hash
      • 键内容的字符串不能过长，以免占用过多内存，影响执行效率
      • Hash更适合对小规模数据对象的存储及操作。
    • 有序集合Sorted Set
      • 有序结合由于采用自动值排序，所有在数据量相对多的情况下，在检索速度上会比散列快。
      • 有序集合支持大量的值更新，这在游戏修改积分等方面具有应用优势
      • 有序集合的键又叫成员（Member），值又叫分值（Score）
    • 位图Bitmap
    • HyperLogLog
    • 地理空间Geospatial

二、Redis命令

　　根据Redis官网提供的最新内容，Redis数据库命令分字符串String、列表List、集合Set、散列表Hashes、有序集合Sorted Sets、发布订阅Pub/Sub、连接Connection、Server脚本Scripting、集群Cluster，一共14大类200多种命令。

1、字符串命令

　　Redis字符串类似Java、C、C#、Python等语言里的字符串，但其所提供的功能远超过其他语言的字符串功能。所能存储的值类型包括了字符串、整数、浮点数、二进制数，并无需各种转换，可以直接对上述值进行各种命令操作。

　　目前对字符串进行操作的命令主要分布为字符串命令 和 位图命令。

A、字符串常用命令

　　基本字符串操作命令：：：

  • Set为一个键设置值（任意类型），如果已经存在，直接覆盖

语法：

Set key value [EX seconds] [PX milliseconds] [NX|XX]  
其中EX seconds设置指定到期时间（单位：秒）
PX milliseconds 设置指定到期时间（单位：毫秒）
NX 如果键不存在，仅建立键名
XX只有指定键名存在时才能设置对应的值

　　返回值：命令执行正常，返回OK；命令加了NX或XX参数，但是命令未执行成功返回nil

实例：

127.0.0.1:6379> set BookName "《C语言》" #设置键名为BookName，值为《C语言》的字符串
OK  #返回值
127.0.0.1:6379> set BookName0 "《D语言》" EX 1 #1秒后BookName过期
OK
  • MSet，对多个键设置值（任意类型），若已经存在，直接覆盖，操作过程是排它锁隔离

语法：MSet key value [key value ……]

返回值：返回值总是OK，因为该命令不会失败。

实例：

127.0.0.1:6379> MSet BookName1 "《A语言》" BookName2 "《B语言》" #同时设置两个键-值对
OK  #返回值
  • MSetNX，对多个键设置值（任意类型），如果键已经在内存中存在，则执行失败。所执行的命令要么都成功、要么都失败。

语法：MSetNX key value [key value ……]

返回值：如果所有键都被设置值，则返回1；如果有键没有被设置值（至少一个键先前已经存在），则返回0

实例：

127.0.0.1:6379> MSetNX BookID1 1001 BookID2 1002 BookID3 1003
(integer) 1
127.0.0.1:6379> MSetNX BookID3 1003 BookID4 1004 BookID5 1005
(integer) 0  #BookID3 已经存在，故返回值为0，即该行命令全部没执行。
127.0.0.1:6379>
  • Get，获取一个键的字符串值，如果键不存在，返回nil；如果键不是字符串，返回错误信息，因为该命令只能处理String类型。

语法：Get key

返回值：返回指定键对应的值；键不存在时，返回nil

实例：

127.0.0.1:6379> set BookName "《C语言》"
OK
127.0.0.1:6379> get BookName
"\xa1\xb6C\xd3\xef\xd1\xd4\xa1\xb7"
127.0.0.1:6379> get BookID3
"1003"

若get命令得到结果为十六进制（一般在含有中文的情况下出现），可以通过启动Redis-cli时在气候面加--raw参数来解决。

[root@dream ~]# redis-cli --raw
127.0.0.1:6379> get BookName
《C语言》
127.0.0.1:6379>
  • Mget，获取所有指定键的字符串，与Get的区别是可以同时指定多个键，并可以同时获取多个字符串的值

语法：mget key [key ……]

返回值：返回所有指定的键对应的值，用列表形式显示，对于不是String值或者不存在的键，都返回nil，所以该命令不会返回执行失败的信息

实例：

127.0.0.1:6379> mget BookName1 BookName2 BookName3  #同时获取3个字符串键的值
《A语言》
《B语言》
 nil   #第1/2个字符串值显示成功，第3个返回nil
  • Del，删除指定键的值（任意类型），允许一次删除多个

语法：Del key [key ……]

返回值：被删除字符串的个数

实例：

127.0.0.1:6379> set FirstName "Tomcat1"
OK
127.0.0.1:6379> set SecondName "Tomcat2"
OK
127.0.0.1:6379> get FirstName
Tomcat1
127.0.0.1:6379> get SecondName
Tomcat2
127.0.0.1:6379> del FirstName SecondName #一次性删除2个
2   #返回值为2，表示删除了2个值
127.0.0.1:6379> get secondName  #返回值为nil，以为这该字符串为空

127.0.0.1:6379>

　　Del还可以删除其他类型的数据结构，例如列表、集合、散列等。

  • StrLen，获取指定键的值为字符串的长度，如果是非字符串，返回错误信息

语法：StrLen key

返回值：返回字符串长度；如果值为非字符串，则返回错误信息；如果键不存在；则返回0

实例：

127.0.0.1:6379> set Myname "张三"
OK
127.0.0.1:6379> strlen Myname  #一个汉字2个字节
4
127.0.0.1:6379> strlen sky #不存在，返回0
0
127.0.0.1:6379>

 

　　修改字符串操作命令：：：

  • Append,追加字符串。

语法：Append key value

返回值：增加字符串后，整个新字符串的长度

实例：

127.0.0.1:6379> get AddTail //返回nil，说明键名为AddTail的字符串不存在

127.0.0.1:6379> append AddTail "A"  //建立1个字节长度的新字符串
1
127.0.0.1:6379> append AddTail " dog! "  //新字符串长度为6个字节
7
127.0.0.1:6379> get AddTail
A dog! 
127.0.0.1:6379>

　　增加固定长度的字符串速度最快。

  • GetRange，得到指定范围内的字符串的字子符串。

语法：GetRange key start end，其中start为字符串开始位置，end为字符串结束位置，开始位置从0开始，依此类推。当开始、结束位置超出字符串的范围时，该命令会自动把结果控制在字符串长度范围之内。开始、结束位置可以用负数表示，-1表示最后一个位置，-2表示倒数第二个位置。

返回值：返回指定范围的子字符串

实例：

127.0.0.1:6379> set context "This a white dog!"
OK
127.0.0.1:6379> GetRange context 0 3 //从第1到第4个
This
127.0.0.1:6379> GetRange context -4 -2 //从倒数第4到倒数第2
dog
127.0.0.1:6379> GetRange context 13 50 //结束位置超过字符串长度
dog!
127.0.0.1:6379> GetRange context 0 -1 //结束位置用-1比较方便，无需一个个数字节或用strLen获取长度
This a white dog!
127.0.0.1:6379>

　　Redis 2.0版之前截取字符串子串使用的命令是SubStr，后面的版本命令改成GetRange

  • GetSet，得到指定字符串键的旧值，然后为键设置新值。

语法：GetSet key value

返回值：返回之前的旧值；如果指定的键不存在，则返回nil

实例：

127.0.0.1:6379> set counter "1" //值一定是字符串型的
OK
127.0.0.1:6379> GetSet counter "0" //给counter设置0，并返回旧值“1”
1
127.0.0.1:6379> get counter
0
127.0.0.1:6379>

　　GetSet主要应用场景为实现支持重置的计数功能，可与Incr命令配合使用。

  • SetRange，替换指定键字符串的一部分。

语法：SetRange key offset value，offset为字符串需要修改的开始位置，value为新的子串值。如果offset位置超过了指定字符串的长度，则超出部分补“0”。所有该命令可以确保在指定位置设置新的字符串值。

返回值：该命令修改后的新的字符串长度

实例：

[root@dream ~]# redis-cli --raw
127.0.0.1:6379> set title "I like dogs."
OK
127.0.0.1:6379> SetRange title 7 "cats."
12
127.0.0.1:6379> get title
I like cats.
127.0.0.1:6379>

补“0”的例子

127.0.0.1:6379> SetRange titles 4 "注意"
(integer) 8
127.0.0.1:6379> get titles
"\x00\x00\x00\x00 注意"
127.0.0.1:6379>

　　Redis把字符串的大小限制在512MB以内，所以offset不能超过536870911

　　当指定的键没有值的情况下，在指定位置设置新值，Redis需要立即分配内存，这可能会导致服务堵塞现象的出现。新建立值长度越大越需要消耗的时间越多，议案消耗时间在几百毫秒到几毫秒之间。

 

　　修改数字值操作命令：：：

　　Redis为字符串作为数字的数据提供了专门的修改命令。

  • Decr，对整数做原子减1操作

语法：Decr key，可以为指定字符串的键，该字符串必须为整型。如果key不存在，则会新建键，并设置对应的值为0.

返回值：返回减1后的数字，如果指定键的字符串存储的是非整数型数据，则该命令返回错误信息。

实例：

127.0.0.1:6379> set countLog "10"
OK
127.0.0.1:6379> Decr countLog  //值减1
(integer) 9
127.0.0.1:6379> Set countLog "10g" //非整型
OK
127.0.0.1:6379> Decr countLog
(error) ERR value is not an integer or out of range  //错误信息提示
127.0.0.1:6379>

Decr最大支持64位有符号的整型数字，Decr英文全称Decrease（减少）的缩写。

  • DecrBy，对整数做原子减指定数操作

语法：DecrBy key decrement，decrement为需要减少的整数数量，如果key不存在，则新建并赋值为0，与Decr的区别在于，Decr一次减1，DecrBy一次减指定数量。

返回值：返回减少数量后的是数字。如果指定键的字符串值 存储的是非整型数据，则该命令返回错误信息。

实例：

127.0.0.1:6379> set countLog "10"
OK
127.0.0.1:6379> DecrBy countLog 8 //一次性减8
(integer) 2
127.0.0.1:6379>
  • Incr，对整数做原子加1操作

语法：Incr key，键对应的值值必须Wie整型数字。

返回值：返回增1后的数字，如果指定的字符串值存储的事非整型数据，则该命令返回错误提示信息。

实例：

127.0.0.1:6379> Set countLog "10"
OK
127.0.0.1:6379> Incr countLog
(integer) 11
127.0.0.1:6379>

Incr命令最大支持64位有符号的整型数字，是Increase（增多）的缩写，常用语计数器、特定场景的限速器。

  • IncrBy，对整数做原子加指定数操作

语法：IncrBy key incrment

返回值：返回增加后的数字。如果key为非整型，则命令返回错误信息。

实例：

127.0.0.1:6379> Set countLog "10"
OK
127.0.0.1:6379> IncrBy countLog 2 //一次性增加2
(integer) 12
127.0.0.1:6379>
  • IncrByFloat，对浮点数做原子加指定数操作

语法：IncrByFloat key increment，键所对应的值必须是浮点数字，并存放于String中，increment为需要增加的浮点数。

返回值：返回增加后的浮点数值，若操作出错，则给出出错提示信息。

实例：

127.0.0.1:6379> Set countPrice 10.1
OK
127.0.0.1:6379> IncrByFloat countPrice 0.2 //一次性增加0.2
"10.3"
127.0.0.1:6379> Set countPrice 10.3e3 //可以用任意指数符号，这里e设置为10000.0
OK
127.0.0.1:6379> IncrByFloat countPrice 2.0e2 //新增值为200
"10500"   //最终结果值
127.0.0.1:6379>

　　

B、位图命令

  •  BitCount，统计字符串指定起止位置的值为“1”比特（Bit）的位数

语法：BitCount key [start end]，start为字符串开始字节下标位置（从0开始）、end为字符串结束下标位置 。-1表示最后一个字符。

返回值：返回指定范围的1Bit位的总数；如果指定的key不存在，，则返回0

实例：

127.0.0.1:6379> Set tkey "foods"
OK
127.0.0.1:6379> BitCount tkey 0 0
(integer) 4
127.0.0.1:6379>

Redis字符串所有的值最终是以二进制形式存储，若要直接通过命令存储二进制位的值，则需要使用SetBit

  • SetBit，设置或者清空指定位置的Bit值

语法：SetBit key offset value，offset为偏移量

返回值：返回在offset处的二进制的原先的Bit值

实例：

127.0.0.1:6379> Set MyName "somcat" //假设s输错了，要改为t
OK
127.0.0.1:6379> SetBit MyName 5 1 //偏移量为5的地方设置比特位为1
(integer) 0  //原先值为0
127.0.0.1:6379> SetBit MyName 6 0 //偏移量为6的地方设置比特位为0
(integer) 1 //原先值为1
127.0.0.1:6379> SetBit MyName 7 0 //偏移量为7的地方设置比特位为0
(integer) 1   //原先值为1
127.0.0.1:6379> Get MyName
"tomcat"
127.0.0.1:6379>  
  • GetBit，获取指定位置的Bit值

语法：GitBit key offset，offset超出部分用0Bit填充

返回值：返回在offset处Bit值；当key不存在时，认为是一个空字符串，返回0.

实例： 

127.0.0.1:6379> SetBit TestBit 7 1 //设置TestBit键是新的，新建该键，0到64Bit位都是0,7位为1
(integer) 0 //返回原先0
127.0.0.1:6379> GetBit TestBit 0 //偏移量为0处的比特值为0
(integer) 0 //返回0处比特值Wie0
127.0.0.1:6379> GetBit TestBit 7 //偏移量为7处的比特值为1
(integer) 1 //返回7处比特值为1
127.0.0.1:6379> GetBit TestBit 10 //偏移量为10处的比特值为0，超过原先的范围了。
(integer) 0 //返回10处比特值为0
127.0.0.1:6379>
  • Bitop，对一个或多个二进制位的字符串进行比特位运算操作

语法：Bitop operation destkey key [key ……]，operation为二进制比特位运算方式，这里可以指定为And（并）、Or（或）、Not（非）、Xor（异或）4种操作。运算结果保存到destkey。除了Not的键只能为一个外，其他操作允许多键。

返回值：返回保存到DestKey的字符串长度，与设置在Key中最长的字符串长度数相等。

实例：

127.0.0.1:6379> SetBit One 6 1
(integer) 0 //返回原先0，产生的One值为00000010
127.0.0.1:6379> Set Two "a" //a的二进制数位01100001
OK
127.0.0.1:6379> Bitop Or dest One Two //00000010 Or 01100001，结果为01100011
(integer) 1 //一个字符串c，其二进制ASCII码为01100011
127.0.0.1:6379> Get dest
"c"
127.0.0.1:6379>  
  • BitPos，获取字符串里第一个被设置为1Bit或0Bit的位置

语法：BitPos key bit [start] [end]

返回值：返回字符串里第一个1Bit或0Bit的位置数值。如果在空字符串里找比特值，则返回-1；

实例：

127.0.0.1:6379> Set testBit "\xff\x0f\x00" //以\x开头的为十六进制数，可以再ASCII表里对照
OK
127.0.0.1:6379> BitPos testBit 0
(integer) 8
127.0.0.1:6379> BitPos testBit 1 1 //查找第二个字节开始的第一个1Bit，第二字节为\x0f
(integer) 12
127.0.0.1:6379> BitPos testBit 1 2 //查找第三个字节开始的第一个1Bit,第三字节为\x00
(integer) -1  //找不到1Bit，返回-1
127.0.0.1:6379>
  • BitField，对指定字符串数据进行位数组寻址、位值自增自减等操作 

语法：BitField key [Gte type offset] [Set type offset value] [Incrby type offset increment] [Overflow wrap|sat|fail]

返回值：返回一个针对子命令给定位置的处理结果组成的数组，OverFlow子命令在响应消息中，不会统计结果的条数，返回nil

实例：无

 　　该命令的使用动机是使许多小证书存储来代替一个单一的大卫图（Large BitMap），这样可以提高内存的使用效率。这在实时分析领域非常有用。

2、列表命令

　　列表是一种可以记录重复字符串值、有序排列的数据存储结构。列表主要适应场景是无需次序调整的业务数据记录和读取，如记录用户在网页端浏览过程的网页信息、记录商品评论信息、传递聊天记录、记录任务队列等。

A、基本列表命令

  • LPush，从列表的左边插入一个或多个元素值

语法：LPush key value [value ……]

返回值：返回插入操作后列表的长度；若key对应的值不是列表，则返回一个错误提示信息。

实例： 

127.0.0.1:6379> LPush NewList "one" //先建空列表，再从左边插入第一个原始“one”
(integer) 1
127.0.0.1:6379> LPush NewList "two"
(integer) 2
127.0.0.1:6379> LPush NewList "tree"
(integer) 3
127.0.0.1:6379>
  • LRange，获取指定范围列表的元素值

语法：LRange key start stop

返回值：返回指定范围里的列表元素，当start大于列表的范围时，返回空列表信息

实例：

127.0.0.1:6379> LPush NewList "one" "two" "tree" //创建列表并赋值
(integer) 3
127.0.0.1:6379> 
127.0.0.1:6379> LRange NewList 0 -1 //返回第1个到最后1个
1) "tree"
2) "two"
3) "one"
127.0.0.1:6379> LRange NewList 0 0 //返回第1个
1) "tree"
127.0.0.1:6379> LRange NewList -2 -1 //返回最后两个
1) "two"  //倒数第2个
2) "one"  //倒数第1个
127.0.0.1:6379> LRange NewList 3 5 //开始值3大于0-2范围
(empty list or set)  //返回空列表提示
127.0.0.1:6379>
  • RPush，从列表的右边插入一个或多个元素值

语法：RPush key value [value ……]

返回值：返回插入操作后的列表长度；若key对应的值不是列表，则返回一个错误提示信息。

实例：

127.0.0.1:6379> RPush NewList1 "1" "2" "3"
(integer) 3
127.0.0.1:6379> LRange NewList1 0 -1
1) "1"
2) "2"
3) "3"
127.0.0.1:6379>
  • LPop，从列表的左边读出并移除一个元素值

语法：LPop key

返回值：返回列表左边第一个元素值；当key不存在时，返回nil

实例：

127.0.0.1:6379> RPush NewList1 "1" "2" "3" //新建列表并赋值
(integer) 3
127.0.0.1:6379> LPop NewList1  //获取列表第1个值
"1"
127.0.0.1:6379> LRange NewList1 0 -1 //列表第1个值被移除后，只剩下2个值
1) "2"
2) "3"
127.0.0.1:6379>
  • RPop，从列表的右边读出并移除一个元素值

语法：RPop key

返回值：返回列表右边最后一个元素值；当key不存在时，返回nil

实例：

127.0.0.1:6379> RPush NewList2 "1" "2" "3"
(integer) 3
127.0.0.1:6379> RPop NewList2  //从右边获取一个值并删除
"3"
127.0.0.1:6379> LRange NewList2 0 -1
1) "1"
2) "2"
127.0.0.1:6379>
  • LRem，从列表里删除指定元素

语法：LRem key count value，count为列表元素下标位置count>0从头到尾删除值value的元素；count<=从尾到头删除值为value的元素；count=0删除所有值为value的元素

返回值：返回被删除的元素个数；key不存在时，返回0

实例：

127.0.0.1:6379> RPush TestList1 "a" "a" "b" "c" "a"
(integer) 5
127.0.0.1:6379> Lrem TestList1 1 "a" //移除左边第1个a
(integer) 1
127.0.0.1:6379> LRange TestList1 0 -1
1) "a"
2) "b"
3) "c"
4) "a"
127.0.0.1:6379> Lrem TestList1 -1 "a" //移除右边第1个a
(integer) 1
127.0.0.1:6379> LRange TestList1 0 -1
1) "a"
2) "b"
3) "c"
127.0.0.1:6379>
  • LIndex，通过指定列表下标，获取一个元素值

语法：LIndex key index

返回值：返回index下标对应的列表元素值；当key指定的不是列表时，返回错误信息；当index超出列表下标范围时，返回nil

实例：

127.0.0.1:6379> RPush TestIndex "a" "b" "c" "d" "e"
(integer) 5
127.0.0.1:6379> LIndex TestIndex 0
"a"
127.0.0.1:6379> LIndex TestIndex -1
"e"
127.0.0.1:6379> LIndex TestIndex 2
"c"
127.0.0.1:6379> LIndex TestIndex 5
(nil)
127.0.0.1:6379> LRange TestIndex 0 -1
1) "a"
2) "b"
3) "c"
4) "d"
5) "e"
127.0.0.1:6379>
  • LLen，获取指定列表的元素个数

语法：LLen key

返回值：返回指定列表的长度（元素个数）；key不存在时，返回0；当key指定不是列表时，返回错误信息。

实例：

127.0.0.1:6379> RPush names "TomCat1"
(integer) 1
127.0.0.1:6379> LLen names
(integer) 1
127.0.0.1:6379> RPush names "TomCat2"
(integer) 2
127.0.0.1:6379> LLen names
(integer) 2
127.0.0.1:6379>
  • LSet，设置列表指定位置的元素值

语法：LSet key index value

返回值：设置成功，返回OK；当index超出范围时，返回一个错误信息。

实例：

127.0.0.1:6379> RPush names1 "TomCat1" "tomCat1"
(integer) 2
127.0.0.1:6379> LSet names1 1 "tomCat2"
OK
127.0.0.1:6379> LRange names1 0 -1
1) "TomCat1"
2) "tomCat2"
127.0.0.1:6379>
  • LTrim，对指定列表范围的元素进行修剪

语法：LTrim key start stop

返回值：修剪成功，返回OK

实例： 

127.0.0.1:6379> RPush TestTrim "One" "Two" "Three"
(integer) 3
127.0.0.1:6379> LTrim TestTrim 1 -1 //从第2个到最后一个，把第1个排除了。
OK
127.0.0.1:6379> LRange TestTrim 0 -1
1) "Two"
2) "Three"
127.0.0.1:6379>

 

B、其他列表操作命令

  • LInsert，在指定位置处插入一个新元素

语法：LInsert key Before|After Pivot value，Before和After二选一，Before表示在指定元素之前插入；After表示在指定元素之后插入；Pivot为列表里存在的指定一个元素值。当key不存在时，该命令不执行任何操作。

返回值：插入成功，返回操作后的列表长度；当指定的pivot值不存在时，返回-1；当指定的key不为列表时，返回出错信息。

实例：

127.0.0.1:6379> RPush TestInsert "One" "Two" "four"
(integer) 3
127.0.0.1:6379> LInsert TestInsert Before "four" "three" //在four之前插入three
(integer) 4
127.0.0.1:6379> LRange TestInsert 0 -1
1) "One"
2) "Two"
3) "three"
4) "four"
127.0.0.1:6379>
  • LPushX，只有列表存在的前提下，从左边插入一个元素

语法：LPushX key value，value为需要插入列表左边的值，只有key存在时才执行；key不存在时，不执行，这是与LPush命令的唯一区别。

返回值：返回操作后的列表的长度；若key不存在，则返回0；若key对应的值不是列表，则返回一个错误提示信息。

实例：

127.0.0.1:6379> LPushX testPushX "TOM" //testPushX不存在
(integer) 0
127.0.0.1:6379> LRange testPushX 0 -1
(empty list or set)
127.0.0.1:6379>
  • RPopLPush，删除左边列表中的最后一个元素，并将其追加到另外一个列表头部

语法：RPopLPush source destination，source、destination都是列表名，从source列表获取并删除右边最后一个元素，把获取的元素插入到destination列表左边的第一个位置。

返回值：返回移动的那个元素值；如果source不存在，则返回nil，且不会执行任何操作。

实例：

127.0.0.1:6379> RPush RoundList "one" "two" "three"
(integer) 3
127.0.0.1:6379> RPopLPush RoundList DList //把three值转到DList列表，该列表允许为新建
"three"
127.0.0.1:6379> LRange RoundList 0 -1
1) "one"
2) "two"
127.0.0.1:6379> LRange DList 0 -1
1) "three"
127.0.0.1:6379>

　　使用场景说明：

    • 可以利用RPopLPush命令，实现对消息队列的轮询
    • 在source和destination列表存储相同内容的情况下，通过该命令可以实现客户端一个接一个地循环访问，而不像LRange那样需要把列表里的所有元素传递到客户端，再进行值比较获取操作。
  • RPushX，只有列表存在的前提下，从右边插入一个元素

语法：RPushX key value

返回值：返回命令执行后的列表的长度。

实例：

127.0.0.1:6379> RPushX TestNewList "one" "two" "three"
(integer) 0
127.0.0.1:6379> LRange TestNewList 0 -1
(empty list or set)
127.0.0.1:6379>
  • BLPop，带阻塞式功能的LPop命令

语法：BLPop key [kyey ……] timeout，Key为指定列表名，可以是多个。timeout为指定阻塞的最大秒数（整型值）；当timeout为0时，标识阻塞时间无限制。

阻塞模式：当BLPop指定的列表无元素可供读取时，则客户端连接进入阻塞模式，一直到有新的值通过LPush或RPush被插入指定的列表时，阻塞模式接触，成对读取列表名和左边第一个元素值到客户端，并把该元素从列表中删除。

返回值：当读取的列表没有值时，返回nil，并且timeout过期；当读取列表元素存在时，会返回成对的值（列表名和该列表左边的第一个元素值）

实例：

127.0.0.1:6379> Del B1 B2  //确保B1、B2为空值
(integer) 0
127.0.0.1:6379> RPush B1 "a" "b" "c"  
(integer) 3
127.0.0.1:6379> BLPop B1 B2 0  //0为过期时间无限制
1) "B1"
2) "a"
127.0.0.1:6379> LRange B1 0 -1  //a被读取后，在列表中被删除了
1) "b"
2) "c"
127.0.0.1:6379>
  • BRPop，带阻塞式功能的RPop命令

语法：BRPop key [key ……] timeout，使用方法同BLPop

返回值：返回值通BLPop命令，唯一的区别是返回的元素是列表的右边最后一个。

实例：略

  • BRPopLPush，带阻塞式功能的RPopLpush命令

语法：BRPopLPush source destination timeout，Source和Destination使用方法同RPopLPush命令参数，Timeout使用方法同BLPop对应参数。

返回值：移动的元素值；如果source超时限，返回多批量的nil

实例：略 

3、集合命令

　　集合和列表的主要区别是集合元素无序且必须唯一，集合适用的场景，如对文章进行分类、存储书签等。

　　集合的命令都以S开头，代表Set。

 

A、基本集合操作命令

  • SAdd，添加一个或多个元素到集合中

语法：SAdd key member [member ……]

返回值：返回成功添加到集合里的元素数量；如果key指定的为非集合，则返回错误信息。

实例：

127.0.0.1:6379> SAdd TitleSet "Group:a1" //假设Group为文章分类，a1代表第1个文章名称。
(integer) 1  //新加入1个元素
127.0.0.1:6379> SAdd TitleSet "Group:b2" //新加入分Group里的第2篇文章b2
(integer) 1
127.0.0.1:6379> SAdd TitleSet "Group:b2" //b2文章重复加入，该命令给予忽略
(integer) 0
127.0.0.1:6379>
  • SMembers返回集合的所有元素

语法：SMembers key

返回值：返回集合中的所有元素列表

实例：

127.0.0.1:6379> SMembers TitleSet
1) "Group:a1"
2) "Group:b2"
127.0.0.1:6379>
  • SRem删除集合中指定的元素

语法：SRem key member [member ……]

返回值：返回集合中移除元素个数，不包括被忽略的元素；如果key不存在，则返回0；如果key指定的不是集合，则返回错误信息。

实例：

127.0.0.1:6379> SAdd TestSet "one" "two" "three"
(integer) 3
127.0.0.1:6379> Srem TestSet "one"
(integer) 1
127.0.0.1:6379> SMembers TestSet
1) "two"
2) "three"
127.0.0.1:6379>
  • SCard返回集合元素的数量

语法：SCard key

返回值：返回集合存储的元素数量；如果key不存在，则返回0

实例：

127.0.0.1:6379> SMembers TestSet
1) "two"
2) "three"
127.0.0.1:6379> SCard TestSet
(integer) 2
127.0.0.1:6379> SCard TestSet1  //集合不存在
(integer) 0
127.0.0.1:6379>
  • SRandMember从集合中随机返回一个或多个元素

语法：SRandMember key [count]

返回值：不使用count的情况下，随机返回集合中一个元素，如果count大于0,且小于指定集合元素的个数，则返回count个的元素；如果count大于指定集合元素的个数，则返回整个集合。如果count小于0且绝对值大于集合元素个数，则返回值会出现一个元出现多次的情况。如果key不存在，返回nil

实例：

127.0.0.1:6379> SAdd testRandSet "1" "2" "3" "4"
(integer) 4
127.0.0.1:6379> SRandMember testRandSet
"3"
127.0.0.1:6379> SRandMember testRandSet 2 //随机返回2个元素
1) "1"
2) "4"
127.0.0.1:6379> SRandMember testRandSet -5
1) "1"
2) "3"
3) "4"
4) "1"
5) "2"
127.0.0.1:6379>
  • SMove把一个集合的元素移动到另一个集合中

语法：SMove source destination member

返回值：source为移除元素集合，destinationWie移入元素集合，member为移入元素。

实例：

127.0.0.1:6379> SAdd testS "1" "2"
(integer) 2
127.0.0.1:6379> SAdd testD "3" "4"
(integer) 2
127.0.0.1:6379> SMove testS testD "1"
(integer) 1
127.0.0.1:6379> SMembers testD
1) "1"
2) "3"
3) "4"
127.0.0.1:6379> SMembers testS
1) "2"
127.0.0.1:6379>
  • SPop从集合中随机返回（并删除）一个或多个元素

语法：SPop key [count]

返回值：返回移除的元素；key不存在时返回nil

实例：

127.0.0.1:6379> SAdd testP "1" "2" "3"
(integer) 3
127.0.0.1:6379> SPop testP //返回随机一个元素并删除
"2"
127.0.0.1:6379> SMembers testP
1) "1"
2) "3"
127.0.0.1:6379>
  • SIsMember集合成员是否存在判断

语法：SIsMember key member

返回值：如果member在集合内，返回1；否则返回0

实例：

127.0.0.1:6379> SAdd testIs "1" "2" "3"
(integer) 3
127.0.0.1:6379> SIsMember testIs "2" //2在集合内
(integer) 1
127.0.0.1:6379> SIsMember testIs "4" //4不在集合内
(integer) 0
127.0.0.1:6379>
  • SScan增量迭代式返回集合中的元素

语法：SSCan key cursor [Match pattern] COUNT count]

返回值：分批次返回，返回的是两个数组列表，第一个数组元素是用于进行下一次迭代的新游标，而第二个数组元素则是一个数组，这个数组中包含了所有被迭代的而原始（一次最多几十个元素，可以把迭代一次看作是读取其中一部分元素）

实例：

127.0.0.1:6379> SAdd testScan "1" "2" "3" "Banana" "Bag" "Bear"
(integer) 6
127.0.0.1:6379> SSCan testScan 0 MATCH B*
1) "0"  //下次迭代游标值，0值代表迭代结束
2) 1) "Bag"
   2) "Bear"
   3) "Banana"  //由于testScan是最小集合，所以一次性迭代全部读取
127.0.0.1:6379>

B、集合并、交、差运算操作命令

  • SUnion集合并运算

语法：SUnion key [key ……]

返回值：返回并运算后所有元素列表

实例：

127.0.0.1:6379> SAdd Set1 "1" "2" "3" "Banana"
(integer) 4
127.0.0.1:6379>  SAdd Set2 "Banana" "Bag" "Bear"
(integer) 3
127.0.0.1:6379> SUnion Set1 Set2 //这里把Banana去掉，不能，并的结果成员不能重复
1) "2"
2) "Banana"
3) "3"
4) "1"
5) "Bag"
6) "Bear"
127.0.0.1:6379>
  • SUnionStore带存储功能集合并运算

语法：SUnionStore destination key [key ……]，destination为存储并运算的结果，也就是生成一个并后的新集合，如果destination存在，会被重写。

返回值：返回并运算后的新的集合中的元素个数

实例：

127.0.0.1:6379> Del Set1 Set2
(integer) 2
127.0.0.1:6379> SAdd Set1 "1" "2" "3" "Banana"
(integer) 4
127.0.0.1:6379>  SAdd Set2 "Banana" "Bag" "Bear"
(integer) 3
127.0.0.1:6379> SUnionStore SetD Set1 Set2
(integer) 6
127.0.0.1:6379> SMembers SetD
1) "2"
2) "Banana"
3) "3"
4) "1"
5) "Bag"
6) "Bear"
127.0.0.1:6379>
  • SInter集合交运算

语法：SInter key [key……]

返回值：返回所有集合的交运算，结果的成员列表

实例：

127.0.0.1:6379> Del Set1 Set2
(integer) 2
127.0.0.1:6379> SAdd Set1 "1" "2" "3" "Banana"
(integer) 4
127.0.0.1:6379>  SAdd Set2 "Banana" "Bag" "Bear"
(integer) 3
127.0.0.1:6379> SAdd Set3 "Banana" "1" "0"
(integer) 3
127.0.0.1:6379> SInter Set1 Set2 Set3
1) "Banana"
127.0.0.1:6379>
  • SInterStore带存储功能集合交运算

语法：SInterStore destination key [key……]，destination为交运算后存储结果的新集合，如果destination存在，则会被重写。

返回值：返回结果集合中成员的个数

实例：

127.0.0.1:6379> Del Set1 Set2 Set3
(integer) 3
127.0.0.1:6379> SAdd Set1 "1" "2" "3" "Banana"
(integer) 4
127.0.0.1:6379> SAdd Set2 "Banana" "Bag" "Bear"
(integer) 3
127.0.0.1:6379> SAdd Set3 "Banana" "1" "0"
(integer) 3
127.0.0.1:6379> SInterStore SetD Set1 Set2 Set3
(integer) 1
127.0.0.1:6379> SMembers SetD
1) "Banana"
127.0.0.1:6379>
  • SDiff集合差运算

语法：SDiff key [key……]

返回值：返回一个与给定集合的差集的元素。

实例：

127.0.0.1:6379> Del Set1 Set2
(integer) 2
127.0.0.1:6379> SAdd Set1 "1" "2" "3" "Banana"
(integer) 4
127.0.0.1:6379> SAdd Set2 "Banana" "Bag" "Bear"
(integer) 3
127.0.0.1:6379> Sdiff Set1 Set2
1) "1"
2) "2"
3) "3"
127.0.0.1:6379>
  • SDiffStore带存储功能集合差运算

语法：SDiffStore destination key [key……]

返回值：返回差运算结果集的元素个数

实例：

127.0.0.1:6379> Del Set1 Set2 SetD
(integer) 3
127.0.0.1:6379> SAdd Set1 "1" "2" "3" "Banana"
(integer) 4
127.0.0.1:6379> SAdd Set2 "Banana" "Bag" "Bear"
(integer) 3
127.0.0.1:6379> SDiffStore SetD Set1 Set2
(integer) 3
127.0.0.1:6379> SMembers SetD
1) "1"
2) "2"
3) "3"
127.0.0.1:6379>

 

4、散列表命令

　　类似文档存储结果，可以把Redis的散列表看作是基于内存的文档数据存储结构。它比MongoDB的处理速度要快，处理功能强大，但是它的持久性没有MongoDB可靠。

　　散列表的最大特点：1）键值对是一一对应的映射关系；2）键必须是唯一的；3）散列表的键是无序的。

　　H为Hash缩写，M为More缩写。

A、基本散列表操作命令

  • HSet，给指定的散列表插入一个键值对

语法：HSet key field value，field为需要插入的键名，键对应的value为需要插入的值，如果key不存在，则创建新的散列表；当field存在时，其值被重写

返回值：如果是新插入一个键值对，返回1；如果是修改键的值，返回0；如果key不是散列表，返回错误信息。

实例：

127.0.0.1:6379> HSet H1 name "Cat1" //H1为新建的散列表名，name为键名，Cat1位键对应的值
(integer) 1
127.0.0.1:6379>
  • HGet，返回指定散列表指定键的一个值

语法：HGet key field，key为散列表名，field为散列表里指定的键名

返回值：返回指定散列表里指定键的一个值；若指定的散列表或指定的键不存在时，返回nil

实例：

127.0.0.1:6379> HGet H1 name
"Cat1"
127.0.0.1:6379>
  • HMSet，给指定的散列表插入一个或多个键值对

语法：HMSet key field value [field value ……]

返回值：命令执行成功返回OK，指定的key不是散列时，返回出错信息。

实例：

127.0.0.1:6379> Del H1
(integer) 1
127.0.0.1:6379> HMSet H1 name "Cat1" sex "男"
OK
127.0.0.1:6379>
  • HMGet，返回指定散列表指定键的值（允许多键值对操作）

语法：HMGet key field [field ……]

返回值返回指定键对应的值的列表；若指定的键不存在，或key指定的散列表不存在，则返回nil；若指定的key为非散列表，则返回出错信息。

实例：

127.0.0.1:6379> HMGet H1 name sex address
Cat1
男
(nil)
127.0.0.1:6379>
  • HGetAll，返回指定散列表的所有键值对

语法：HGetAll key

返回值：返回指定散列的所有键值对的列表；若key指定的散列不存在时，则返回nil；若指定的key为非散列表，则返回出错信息。

实例：

127.0.0.1:6379> HGetAll H1
name
Cat1
sex
男
127.0.0.1:6379>

　　HGetAll命令返回的内容大小将未散列表本身大小2倍。连键带值一起返回。

  • HExists，返回指定散列表的指定键是否存在的标志（1或0）

语法：HExists key field

返回值：存在返回1，不存在返回0，不是散列表返回错误信息。

实例：

127.0.0.1:6379> HExists H1 name
1
127.0.0.1:6379> HExists H1 phone
0
127.0.0.1:6379>
  • HDel，删除散列表中指定的键值对

语法：HDel key field [field ……]

返回值：返回从散列表中删除的键值队个数，不包括不存在的键值对数；若指定的key不是散列表或不存在，则返回0

实例：

127.0.0.1:6379> HMSet H2 BookID "200101" Bookname "Python" Press "清华出版社"
OK
127.0.0.1:6379> HDel H2 BookId //区分大小写，返回删除0个值
0
127.0.0.1:6379> HDel H2 BookID
1
127.0.0.1:6379> HMGet H2 Bookname Press
Python
清华出版社
127.0.0.1:6379> HDel H2 Bookname Press //删除2个值
2
127.0.0.1:6379>

B、其他散列表操作命令

  • HLen，返回散列表包含的键值对数量

语法：HLen key

返回值：返回散列表中键值对的数量；当散列表不存在时，返回0；当指定的不是散列表时，返回出错信息提示。

实例：

127.0.0.1:6379> HMSet H3 title "新闻头条" id "1010"
OK
127.0.0.1:6379> HLen H3
2
127.0.0.1:6379>
  • HSetNX，仅对指定散列表的新建设置值

语法：HSetNX key field value

返回值：如果新建键值对成功，则返回1；如果已经存在该键，则返回0；当指定的不是散列表时，返回错误信息。

实例：

127.0.0.1:6379> HSetNX H4 Address "中国上海"
1
127.0.0.1:6379> HSetNX H4 Address "中国天津"
0
127.0.0.1:6379> HGet H4 Address
中国上海
127.0.0.1:6379>
  • HStrLen，返回散列表指定键的值的字符串长度

语法：HStrLen key field，field为指定的键名

返回值：返回散列表指定键的值的字符串长度，若散列表或键不存在，则返回0；若指定的不是散列表，则返回错误信息

实例：

127.0.0.1:6379> HSetNX H4 Address "中国上海"
1
127.0.0.1:6379> HStrLen H4 Address
8
127.0.0.1:6379>
  • HVals，返回指定散列表中所有键的值

语法：HVals key

返回值：返回指定散列表里所有键值的列表；当key指定的散列表不存在时，返回空列表；当指定的不是散列表时，返回出错信息。

实例：

127.0.0.1:6379> HMSet H5 first "Li" next "ming"
OK
127.0.0.1:6379> HVals H5
Li
ming
127.0.0.1:6379>
  • HIncrBy，对散列表指定键的整型值进行增量操作

语法：HIncrBy key field increment，field为指定的键名，increment为增量。若指定的散列表或键不存在，则先建立散列表或键，并给值赋予0，然后做增量动作。

返回值：返回增量操作后该键的新值

实例：

127.0.0.1:6379> HSet Goods amount 1
(integer) 1
127.0.0.1:6379> HIncrBy Goods amount 5
(integer) 6
127.0.0.1:6379> HIncrBy Goods amount -1
(integer) 5
127.0.0.1:6379> HIncrBy Goods price 10  //新增加一个键值对，初始值为0
(integer) 10
127.0.0.1:6379>
  • HIncrByFloat，对散列表指定键的浮点型值就行增量操作

语法：HIncrByFloat key field increment

返回值：返回键指定的值增量后的结果数；若指定的不是散列表或键对应的值不能解析为浮点数时，则返回出错信息。

实例：

127.0.0.1:6379> HSet H6 price "10.5"
(integer) 1
127.0.0.1:6379> HIncrByFloat H6 price "0.2"
"10.7"
127.0.0.1:6379> HIncrByFloat H6 amount "0.8"
"0.8"
127.0.0.1:6379>
  • HKeys，返回指定散列表的所有键名

语法：HKeys key

返回值：返回指定散列表的所有键名列表；当指定的散列表不存在时，返回空列表；当指定的不是散列表时，返回出错信息提示。

实例：

127.0.0.1:6379> HKeys H6
1) "price"
2) "amount"
127.0.0.1:6379>
  • HScan，增量迭代式返回散列表中的指定键值对

语法：HScan key cursor [MATCH pattern] [COUNT count]

返回值：分次返回指定符合条件的散列表里的键值对

实例：略 

5、有序集合命令

　　有序集合与散列数据存储结构类似，都采用一对一影射关系的键值对实现对数据的管理。不同之处是有序集合键（又叫成员Member）所对应的值只能是浮点数，因此有序集合的键所对应的值又叫分值（Score），而且对该值按照由低到高顺序进行排序。

特点：1）有序集合的键必须唯一，值允许相同；2）有序集合的分值，默认排序方式是顺序排序方式，也就是从低分值往高分值递增排序；3）第一排序条件是分值，第二排序条件是键值。

A、基本的有序集合操作命令

  • ZAdd，有序集合增加键值对

语法：ZAdd key [NX|XX] [CH] [INCR] score  member [score member ……]

返回值：在没有附件可选参数的情况下，该命令只返回新增加的键值对数量；在加CH参数情况下，返回所有变化的键值对数量。

实例：

127.0.0.1:6379> ZAdd SSet1 1 "Game1" 1 "Game2" 2 "Game3" 3 "Game4"
(integer) 4   //新建一个包含4个键值对的有序集合。
127.0.0.1:6379>
  • ZRange，返回指定范围有序集合的键或键值对

语法：ZRange key start stop [WITHSCORES]

返回值：返回指定范围的键列表；如果start超出有序集合的最大下标数或start>stop，则返回一个空列表；选择WITHSCORES选项，则返回键值对列表。

实例：

127.0.0.1:6379> ZRange SSet1 0 -1
1) "Game1"
2) "Game2"
3) "Game3"
4) "Game4"
127.0.0.1:6379>
  • ZCount，返回有序集合指定值返回的个数

语法：ZCount key min max，用(表示小于符号，)表示大于符号，max和min可以 是inf，-inf表示无线小，inf表示无限大

返回值：返回指定分值范围的键值对个数，当指定的key为非有序集合时，返回出错信息。

实例：

127.0.0.1:6379> ZCount SSet1 -inf +inf
(integer) 4
127.0.0.1:6379> ZCount SSet1 (1 3    //1<Score<=3
(integer) 2
127.0.0.1:6379>
  • ZRem，删除有序集合键值对

语法：ZRem key member [member……],member为要删除的键名，允许多键

返回值：返回删除的键值对个数（不包括不存在的member），当指定的key为非有序集合时，返回出错信息

实例：

127.0.0.1:6379> ZRem SSet1 "Game1" "Game4"
(integer) 2
127.0.0.1:6379> ZRange SSet1 0 -1 withScores
1) "Game2"
2) "1"
3) "Game3"
4) "2"
127.0.0.1:6379>
  • ZCard，返回有序集合键值对个数　　

语法：ZCard key

返回值：返回有序集合的键值对个数

实例：

127.0.0.1:6379> ZCard SSet1
(integer) 2
127.0.0.1:6379> ZCard SSet2  //有序集合不存在
(integer) 0
127.0.0.1:6379>
  • ZIncrBy，对有序集合指定键的值进行增量操作

语法：ZIncrBy key increment member

返回值：返回指定member对应做增量操作后的新值；若key指定的为非有序集合，则返回出错信息

实例：

127.0.0.1:6379> ZIncrBy SSet1 2 "Games"
"2"
127.0.0.1:6379> ZRange SSet1 0 -1 WithScores
1) "Game2"
2) "1"
3) "Game3"
4) "2"
5) "Games"
6) "2"
127.0.0.1:6379>
  • ZLexCount，返回有序集合指定键返回的个数

语法：ZLexCount key min max，采用min和max参数时，必须以"[","("开头，或“-”，“+”代表。其中[标识闭区间，(表示开区间，-标识二进制值最小的键，+标识二进制值最大的键，“-”和“+”一起使用，就是统计有序集合的全部键值对

返回值：返回有序集合min和max之间的键值对数量，min和max位置放反了，则返回0；若key为非有序集合，则返回出错信息。

实例：

127.0.0.1:6379> ZAdd ZSet1 1 "a" 2 "b" 3 "c" 4 "d" 5 "e" 6 "f"
(integer) 6
127.0.0.1:6379> ZLexCount ZSet1
(error) ERR wrong number of arguments for 'zlexcount' command
127.0.0.1:6379> ZLexCount ZSet1 [b [d //b<<Member<<d
(integer) 3
127.0.0.1:6379>
  • ZScore，返回有序集合指定键对应的值

语法：ZCores key member

返回值：返回member对应的值；若指定的key或member不存在，则犯规nil

实例：

127.0.0.1:6379> ZScore ZSet1 "c"
"3"
127.0.0.1:6379>
  • ZRank，返回有序集合指定值排名位号

语法：ZRank key member

返回值：返回指定member在有序集合中的排名数（根据分值排序），若指定的member不存在，则返回nil

实例： 

127.0.0.1:6379> ZRank ZSet1 "c"
(integer) 2
127.0.0.1:6379> ZRank ZSet1 "g"
(nil)
127.0.0.1:6379>

B、其他有序集合操作命令

　　Rev是Reverse Order的缩略方式，中文为相反的排序。

  • ZUnionStore，带存储功能的多有序集合并运算

语法：ZUnionStore destination numkeys key [key ……] [WEIGHTS weights] [SNUM|MIN|MAX]，destination为存放多个有序集合并运算结果的有序集合，若destination已经存在，则覆盖原先内容；numkeys为参与并运算的有序集合的个数；key为参与运算的有序集合，key数量要与numkeys保持一致；可选参数WEIGHTS，可以为每个key指定一个乘法因子，用于该命令在进行聚合运算之前，每个key里面参与运算的score先跟该因子相乘，如果没有指定该项，则默认值为1。

　　SUM：把确定的member的所有score进行累加，作为某个member的新分值

　　MIN：把确定member的所有score取最小值，作为某个member的新分值

　　MAX：把确定member的所有score取最大值，作为某个member的新分值

返回值：返回并运算结果有序集合destination中键值对个数。

实例：

127.0.0.1:6379> ZAdd ZSet2 1 "Book1" 2 "Book2" 3 "Book3"
(integer) 3
127.0.0.1:6379> ZAdd ZSet3 2 "Book1" 2 "Book2" 4 "Book4"
(integer) 3
127.0.0.1:6379> ZUnionStore ZEnd0 2 ZSet2 ZSet3 WEIGHTS 1 2  //默认SUM
(integer) 4
127.0.0.1:6379> ZRange ZEnd0 0 -1 WithScores
1) "Book3"
2) "3"  //Book3=3*1=3
3) "Book1"
4) "5"  //Book1=1*1+2*2=5
5) "Book2"
6) "6" //Book2=2*1+2*2=6
7) "Book4"
8) "8" //Book4=4*2=6
127.0.0.1:6379>
  • ZInterStore，带存储功能的多有序集合交运算

语法：ZInterStore destination numkeys key [key……] [WEIGHTS weights] [SUM|MIN|MAX]

返回值：返回交运算结果有序集合destination中键值对个数

实例：

127.0.0.1:6379> ZAdd zset2 1 "Book1" 2 "Book2" 3 "Book3"
127.0.0.1:6379> ZAdd zset3 2 "Book1" 2 "Book2" 4 "Book4"
127.0.0.1:6379> ZInterStore IEnd0 zset2 zset3 WEIGHTS 1 2 //默认SUM，要确保zset、zset3存在
127.0.0.1:6379> ZRange IEnd0 0 -1 WithScore
127.0.0.1:6379>
  • ZRemRangByLex，在相同情况下，删除指定范围的键值对

语法：ZRemRangeByLex key min max ，min和max为指定键范围的下限和上限值，必须以"[" 闭区间范围,"("开头 开区间范围，或"-" 二进制最小键 ,"+" 二进制最大键 代表

返回值：返回删除键值对个数；min和max若放反位置，则返回0；若key指定的为费有序集合，则返回出错信息。

实例：

127.0.0.1:6379> ZAdd ZDel 0 "Bag" 0 "Bed" 0 "Bear"
(integer) 3
127.0.0.1:6379> ZRemRangeByLex ZDel - +
(integer) 3
127.0.0.1:6379> ZRange ZDel 0 -1
(empty list or set)
127.0.0.1:6379>
  • ZRangeByLex，在同值情况下，返回指定范围的键的列表

语法：ZRangeByLex key min max [LIMIT offset count]

返回值：返回指定键范围的键列表

实例：

127.0.0.1:6379> ZAdd ZDel 0 "Bag" 0 "Bed" 0 "Bear" 0 "apple" 0 "and" 0 "ant"
(integer) 6
127.0.0.1:6379> ZRangeByLex ZDel - +
1) "Bag"
2) "Bear"
3) "Bed"
4) "and"
5) "ant"
6) "apple"
127.0.0.1:6379>

分页操作：

127.0.0.1:6379> ZRangeByLex ZDel - +
1) "Bag"
2) "Bear"
3) "Bed"
4) "and"
5) "ant"
6) "apple"
127.0.0.1:6379> ZRangeByLex ZDel - + Limit 0 3 //第1页3条记录
1) "Bag"
2) "Bear"
3) "Bed"
127.0.0.1:6379> ZRangeByLex ZDel - + Limit 3 3 //第2页三条记录
1) "and"
2) "ant"
3) "apple"
127.0.0.1:6379>
  • ZRangeByScore，删除指定值大小范围的键值对

语法：ZRangeByScore key min max [WITHSCORES] [LIMIT offset count]

返回值：返回指定分值范围的键或键值对列表

实例：

127.0.0.1:6379> ZAdd ZGet 1 "Bag" 2 "Bed" 3 "Bear" 4 "apple" 5 "and" 6 "ant"
(integer) 6
127.0.0.1:6379> ZRangeByScore ZGet -inf +inf
1) "Bag"
2) "Bed"
3) "Bear"
4) "apple"
5) "and"
6) "ant"
127.0.0.1:6379>
  • ZRemRangeByScore，删除指定值范围的键值对

语法：ZRemRangeByScore key min max

返回值：返回删除键值对个数

实例：

127.0.0.1:6379> ZRemRangeByScore ZGet (3 +inf
(integer) 3
127.0.0.1:6379> ZRange ZGet 0 -1 WithScores
1) "Bag"
2) "1"
3) "Bed"
4) "2"
5) "Bear"
6) "3"
127.0.0.1:6379>
  • ZRemRangeByRank，删除指定值下标范围的键值对

语法：ZRemRangeRank key start stop

返回值：返回删除的键值对个数

实例：

127.0.0.1:6379> ZRemRangeByRank ZGet 0 1
(integer) 2
127.0.0.1:6379> ZRange ZGet 0 -1 WithScores
1) "Bear"
2) "3"
127.0.0.1:6379>
  • ZRevRange，返回指定值下标范围的固定排序键值对列表

语法：ZRevRange key  start stop

返回值：返回指定分值下标范围的键或键值对列表

实例：

127.0.0.1:6379> ZAdd ZGetRev 1 "Bag" 2 "Bed" 3 "Bear" 4 "apple" 5 "and" 6 "ant"

(integer) 6
127.0.0.1:6379> ZRevRange ZGetRev 0 -1
1) "ant"
2) "and"
3) "apple"
4) "Bear"
5) "Bed"
6) "Bag"
127.0.0.1:6379>
  • ZRevRangeByLex，在同值情况下，返回指定键范围倒排序键列表

语法：ZRevRangeByLex key max min

返回值：返回指定范围的键列表

实例：

127.0.0.1:6379> ZAdd ZRev1 0 "Bag" 0 "Bed" 0 "Bear" 0 "apple" 0 "and" 0 "ant"
(integer) 6
127.0.0.1:6379> ZRevRangeByLex ZRev1 + -
1) "apple"
2) "ant"
3) "and"
4) "Bed"
5) "Bear"
6) "Bag"
127.0.0.1:6379>
  • ZRevRangeByScore，返回指定值大小范围的固定排序键或键值对列表

语法：ZRevRangeByScore key max min [WITHSCORES] [LIMIT offset count]

返回值：返回指定分值范围的键或键值对列表

实例：

127.0.0.1:6379> ZRemRangeByRank ZGetRev 0 -1
(integer) 6
127.0.0.1:6379> ZAdd ZGetRev 1 "Bag" 2 "Bed" 3 "Bear" 4 "apple" 5 "and" 6 "ant"

(integer) 6
127.0.0.1:6379> ZRevRangeByScore - +
127.0.0.1:6379> ZRevRangeByScore ZGetRev1 - +
127.0.0.1:6379>
  • ZRevRank，返回指定键在有序集合里的排名位数

语法：ZRevRank key member

返回值：返回指定member在有序集合中的排名数（根据分值）；如果指定的member不存在，则返回nil

实例：

127.0.0.1:6379> ZAdd ZSetRev 1 "a" 2 "b" 3 "c" 4 "d" 5 "e" 6 "f"
(integer) 6
127.0.0.1:6379> ZRevRank ZSetRev "c"
(integer) 3
127.0.0.1:6379>
  • ZScan，增量迭代式返回有序集合中的键值对列表

语法：ZScan key cursor [MATCH pattern] [COUNT count]

返回值：分批次返回游标指定的有序集合内容

实例：略 

6、发布订阅命令

　　为了灵活发布或获取消息，人们发明了发布订阅模式来处理消息。由发布者Publish、消息Message、频道Channel、订阅者Subscribe组成。

　　Publish和Subscribe命令的确定是客户端一方下线，下线后发布的信息无法接续接收。也就是一部分信息将被丢失，因为这些命令都是基于内存运行，没有把信息先保存到磁盘上。

  • Publish，发布信息到指定的频道

语法：Publish channel message，channel为建立的频道名，也可以看做是键名；message为需要发送的信息，也可以看做值，该值为字符类型。在服务端，频道内部自行产生存储频道名、消息及连接客户端地址特定数据结构（也叫字典），应用开发无序关系该数据结构的生成，Redis自动生成。

返回值：收到信息的客户端数量。

实例：

127.0.0.1:6379> Publish ChatChannel1 "在家么?" 
1
127.0.0.1:6379>
  • Subscribe，订阅指定频道的信息

语法：Subscribe channel [channel ……],可以设置多个频道

返回值：读取指定频道的消息列表

实例：

127.0.0.1:6379> Subscribe ChatChannel1
subscribe      //订阅命令反馈
ChatChannel1     //订阅频道
1     //目前客户端已订阅频道/模式数量
message     //订阅信息标志
ChatChannel1     //发送信息的频道
在家么？    //接收的内容
  • PSubscribe，订阅指定模式的频道信息

语法：PSubscribe pattern [pattern ……]  ,pettarn为订阅模式，允许多模式指定，这里模式包括：

　　?，如果设置pattern为w?，则返回消息为we、wo、wa、wl、w1等。也就是第一个字母必须是w，第2个可以是任何字符。

　　*，如果设置pattern为w*，则返回消息为we、want、wove、w12355等，也就是第一个必须是w，第二个开始可以是任何其他字符。

　　[]，如果pattern为w[2e]are，则返回消息为weare、w2are，也就是第一个字母必须是w，第二个字母为[]里的任意字符

返回值：返回指定模式的消息列表

实例：

127.0.0.1:6379> PSubscribe ChatChannel1 w?
psubscribe
ChatChannel1
1
psubscribe
w?
2
pmessage
ChatChannel1
ChatChannel1
We
  • PunSubscribe，退订指定模式，并返回相关信息

语法：PunSubscribe [pattern [pattern ……]]

返回值：返回取消模式的消息列表；存在其他返回情况。

实例：

127.0.0.1:6379> PunSubscribe w?
punsubscribe
w?
0
127.0.0.1:6379>
  • UnSubscribe，退订指定频道的信息

语法：UnSubscribe [channel [channel ……]]

返回值：当去取消某指定的频道后，将返回取消消息列表；存在其他返回结果。

实例：

127.0.0.1:6379> UnSubscribe ChatChannel1
unsubscribe
ChatChannel1
0    //1为退订成功，0为退订失败
127.0.0.1:6379>
  • PubSub，统计Pub/Sub子系统状态的数量

语法：PubSub subcommand [argument [argument ……]]，subcommand为子命令，这里包括Channels、NumSub、NumPat，argument为子命令参数

实例：略 

7、连接命令

　　连接服务器端Redis数据库的基本操作

  • Auth，验证服务器命令

语法：Auth password，password为Redis数据库登录认证密码。如果数据库管理员已经在/etc/redis.conf配置文件的#requirepass foobared参数选项设置了密码，则客户端登录Redis数据库服务器时，先要求通过Auth命令，输入与配置里一样的密码，才能进行客户端命令操作。

返回值：如果该命令的密码跟配置文件里的密码一致，则返回OK，否则返回错误信息

实例： 

127.0.0.1:6379> Auth ErrorRedis  //假设ErrorRedis为错误密码
(error) ERR Client sent AUTH, but no password is set
127.0.0.1:6379> Auth touchRedis  //假设配置文件参数requirepass touchRedis
OK
127.0.0.1:6379>
  • Echo，回显输入的字符串

语法：Echo message，message为输入的字符串

返回值：在客户端直接返回输入的字符串

实例：

127.0.0.1:6379> Echo "See me!"
"See me!"
127.0.0.1:6379>
  • Ping，Ping服务器

语法：ping [字符串]

返回值：没有参数时，返回PONG，否则连字符串一起返回。用于测试客户端跟服务端Redis之间的链接是否可用，或者用来测试延迟情况。

实例：

127.0.0.1:6379> ping
PONG
127.0.0.1:6379>
  • Quit，关闭客户端跟服务器Redis连接

语法：Quit，无参数，请求服务器关闭跟客户端的链接，在关闭前，链接将会尽可能快地将未完成的客户端请求完成处理。

返回值：返回OK

实例：

127.0.0.1:6379> Quit
[root@dream etc]#
  • Select，选择新数据库

语法：Select index，index为跟服务端Redis数据库连接下标值，从0开始，第一个新连接的数据库是DB0，第二个是DBI，第三个DB2，一次类推。

返回值：指定的索引值，有对应的数据库，则返回OK；指定的索引值没有对应的数据库，则返回出错信息。

实例：

127.0.0.1:6379> Select 1
OK
127.0.0.1:6379[1]>

8、Server操作命令

　　Redis数据库Server操作命令，主要实现对数据库的各种管理。

A、与客户端连接、获取命令信息相关的命令

  • Client List 获得客户端连接信息及数量列表

语法：Client List

返回值：每个已连接客户端对应一行（以LF分割），每行字符串由一系列“属性=值”（Property=Value）形式的域组成，每个域之间以空格分开。

　　每个域包含如下内容：id：唯一的客户端ID号；addr：客户端IP端口；fd：对应于套接字的文件描述……

实例：

127.0.0.1:6379> Client List
id=28 addr=127.0.0.1:39032 fd=7 name= age=17 idle=0 flags=N db=0 sub=0 psub=0 multi=-1 qbuf=26 qbuf-free=32742 obl=0 oll=0 omem=0 events=r cmd=client
127.0.0.1:6379>  
  • Client SetName 设置当前连接的名称

语法：Client SetName

返回值：如果客户端连接名被设置成功，则返回OK

实例：

127.0.0.1:6379> Client SetName Conn1
OK   //该设置会体现在Client List显示结果里
127.0.0.1:6379>
  • Client GetName 获得当前连接的名称

语法：Client GetName

返回值：如果连接没设置名称，则返回nil；如果有设置名称，则返回连接名称。

实例：

127.0.0.1:6379> Client SetName Conn1
OK
127.0.0.1:6379> Client GetName
"Conn1"
127.0.0.1:6379> Client SetName ""
OK
127.0.0.1:6379> Client GetName
(nil)
127.0.0.1:6379>
  • Client Kill 关闭客户端连接

语法：Client Kill [ip:port] [ID client-id] [TYPE normal|master|slave|pubsub] [ADDR ip:port] [SKIPME yes/no]

返回值：指定IP地址情况下，关闭成功，返回OK；当使用TYPE参数时，返回被关闭的客户端个数。

实例：

127.0.0.1:6379> Client List
id=28 addr=127.0.0.1:39032 fd=7 name= age=552 ……127.0.0.1:6379> Client Kill 127.0.0.1:39032 //关闭客户端连接
OK
127.0.0.1:6379>
  • Client Pause 暂停处理客户端命令

语法：Client Pause timeout

返回值：设置成功，返回OK；若timeout设置无效，则返回出错信息。

实例：

127.0.0.1:6379> Client Pause 3000  //所有客户端连接暂停3秒
OK
127.0.0.1:6379>
  • Command Count 统计Redis所有命令

语法：Command

返回值：返回Redis所有命令的详细信息，以数组形式显示。

实例：

127.0.0.1:6379> Command
  1) 1) "readwrite"
     2) (integer) 1
     3) 1) fast
     4) (integer) 0
     5) (integer) 0
     6) (integer) 0
  2) 1) "setex"
     2) (integer) 4
     3) 1) write
        2) denyoom
     4) (integer) 1
   ……
  • Command Count 统计Redis命令总数

语法：Command Count

返回值：返回Redis命令的总统计数

实例：

127.0.0.1:6379> Command Count
(integer) 200
127.0.0.1:6379>
  • Command GetKeys 获得指定命令的所有键

语法：Command GetKeys

返回值：返回Redis指定命令的键列表

实例：

127.0.0.1:6379> Command GetKeys MSet a b c d e f
1) "a"
2) "c"
3) "e"   //a c e为该命令的键
127.0.0.1:6379>
  • Command Info 获得指定命令的详细使用信息

语法：Command Info command-name [command-name ……]，Command-name为Redis里的任意命令名，允许指定多个命令名。

返回值：返回指定命令的相信信息

实例：

127.0.0.1:6379> Command Info get
1) 1) "get"
   2) (integer) 2
   3) 1) readonly
      2) fast
   4) (integer) 1
   5) (integer) 1
   6) (integer) 1
127.0.0.1:6379>  

B、与配置文件、磁盘操作相关的命令

  • Config Get 获取服务端配置文件参数的值

语法：Config Get parameter，parameter为Redis配置文件里的参数名。在参数名里可以用*匹配符号。如*max*，可以返回所有参数名称里max先关的参数键值对。

返回值：返回配置文件里给定参数的键值对列表

实例：

127.0.0.1:6379> Config Get slowlog-max-len
1) "slowlog-max-len"
2) "128"
127.0.0.1:6379> Config Get *
  1) "dbfilename"
  2) "dump.rdb"
  3) "requirepass"
……
  • Config ResetStat 复位再分配使用Info命令报告的统计

语法：Config ResetStat

返回值：总是返回OK

实例：

127.0.0.1:6379> Config ResetStat
OK
127.0.0.1:6379>
  • Config set 设置配置文件指定参数的值

语法：Config Set parameter value，parameter为Redis配置文件里的参数名；value为参数对应的值

返回值：如果配置参数设置成功，则返回OK;；若失败，则返回出错提示信息。

实例：

127.0.0.1:6379> Config Get slowlog-max-len
1) "slowlog-max-len"
2) "128"
127.0.0.1:6379> Config Set slowlog-max-len 1050
OK
127.0.0.1:6379> Config Get slowlog-max-len
1) "slowlog-max-len"
2) "1050"
127.0.0.1:6379>
  • Config Rewrite 重写内存中的配置文件

语法：Config Rewrite

返回值：如果配置重写成功，则返回OK，若失败，则返回出错提示信息

实例：

127.0.0.1:6379> Config Get appendonly
1) "appendonly"
2) "no"
127.0.0.1:6379> Config Set appendonly yes
OK
127.0.0.1:6379> Config Rewrite
OK
127.0.0.1:6379>

　　Config Rewrite把运行在内存的配置信息更新到磁盘上，Config Set先写到内存配置文件上，再根据一定的方式更新到磁盘上。

  • BGRewriterAof 异步重写追加文件命令

语法：BGRewriterAof

返回值：总是返回OK

实例：略

  • BGSave 异步保存数据集到磁盘上

语法：BGSave

返回值：把内存数据异步保存到磁盘文件上，返回OK。

实例：

127.0.0.1:6379> BGSave
Background saving started
127.0.0.1:6379> BGSave
  • LastSave 获得最后一次同步磁盘的时间

语法：LastSave

返回值：返回UNIX时间戳

实例：

127.0.0.1:6379> LastSave
(integer) 1584281162
127.0.0.1:6379>
  • Save 同步数据到磁盘上

语法：Save

返回值：若命令执行成功，则返回OK

实例： 

127.0.0.1:6379> Save
OK
127.0.0.1:6379>

C、其他命令

  • DBSize，返回数据库实例数据存储对象个数

语法：DBSize

返回值：返回当前数据库实例里数据存储对象个数

实例：

127.0.0.1:6379> DBSize
(integer) 66
127.0.0.1:6379> Set NewSet1 "DBSize"  //新增一个字符串对象
OK
127.0.0.1:6379> DBSize
(integer) 67
127.0.0.1:6379>
  • Debug Object，数据存储对象调试命令

语法：Debug Object key

返回值：当指定的key对象存在时，返回有关信息；若key指定的对象不存在，则返回出错信息。

实例：

127.0.0.1:6379> Debug Object NewSet1
Value at:0x7f61b820e480 refcount:1 encoding:embstr serializedlength:7 lru:7223684 lru_seconds_idle:120
127.0.0.1:6379> Debug Object NoOne
(error) ERR no such key
127.0.0.1:6379>
  • Debug Segfault，让Redis崩溃

语法：Debug Segfault，该命令执行非法的内存访问，从而让Redis系统崩溃，仅在开发时用于Bug调试。

返回值：无

实例：

127.0.0.1:6379> Debug Segfault
Could not connect to Redis at 127.0.0.1:6379: Connection refused
not connected>
  • FlushAll，删除所有数据库里的所有数据

语法：FlushAll

返回值：总是返回OK

实例：

127.0.0.1:6379[1]> FlushAll  //删除Redis所有数据库的数据，破坏力很大
OK
127.0.0.1:6379[1]> Select 0
OK
127.0.0.1:6379> DBSize  //0号数据库没有任何存储对象
(integer) 0
127.0.0.1:6379> Select 1
OK
127.0.0.1:6379[1]> DBSize  //1号数据库没有任何存储对象
(integer) 0
127.0.0.1:6379[1]>
  • FlushDB，删除当前数据库里的所有数据

语法：FlushDB

返回值：总是返回OK

实例：

127.0.0.1:6379> FlushDB //删除当前数据库的所有数据
OK
127.0.0.1:6379>
  • Info，返回Redis服务器的各种信息和统计值

语法：Info [selection]，如果没有使用任何参数，默认是default；select参数的值：server。client，memory，stats，default等。

返回值：范文文本行的集合，以键值对的形式出现

实例：

127.0.0.1:6379> Info
# Server
redis_version:5.0.5
redis_git_sha1:00000000
redis_git_dirty:0
redis_build_id:2fbb6b4ff841724c
redis_mode:standalone
os:Linux 3.10.0-1062.1.2.el7.x86_64 x86_64
……
  • Monitor，持续返回服务器端处理的每一个命令信息

语法：Monitor

返回值：持续返回服务器端处理的每一个命令信息

实例：

127.0.0.1:6379> Monitor
OK
  • Role，返回主从实例所属的角色

语法：Role

返回值：返回角色信息列表

实例：

127.0.0.1:6379> Role
1) "master"
2) (integer) 0
3) (empty list or set)
127.0.0.1:6379>
  • ShutDown，异步保存数据到磁盘，并关闭服务器Redis

语法：ShutDown [NOSAVE] [SAVE]

返回值：执行成功时不返回任何信息，服务端和客户端的链接断开，客户端自动退出；执行失败时返回出错信息。

实例：

127.0.0.1:6379> Ping
PONG
127.0.0.1:6379>ShutDown //正常关闭Redis，退出Reids-cli回到操作系统界面
  • SlaveOf，将当前服务器转变为指定服务器的从属服务器（Slave server）

语法：SlaveOf host port

返回值：总是返回OK

实例：

127.0.0.1:6379> SlaveOf 192.168.1.110 6370 //将当前服务器设置为指定服务器的从属服务器
OK
127.0.0.1:6379> SlaveOf No One //从属服务器恢复主服务器状态
OK
127.0.0.1:6379>
  • SlowLog，管理Redis的慢速记录日志

语法：SlowLog subcommand [argument]

返回值：指定Get子命令时，返回指定数量的日子记录，指定Len子命令，返回慢速日志的总记录长度；指定Reset子命令，返回OK

实例：

127.0.0.1:6379> Showlog 2
127.0.0.1:6379>
  • SYNC，用于复制功能的内部命令

语法：SYNC

返回值：不确定内容

实例：

127.0.0.1:6379> SYNC
Entering replica output mode...  (press Ctrl-C to quit)
SYNC with master, discarding 175 bytes of bulk transfer...
SYNC done. Logging commands from master.
"PING"
"PING"
  • Time，返回当前服务器的时间

语法：Time

返回值：返回包含两个字符串的列表，第一个标识服务器的当前UNIX时间戳；第二个标识最近一秒已经过去的微秒数。

实例： 

127.0.0.1:6379> Time
1) "1584367461"
2) "204087"
127.0.0.1:6379>

9、脚本命令

　　Redis的Lua脚本语言提供了再Redis服务端连续执行代码的功能，具体命令如下：

  • EVal，执行Lua命令

语法：EVal script numkeys key [key……] arg [arg……]，script为Lua脚本代码，numkeys为key参数个数，key标识在脚本中所用到的那些Redis键，这些键名参数可以在Lua中通过全局变量KEYS数组，用1位基址的形似访问（Key[1] ,Key[2],以此类推）；arg为可选参数，可以在Lua中通过全局变量ARGV数组访问，访问形式和KEYS变量类似（ARGV[1],ARGV[2]）

返回值：返回Lua脚本运算结果，返回形式有多种

实例： 

127.0.0.1:6379> EVal "return {KEYS[1],KEY[2],ARGV[1]}" 2 key1 key2 first
127.0.0.1:6379>
  • EValSha，根据给定的校验码，执行服务端Lua脚本命令

语法：EValSha shal 1 numkeys key [key ……] arg [arg ……]

返回值：返回Lua脚本运算结果，返回形式有多种

实例：

127.0.0.1:6379> Script Load "Return '服务端返回的值'"
798a9a0c6c60b86d11af4511210cffcbb4493542
127.0.0.1:6379> EValSha "798a9a0c6c60b86d11af4511210cffcbb4493542" 0
ERR Error running script (call to f_798a9a0c6c60b86d11af4511210cffcbb4493542): @enable_strict_lua:15: user_script:1: Script attempted to access nonexistent global variable 'Return' 

127.0.0.1:6379>

 

127.0.0.1:6379> EValSha "e0e1f9faj545hk454hkh54ljlk5j2jljl" 0 //先执行3）Script Load命令 再执行
"服务端返回的值"
127.0.0.1:6379>
  • Script Load，把Lua脚本代码加载到服务缓存上，并不执行

语法：Script Load script

返回值：给定脚本的SHA1校验和

实例： 

127.0.0.1:6379> Script Load "Return '服务端返回的值'"
798a9a0c6c60b86d11af4511210cffcbb4493542
127.0.0.1:6379>
  • Script Plush，从脚本缓存中移除所有脚本

语法：Script Flush

返回值：总是返回OK

实例： 

127.0.0.1:6379> Script Flush //清除当前连接的额服务器脚本缓存的所有Lua脚本
OK
127.0.0.1:6379>
  • Script Exists，查看指定的脚本是否已经被保存在缓存中

语法：Script Exists script [script ……]

返回值：返回对应于每一个Shal的数组，脚本存在返回1，不存在返回0

实例： 

127.0.0.1:6379> Script Exists "798a9a0c6c60b86d11af4511210cffcbb4493542"
0   //不存在
127.0.0.1:6379>
  • Script Kill，终止当前正在运行的Lua脚本

语法：Script Kill

返回值：执行成功返回OK，否则返回一个错误提示信息

实例： 

127.0.0.1:6379> Script Kill  //终止当前服务端正在运行的Lua脚本
NOTBUSY No scripts in execution right now.

127.0.0.1:6379>

10、键命令

　　键，即Keys，指存储在数据库里的各种数据存储对象，如字符串、列表、集合、散列、有序集合的名称等。

　　与Keys有关的各种命令如下：

  • Del，删除Key指定的数据存储对象

语法：Del Key [Key ……]，Key为指定的Redis数据库里的额数据存储对象，如字符串、列表、集合、散列、有序集合等，允许多Key指定。

返回值：返回被删除的Key的数量

实例：

127.0.0.1:6379> Set s1 "¡¶Python¡·"
OK
127.0.0.1:6379> Del s1
(integer) 1
127.0.0.1:6379>
  • Dump，序列化给定的Key

语法：Dump key

返回值：如果指定的key不存在，返回nil；存在则返回序列化后的值

实例：

127.0.0.1:6379> Set s1 "¡¶Python¡·"
OK
127.0.0.1:6379> Dump s1
"\x00\n\xa1\xb6Python\xa1\xb7\t\x000>~\xde5\xaazX"
127.0.0.1:6379>
  • Exists，检查指定Key是否存在

语法：Exists key [key ……]

返回值：若key存在则返回1，否则返回0

实例：

127.0.0.1:6379> Set s1 "¡¶Python¡·"
OK
127.0.0.1:6379> Exists s1
(integer) 1  //存在
127.0.0.1:6379> Exists s2
(integer) 0 //不存在
127.0.0.1:6379>
  • Expire，设置Key的过期时间（单位：秒）

语法：Expire key seconds，seconds为指定的过期时间（单位：秒），超过指定设置的过期时间，会自动删除该Key，对Key的修改操作，不影响过期时间。

返回值：设置成功，放回1；指定的Key不存在或设置失败，返回0

实例：

127.0.0.1:6379> LPush ExpList "one1"
(integer) 1
127.0.0.1:6379> Expire ExpList 2
(integer) 1
127.0.0.1:6379> Exists ExpList
(integer) 0
127.0.0.1:6379>
  • ExpireAt，设置Key的过期时间（单位：秒，用UNIX的时间戳）

语法：ExpireAt key timestamp，timestamp为指定的UNIX时间戳（单位：秒）

返回值：若设置成功，返回1；若指定key不存在或设置失败，返回0

实例：

127.0.0.1:6379> Del ExpList
(integer) 0
127.0.0.1:6379> LPush ExpList "one1"
(integer) 1
127.0.0.1:6379> ExpireAt ExpList 1293840000
(integer) 1
127.0.0.1:6379>
  • Keys，查找所有符合指定模式的Key

语法：Keys pattern，pattern为指定的查找条件模式，例如：

1）？，a?c，匹配abc、aac、adc

2）*，如*n*，匹配one、number、fine

3）[ab]，如t[ab]e，匹配tae、tbe

4）[^e]，如[^e]e，匹配tae、tbe，但不能是tee

5）[a-b]，如t[a-b]e，匹配tae、tbe

返回值：返回符合模式要求的Key对象列表

实例：

127.0.0.1:6379> MSet one 1 two 2 three 4 four 4
OK
127.0.0.1:6379> Keys t?o
1) "two"
127.0.0.1:6379> Keys t*
1) "two"
2) "three"
127.0.0.1:6379>
  • Migrate，原子性地把当前Key转移到指定数据库中（可跨服务器）

语法：Migrate host port key destionation-db timeout [COPY] [REPLACE]，destionation-db为目标数据库实例名，timer为传输数据超时时间范围（单位：毫秒），COPY复制或REPLACE替换

返回值：迁移成功返回OK，否则返回IOERROR。

实例：略

  • Move，将当前数据库的Key转移到指定的数据库中（本机内）

语法：Move key db

返回值：若迁移成功，则返回1；失败返回0

实例：略

  • Object，以内部调试方式给出Key的内部对象信息

语法：Object subcommand [arguments [arguments ……]]

返回值：若在RefCount和IdleTime方式下，则返回数字；若在Encoding方式下，则返回相应的压缩编码方式

实例：略

  • Persist，移除Key的过期时间

语法：Persist key

返回值：若移除成功，返回1；若key不存在或ke没有设置过期时间，则返回0

实例：

127.0.0.1:6379> Del testset1
(integer) 0
127.0.0.1:6379> Set testset1 "This is a dog!"
OK
127.0.0.1:6379> Expire testset1 10
(integer) 1
127.0.0.1:6379> Persist testset1
(integer) 1
127.0.0.1:6379>
  • PExpire，设置Key的过期时间（单位：毫秒）

语法：PExpire key milliseconds

返回值：设置成功，返回1；否则返回0

实例：

127.0.0.1:6379> Del testset1
(integer) 1
127.0.0.1:6379> Set testset1 "This is a dog!"
OK
127.0.0.1:6379> PExpire testset1 10
(integer) 1
127.0.0.1:6379>
  • PExpireAt，设置Key的过期时间（单位：毫秒，用UNIX时间戳） 

语法：PExpireAt key milliseconds-timestamp

返回值：成功返回1；否则返回0

实例：同ExpireAt，略

  • PTTL，以毫秒为单位返回Key的剩余生命时间

语法：PTTL key

返回值：当Key不存在，返回-2；key存在但没有设置剩余生存时间，返回-1；否则返回key的剩余生命时间（单位：毫秒）

实例：

127.0.0.1:6379> Del testset1
(integer) 0
127.0.0.1:6379> Set testset1 "This is a dog!"
OK
127.0.0.1:6379> Expire testset1 10
(integer) 1
127.0.0.1:6379> PTTL testset1
(integer) 3067 //剩余3067 毫秒
127.0.0.1:6379>
  • RandomKey，从当前数据库返回一个随机的Key

语法：RandomKey

返回值：如果数据库没有任何key，则返回nil，否则返回一个随机的key

实例：

127.0.0.1:6379> FlushDB  //删除当前数据库的所有数据
OK
127.0.0.1:6379> MSet first "I" two " am" third " a" fourth " boy!"
OK
127.0.0.1:6379> RandomKey
"two"
127.0.0.1:6379> RandomKey
"fourth"
127.0.0.1:6379>
  • Rename，将指定的Key重新命名（允许新的Key已经存在）

语法：Rename key newkey

返回值：重命名成功返回OK；如果key名与newkey一样，返回出错信息

实例：

127.0.0.1:6379> Set rNameKey "TomCat"
OK
127.0.0.1:6379> Rename rNameKey NameKey
OK
127.0.0.1:6379> Get NameKey
"TomCat"
127.0.0.1:6379>
  • RenameNX，将指定的Key重新命名为不存在的Key

语法：RenameNX key newkey

返回值：修改成功，返回1；若newkey已经㛮，返回0；key不存在，返回出错信息

实例：

127.0.0.1:6379> Set NameKey2 "OK!"
OK
127.0.0.1:6379> RenameNX NameKey NameKey2
(integer) 0
127.0.0.1:6379> Del NameKey2
(integer) 1
127.0.0.1:6379> RenameNX NameKey NameKey2
(integer) 1
127.0.0.1:6379>
  • Restore，反序列化指定Key

语法：Restore key ttl serialized-value [REPLACE]

返回值：若反序列化成功，则返回OK；都在返回一条出错信息

实例：

127.0.0.1:6379> Set gg "hello,dumping world!"
OK
127.0.0.1:6379> Dump gg
"\x00\x14hello,dumping world!\t\x00\xcb\xf7\xbe\xbe\xd8\xc0\xb6\xf9"
127.0.0.1:6379> 
OK
127.0.0.1:6379> Get ggg
127.0.0.1:6379>
  • Scan，增量迭代返回当前数据库中的Key的数组列表

语法：Scan cursor [MATCH pattern] [COUNT count] 

返回值：是一个包含两个元素的数组，第一个数组元素但是用于下一次迭代的新游标，而第二个数组元素则是一个数组，这个数组中包含了所有被迭代的元素

实例：

127.0.0.1:6379> Scan 0
1) "0"
2) 1) "first"
   2) "two"
   3) "third"
   4) "NameKey2"
   5) "fourth"
   6) "gg"
127.0.0.1:6379>
  • Sort，对指定Key对象进行排序并返回或保存到目标Key

语法：Sort key [BY pattern] [LIMIT offset count][GET pattern] [ASC|DESC] [ALPHA] STORE destionation

返回值：没有指定STORE，则返回列表形式的排序结果；若使用STORE参数，则返回排序结果的元素数量。

实例：

127.0.0.1:6379> LPush BookPrice 34 21 55 48.5
(integer) 4
127.0.0.1:6379> Sort BookPrice   //默认升序
1) "21"
2) "34"
3) "48.5"
4) "55"
127.0.0.1:6379> Sort BookPrice Desc //降序
1) "55"
2) "48.5"
3) "34"
4) "21"
127.0.0.1:6379>
  • TTL，以秒为单位返回Key的剩余生存时间

语法：TTL key，与PTTL仅为时间单位的区别，TTL是秒，PTTL是毫秒

返回值：key不存在时，返回-2；key存在但没有设置剩余生存时间时，返回-1；否则返回剩余生存时间（单位：秒）

实例：

127.0.0.1:6379> TTL NoKey
(integer) -2
127.0.0.1:6379>
  • Type，返回Key指定数据结构类型

语法：Type key

返回值：若key存在，则返回对应的数据结构类型；若key不存在，则返回none

实例：

127.0.0.1:6379> LPush PType "I" "Like" "TomCat"
(integer) 3
127.0.0.1:6379> Type PType
list
127.0.0.1:6379>
  • Wait，阻塞当前客户端到指定从（Slaves）服务器端的写操作

语法：Wait numslaves timeout，numslaves为需要阻塞的从服务器号；timeout为过期时限（单位：毫秒）

返回值：返回已经写入服务器的个数

实例： 

127.0.0.1:6379> Set String1 "OK"
OK
127.0.0.1:6379> wait 1 1000
(integer) 0
(1.04s)
127.0.0.1:6379>

 

11、HyperLogLog命令

　　HyperLogLog是一种概率数据结构，被用于统计唯一事务——数学集合论里叫的基数。适合超大数量情况下近似基数统计。

  • PFAdd，将制定元素添加到HyperLogLog

语法：PFAd key element [element]，key为指定的HyperLogLog对象名，element为需要增加的元素，允许多个指定。如果指定的key不存在，这个命令会自动创建一个空的HyperLogLog结构。

返回值：如果key对象的内部存储被更新，则返回1；否则返回0

实例： 

127.0.0.1:6379> PFAdd Visitor "192.168.0.1:3828" "192.168.0.2:3821" "192.168.0.3:3822"
(integer) 1
127.0.0.1:6379>
  • PFCount，返回指定key的近似基数

语法：PFCount key [key ……]

返回值：当一个key时，返回近似基数；当多个key时，返回这些key指定的HyperLogLog结构元素进行并（AND）运算后的近似基数；当key不存在时，返回0

实例：

127.0.0.1:6379> PFAdd Visitor "192.168.0.1:3828" "192.168.0.2:3821" "192.168.0.3:3822"
(integer) 1
127.0.0.1:6379> PFCount Visitor
(integer) 3   //Visitor的基数为3，代表3个不通的IP:Port
127.0.0.1:6379>
  • PFMerge，将多个HyperLogLog合并为一个HyperLogLog

语法：PFMerge destkey sourcekey [sourcekey ……],destkey为存储合并后的HyperLogLog对象；sourcekey为进行合并前的指定的HyperLogLog对象，允许指定多个sourcekey对象（合并时，进行并运算）

返回值：总是返回OK

实例： 

127.0.0.1:6379> PFAdd py22 1 2 5 6
(integer) 1
127.0.0.1:6379> PFAdd py21 1 2 3 4
(integer) 1
127.0.0.1:6379> PFMerge py2 py21 py22
OK
127.0.0.1:6379> PFCount py2
(integer) 6
127.0.0.1:6379>

12、地理空间命令

　　网站运行需要用到地理空间数据（地图），如旅游网想给游客提供出行最佳路径选择、外卖网想给食客提供指定范围的合适餐饮地址等。

  • GEOAdd，将指定的空间元素添加到指定的Key里

语法：GEOAdd key longitude latitude member [longitude latitude member ……]，key为地理空间的对象名，longitude为指定的经度值，latitude为指定的纬度值，member为地理位置名称，允许多个longitude latitude member 

返回值： 返回新添加的元素个数，不包括更新的元素个数

实例： 

127.0.0.1:6379> GEOADD Adress 121.47 31.23 "shanghai" 116.23 39.54 "beijing"
(integer) 2 //必须经度在前、纬度在后
127.0.0.1:6379>
  • GEODist，返回指定位置之间的距离

语法：GEODist key member1 member2 [unit]，member为地址位置名称，unit为返回位置之间距离的单位，可以是m（米）、km（千米）、mi（英里）、fy（英尺），默认为m

返回值： 计算得到的距离会以双精度浮点数的形式被返回，如果指定的位置元素不存在，那么会返回空值。

实例：

127.0.0.1:6379> GEOADD Adress 121.47 31.23 "shanghai" 116.23 39.54 "beijing"
(integer) 2
127.0.0.1:6379> GEODist Adress "shanghai" "beijing" km
"1038.7720"
127.0.0.1:6379> GEODist Adress "shanghai" "beijing" 
"1038772.0304"
127.0.0.1:6379> GEODist Adress "shanghai" "beijing" m
"1038772.0304"
127.0.0.1:6379> GEODist Adress "shanghai" "beijing" ft
"3408044.7191"
127.0.0.1:6379>
  • GEOHash，返回一个标准的地理空间的GEOHash字符串

语法：GEOHash key member [member ……]

返回值： 一个数组，数组的每个项都是一个GEOHash；返回GEOHash的位置与用户给定的位置元素的位置一一对应。

实例：

127.0.0.1:6379> GEOADD Adress 121.47 31.23 "shanghai" 116.23 39.54 "beijing"
(integer) 2
127.0.0.1:6379> GEOHash Adress "shanghai" "beijing"
1) "wtw3sj5zbj0"
2) "wx48uyh15q0"
127.0.0.1:6379>
  • GEOPos，返回地理空间的经纬度

语法：GEOPos key member [memeber ……]

返回值： 返回一个数组，数组中的每个项都由两个元素组成，第一个元素为指定位置元素的经度，第二个元素则为指定位置元素的维度；当指定的位置元素不存在时，对应的数组项为空值。

实例：

127.0.0.1:6379> GEOADD Adress 121.47 31.23 "shanghai" 116.23 39.54 "beijing"
(integer) 2
127.0.0.1:6379> GEOPos Adress "shanghai" "beijing"
1) 1) "121.47000163793563843"
   2) "31.22999903975783553"
2) 1) "116.23000055551528931"
   2) "39.54000124957348561"
127.0.0.1:6379> GEOPos Adress "shanghai" "beiji" //值不存在时返回nil
1) 1) "121.47000163793563843"
   2) "31.22999903975783553"
2) (nil)
127.0.0.1:6379>
  • GEORadius，查询指定半径内所有的地理空间元素的集合

语法：GEORadius key longitude latitude radius m|km|ft|mi [WITHCOORD] [WITHDIST] [WITHHASH] [COUNT count]

返回值： 在默认情况下会返回所有匹配的位置名称列表；在有可选项的情况下，返回一个二层嵌套数组，内层的每个子数组就表示一个元素。

实例：

127.0.0.1:6379> GEOADD Adress 121.47 31.23 "shanghai" 116.23 39.54 "beijing"
(integer) 2
127.0.0.1:6379> GEORadius Adress 121.47 31.23 100 km WITHDIST
1) 1) "shanghai"
   2) "0.0002"
127.0.0.1:6379>
  • GEORadiusByMember，查询指定半径内匹配的最大距离的一个地理空间元素

语法：GEORadiusByMember key member radius m|km|ft|mi [WITHCOORD] [WITHDIST] [WITHHASH] [COUNT count]

返回值：在默认情况下，返回所有匹配的位置名称列表；在有可选项的情况下返回一个二层嵌套数组，内层的每个子数组就表示一个元素。

实例： 

127.0.0.1:6379> GEOADD Adress 121.47 31.23 "shanghai" 116.23 39.54 "beijing"
(integer) 2
127.0.0.1:6379> GEORadiusByMember Adress "shanghai" 100 m
1) "shanghai"
127.0.0.1:6379>

13、事务命令

  • Multi，标记一个事务块的开始

语法：Multi

返回值：总是返回OK

实例：必须与Exec配合使用。

  • Exec，执行所有事务块内的命令

语法：Exec

返回值：事务块内所有的命令都被执行时，返回所有命令执行的返回值；若事务被中断，返回nil

实例：

127.0.0.1:6379> Multi
OK
127.0.0.1:6379> Set count 10
QUEUED
127.0.0.1:6379> Decr count
QUEUED
127.0.0.1:6379> Decr count
QUEUED
127.0.0.1:6379> Exec
1) OK
2) (integer) 9
3) (integer) 8
127.0.0.1:6379>
  • Discard，取消事务

语法：Discard，取消事务，放弃执行事务块内的所有命令。如果正在使用Watch命令监视某个（或某些）key，name取消所有监视，等同于执行命令UnWatch。

返回值：总是返回OK

实例：

127.0.0.1:6379> Discard
(error) ERR DISCARD without MULTI
127.0.0.1:6379>
  • Watch，监视一个或多个Key

语法：Watch key [key ……]，监视一个（或多个）key，如果在事务执行之前这个（或这些）key被其他命令所改动，name事务被打断。该命令配合Multi

、Exec命令使用。Exec执行过后，Watch作用自动取消。

返回值：总是返回OK

实例：

127.0.0.1:6379> Watch w1 w2
OK
127.0.0.1:6379> Set w2 0
OK
127.0.0.1:6379> Multi
OK
127.0.0.1:6379> Set w1 "one"
QUEUED
127.0.0.1:6379> Incr w2
QUEUED
127.0.0.1:6379> Exec
(nil)
127.0.0.1:6379>
  • UnWatch，取消WATCH命令对所有key的监视

语法：UnWatch

返回值：总是返回OK

实例： 

127.0.0.1:6379> Set w3 "Cat"
OK
127.0.0.1:6379> Watch w3
OK
127.0.0.1:6379> UnWatch
OK
127.0.0.1:6379>

 

14、集群命令

　　Redis集群（Cluster）概念，首先是指多服务器的物理部署，另外也指向配套的Redis数据库软件支持功能，主要指集群相关的何总操作命令及配置内容。

　　Redis物理布置：物理部署必须遵从主从复制原理要求，也遵循分片存储原理要求，这种部署实现原理与MongoDB的复制、分片原理非常相似。

　　Redis的软件功能：

　　　　1)单服务器的内存容量受限，在Redis里对应解决的技术方案为数据分片（分区）技术。

　　　　2)单服务器的单点故障解决方案，主要为主从复制技术、哨兵（Sentinel）技术。

　　　　3)单服务器超负荷访问问题的解决方案是分布式读写分离技术。

　　集群命令的相关术语：

　　　　1）Hash Slots 哈希槽

　　　　2）Node 节点

　　　　3）Gossip，Redis的节点之间的通信协议

 

　　集群相关的操作命令如下：

  • Cluster info ，获取Redis集群相关所有命令信息

语法：Cluster info

返回值：以键值对形式返回所有集合相关的命令信息

实例：无

127.0.0.1:6379> Cluster info
127.0.0.1:6379>
  • CLuster Meet，实现集群节点之间的通信

语法：Cluster Meet ip port

返回值：如果命令执行成功，返回OK；如果参数设置无效，返回出错信息。

实例：

127.0.0.1:6379> Cluster Meet 127.0.0.11:8010
OK
127.0.0.1:6379>
  • CLuster Replicate，把Master节点改为Slave节点

语法：Cluster Replicate node-id

返回值：如果角色修改成，返回OK；否则，返回出错信息。

实例：

127.0.0.1:6379> Cluster Replicate rtryewtray126743hjkh4j3  //节点ID号
OK
127.0.0.1:6379>
  • Cluster Nodes，列出当前集群的而所有节点信息

语法：Cluster Nodes

返回值：返回集群配置节点详细信息

实例：略

  • Cluster Forget，移除指定节点

语法：Cluster Forget node-id

返回值：如果节点移除成功，则返回OK；否则，返回出错信息。

实例：略

  • Cluster Reset，重新设置集合节点

语法：Cluster Reset [HARD|SOFT]

返回值：若集群设置成功，返回OK；否则返回出错信息

实例：

127.0.0.1:6379> Cluster Reset Soft
OK
127.0.0.1:6379>
  • Cluster SaveCOnfig，将节点的配置文件保存到磁盘

语法：Cluster SaveConfig

返回值：把运行在内存中的节点配置信息，强制保存到磁盘的Nodes.conf中，若操作成，返回OK；否则返回出错信息。

实例：

127.0.0.1:6379> Cluster SaveConfig
OK
127.0.0.1:6379>
  • Cluster Set-Config-Epoch，为新节点设置特定的新的配置时间标志

语法：Cluster Set-Config-Epoch config-epoch，config-epoch为当前节点指定的最新配置时间标志（整数），不同节点要求唯一。

返回值：设置成功返回OK，否则返回出错信息。

实例： 

127.0.0.1:6379> Cluster Set-Config-Epoch 1
OK
127.0.0.1:6379>
  • Cluster Slave是，提供为指定主节点的故障报告数

语法：Cluster Slaves node-id，node-id为指定的主节点ID号

返回值：执行成功，返回指定主节点的从节点列表信息；如果指定的node-id不是主节点或不是节点对象ID号，返回出错信息。

实例：

127.0.0.1:6379> Cluster Slaves uorhrueiu9978hj908971hadf
略
127.0.0.1:6379>
  • Cluster Count-Failure-Reports，返回指定节点的故障报告数

语法：Cluster Count-Failure-Reports node-id，node-id为指定节点的ID号

返回值：返回指定节点的故障报告数，主要用于技术人员内部调试

实例：

127.0.0.1:6379> CLuster Count-Failure-Reports node-id
0
127.0.0.1:6379>
  • Cluster FailOver，手动从节点强制启动为主节点

语法：Cluster FailOver [FORCE|TAKEOVER]

返回值：手动故障转移成功，返回OK；否则返回出错信息。

实例：

127.0.0.1:6379> Cluster FailOver
OK
127.0.0.1:6379>
  • ReadOnly，在集群中的从节点开启制度模式

语法：ReadOnly

返回值：执行成功返回OK；否则返回出错信息

实例：

127.0.0.1:6379> ReadOnly
OK
127.0.0.1:6379>
  • ReadWrite，禁止读取请求跳转到集群的从节点上

语法：ReadWrite

返回值：执行成功，返回OK，否则返回出错信息

实例：

127.0.0.1:6379> ReadWrite
OK
127.0.0.1:6379>
  • CLuster AddSlots，把Hash插槽分配给接受命令的服务器节点

语法：Cluster AddSlots slot [slot ……]，slot为需要新增加的插槽序号

返回值：执行成功返回OK，否则返回出错信息

实例：

127.0.0.1:6379> Cluster AddSlots 1 2 3
OK
127.0.0.1:6379>
  • Cluster SetSlot，设置指定节点的插槽信息

语法：Cluster SetSlot slot IMPORTING|MIGRATING|STABLE|NODE [node-id]，slot为插槽序列号，node-id为目标节点ID号

返回值：若取消成功，返回OK；否则返回出错信息。

实例：

127.0.0.1:6379> Cluster SetSlot 1 Migrating 14343qiuy54wq987fdaui
OK
127.0.0.1:6379>
  • Cluster GetKeysSinSlot，返回连接节点指定Hash Slot里的key

语法：Cluster GetKeySinSlot slot count，count为将要返回的插槽里的key兑现的列表

返回值：返回指定插槽下的key对象的列表，若没有key对象则返回空列表。

实例：

127.0.0.1:6379> Cluster GetKeySinSlot 2 10
nil
127.0.0.1:6379>
  • Cluster DelSlots，删除当前节点的指定插槽

语法：Cluster DelSlots slot [slot ……]

返回值：删除成功，返回OK；否则返回出错信息；

实例：

127.0.0.1:6379> Cluster DelSlots 2 3
OK
127.0.0.1:6379>
  • Cluster Slots，返回与插槽相关的节点信息

语法：Cluster Slots

返回值：执行成功，返回带IP/PORT映射的插槽范围列表。

实例：

127.0.0.1:6379> Cluster Slots
略
127.0.0.1:6379>
  • CLuster KeySlot，计算key应该被放置在哪个插槽上

语法：Cluster KeySlot key

返回值：返回指定key产生的韩系插槽序列号（整数）

实例：

127.0.0.1:6379> Cluster KeySlot MyfirstSet{hash_tag}
0
127.0.0.1:6379>

 

  • CLuster CountKeySinSlot，放回当前节点执行插槽中键的数量

语法：Cluster CountKeySinSlot slot

返回值：返回指定插槽下的keys的数量；如果插槽序列不合法，则返回出错信息。

实例： 

127.0.0.1:6379> Cluster CountKeySinSlot 1
0
127.0.0.1:6379>

 

三、Redis配置及参数

1、config配置文件

　　在Redis数据库系统刚刚安装完成启动数据库服务时，在操作系统环境下必须采用如下格式才能生成Redis.conf文件，不然，Redis会启动内存自带的配置文件（在硬盘安装路径下无法找到） 

[root@dream redis-5.0.5]# ./redis-server redis.conf

设置Redis.conf文件参数有以下几种形式：

 1）启动Redis服务器，带参数配置，该方法适合技术人员测试使用。

[root@dream Redis]# ./redis-server -slaveof 127.0.0.1 8000
[root@dream Redis]#

2）在Redis服务运行期间，通过配置命令，更改参数设置。

[root@dream etc]# pwd
/usr/local/redis/etc
[root@dream etc]# ls
appendonly.aof dump.rdb redis.conf
[root@dream etc]#Config Get *

 

Config Get *  获取当前节点的Redis.conf配置信息

deamonize no  是否启动守护进程，默认为no，设置为yes，就意味着启动守护进程

pidfile /var/run/redis.pid 当启动守护进程，可以在这里设置redis.pid文件的另存为路径。

port 6379   Redis服务数据库端口号

 

配置文件主要参数有：

常用General、快照SnapShotting、主从复制Replication、安全Security、限制Limits、AOF持久化Append Only Mode、Lua脚本运行最大时限Lua Scripting、Redis集群Redis Cluster、慢命令记录日志Slow Log、延迟监控Latency Monitor、数据集时间通知Event Notification、高级配置Advanced Config

127.0.0.1:6379> COnfig Get *
  1) "dbfilename"
  2) "dump.rdb"
  3) "requirepass"
  4) ""
  5) "masterauth"
  6) ""
  7) "cluster-announce-ip"
  8) ""
  9) "unixsocket"
 10) ""
 11) "logfile"
 12) ""
 13) "pidfile"
 14) "/var/run/redis_6379.pid"
 15) "slave-announce-ip"
 16) ""
 17) "replica-announce-ip"
 18) ""
 19) "maxmemory"
 20) "0"
 21) "proto-max-bulk-len"
 22) "536870912"
 23) "client-query-buffer-limit"
 24) "1073741824"
 25) "maxmemory-samples"
 26) "5"
 27) "lfu-log-factor"
 28) "10"
 29) "lfu-decay-time"
 30) "1"
 31) "timeout"
 32) "0"
 33) "active-defrag-threshold-lower"
 34) "10"
 35) "active-defrag-threshold-upper"
 36) "100"
 37) "active-defrag-ignore-bytes"
 38) "104857600"
 39) "active-defrag-cycle-min"
 40) "5"
 41) "active-defrag-cycle-max"
 42) "75"
 43) "active-defrag-max-scan-fields"
 44) "1000"
 45) "auto-aof-rewrite-percentage"
 46) "100"
 47) "auto-aof-rewrite-min-size"
 48) "67108864"
 49) "hash-max-ziplist-entries"
 50) "512"
 51) "hash-max-ziplist-value"
 52) "64"
 53) "stream-node-max-bytes"
 54) "4096"
 55) "stream-node-max-entries"
 56) "100"
 57) "list-max-ziplist-size"
 58) "-2"
 59) "list-compress-depth"
 60) "0"
 61) "set-max-intset-entries"
 62) "512"
 63) "zset-max-ziplist-entries"
 64) "128"
 65) "zset-max-ziplist-value"
 66) "64"
 67) "hll-sparse-max-bytes"
 68) "3000"
 69) "lua-time-limit"
 70) "5000"
 71) "slowlog-log-slower-than"
 72) "10000"
 73) "latency-monitor-threshold"
 74) "0"
 75) "slowlog-max-len"
 76) "1050"
 77) "port"
 78) "6379"
 79) "cluster-announce-port"
 80) "0"
 81) "cluster-announce-bus-port"
 82) "0"
 83) "tcp-backlog"
 84) "511"
 85) "databases"
 86) "16"
 87) "repl-ping-slave-period"
 88) "10"
 89) "repl-ping-replica-period"
 90) "10"
 91) "repl-timeout"
 92) "60"
 93) "repl-backlog-size"
 94) "1048576"
 95) "repl-backlog-ttl"
 96) "3600"
 97) "maxclients"
 98) "10000"
 99) "watchdog-period"
100) "0"
101) "slave-priority"
102) "100"
103) "replica-priority"
104) "100"
105) "slave-announce-port"
106) "0"
107) "replica-announce-port"
108) "0"
109) "min-slaves-to-write"
110) "0"
111) "min-replicas-to-write"
112) "0"
113) "min-slaves-max-lag"
114) "10"
115) "min-replicas-max-lag"
116) "10"
117) "hz"
118) "10"
119) "cluster-node-timeout"
120) "15000"
121) "cluster-migration-barrier"
122) "1"
123) "cluster-slave-validity-factor"
124) "10"
125) "cluster-replica-validity-factor"
126) "10"
127) "repl-diskless-sync-delay"
128) "5"
129) "tcp-keepalive"
130) "300"
131) "cluster-require-full-coverage"
132) "yes"
133) "cluster-slave-no-failover"
134) "no"
135) "cluster-replica-no-failover"
136) "no"
137) "no-appendfsync-on-rewrite"
138) "no"
139) "slave-serve-stale-data"
140) "yes"
141) "replica-serve-stale-data"
142) "yes"
143) "slave-read-only"
144) "yes"
145) "replica-read-only"
146) "yes"
147) "slave-ignore-maxmemory"
148) "yes"
149) "replica-ignore-maxmemory"
150) "yes"
151) "stop-writes-on-bgsave-error"
152) "yes"
153) "daemonize"
154) "no"
155) "rdbcompression"
156) "yes"
157) "rdbchecksum"
158) "yes"
159) "activerehashing"
160) "yes"
161) "activedefrag"
162) "no"
163) "protected-mode"
164) "yes"
165) "repl-disable-tcp-nodelay"
166) "no"
167) "repl-diskless-sync"
168) "no"
169) "aof-rewrite-incremental-fsync"
170) "yes"
171) "rdb-save-incremental-fsync"
172) "yes"
173) "aof-load-truncated"
174) "yes"
175) "aof-use-rdb-preamble"
176) "yes"
177) "lazyfree-lazy-eviction"
178) "no"
179) "lazyfree-lazy-expire"
180) "no"
181) "lazyfree-lazy-server-del"
182) "no"
183) "slave-lazy-flush"
184) "no"
185) "replica-lazy-flush"
186) "no"
187) "dynamic-hz"
188) "yes"
189) "maxmemory-policy"
190) "noeviction"
191) "loglevel"
192) "notice"
193) "supervised"
194) "no"
195) "appendfsync"
196) "everysec"
197) "syslog-facility"
198) "local0"
199) "appendonly"
200) "yes"
201) "dir"
202) "/usr/local/redis/etc"
203) "save"
204) "900 1 300 10 60 10000"
205) "client-output-buffer-limit"
206) "normal 0 0 0 slave 268435456 67108864 60 pubsub 33554432 8388608 60"
207) "unixsocketperm"
208) "0"
209) "slaveof"
210) ""
211) "notify-keyspace-events"
212) ""
213) "bind"
214) "127.0.0.1"
127.0.0.1:6379>
redis.conf

 

3）把Redis配置成为一个缓存

如果在实际的业务应用中，只把Redis当作缓存使用（不产生磁盘持久化功能），则需要对所有Keys对象配置指定过期时间（通过Expire命令）。这里可以采用如下方式一次性设置过期时间。

127.0.0.1:6379> Config Set maxmemory 2mb //假设最大内存使用时2MB
OK
127.0.0.1:6379> Config Set maxmemory-policy allkeys-lru
OK
127.0.0.1:6379>

 

2、配置文件参数

在Redis.conf文件中的主要参数如下：

1）常用配置参数

  • daemonize yes，守护进程，3.2版本前默认值为no，3.2版本后默认值为yes
  • pidfile /var/run/redis.pid，在daemonize yes的情况下可以生成的redis.pid文件指定其他路径，默认为/var/run/redis.pid
  • bind 127.0.0.1，用于绑定安装Redis数据库的服务器IP地址，默认是127.0.0.1
  • port 6379，Redis数据库监听端口，默认是6379，允许一台服务器装多个Redis数据库 ，在此情况下，必须用不通端口区分数据库实例。
  • timeout 300，设置客户端空闲时间是否超过时限，若超过时限，则连接的服务器将断开，默认是300秒；若设置为0，服务器就不会主动跟客户端断开连接。
  • tcp-keepalive 0，默认值是0，当设置为SO_KEEPALIVE值时，可以检测终止的客户端
  • loglevel notice，指定Redis数据库日志的级别：Debug，日志可以记录很多信息，方便开发、测试；werbose，默认值，记录的信息不如Debug级别多；notice，适合生产环境；warn，日志只记录非常重要的信息
  • logfile /var/log/redis.log，指定Redis日志文件名及存放路径，如果指定内容为空，则日志打印到标准输出设备
  • databases 16，在Redis一个数据库系统实例上，可以建立的数据库数量，默认是16个。

2）快照诶之参数

  • save
    • save 900 1  //900秒内至少1个key被改变，则把数据持久化到磁盘上
    • save 300 10 //300秒内至少有10额key被改变，则把数据持久化到磁盘上
    • save 60 10000 //60秒内至少有10000个key被改变，则把数据持久化到磁盘上
  • stop-writes-on-bgsave-error yes，当采用RDB方式持久化出现错误后，是否继续进行持久化工作？默认设置为yes。
  • rdbcompression yes，存储至本地磁盘上时是否压缩数据，默认为yes
  • dbfilename dump.rdb，存储到本地磁盘的数据库文件名，默认为dump.rdb
  • dir /var/lib/redis ，指定的数据库存放路径，默认为./

3）复制配置参数

  • slaveof 10.0.0.12 6379，当本机为从服务节点时，设置主服务节点的IP及端口号
  • masterauth <master-password>，如果Master节点数据库通过requirepass参数设置了访问密码，nameSlave节点连接对应的Master节点前，必须用该参数设置与Master对应的密码，才能访问Master节点。在不使用该参数的情况下，默认用#符号注释掉了该参数
  • slave-server-stale-data yes，当Slave节点与Master节点连接断开或正在进行主从复制时，从数据库有以下两种运行方式：1）yes 从数据库继续响应客户端请求；2）no，从数据库仅执行Info和Slaveof命令
  • slave-read-only yes，默认值yes，保证Slave节点只允许客户端读取数据；no，则允许往Slave希尔数据，一般不建议这么做。
  • repl-diskless-sync no
  • repl-diskless-sync-delay 5
  • repl-disable-tcp-nodelay no
  • slave-prioprity 100

4）安全配置参数

  • requirepass foobared，该参数默认被#注释（不启用），如果Redis节点数据要求被使用密码访问，则通过启用该参数，强制要求客户端访问节点时，提供AUTH命令来认证密码
  • rename-commandCONFIG 74983yhrea8rehureourwoiukjfklds

5）限制配置参数

  • maxclients 10000，客户端最大连接数，默认是10000
  • maxmemory <bytes>，设置Redis数据库系统运行的最大内存数值。
  • maxmemory-policy noeviction，当使用内存超过maxmemory设置值后，可以采用以下6种处理方式：
    • volatile-lru，使用LRU算法删除带有过期（Expire）设置的key对象
    • allkeys-lru，根据LRU算法删除任何key对象
    • volation-random，根据随机函数删除带有过期设置的key对象
    • allkeys-random，根据随机数删除任何被确定的key对象
    • volatile-ttl，删除最近过期时间（次要TTL）的key对象
    • noeviction，所有内存key对象不过期，只是在超出内存最大限制范围后，返回出错信息给写操作对象。默认被#注释

6）AOF持久化配置参数

  • appendonly no
  • appendfilename Appendonly.aof
  • appendfsync everysec
  • no-appendfsync-on-rewrite no
  • auto-aof-rewrite-percentage 100
  • auto-aof-write-min-size 64mb
  • aof-load-truncated yes 

7）Lua脚本配置参数

  • lua-time-limit 5000，这是Lua脚本最大执行时间（单位：毫秒），5000毫秒为默认时间；其值为0时，将无线时地执行Lua脚本。当Lua脚本执行时间超过该参数的设置时限后，脚本继续执行，Redis将记录脚本的相关信息，而且Redis只有SCRIPT KILL和SHUTDOWN NOSAVE可用。

8）集群配置参数

  • cluster-enabled yes
  • cluster-config-file nodes-6379.conf
  • cluster-node-timeout 15000
  • cluster-slave-validity-factor 10
  • cluster-migration-barrier 1
  • cluster-require-full-coverage yes

9）慢命令记录

  • slowlog-log-slower-than 1000
  • slowlog-max-len 128

10）延迟监控配置参数

  • latency-monitor-treshold 0，监控超过设置数的而延迟操作命令，如100毫秒，默认为0（毫秒）代表关闭该监控功能。

11）数据集时间通知配置参数

  • notify-keyspace-events ""，以订阅方式接受那些改动了数据集合内容的事件命令，因为开启该方式会消耗一些CPU计算资源，所以默认配置下不使用该参数。

12）高级配置参数

  • 略，详见Redis官方文档。 

四、JAVA连接Redis数据库

　　Redis支持C、C#、C++、D、GO、Jave、Perl、PHP、Python、R、Ruby等代码语言的开发。

1、Redis连接配置

 　　Java开发工具（如Eclipse）单独生成redis-config.properties文件，用于Java项目的参数配置，其基本配置内容如下：

ip=127.0.0.1:6379  //Redis数据库系统链接地址和端口号，只有配置文件参数和在服务器上实际数据库系统安装内容一致，才能正确建立应用系统和数据库的连接
maxActive=1000 //单个应用中的连接池最大连接数，默认为8.在生产环境下，具体连接数大小，应该根据压力测试工具的测试效果或实际使用观察结果，进行合理调整。在实际生产环境下，该值最大值和最小值都受限制
maxIdle=100 //单个应用中的连接池取连接时最大空闲数，默认为8.空闲连接数太多，容易占用服务器资源，连接数太少影响客户端用户使用感受
maxWait=10000 //单个应用中的连接池取连接时最大等待时间（单位：毫秒），默认-1时不等待
testOnBorrow=false //设置每一次取对象时测试ping，以验证连接有效性
timeout=2000 //设置Redis connect request reesponse timeout（单位：毫秒）
cluster.ip=127.0.0.1:6379 //Redis集群链接地址，可以用分隔符号连续提供多节点地址

2、Redis初始化工具类

　　1）下载Windows版redis：https://github.com/MSOpenTech/redis/releases

 　　

 　　2）解压Redis、配置并运行

解压后，我们可以看到有可执行文件、配置文件、文档说明等等

  

 配置文件我只修改了密码：打开redis.windows.conf 这个配置文件，搜索masterauth，找到# masterauth <master-password>，去掉注释并把<master-password>改为你的密码

masterauth 123456

配置文件修改完成后，在Redis目录下按住Shift+鼠标右键，点击“在此处打开命令窗口”打开cmd，使用以下命令运行Redis服务器

redis-server  redis.windows.conf

成功运行的话，你将看到一个大大的Redis logo

　　3）下载Jar包（commons-pool2-2.4.2.jar、jedis-2.9.0.jar）

　　4）创建java project并导入2个包

　　

 

　　5）测试

在测试前，请确保你的Redis服务器正在运行
[ RedisTest.java ]

package com.yorichan.test;

import org.junit.Before;
import org.junit.Test;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

public class RedisTest {

    JedisPool pool;
    Jedis jedis;

    @Before
    public void start() {

        // 初始化Redis连接池
        pool = new JedisPool(new JedisPoolConfig(), "127.0.0.1");
        // 从Redis连接池中获取一个连接
        jedis = pool.getResource();
        // Redis的密码，对应redis.windows.conf中的masterauth
        jedis.auth("123456");

    }

    /**
     * 添加测试
     */
    @Test
    public void putTest() {

        jedis.set("user", "YoriChan");
        System.out.println(jedis.get("user"));

        // 输出结果：YoriChan

    }

    /**
     * 覆盖测试
     */
    @Test
    public void overWriteTest() {

        jedis.set("user", "chanyulin");
        System.out.println(jedis.get("user"));

        // 输出结果：chanyulin

    }

    /**
     * 追加测试
     */
    @Test
    public void appendTest() {

        jedis.append("user", "陈昱霖");
        System.out.println(jedis.get("user"));

        // 输出结果：chanyulin陈昱霖

    }

    /**
     * 删除测试
     */
    @Test
    public void deleteTest() {

        jedis.del("user");
        System.out.println(jedis.get("user"));

        // 输出结果：null

    }

}

书本上的案例：

//Java 的驱动包
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;
//Redis 的驱动包
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

/**
 * 代码功能描述：连接Redis数据库
 */
public class RedisOper{ //自定义连接公共类，供其他代码调用
    /**
     * @return
     * @throws IOException
     */
    public static JedisPool initPool() throws IOException{
        //加载Redis配置文件
        InputStreem inputStreem=RedisClusterUtil.class.getClass().getResourceAsStream("/redis-config.properties");
        Properties properties=new Properties();
        properties.load(inputStreem);
        //初始化Redis连接池配置，即把配置文件参数指定给连接代码
        JedisPoolConfig config=new JedisPoolConfig();
        config.setMaxTotal(Integer.valueOf(properties.getProperty("maxActive")));
        config.setMaxIdle(Integer.valueOf(properties.getProperty("maxIdle")));
        config.setMaxWaitMillis(Long.valueOf(properties.getProperty("maxWait")));
        config.setTestOnBorrow(Boolean.valueOf(properties.getProperty("testOnBorrow")));
        String [] address=properties.getProperty("ip").split(":");
        //初始化Redis连接池，实现客户端程序，通过连接池与Redis数据库建立连接
        JedisPool pool=new JedisPool(config,address[0],Integer.valueOf(address[1]),Integer.valueOf(properties.getProperty("timeout")));
        return pool;
    }
    
    public static void main(String [] args){
        System.out.println("Hello World!");
    }
}

 

　　

 

　　6）Jedis所能提供的客户端支持功能（主要是类），如下：

序号 类英文名 功能描述 说明
1 Connectiion 普通连接数据库配置类 与Jedis配合使用
2 Jedis 普通初始化连接类 在该类实例上可以直接调用命令，如jedis.set("title","《C语言》")　　
3 JedisPool 带连接池初始化连接类 本文主要用该方式
4 JedisPoolConfig　　 带连接池连接配置类 使用过程与Connection类似
5 JedisCluster 带集群功能初始化连接类 该类支持的客户端命令类似Jedis
6 Pipeline 带管道功能初始化连接类　　 该类支持的客户端命令类似Jedis
7 …… …… ……

　　对于Jedsi提供的所有类及所能提供的各种命令API接口，可以参考如下地址的详细内容http://xetorthio.github.io/jedis/

 

 

五、管道

　　为了提高客户端与服务端之间多命令的执行效率，Redis引入了管道（Pipelining）技术。

　　管道的技术原理：先批量发送命令，而不是一条一条地返回执行命令，等服务器接收所有命令后，在服务端一起执行，最后把结果一次性发送回客户端。这样既可以减少命令的返回次数，并减少阻塞时间，被证明是可以大幅提高命令的执行效率的。

　　基于Java的管道技术使用：书P332页

六、分布式集群

1、集群安装

1）安装清单

Master1:127.0.0.1:8000 //主节点1，指定IP：Port

Slave1:127.0.11:8010 //从节点1，指定IP：Port

Master2：127.0.0.2:8001 //主节点2，指定IP：Port

Slave2：127.0.0.12:8011 //从节点2，指定IP：Port

Master3:127.0.0.3:8002 //主节点3，指定IP：Port

Slave3:127.0.0.13:8012 //从节点3，指定IP：Port

Redis官方建议构建Redis集群的最小数量为6个节点：3个主节点、3个从节点。从节点用于复制备份主节点数据，当主节点出现故障时，从节点可以快速切换为主节点。

另外主从方式，为读写分离设计提供了技术支持。

2）在Linux操作环境下，安装集群

Redis提供两种安装集群的方法：1）手工命令安装；2）采用集群安装工具（redis-trib工具）。由于手工安装过程比较容易出错，这里采用集群工具安装方法快速安装集群。

第一步：下载、解压、编译、安装Redis安装包

第二步：将Redis-trib.rb文件复制到/usr/local/bin/路径下

第三步：在Linux操作系统上建立安装集群的子文件路径，例如：/root/software/redis_cluster/8001 //主节点1的安装路径

第四步：修改配置文件（/usr/local/etc/redis.conf），并复制到指定的子路径上

prot 8001 //端口
bind 127.0.0.1 //实际服务器IP
demonize yes //启动redis后台守护进程
pidfile /var/run/redis_8001.pid //pid文件
cluster-enabled yes //开启集群，把注释#去掉
cluster-config-file nodes_8001.conf //集群节点配置，配置文件首次启动自动生成
cluster-node-timeout 15000 //集群节点互连超时设置，默认15秒
appendonly yes //开启AOF持久化

　　修改并确保Redis.conf被修改，然后把该文件复制到cp redis.conf /root/software/redis_cluster/8001

　　复制完成8001节点的配置文件后，用vi修改redis.conf参数并复制到下一个对应的节点文件路径下，直到6个节点的配置文件都复制完成。

第五步：把redis-server可执行文件复制到6个节点的文件路径下cp redis-server /root/software/redis_cluster/8001

　　依次执行上述命令6次，确保把redis-server可执行文件都复制到指定的节点文件路径下。

第六步：启动所有节点

cd /root/software/redis_cluster/8000
redis-server ./redis.conf

cd /root/software/redis_cluster/8001
redis-server ./redis.conf

cd /root/software/redis_cluster/8002
redis-server ./redis.conf

　　可以用Linux的ps -ef|grep redis命令查看6个节点是否启动成功

第七步：升级rubby并安装gem。

　　Redis-trib是ruby语言开发完成的，所以要安装ruby才能使用该工具。

　　从ruby官网下载ruby-2.4.tar.gz，http://www/ruby-lang.org/en/downloads/

在Linux上进行解压编译，然后安装：

yum -y install ruby ruby-devel rubygems rpm-build
gem install redis

第八步：用redis-trib.rb命令创建集群

redis-trib.rb create -replicas 1 127.0.0.1:8000 127.0.0.1:8001 127.0.0.1:8002 //replicas 1表示一个主节点必须有一个从节点

　　在redis-trib.rb命令后，若执行成功，将会出现若干条提示信息。其中有一条是Can I set the above configuration？（type 'Yes' to accept）:，输入yes即可。然后会提示一系列集群简历信息。信息中M表示Master、S小时Slave

第九步：测试集群

　　在集群安装完成后，可以通过客户端来测试一下，看看集群是否可以正常使用，这里采用Redis-cli工具来实现。 

2、节点故障模拟

1）模拟节点故障，使用kill命令强制终止某进程号，ps -ef|grep redis

2）cluster nodes命令查看集群节点运行情况：redis-cli -c -p 8001 

3）把8002恢复为8012的从节点，操作P340

../../src/redis-server --port 8002 
--cluster-enabled yes 
--cluster-confgi-file nodes-8002.conf 
--cluster-node-timeout 15000 
--appendonly yes 
--appendfilename appendonly-8002.aof 
--dbfilename dump-8002.rdb 
--logfile 8002.log 
--deamonize yes

4）用Cluster nodes命令查看8001的从服务节点是否自动分配到8012

./redis-trib.rb add-node --slave --master-id e165b578932ed7dda1a90e-5acaba  127.0.0.1:8002

3、加减节点

　　随着业务的发展，可能需要加减集群节点。

1）增加一个主节点，端口为8003

先建立一个子文件夹路径8003，并启动该节点8003数据库服务进程。然后用redis-trib.rb工具实现新主节点的添加

./redis-trib.rb add-node 127.0.0.1:8003 127.0.0.2:8000

在redis-cli环境下，用Cluster nodes可以查找到8003节点一斤被添加到集群之中了。

Clu nodes

2）为8003主节点增一个从节点

先按照增加8003的方式，新增一个从节点8013，并启动。然后通过redis-trib.rb工具把8013从节点添加到8003主节点上

./redis-trib.rb add-node --slave --master-id fcbe1bnbnmbcddzse2324344dec 127.0.0.1:8013 127.0.0.1:8000//其中8000为正常使用的节点，8013为新增的从节点

3）移除一个节点

可以用redis-trib.rb工具类实现

./redis-trib.rb del-node 127.0.0.1:8000 fcbe1bnbnmbcddzse2324344dec

用Cluster nodes命令检查执行结果，也可以用redis-trib.rb工具查看删除情况。

./redis-trib.rb info 127.0.0.1:8000  //可以再任意主节点上执行该命令

4）迁移节点数据

使用redis-trib.rb工具

格式：./redis-trib.rb reshard <host>:<port> --from <node-id> --to <node-id> --slots <args> --yes

实例：./redis-trib.rb reshard 127.0.0.1:8000 -from all to fcbe1bnbnmbcddzse2324344dec -slots 4000 --yes

 

七、Lua脚本

　　Lua脚本类似关系型数据库的存储过程。Luaa是一种独立的脚本编程语言，他的优点是能很方便地嵌入到其他语言中，然后被调用。

1、Lua脚本的基础知识

　　1）减少网络开销：在交互模式下，相关代码从客户端传到服务端执行命令，是需要产生额外的通信带宽消耗，同时会产生通信时间延迟的问题，而把部分特殊代码直接放到服务器端执行，则可以解决因交互而产生的额外的网络开销问题。

　　2）原子操作 ：Lua脚本在服务端执行时，将采用排他性行为，也就是脚本代码执行时，其他命令或脚本无法在同一个服务端执行（除了极个别命令外）；同时命令实现要么都被执行，要么都被放弃，具有完整的执行原子性。

　　3）服务器端快速代码替换：Lua脚本第一次被执行后，将一直保存在服务器端的脚本缓存中，可以提供其他客户端持续调用，小龙搞，占用内存少。需要改变Lua脚本代码时，只需要更新内存中的脚本内容即可，无需修改业务系统的原始代码，这样做的好处是在代码更新过程中对客户端几乎不产生操作影响，同时方便了技术人员对业务规则或算法的灵活更新。

2、Lua脚本实现案例

 Redis数据库系统已经内嵌了Lua脚本运行环境，可以直接在客户端提交相关的Lua脚本命令。

这里通过Lua脚本来实现指定客户端IP地址用户，对两个字符串值的同步修改。

#!/usr/local/bin/lua
--体现Lua的原子性，快速性，代码可替代性
--在Redis环境下，Lua脚本不允许使用全局变量，所以必须限制为Local变量
local key1=KEYS[1] //字符串1
local key2=KEYS[2] //字符串2
local Amount=tonumber(ARGV[1])

local is_exists1=redis.call("EXISTS",key1)
local is_exists2=redis.call("EXISTS",key2)

if is_exists1==1 and is_exists2==1 then //确保传入的key1、key2对象都存在
    redis.call("DecrBy",key1,Amount) //减指定数量
    redis.call("Set",key2,Amount)  //设置指定数量
    return 0
else
    return 1
end

以上Lua脚本两种执行方式：在Redis-cli客户端上执行Eval命令；在Java代码上调用该脚本代码（要事先在Java调用代码项目立把上述脚本代码存入script.lua文件中） 

private boolean AtomicityOperator(String ip,int amount,Jedis connetion)
throws IOException{
    Jedis.set("key1",10);
    List<String> key1=Jedis.get("key1",0);
    return 1==(long)connetion.eval(loadScriptString("script.lua"),2,key1,key2,argv);
}
private String loadScriptString(String fileName) throws IOException{
    Reader reader =new InputStream(Client.class.getClassLoader().getResourceAsStream(fileName));
    return CharStreams.toString(reader);
}

Lua脚本应用于抢红包项目的经典案例，参考：https://blog.csdn.net/hengyunabc/article/details/19433779,《利用redis+lua解决抢红包高并发的问题》

 

八、客户化管理工具

　　在掌握蟾宫命令操作Redis数据库的基础上，需要一个更直观的图形化操作界面客户端工具，可选择的客户端有：Redis Desktop Manager、Redis Client、RedisStudio、Redismin/proxy四款Redis客户端客户观管理工具。

　　简要介绍：

1、Redis Desktop Manager

　　Redis Desktop Manager是一款开源的Redis数据库管理工具，用C++编写而成，主要支持的操作系统包括Windows 7+，Mac OS X 10.11+、Ubuntu 14+、Linux Mint|Fedora|CentOS|OpensUSE。

　　主要特点是响应迅速、性能好。支持对key对象进行直接的新增、修改、参数等操作，支持控制台命令操作、支持数据库文件的导出导入操作。。

　　下载地址：https://github.com/uglide/RedisDestopManager

2、Redis Client

　　Redis Client，国产软件，发布人为曹新宇，开源，使用Java swt和Jedis编写。

　　主要功能，可以帮助Redis开发人员和维护人员方便地建立、修改、删除、查询Redis数据，可以让用户方便地编辑数据，可以剪切、复制、粘贴Redis数据，可以导入导出Redis数据，可以对Redis数据排序。

　　下载地址：https://gitbub.com/caoyinyu/RedisClient

3、RedisStudio

　　RedisStudio工具基于Windows操作系统的Redis数据库客户端工具，由cinience（国内昵称）用C/C++开发而成，开源。

　　主要功能，包括与Redis数据库的连接、Redis服务器 信息的获取、Redis数据库的操作、配置管理、命令控制台功能等。

　　下载地址：https://github.com/cinience/RedisStudio

4、Redismin/proxy

　　Redismin/proxy是一款功能齐全的Redis数据库管理和监视工具，由法国人FGRibreau编写，开源，用C++编写而成。支持的操作包括Windows系列、Mac OSX、Debian/Ubuntn、Linux系列，具体版本分为免费版、优先授权版和完全授权版。

　　主要功能，包括对Redis集群的全面操作管理及高级监管能力、对云平台下的应用支持，支持基于防火墙运行环境下的绑定应用等。

　　下载地址：https://github.com/Redismin/proxy

posted @ 2020-03-16 12:27  航松先生  阅读(3)  评论(0)    收藏  举报