Redis基础(官方文档总结)

柔光的暖阳◎ 2023-07-24 14:54 15阅读 0赞

1.  配置主从  
    例如。为MySQL 服务器配置主从。一台者机，另一台可以顶上继续服务，以满足高  
    可用的要求。
2.  读写分离  
    配置一主多从。因为一般系统80 % 的请求都是读取操作，将这些操作分发到从服务器  
    上可以有效地提升网站响应速度。
3.  分库分表  
    随着数据量的增长，单库单表已经难以满足要求。一些诸如TDDL 、C obar 、MyCAT  
    等的MySQL 分布式数据库中间件应运而生。

# REmote DIctionary Server(Redis) #

Redis是一个开源的使用ANSI C语言编写、遵守BSD协议、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API。

它通常被称为数据结构服务器，因为值（value）可以是 字符串(String), 哈希(Map), 列表(list), 集合(sets) 和 有序集合(sorted sets)等类型。

更多详细数据请见官方bench-mark page（[http://code.google.com/p/redis/wiki/Benchmarks][http_code.google.com_p_redis_wiki_Benchmarks]）

# 安装 #

学习玩windows ,Linux都差不多.

安装略

# 配置 #

Redis 的配置文件位于 Redis 安装目录下，文件名为 redis.conf。

你可以通过 **CONFIG** 命令查看或设置配置项。

--------------------

### 语法 ###

Redis CONFIG 命令格式如下：

redis 127.0.0.1:6379> CONFIG GET CONFIG_SETTING_NAME

### 实例 ###

redis 127.0.0.1:6379> CONFIG GET loglevel
    
    1) "loglevel"
    2) "notice"

使用 \*\*\*\*\* 号获取所有配置项：

### 实例 ###

redis 127.0.0.1:6379> CONFIG GET *

## 编辑配置 ##

你可以通过修改 redis.conf 文件或使用 **CONFIG set** 命令来修改配置。

**在Linux下建议复制一份 redis.conf再配置.**

**然后使用复制的配置文件来启动redis**

redis-server /etc/redis.conf

3.2.100 有个134条

### 语法 ###

**CONFIG SET** 命令基本语法：

redis 127.0.0.1:6379> CONFIG SET CONFIG_SETTING_NAME NEW_CONFIG_VALUE

### 例 ###

redis 127.0.0.1:6379> CONFIG SET loglevel "notice"
    OK
    redis 127.0.0.1:6379> CONFIG GET loglevel
    
    1) "loglevel"
    2) "notice"

--------------------

## 参数说明 ##

redis.conf 配置项说明如下：

\\1. Redis默认不是以守护进程的方式运行，可以通过该配置项修改，使用yes启用守护进程

**daemonize no**

\\2. 当Redis以守护进程方式运行时，Redis默认会把pid写入/var/run/redis.pid文件，可以通过pidfile指定

**pidfile /var/run/redis.pid**

\\3. 指定Redis监听端口，默认端口为6379，作者在自己的一篇博文中解释了为什么选用6379作为默认端口，因为6379在手机按键上MERZ对应的号码，而MERZ取自意大利歌女Alessia Merz的名字

**port 6379**

\\4. 绑定的主机地址

**bind 127.0.0.1**

\\5.当 客户端闲置多长时间后关闭连接，如果指定为0，表示关闭该功能

**timeout 300**

\\6. 指定日志记录级别，Redis总共支持四个级别：debug、verbose、notice、warning，默认为verbose

**loglevel verbose**

\\7. 日志记录方式，默认为标准输出，如果配置Redis为守护进程方式运行，而这里又配置为日志记录方式为标准输出，则日志将会发送给/dev/null

**logfile stdout**

\\8. 设置数据库的数量，默认数据库为0，可以使用SELECT `<dbid>`命令在连接上指定数据库id

**databases 16**

\\9. 指定在多长时间内，有多少次更新操作，就将数据同步到数据文件，可以多个条件配合

**save**

Redis默认配置文件中提供了三个条件：

**save 900 1**

**save 300 10**

**save 60 10000**

分别表示900秒（15分钟）内有1个更改，300秒（5分钟）内有10个更改以及60秒内有10000个更改。

\\10. 指定存储至本地数据库时是否压缩数据，默认为yes，Redis采用LZF压缩，如果为了节省CPU时间，可以关闭该选项，但会导致数据库文件变的巨大

**rdbcompression yes**

\\11. 指定本地数据库文件名，默认值为dump.rdb

**dbfilename dump.rdb**

\\12. 指定本地数据库存放目录

**dir ./**

\\13. 设置当本机为slav服务时，设置master服务的IP地址及端口，在Redis启动时，它会自动从master进行数据同步

**slaveof**

\\14. 当master服务设置了密码保护时，slav服务连接master的密码

**masterauth**

\\15. 设置Redis连接密码，如果配置了连接密码，客户端在连接Redis时需要通过AUTH `<password>`命令提供密码，默认关闭

**requirepass foobared**

\\16. 设置同一时间最大客户端连接数，默认无限制，Redis可以同时打开的客户端连接数为Redis进程可以打开的最大文件描述符数，如果设置 maxclients 0，表示不作限制。当客户端连接数到达限制时，Redis会关闭新的连接并向客户端返回max number of clients reached错误信息

**maxclients 128**

\\17. 指定Redis最大内存限制，Redis在启动时会把数据加载到内存中，达到最大内存后，Redis会先尝试清除已到期或即将到期的Key，当此方法处理 后，仍然到达最大内存设置，将无法再进行写入操作，但仍然可以进行读取操作。Redis新的vm机制，会把Key存放内存，Value会存放在swap区

**maxmemory**

\\18. 指定是否在每次更新操作后进行日志记录，Redis在默认情况下是异步的把数据写入磁盘，如果不开启，可能会在断电时导致一段时间内的数据丢失。因为 redis本身同步数据文件是按上面save条件来同步的，所以有的数据会在一段时间内只存在于内存中。默认为no

**appendonly no**

\\19. 指定更新日志文件名，默认为appendonly.aof

**appendfilename appendonly.aof**

\\20. 指定更新日志条件，共有3个可选值： **no**：表示等操作系统进行数据缓存同步到磁盘（快） **always**：表示每次更新操作后手动调用fsync()将数据写到磁盘（慢，安全） **everysec**：表示每秒同步一次（折衷，默认值）

**appendfsync everysec**

\\21. 指定是否启用虚拟内存机制，默认值为no，简单的介绍一下，VM机制将数据分页存放，由Redis将访问量较少的页即冷数据swap到磁盘上，访问多的页面由磁盘自动换出到内存中（在后面的文章我会仔细分析Redis的VM机制）

**vm-enabled no**

\\22. 虚拟内存文件路径，默认值为/tmp/redis.swap，不可多个Redis实例共享

**vm-swap-file /tmp/redis.swap**

\\23. 将所有大于vm-max-memory的数据存入虚拟内存,无论vm-max-memory设置多小,所有索引数据都是内存存储的(Redis的索引数据 就是keys),也就是说,当vm-max-memory设置为0的时候,其实是所有value都存在于磁盘。默认值为0

**vm-max-memory 0**

\\24. Redis swap文件分成了很多的page，一个对象可以保存在多个page上面，但一个page上不能被多个对象共享，vm-page-size是要根据存储的 数据大小来设定的，作者建议如果存储很多小对象，page大小最好设置为32或者64bytes；如果存储很大大对象，则可以使用更大的page，如果不 确定，就使用默认值

**vm-page-size 32**

\\25. 设置swap文件中的page数量，由于页表（一种表示页面空闲或使用的bitmap）是在放在内存中的，，在磁盘上每8个pages将消耗1byte的内存。

**vm-pages 134217728**

\\26. 设置访问swap文件的线程数,最好不要超过机器的核数,如果设置为0,那么所有对swap文件的操作都是串行的，可能会造成比较长时间的延迟。默认值为4

**vm-max-threads 4**

\\27. 设置在向客户端应答时，是否把较小的包合并为一个包发送，默认为开启

**glueoutputbuf yes**

\\28. 指定在超过一定的数量或者最大的元素超过某一临界值时，采用一种特殊的哈希算法

**hash-max-zipmap-entries 64**

**hash-max-zipmap-value 512**

\\29. 指定是否激活重置哈希，默认为开启（后面在介绍Redis的哈希算法时具体介绍）

**activerehashing yes**

\\30. 指定包含其它的配置文件，可以在同一主机上多个Redis实例之间使用同一份配置文件，而同时各个实例又拥有自己的特定配置文件

**include /path/to/local.conf**

# redis数据类型 #

## String（字符串） ##

string是redis最基本的类型，你可以理解成与Memcached一模一样的类型，一个key对应一个value。

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

string类型是Redis最基本的数据类型，一个键最大能存储512MB。

### 实例 ###

redis 127.0.0.1:6379> SET name "redis.net.cn"OKredis 127.0.0.1:6379> GET name"redis.net.cn"

在以上实例中我们使用了 Redis 的 **SET** 和 **GET** 命令。键为 name，对应的值为redis.net.cn。

## Redis 字符串命令 ##

下表列出了常用的 redis 字符串命令：

<table> 
 <thead> 
  <tr> 
   <th align="left">序号</th> 
   <th align="left">命令及描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">1</td> 
   <td align="left">[SET key value] 设置指定 key 的值</td> 
  </tr> 
  <tr> 
   <td align="left">2</td> 
   <td align="left"><a href="https://www.redis.net.cn/tutorial/8670.html" rel="nofollow">GET key</a> 获取指定 key 的值。</td> 
  </tr> 
  <tr> 
   <td align="left">3</td> 
   <td align="left"><a href="https://www.redis.net.cn/tutorial/8671.html" rel="nofollow">GETRANGE key start end</a> 返回 key 中字符串值的子字符</td> 
  </tr> 
  <tr> 
   <td align="left">4</td> 
   <td align="left"><a href="https://www.redis.net.cn/tutorial/8672.html" rel="nofollow">GETSET key value</a> 将给定 key 的值设为 value ，并返回 key 的旧值(old value)。</td> 
  </tr> 
  <tr> 
   <td align="left">5</td> 
   <td align="left"><a href="https://www.redis.net.cn/tutorial/8673.html" rel="nofollow">GETBIT key offset</a> 对 key 所储存的字符串值，获取指定偏移量上的位(bit)。</td> 
  </tr> 
  <tr> 
   <td align="left">6</td> 
   <td align="left">[MGET key1 <a href="https://www.redis.net.cn/tutorial/8674.html" rel="nofollow">key2…]</a> 获取所有(一个或多个)给定 key 的值。</td> 
  </tr> 
  <tr> 
   <td align="left">7</td> 
   <td align="left"><a href="https://www.redis.net.cn/tutorial/8675.html" rel="nofollow">SETBIT key offset value</a> 对 key 所储存的字符串值，设置或清除指定偏移量上的位(bit)。</td> 
  </tr> 
  <tr> 
   <td align="left">8</td> 
   <td align="left"><a href="https://www.redis.net.cn/tutorial/8676.html" rel="nofollow">SETEX key seconds value</a> 将值 value 关联到 key ，并将 key 的过期时间设为 seconds (以秒为单位)。</td> 
  </tr> 
  <tr> 
   <td align="left">9</td> 
   <td align="left"><a href="https://www.redis.net.cn/tutorial/8677.html" rel="nofollow">SETNX key value</a> 只有在 key 不存在时设置 key 的值。</td> 
  </tr> 
  <tr> 
   <td align="left">10</td> 
   <td align="left"><a href="https://www.redis.net.cn/tutorial/8678.html" rel="nofollow">SETRANGE key offset value</a> 用 value 参数覆写给定 key 所储存的字符串值，从偏移量 offset 开始。</td> 
  </tr> 
  <tr> 
   <td align="left">11</td> 
   <td align="left"><a href="https://www.redis.net.cn/tutorial/8679.html" rel="nofollow">STRLEN key</a> 返回 key 所储存的字符串值的长度。</td> 
  </tr> 
  <tr> 
   <td align="left">12</td> 
   <td align="left">[MSET key value <a href="https://www.redis.net.cn/tutorial/8680.html" rel="nofollow">key value …]</a> 同时设置一个或多个 key-value 对。</td> 
  </tr> 
  <tr> 
   <td align="left">13</td> 
   <td align="left">[MSETNX key value <a href="https://www.redis.net.cn/tutorial/8681.html" rel="nofollow">key value …]</a> 同时设置一个或多个 key-value 对，当且仅当所有给定 key 都不存在。</td> 
  </tr> 
  <tr> 
   <td align="left">14</td> 
   <td align="left"><a href="https://www.redis.net.cn/tutorial/8682.html" rel="nofollow">PSETEX key milliseconds value</a> 这个命令和 SETEX 命令相似，但它以毫秒为单位设置 key 的生存时间，而不是像 SETEX 命令那样，以秒为单位。</td> 
  </tr> 
  <tr> 
   <td align="left">15</td> 
   <td align="left"><a href="https://www.redis.net.cn/tutorial/8683.html" rel="nofollow">INCR key</a> 将 key 中储存的数字值增一。</td> 
  </tr> 
  <tr> 
   <td align="left">16</td> 
   <td align="left"><a href="https://www.redis.net.cn/tutorial/8684.html" rel="nofollow">INCRBY key increment</a> 将 key 所储存的值加上给定的增量值（increment） 。</td> 
  </tr> 
  <tr> 
   <td align="left">17</td> 
   <td align="left"><a href="https://www.redis.net.cn/tutorial/8685.html" rel="nofollow">INCRBYFLOAT key increment</a> 将 key 所储存的值加上给定的浮点增量值（increment） 。</td> 
  </tr> 
  <tr> 
   <td align="left">18</td> 
   <td align="left"><a href="https://www.redis.net.cn/tutorial/8686.html" rel="nofollow">DECR key</a> 将 key 中储存的数字值减一。</td> 
  </tr> 
  <tr> 
   <td align="left">19</td> 
   <td align="left"><a href="https://www.redis.net.cn/tutorial/8687.html" rel="nofollow">DECRBY key decrement</a> key 所储存的值减去给定的减量值（decrement） 。</td> 
  </tr> 
  <tr> 
   <td align="left">20</td> 
   <td align="left"><a href="https://www.redis.net.cn/tutorial/8688.html" rel="nofollow">APPEND key value</a> 如果 key 已经存在并且是一个字符串， APPEND 命令将 value 追加到 key 原来的值的末尾。</td> 
  </tr> 
 </tbody> 
</table>

## Hash（哈希） ##

Redis hash 是一个键值对集合。

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

### 实例 ###

redis 127.0.0.1:6379> HMSET user:1 username redis.net.cn password redis.net.cn points 200OKredis 127.0.0.1:6379> HGETALL user:1
    1) "username"
    2) "redis.net.cn"
    3) "password"
    4) "redis.net.cn
    "5) "points"
    6) "200"redis 
    127.0.0.1:6379>

### Redis 列表命令 ###

下表列出了列表相关的基本命令：

<table> 
 <thead> 
  <tr> 
   <th align="left">序号</th> 
   <th align="left">命令及描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">1</td> 
   <td align="left">[BLPOP key1 <a href="https://www.redis.net.cn/order/3577.html" rel="nofollow">key2 ] timeout</a> 移出并获取列表的第一个元素， 如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止。</td> 
  </tr> 
  <tr> 
   <td align="left">2</td> 
   <td align="left">[BRPOP key1 <a href="https://www.redis.net.cn/order/3578.html" rel="nofollow">key2 ] timeout</a> 移出并获取列表的最后一个元素， 如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止。</td> 
  </tr> 
  <tr> 
   <td align="left">3</td> 
   <td align="left"><a href="https://www.redis.net.cn/order/3579.html" rel="nofollow">BRPOPLPUSH source destination timeout</a> 从列表中弹出一个值，将弹出的元素插入到另外一个列表中并返回它； 如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止。</td> 
  </tr> 
  <tr> 
   <td align="left">4</td> 
   <td align="left"><a href="https://www.redis.net.cn/order/3580.html" rel="nofollow">LINDEX key index</a> 通过索引获取列表中的元素</td> 
  </tr> 
  <tr> 
   <td align="left">5</td> 
   <td align="left"><a href="https://www.redis.net.cn/order/3581.html" rel="nofollow">LINSERT key BEFORE|AFTER pivot value</a> 在列表的元素前或者后插入元素</td> 
  </tr> 
  <tr> 
   <td align="left">6</td> 
   <td align="left"><a href="https://www.redis.net.cn/order/3582.html" rel="nofollow">LLEN key</a> 获取列表长度</td> 
  </tr> 
  <tr> 
   <td align="left">7</td> 
   <td align="left"><a href="https://www.redis.net.cn/order/3583.html" rel="nofollow">LPOP key</a> 移出并获取列表的第一个元素</td> 
  </tr> 
  <tr> 
   <td align="left">8</td> 
   <td align="left">[LPUSH key value1 <a href="https://www.redis.net.cn/order/3584.html" rel="nofollow">value2]</a> 将一个或多个值插入到列表头部</td> 
  </tr> 
  <tr> 
   <td align="left">9</td> 
   <td align="left"><a href="https://www.redis.net.cn/order/3585.html" rel="nofollow">LPUSHX key value</a> 将一个或多个值插入到已存在的列表头部</td> 
  </tr> 
  <tr> 
   <td align="left">10</td> 
   <td align="left"><a href="https://www.redis.net.cn/order/3586.html" rel="nofollow">LRANGE key start stop</a> 获取列表指定范围内的元素</td> 
  </tr> 
  <tr> 
   <td align="left">11</td> 
   <td align="left"><a href="https://www.redis.net.cn/order/3587.html" rel="nofollow">LREM key count value</a> 移除列表元素</td> 
  </tr> 
  <tr> 
   <td align="left">12</td> 
   <td align="left"><a href="https://www.redis.net.cn/order/3588.html" rel="nofollow">LSET key index value</a> 通过索引设置列表元素的值</td> 
  </tr> 
  <tr> 
   <td align="left">13</td> 
   <td align="left"><a href="https://www.redis.net.cn/order/3589.html" rel="nofollow">LTRIM key start stop</a> 对一个列表进行修剪(trim)，就是说，让列表只保留指定区间内的元素，不在指定区间之内的元素都将被删除。</td> 
  </tr> 
  <tr> 
   <td align="left">14</td> 
   <td align="left"><a href="https://www.redis.net.cn/order/3590.html" rel="nofollow">RPOP key</a> 移除并获取列表最后一个元素</td> 
  </tr> 
  <tr> 
   <td align="left">15</td> 
   <td align="left"><a href="https://www.redis.net.cn/order/3591.html" rel="nofollow">RPOPLPUSH source destination</a> 移除列表的最后一个元素，并将该元素添加到另一个列表并返回</td> 
  </tr> 
  <tr> 
   <td align="left">16</td> 
   <td align="left">[RPUSH key value1 <a href="https://www.redis.net.cn/order/3592.html" rel="nofollow">value2]</a> 在列表中添加一个或多个值</td> 
  </tr> 
  <tr> 
   <td align="left">17</td> 
   <td align="left"><a href="https://www.redis.net.cn/order/3593.html" rel="nofollow">RPUSHX key value</a> 为已存在的列表添加值</td> 
  </tr> 
 </tbody> 
</table>

## Redis hash 命令 ##

下表列出了 redis hash 基本的相关命令：

<table> 
 <thead> 
  <tr> 
   <th align="left">序号</th> 
   <th align="left">命令及描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">1</td> 
   <td align="left">[HDEL key field2 <a href="https://www.redis.net.cn/order/3564.html" rel="nofollow">field2]</a> 删除一个或多个哈希表字段</td> 
  </tr> 
  <tr> 
   <td align="left">2</td> 
   <td align="left"><a href="https://www.redis.net.cn/order/3565.html" rel="nofollow">HEXISTS key field</a> 查看哈希表 key 中，指定的字段是否存在。</td> 
  </tr> 
  <tr> 
   <td align="left">3</td> 
   <td align="left"><a href="https://www.redis.net.cn/order/3566.html" rel="nofollow">HGET key field</a> 获取存储在哈希表中指定字段的值/td&gt;</td> 
  </tr> 
  <tr> 
   <td align="left">4</td> 
   <td align="left"><a href="https://www.redis.net.cn/order/3567.html" rel="nofollow">HGETALL key</a> 获取在哈希表中指定 key 的所有字段和值</td> 
  </tr> 
  <tr> 
   <td align="left">5</td> 
   <td align="left"><a href="https://www.redis.net.cn/order/3568.html" rel="nofollow">HINCRBY key field increment</a> 为哈希表 key 中的指定字段的整数值加上增量 increment 。</td> 
  </tr> 
  <tr> 
   <td align="left">6</td> 
   <td align="left"><a href="https://www.redis.net.cn/order/3569.html" rel="nofollow">HINCRBYFLOAT key field increment</a> 为哈希表 key 中的指定字段的浮点数值加上增量 increment 。</td> 
  </tr> 
  <tr> 
   <td align="left">7</td> 
   <td align="left"><a href="https://www.redis.net.cn/order/3570.html" rel="nofollow">HKEYS key</a> 获取所有哈希表中的字段</td> 
  </tr> 
  <tr> 
   <td align="left">8</td> 
   <td align="left"><a href="https://www.redis.net.cn/order/3571.html" rel="nofollow">HLEN key</a> 获取哈希表中字段的数量</td> 
  </tr> 
  <tr> 
   <td align="left">9</td> 
   <td align="left">[HMGET key field1 <a href="https://www.redis.net.cn/order/3572.html" rel="nofollow">field2]</a> 获取所有给定字段的值</td> 
  </tr> 
  <tr> 
   <td align="left">10</td> 
   <td align="left">[HMSET key field1 value1 <a href="https://www.redis.net.cn/order/3573.html" rel="nofollow">field2 value2 ]</a> 同时将多个 field-value (域-值)对设置到哈希表 key 中。</td> 
  </tr> 
  <tr> 
   <td align="left">11</td> 
   <td align="left"><a href="https://www.redis.net.cn/order/3574.html" rel="nofollow">HSET key field value</a> 将哈希表 key 中的字段 field 的值设为 value 。</td> 
  </tr> 
  <tr> 
   <td align="left">12</td> 
   <td align="left"><a href="https://www.redis.net.cn/order/3575.html" rel="nofollow">HSETNX key field value</a> 只有在字段 field 不存在时，设置哈希表字段的值。</td> 
  </tr> 
  <tr> 
   <td align="left">13</td> 
   <td align="left"><a href="https://www.redis.net.cn/order/3576.html" rel="nofollow">HVALS key</a> 获取哈希表中所有值</td> 
  </tr> 
  <tr> 
   <td align="left">14</td> 
   <td align="left">HSCAN key cursor [MATCH pattern] [COUNT count] 迭代哈希表中的键值对。</td> 
  </tr> 
 </tbody> 
</table>

## List（列表） ##

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

### 实例 ###

redis 127.0.0.1:6379> lpush redis.net.cn redis
    (integer) 1
    redis 127.0.0.1:6379> lpush redis.net.cn mongodb
    (integer) 2
    redis 127.0.0.1:6379> lpush redis.net.cn rabitmq
    (integer) 3
    redis 127.0.0.1:6379> lrange redis.net.cn 0 10
    1) "rabitmq"
    2) "mongodb"
    3) "redis"redis 
    127.0.0.1:6379>

## Set（集合） ##

Redis的Set是string类型的无序集合。

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

### sadd 命令 ###

添加一个string元素到,key对应的set集合中，成功返回1,如果元素以及在集合中返回0,key对应的set不存在返回错误。

sadd key member

### 实例 ###

redis 127.0.0.1:6379> sadd redis.net.cn redis
    (integer) 1
    redis 127.0.0.1:6379> sadd redis.net.cn mongodb
    (integer) 1
    redis 127.0.0.1:6379> sadd redis.net.cn rabitmq
    (integer) 1
    redis 127.0.0.1:6379> sadd redis.net.cn rabitmq
    (integer) 0
    redis 127.0.0.1:6379> smembers redis.net.cn
    1) "rabitmq"
    2) "mongodb"
    3) "redis"

\*\*注意：\*\*以上实例中 rabitmq 添加了两次，但根据集合内元素的唯一性，第二次插入的元素将被忽略。

## Redis 集合命令 ##

下表列出了 Redis 集合基本命令：

<table> 
 <thead> 
  <tr> 
   <th align="left">序号</th> 
   <th align="left">命令及描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">1</td> 
   <td align="left">[SADD key member1 <a href="https://www.redis.net.cn/order/3594.html" rel="nofollow">member2]</a> 向集合添加一个或多个成员</td> 
  </tr> 
  <tr> 
   <td align="left">2</td> 
   <td align="left"><a href="https://www.redis.net.cn/order/3595.html" rel="nofollow">SCARD key</a> 获取集合的成员数</td> 
  </tr> 
  <tr> 
   <td align="left">3</td> 
   <td align="left">[SDIFF key1 <a href="https://www.redis.net.cn/order/3596.html" rel="nofollow">key2]</a> 返回给定所有集合的差集</td> 
  </tr> 
  <tr> 
   <td align="left">4</td> 
   <td align="left">[SDIFFSTORE destination key1 <a href="https://www.redis.net.cn/order/3597.html" rel="nofollow">key2]</a> 返回给定所有集合的差集并存储在 destination 中</td> 
  </tr> 
  <tr> 
   <td align="left">5</td> 
   <td align="left">[SINTER key1 <a href="https://www.redis.net.cn/order/3598.html" rel="nofollow">key2]</a> 返回给定所有集合的交集</td> 
  </tr> 
  <tr> 
   <td align="left">6</td> 
   <td align="left">[SINTERSTORE destination key1 <a href="https://www.redis.net.cn/order/3599.html" rel="nofollow">key2]</a> 返回给定所有集合的交集并存储在 destination 中</td> 
  </tr> 
  <tr> 
   <td align="left">7</td> 
   <td align="left"><a href="https://www.redis.net.cn/order/3600.html" rel="nofollow">SISMEMBER key member</a> 判断 member 元素是否是集合 key 的成员</td> 
  </tr> 
  <tr> 
   <td align="left">8</td> 
   <td align="left">[<strong>SMEMBERS</strong> key]返回集合中的所有成员</td> 
  </tr> 
  <tr> 
   <td align="left">9</td> 
   <td align="left"><a href="https://www.redis.net.cn/order/3602.html" rel="nofollow">SMOVE source destination member</a> 将 member 元素从 source 集合移动到 destination 集合</td> 
  </tr> 
  <tr> 
   <td align="left">10</td> 
   <td align="left"><a href="https://www.redis.net.cn/order/3603.html" rel="nofollow">SPOP key</a> 移除并返回集合中的一个随机元素</td> 
  </tr> 
  <tr> 
   <td align="left">11</td> 
   <td align="left">[SRANDMEMBER key <a href="https://www.redis.net.cn/order/3604.html" rel="nofollow">count]</a> 返回集合中一个或多个随机数</td> 
  </tr> 
  <tr> 
   <td align="left">12</td> 
   <td align="left">[SREM key member1 <a href="https://www.redis.net.cn/order/3605.html" rel="nofollow">member2]</a> 移除集合中一个或多个成员</td> 
  </tr> 
  <tr> 
   <td align="left">13</td> 
   <td align="left">[SUNION key1 <a href="https://www.redis.net.cn/order/3606.html" rel="nofollow">key2]</a> 返回所有给定集合的并集</td> 
  </tr> 
  <tr> 
   <td align="left">14</td> 
   <td align="left">[SUNIONSTORE destination key1 <a href="https://www.redis.net.cn/order/3607.html" rel="nofollow">key2]</a> 所有给定集合的并集存储在 destination 集合中</td> 
  </tr> 
  <tr> 
   <td align="left">15</td> 
   <td align="left">[SSCAN key cursor <a href="https://www.redis.net.cn/order/3608.html" rel="nofollow">MATCH pattern] [COUNT count]</a> 迭代集合中的元素</td> 
  </tr> 
 </tbody> 
</table>

## zset(sorted set：有序集合) ##

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

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

zset的成员是唯一的,但分数(score)却可以重复。

### zadd 命令 ###

添加元素到集合，元素在集合中存在则更新对应score

zadd key score member

### 实例 ###

redis 127.0.0.1:6379> zadd redis.net.cn 0 redis
    (integer) 1
    redis 127.0.0.1:6379> zadd redis.net.cn 0 mongodb
    (integer) 1
    redis 127.0.0.1:6379> zadd redis.net.cn 0 rabitmq
    (integer) 1
    redis 127.0.0.1:6379> zadd redis.net.cn 0 rabitmq
    (integer) 0
    redis 127.0.0.1:6379> ZRANGEBYSCORE redis.net.cn 0 1000 
    1) "redis"
    2) "mongodb"
    3) "rabitmq"

## Redis 有序集合命令 ##

下表列出了 redis 有序集合的基本命令:

<table> 
 <thead> 
  <tr> 
   <th align="left">序号</th> 
   <th align="left">命令及描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">1</td> 
   <td align="left">[ZADD key score1 member1 <a href="https://www.redis.net.cn/order/3609.html" rel="nofollow">score2 member2]</a> 向有序集合添加一个或多个成员，或者更新已存在成员的分数</td> 
  </tr> 
  <tr> 
   <td align="left">2</td> 
   <td align="left"><a href="https://www.redis.net.cn/order/3610.html" rel="nofollow">ZCARD key</a> 获取有序集合的成员数</td> 
  </tr> 
  <tr> 
   <td align="left">3</td> 
   <td align="left"><a href="https://www.redis.net.cn/order/3611.html" rel="nofollow">ZCOUNT key min max</a> 计算在有序集合中指定区间分数的成员数</td> 
  </tr> 
  <tr> 
   <td align="left">4</td> 
   <td align="left"><a href="https://www.redis.net.cn/order/3612.html" rel="nofollow">ZINCRBY key increment member</a> 有序集合中对指定成员的分数加上增量 increment</td> 
  </tr> 
  <tr> 
   <td align="left">5</td> 
   <td align="left">[ZINTERSTORE destination numkeys key <a href="https://www.redis.net.cn/order/3613.html" rel="nofollow">key …]</a> 计算给定的一个或多个有序集的交集并将结果集存储在新的有序集合 key 中</td> 
  </tr> 
  <tr> 
   <td align="left">6</td> 
   <td align="left"><a href="https://www.redis.net.cn/order/3614.html" rel="nofollow">ZLEXCOUNT key min max</a> 在有序集合中计算指定字典区间内成员数量</td> 
  </tr> 
  <tr> 
   <td align="left">7</td> 
   <td align="left">[ZRANGE key start stop <a href="https://www.redis.net.cn/order/3615.html" rel="nofollow">WITHSCORES]</a> 通过索引区间返回有序集合成指定区间内的成员</td> 
  </tr> 
  <tr> 
   <td align="left">8</td> 
   <td align="left">[ZRANGEBYLEX key min max <a href="https://www.redis.net.cn/order/3616.html" rel="nofollow">LIMIT offset count]</a> 通过字典区间返回有序集合的成员</td> 
  </tr> 
  <tr> 
   <td align="left">9</td> 
   <td align="left">[ZRANGEBYSCORE key min max <a href="https://www.redis.net.cn/order/3617.html" rel="nofollow">WITHSCORES] [LIMIT]</a> 通过分数返回有序集合指定区间内的成员</td> 
  </tr> 
  <tr> 
   <td align="left">10</td> 
   <td align="left"><a href="https://www.redis.net.cn/order/3618.html" rel="nofollow">ZRANK key member</a> 返回有序集合中指定成员的索引</td> 
  </tr> 
  <tr> 
   <td align="left">11</td> 
   <td align="left">[ZREM key member <a href="https://www.redis.net.cn/order/3619.html" rel="nofollow">member …]</a> 移除有序集合中的一个或多个成员</td> 
  </tr> 
  <tr> 
   <td align="left">12</td> 
   <td align="left"><a href="https://www.redis.net.cn/order/3620.html" rel="nofollow">ZREMRANGEBYLEX key min max</a> 移除有序集合中给定的字典区间的所有成员</td> 
  </tr> 
  <tr> 
   <td align="left">13</td> 
   <td align="left"><a href="https://www.redis.net.cn/order/3621.html" rel="nofollow">ZREMRANGEBYRANK key start stop</a> 移除有序集合中给定的排名区间的所有成员</td> 
  </tr> 
  <tr> 
   <td align="left">14</td> 
   <td align="left"><a href="https://www.redis.net.cn/order/3622.html" rel="nofollow">ZREMRANGEBYSCORE key min max</a> 移除有序集合中给定的分数区间的所有成员</td> 
  </tr> 
  <tr> 
   <td align="left">15</td> 
   <td align="left">[ZREVRANGE key start stop <a href="https://www.redis.net.cn/order/3623.html" rel="nofollow">WITHSCORES]</a> 返回有序集中指定区间内的成员，通过索引，分数从高到底</td> 
  </tr> 
  <tr> 
   <td align="left">16</td> 
   <td align="left">[ZREVRANGEBYSCORE key max min <a href="https://www.redis.net.cn/order/3624.html" rel="nofollow">WITHSCORES]</a> 返回有序集中指定分数区间内的成员，分数从高到低排序</td> 
  </tr> 
  <tr> 
   <td align="left">17</td> 
   <td align="left"><a href="https://www.redis.net.cn/order/3625.html" rel="nofollow">ZREVRANK key member</a> 返回有序集合中指定成员的排名，有序集成员按分数值递减(从大到小)排序</td> 
  </tr> 
  <tr> 
   <td align="left">18</td> 
   <td align="left"><a href="https://www.redis.net.cn/order/3626.html" rel="nofollow">ZSCORE key member</a> 返回有序集中，成员的分数值</td> 
  </tr> 
  <tr> 
   <td align="left">19</td> 
   <td align="left">[ZUNIONSTORE destination numkeys key <a href="https://www.redis.net.cn/order/3627.html" rel="nofollow">key …]</a> 计算给定的一个或多个有序集的并集，并存储在新的 key 中</td> 
  </tr> 
  <tr> 
   <td align="left">20</td> 
   <td align="left">[ZSCAN key cursor <a href="https://www.redis.net.cn/order/3628.html" rel="nofollow">MATCH pattern] [COUNT count]</a> 迭代有序集合中的元素（包括元素成员和元素分值）</td> 
  </tr> 
 </tbody> 
</table>

# redis启动 #

Redis 命令用于在 redis 服务上执行操作。

要在 redis 服务上执行命令需要一个 redis 客户端。Redis 客户端在我们之前下载的的 redis 的安装包中。

### 语法 ###

Redis 客户端的基本语法为：

$ redis-cli

### 实例 ###

以下实例讲解了如何启动 redis 客户端：

启动 redis 客户端，打开终端并输入命令 **redis-cli**。该命令会连接本地的 redis 服务。

$redis-cliredis 127.0.0.1:6379>redis 127.0.0.1:6379> PING PONG

在以上实例中我们连接到本地的 redis 服务并执行 **PING** 命令，该命令用于检测 redis 服务是否启动。

--------------------

## 在远程服务上执行命令 ##

如果需要在远程 redis 服务上执行命令，同样我们使用的也是 **redis-cli** 命令。

### 语法 ###

$ redis-cli -h host -p port -a password

### 实例 ###

以下实例演示了如何连接到主机为 127.0.0.1，端口为 6379 ，密码为 mypass 的 redis 服务上。

$redis-cli -h 127.0.0.1 -p 6379 -a "mypass"
    redis 127.0.0.1:6379>
    redis 127.0.0.1:6379> PING
    	PONG

## Redis keys 命令 ##

下表给出了与 Redis 键相关的基本命令：

# Redis HyperLogLog #

Redis 在 2.8.9 版本添加了 HyperLogLog 结构。

Redis HyperLogLog 是用来做基数统计的算法，HyperLogLog 的优点是，在输入元素的数量或者体积非常非常大时，计算基数所需的空间总是固定 的、并且是很小的。

在 Redis 里面，每个 HyperLogLog 键只需要花费 12 KB 内存，就可以计算接近 2^64 个不同元素的基 数。这和计算基数时，元素越多耗费内存就越多的集合形成鲜明对比。

但是，因为 HyperLogLog 只会根据输入元素来计算基数，而不会储存输入元素本身，所以 HyperLogLog 不能像集合那样，返回输入的各个元素。

--------------------

## 什么是基数? ##

比如数据集 \{1, 3, 5, 7, 5, 7, 8\}， 那么这个数据集的基数集为 \{1, 3, 5 ,7, 8\}, 基数(不重复元素)为5。 基数估计就是在误差可接受的范围内，快速计算基数。

--------------------

## 实例 ##

以下实例演示了 HyperLogLog 的工作过程：

redis 127.0.0.1:6379> PFADD w3ckey "redis" 1) (integer) 1 redis 127.0.0.1:6379> PFADD w3ckey "mongodb" 1) (integer) 1 redis 127.0.0.1:6379> PFADD w3ckey "mysql" 1) (integer) 1 redis 127.0.0.1:6379> PFCOUNT w3ckey (integer) 3

--------------------

## Redis HyperLogLog 命令 ##

下表列出了 redis HyperLogLog 的基本命令：

<table> 
 <thead> 
  <tr> 
   <th align="left">序号</th> 
   <th align="left">命令及描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">1</td> 
   <td align="left">[PFADD key element <a href="https://www.redis.net.cn/order/3629.html" rel="nofollow">element …]</a> 添加指定元素到 HyperLogLog 中。</td> 
  </tr> 
  <tr> 
   <td align="left">2</td> 
   <td align="left">[PFCOUNT key <a href="https://www.redis.net.cn/order/3630.html" rel="nofollow">key …]</a> 返回给定 HyperLogLog 的基数估算值。</td> 
  </tr> 
  <tr> 
   <td align="left">3</td> 
   <td align="left">[PFMERGE destkey sourcekey <a href="https://www.redis.net.cn/order/3631.html" rel="nofollow">sourcekey …]</a> 将多个 HyperLogLog 合并为一个 HyperLogLog</td> 
  </tr> 
 </tbody> 
</table>

--------------------

# Redis 订阅 #

Redis 发布订阅(pub/sub)是一种消息通信模式：发送者(pub)发送消息，订阅者(sub)接收消息。

Redis 客户端可以订阅任意数量的频道。

下图展示了频道 channel1 ， 以及订阅这个频道的三个客户端 —— client2 、 client5 和 client1 之间的关系：

![pubsub1][]

当有新消息通过 PUBLISH 命令发送给频道 channel1 时， 这个消息就会被发送给订阅它的三个客户端：

![pubsub2][]

--------------------

## 实例 ##

以下实例演示了发布订阅是如何工作的。在我们实例中我们创建了订阅频道名为 **redisChat**:

redis 127.0.0.1:6379> SUBSCRIBE redisChat
     
    Reading messages... (press Ctrl-C to quit)
    1) "subscribe"
    2) "redisChat"
    3) (integer) 1

现在，我们先重新开启个 redis 客户端，然后在同一个频道 redisChat 发布两次消息，订阅者就能接收到消息。

redis 127.0.0.1:6379> PUBLISH redisChat "Redis is a great caching technique"
     
    (integer) 1
     
    redis 127.0.0.1:6379> PUBLISH redisChat "Learn redis by w3cschool.cc"
     
    (integer) 1
     
    # 订阅者的客户端会显示如下消息
    1) "message"
    2) "redisChat"
    3) "Redis is a great caching technique"
    1) "message"
    2) "redisChat"
    3) "Learn redis by w3cschool.cc"

--------------------

## Redis 发布订阅命令 ##

下表列出了 redis 发布订阅常用命令：

<table> 
 <thead> 
  <tr> 
   <th align="left">序号</th> 
   <th align="left">命令及描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">1</td> 
   <td align="left">[PSUBSCRIBE pattern [pattern …]]订阅一个或多个符合给定模式的频道。</td> 
  </tr> 
  <tr> 
   <td align="left">2</td> 
   <td align="left">[PUBSUB subcommand [argument [argument …]]]查看订阅与发布系统状态。</td> 
  </tr> 
  <tr> 
   <td align="left">3</td> 
   <td align="left">[PUBLISH channel message]将信息发送到指定的频道。</td> 
  </tr> 
  <tr> 
   <td align="left">4</td> 
   <td align="left">[PUNSUBSCRIBE [pattern [pattern …]]]退订所有给定模式的频道。</td> 
  </tr> 
  <tr> 
   <td align="left">5</td> 
   <td align="left">[SUBSCRIBE channel [channel …]]订阅给定的一个或多个频道的信息。</td> 
  </tr> 
  <tr> 
   <td align="left">6</td> 
   <td align="left">[UNSUBSCRIBE [channel [channel …]]]指退订给定的频道。</td> 
  </tr> 
 </tbody> 
</table>

# Redis 事务 #

Redis 事务可以一次执行多个命令， 并且带有以下两个重要的保证：

*  事务是一个单独的隔离操作：事务中的所有命令都会序列化、按顺序地执行。事务在执行的过程中，不会被其他客户端发送来的命令请求所打断。
 *  事务是一个原子操作：事务中的命令要么全部被执行，要么全部都不执行。

一个事务从开始到执行会经历以下三个阶段：

*  开始事务。
 *  命令入队。
 *  执行事务。

--------------------

## 实例 ##

以下是一个事务的例子， 它先以 **MULTI** 开始一个事务， 然后将多个命令入队到事务中， 最后由 **EXEC** 命令触发事务， 一并执行事务中的所有命令：

redis 127.0.0.1:6379> MULTI
    OK
    
    redis 127.0.0.1:6379> SET book-name "Mastering C++ in 21 days"
    QUEUED
    
    redis 127.0.0.1:6379> GET book-name
    QUEUED
    
    redis 127.0.0.1:6379> SADD tag "C++" "Programming" "Mastering Series"
    QUEUED
    
    redis 127.0.0.1:6379> SMEMBERS tag
    QUEUED
    
    redis 127.0.0.1:6379> EXEC
    1) OK
    2) "Mastering C++ in 21 days"
    3) (integer) 3
    4) 1) "Mastering Series"
       2) "C++"
       3) "Programming"

--------------------

## Redis 事务命令 ##

下表列出了 redis 事务的相关命令：

# Redis 脚本 #

Redis 脚本使用 Lua 解释器来执行脚本。 Reids 2.6 版本通过内嵌支持 Lua 环境。执行脚本的常用命令为 **EVAL**。

### 语法 ###

Eval 命令的基本语法如下：

redis 127.0.0.1:6379> EVAL script numkeys key [key ...] arg [arg ...]

### 实例 ###

以下实例演示了 redis 脚本工作过程：

redis 127.0.0.1:6379> EVAL "return {KEYS[1],KEYS[2],ARGV[1],ARGV[2]}" 2 key1 key2 first second
    
    1) "key1"
    2) "key2"
    3) "first"
    4) "second"

--------------------

## Redis 脚本命令 ##

下表列出了 redis 脚本常用命令：

<table> 
 <thead> 
  <tr> 
   <th align="left">序号</th> 
   <th align="left">命令及描</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">1</td> 
   <td align="left">[EVAL script numkeys key <a href="https://www.redis.net.cn/order/3643.html" rel="nofollow">key …] arg [arg …]</a> 执行 Lua 脚本。</td> 
  </tr> 
  <tr> 
   <td align="left">2</td> 
   <td align="left">[EVALSHA sha1 numkeys key [key …] arg [arg …]] 执行 Lua 脚本。</td> 
  </tr> 
  <tr> 
   <td align="left">3</td> 
   <td align="left">[SCRIPT EXISTS script <a href="https://www.redis.net.cn/order/3645.html" rel="nofollow">script …]</a> 查看指定的脚本是否已经被保存在缓存当中。</td> 
  </tr> 
  <tr> 
   <td align="left">4</td> 
   <td align="left"><a href="https://www.redis.net.cn/order/3646.html" rel="nofollow">SCRIPT FLUSH</a> 从脚本缓存中移除所有脚本。</td> 
  </tr> 
  <tr> 
   <td align="left">5</td> 
   <td align="left"><a href="https://www.redis.net.cn/order/3647.html" rel="nofollow">SCRIPT KILL</a> 杀死当前正在运行的 Lua 脚本。</td> 
  </tr> 
  <tr> 
   <td align="left">6</td> 
   <td align="left"><a href="https://www.redis.net.cn/order/3648.html" rel="nofollow">SCRIPT LOAD script</a> 将脚本 script 添加到脚本缓存中，但并不立即执行这个脚本。</td> 
  </tr> 
 </tbody> 
</table>

# Redis 连接 #

Redis 连接命令主要是用于连接 redis 服务。

### 实例 ###

以下实例演示了客户端如何通过密码验证连接到 redis 服务，并检测服务是否在运行：

redis 127.0.0.1:6379> AUTH "password"
    OK
    redis 127.0.0.1:6379> PING
    PONG

--------------------

## Redis 连接命令 ##

下表列出了 redis 连接的基本命令：

# Redis 服务器 #

Redis 服务器命令主要是用于管理 redis 服务。

### 实例 ###

以下实例演示了如何获取 redis 服务器的统计信息：

redis 127.0.0.1:6379> INFO
    
    # Server
    redis_version:2.8.13
    redis_git_sha1:00000000
    redis_git_dirty:0
    redis_build_id:c2238b38b1edb0e2
    redis_mode:standalone
    os:Linux 3.5.0-48-generic x86_64
    arch_bits:64
    multiplexing_api:epoll
    gcc_version:4.7.2
    process_id:3856
    run_id:0e61abd297771de3fe812a3c21027732ac9f41fe
    tcp_port:6379
    uptime_in_seconds:11554
    uptime_in_days:0
    hz:10
    lru_clock:16651447
    config_file:
    
    # Clients
    connected_clients:1
    client-longest_output_list:0
    client-biggest_input_buf:0
    blocked_clients:0
    
    # Memory
    used_memory:589016
    used_memory_human:575.21K
    used_memory_rss:2461696
    used_memory_peak:667312
    used_memory_peak_human:651.67K
    used_memory_lua:33792
    mem_fragmentation_ratio:4.18
    mem_allocator:jemalloc-3.6.0
    
    # Persistence
    loading:0
    rdb_changes_since_last_save:3
    rdb_bgsave_in_progress:0
    rdb_last_save_time:1409158561
    rdb_last_bgsave_status:ok
    rdb_last_bgsave_time_sec:0
    rdb_current_bgsave_time_sec:-1
    aof_enabled:0
    aof_rewrite_in_progress:0
    aof_rewrite_scheduled:0
    aof_last_rewrite_time_sec:-1
    aof_current_rewrite_time_sec:-1
    aof_last_bgrewrite_status:ok
    aof_last_write_status:ok
    
    # Stats
    total_connections_received:24
    total_commands_processed:294
    instantaneous_ops_per_sec:0
    rejected_connections:0
    sync_full:0
    sync_partial_ok:0
    sync_partial_err:0
    expired_keys:0
    evicted_keys:0
    keyspace_hits:41
    keyspace_misses:82
    pubsub_channels:0
    pubsub_patterns:0
    latest_fork_usec:264
    
    # Replication
    role:master
    connected_slaves:0
    master_repl_offset:0
    repl_backlog_active:0
    repl_backlog_size:1048576
    repl_backlog_first_byte_offset:0
    repl_backlog_histlen:0
    
    # CPU
    used_cpu_sys:10.49
    used_cpu_user:4.96
    used_cpu_sys_children:0.00
    used_cpu_user_children:0.01
    
    # Keyspace
    db0:keys=94,expires=1,avg_ttl=41638810
    db1:keys=1,expires=0,avg_ttl=0
    db3:keys=1,expires=0,avg_ttl=0

--------------------

## Redis 服务器命令 ##

下表列出了 redis 服务器的相关命令:

<table> 
 <thead> 
  <tr> 
   <th align="left">序号</th> 
   <th align="left">命令及描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">1</td> 
   <td align="left"><a href="https://www.redis.net.cn/order/3654.html" rel="nofollow">BGREWRITEAOF</a> 异步执行一个 AOF（AppendOnly File） 文件重写操作</td> 
  </tr> 
  <tr> 
   <td align="left">2</td> 
   <td align="left"><a href="https://www.redis.net.cn/order/3655.html" rel="nofollow">BGSAVE</a> 在后台异步保存当前数据库的数据到磁盘</td> 
  </tr> 
  <tr> 
   <td align="left">3</td> 
   <td align="left">[CLIENT KILL <a href="https://www.redis.net.cn/order/3656.html" rel="nofollow">ip:port] [ID client-id]</a> 关闭客户端连接</td> 
  </tr> 
  <tr> 
   <td align="left">4</td> 
   <td align="left"><a href="https://www.redis.net.cn/order/3657.html" rel="nofollow">CLIENT LIST</a> 获取连接到服务器的客户端连接列表</td> 
  </tr> 
  <tr> 
   <td align="left">5</td> 
   <td align="left"><a href="https://www.redis.net.cn/order/3658.html" rel="nofollow">CLIENT GETNAME</a> 获取连接的名称</td> 
  </tr> 
  <tr> 
   <td align="left">6</td> 
   <td align="left"><a href="https://www.redis.net.cn/order/3659.html" rel="nofollow">CLIENT PAUSE timeout</a> 在指定时间内终止运行来自客户端的命令</td> 
  </tr> 
  <tr> 
   <td align="left">7</td> 
   <td align="left"><a href="https://www.redis.net.cn/order/3660.html" rel="nofollow">CLIENT SETNAME connection-name</a> 设置当前连接的名称</td> 
  </tr> 
  <tr> 
   <td align="left">8</td> 
   <td align="left"><a href="https://www.redis.net.cn/order/3661.html" rel="nofollow">CLUSTER SLOTS</a> 获取集群节点的映射数组</td> 
  </tr> 
  <tr> 
   <td align="left">9</td> 
   <td align="left"><a href="https://www.redis.net.cn/order/3662.html" rel="nofollow">COMMAND</a> 获取 Redis 命令详情数组</td> 
  </tr> 
  <tr> 
   <td align="left">10</td> 
   <td align="left"><a href="https://www.redis.net.cn/order/3663.html" rel="nofollow">COMMAND COUNT</a> 获取 Redis 命令总数</td> 
  </tr> 
  <tr> 
   <td align="left">11</td> 
   <td align="left"><a href="https://www.redis.net.cn/order/3664.html" rel="nofollow">COMMAND GETKEYS</a> 获取给定命令的所有键</td> 
  </tr> 
  <tr> 
   <td align="left">12</td> 
   <td align="left"><a href="https://www.redis.net.cn/order/3665.html" rel="nofollow">TIME</a> 返回当前服务器时间</td> 
  </tr> 
  <tr> 
   <td align="left">13</td> 
   <td align="left">[COMMAND INFO command-name <a href="https://www.redis.net.cn/order/3666.html" rel="nofollow">command-name …]</a> 获取指定 Redis 命令描述的数组</td> 
  </tr> 
  <tr> 
   <td align="left">14</td> 
   <td align="left"><a href="https://www.redis.net.cn/order/3667.html" rel="nofollow">CONFIG GET parameter</a> 获取指定配置参数的值</td> 
  </tr> 
  <tr> 
   <td align="left">15</td> 
   <td align="left"><a href="https://www.redis.net.cn/order/3668.html" rel="nofollow">CONFIG REWRITE</a> 对启动 Redis 服务器时所指定的 redis.conf 配置文件进行改写</td> 
  </tr> 
  <tr> 
   <td align="left">16</td> 
   <td align="left"><a href="https://www.redis.net.cn/order/3669.html" rel="nofollow">CONFIG SET parameter value</a> 修改 redis 配置参数，无需重启</td> 
  </tr> 
  <tr> 
   <td align="left">17</td> 
   <td align="left"><a href="https://www.redis.net.cn/order/3670.html" rel="nofollow">CONFIG RESETSTAT</a> 重置 INFO 命令中的某些统计数据</td> 
  </tr> 
  <tr> 
   <td align="left">18</td> 
   <td align="left"><a href="https://www.redis.net.cn/order/3671.html" rel="nofollow">DBSIZE</a> 返回当前数据库的 key 的数量</td> 
  </tr> 
  <tr> 
   <td align="left">19</td> 
   <td align="left"><a href="https://www.redis.net.cn/order/3672.html" rel="nofollow">DEBUG OBJECT key</a> 获取 key 的调试信息</td> 
  </tr> 
  <tr> 
   <td align="left">20</td> 
   <td align="left"><a href="https://www.redis.net.cn/order/3673.html" rel="nofollow">DEBUG SEGFAULT</a> 让 Redis 服务崩溃</td> 
  </tr> 
  <tr> 
   <td align="left">21</td> 
   <td align="left"><a href="https://www.redis.net.cn/order/3674.html" rel="nofollow">FLUSHALL</a> 删除所有数据库的所有key</td> 
  </tr> 
  <tr> 
   <td align="left">22</td> 
   <td align="left"><a href="https://www.redis.net.cn/order/3675.html" rel="nofollow">FLUSHDB</a> 删除当前数据库的所有key</td> 
  </tr> 
  <tr> 
   <td align="left">23</td> 
   <td align="left">[INFO <a href="https://www.redis.net.cn/order/3676.html" rel="nofollow">section]</a> 获取 Redis 服务器的各种信息和统计数值</td> 
  </tr> 
  <tr> 
   <td align="left">24</td> 
   <td align="left"><a href="https://www.redis.net.cn/order/3677.html" rel="nofollow">LASTSAVE</a> 返回最近一次 Redis 成功将数据保存到磁盘上的时间，以 UNIX 时间戳格式表示</td> 
  </tr> 
  <tr> 
   <td align="left">25</td> 
   <td align="left"><a href="https://www.redis.net.cn/order/3678.html" rel="nofollow">MONITOR</a> 实时打印出 Redis 服务器接收到的命令，调试用</td> 
  </tr> 
  <tr> 
   <td align="left">26</td> 
   <td align="left"><a href="https://www.redis.net.cn/order/3679.html" rel="nofollow">ROLE</a> 返回主从实例所属的角色</td> 
  </tr> 
  <tr> 
   <td align="left">27</td> 
   <td align="left"><a href="https://www.redis.net.cn/order/3680.html" rel="nofollow">SAVE</a> 异步保存数据到硬盘</td> 
  </tr> 
  <tr> 
   <td align="left">28</td> 
   <td align="left">[SHUTDOWN <a href="https://www.redis.net.cn/order/3681.html" rel="nofollow">NOSAVE] [SAVE]</a> 异步保存数据到硬盘，并关闭服务器</td> 
  </tr> 
  <tr> 
   <td align="left">29</td> 
   <td align="left"><a href="https://www.redis.net.cn/order/3682.html" rel="nofollow">SLAVEOF host port</a> 将当前服务器转变为指定服务器的从属服务器(slave server)</td> 
  </tr> 
  <tr> 
   <td align="left">30</td> 
   <td align="left">[SLOWLOG subcommand <a href="https://www.redis.net.cn/order/3683.html" rel="nofollow">argument]</a> 管理 redis 的慢日志</td> 
  </tr> 
  <tr> 
   <td align="left">31</td> 
   <td align="left"><a href="https://www.redis.net.cn/order/3684.html" rel="nofollow">SYNC</a> 用于复制功能(replication)的内部命令</td> 
  </tr> 
 </tbody> 
</table>

# Redis 数据备份与恢复 #

Redis **SAVE** 命令用于创建当前数据库的备份。

### 语法 ###

redis Save 命令基本语法如下：

redis 127.0.0.1:6379> SAVE

### 实例 ###

redis 127.0.0.1:6379> SAVE OK

该命令将在 redis 安装目录中创建dump.rdb文件。

--------------------

## 恢复数据 ##

如果需要恢复数据，只需将备份文件 (dump.rdb) 移动到 redis 安装目录并启动服务即可。获取 redis 目录可以使用

CONFIG

命令，如下所示：

redis 127.0.0.1:6379> CONFIG GET dir
     1) "dir"
     2) "/usr/local/redis/bin"

以上命令 **CONFIG GET dir** 输出的 redis 安装目录为 /usr/local/redis/bin。

--------------------

## Bgsave ##

创建 redis 备份文件也可以使用命令 **BGSAVE**，该命令在后台执行。

### 实例 ###

127.0.0.1:6379> BGSAVE Background saving started

# Redis 安全 #

我们可以通过 redis 的配置文件设置密码参数，这样客户端连接到 redis 服务就需要密码验证，这样可以让你的 redis 服务更安全。

### 实例 ###

我们可以通过以下命令查看是否设置了密码验证：

127.0.0.1:6379> CONFIG get requirepass
    1) "requirepass"
    2) ""

默认情况下 requirepass 参数是空的，这就意味着你无需通过密码验证就可以连接到 redis 服务。

你可以通过以下命令来修改该参数：

127.0.0.1:6379> CONFIG set requirepass "w3cschool.cc"
    OK
    127.0.0.1:6379> CONFIG get requirepass
    1) "requirepass"
    2) "w3cschool.cc"

设置密码后，客户端连接 redis 服务就需要密码验证，否则无法执行命令。

### 语法 ###

**AUTH** 命令基本语法格式如下：

127.0.0.1:6379> AUTH password

### 实例 ###

127.0.0.1:6379> AUTH "w3cschool.cc"
    OK
    127.0.0.1:6379> SET mykey "Test value"
    OK
    127.0.0.1:6379> GET mykey
    "Test value"

# Redis 性能测试 #

Redis 性能测试是通过同时执行多个命令实现的。

### 语法 ###

redis 性能测试的基本命令如下：

redis-benchmark [option] [option value]

### 实例 ###

以下实例同时执行 10000 个请求来检测性能：

redis-benchmark -n 100000
    
    PING_INLINE: 141043.72 requests per second
    PING_BULK: 142857.14 requests per second
    SET: 141442.72 requests per second
    GET: 145348.83 requests per second
    INCR: 137362.64 requests per second
    LPUSH: 145348.83 requests per second
    LPOP: 146198.83 requests per second
    SADD: 146198.83 requests per second
    SPOP: 149253.73 requests per second
    LPUSH (needed to benchmark LRANGE): 148588.42 requests per second
    LRANGE_100 (first 100 elements): 58411.21 requests per second
    LRANGE_300 (first 300 elements): 21195.42 requests per second
    LRANGE_500 (first 450 elements): 14539.11 requests per second
    LRANGE_600 (first 600 elements): 10504.20 requests per second
    MSET (10 keys): 93283.58 requests per second

redis 性能测试工具可选参数如下所示：

<table> 
 <thead> 
  <tr> 
   <th align="left">序号</th> 
   <th align="left">选项</th> 
   <th align="left">描述</th> 
   <th align="left">默认值</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">1</td> 
   <td align="left"><strong>-h</strong></td> 
   <td align="left">指定服务器主机名</td> 
   <td align="left">127.0.0.1</td> 
  </tr> 
  <tr> 
   <td align="left">2</td> 
   <td align="left"><strong>-p</strong></td> 
   <td align="left">指定服务器端口</td> 
   <td align="left">6379</td> 
  </tr> 
  <tr> 
   <td align="left">3</td> 
   <td align="left"><strong>-s</strong></td> 
   <td align="left">指定服务器 socket</td> 
   <td align="left"></td> 
  </tr> 
  <tr> 
   <td align="left">4</td> 
   <td align="left"><strong>-c</strong></td> 
   <td align="left">指定并发连接数</td> 
   <td align="left">50</td> 
  </tr> 
  <tr> 
   <td align="left">5</td> 
   <td align="left"><strong>-n</strong></td> 
   <td align="left">指定请求数</td> 
   <td align="left">10000</td> 
  </tr> 
  <tr> 
   <td align="left">6</td> 
   <td align="left"><strong>-d</strong></td> 
   <td align="left">以字节的形式指定 SET/GET 值的数据大小</td> 
   <td align="left">2</td> 
  </tr> 
  <tr> 
   <td align="left">7</td> 
   <td align="left"><strong>-k</strong></td> 
   <td align="left">1=keep alive 0=reconnect</td> 
   <td align="left">1</td> 
  </tr> 
  <tr> 
   <td align="left">8</td> 
   <td align="left"><strong>-r</strong></td> 
   <td align="left">SET/GET/INCR 使用随机 key, SADD 使用随机值</td> 
   <td align="left"></td> 
  </tr> 
  <tr> 
   <td align="left">9</td> 
   <td align="left"><strong>-P</strong></td> 
   <td align="left">通过管道传输 <code>&lt;numreq&gt;</code> 请求</td> 
   <td align="left">1</td> 
  </tr> 
  <tr> 
   <td align="left">10</td> 
   <td align="left"><strong>-q</strong></td> 
   <td align="left">强制退出 redis。仅显示 query/sec 值</td> 
   <td align="left"></td> 
  </tr> 
  <tr> 
   <td align="left">11</td> 
   <td align="left"><strong>–csv</strong></td> 
   <td align="left">以 CSV 格式输出</td> 
   <td align="left"></td> 
  </tr> 
  <tr> 
   <td align="left">12</td> 
   <td align="left"><strong>-l</strong></td> 
   <td align="left">生成循环，永久执行测试</td> 
   <td align="left"></td> 
  </tr> 
  <tr> 
   <td align="left">13</td> 
   <td align="left"><strong>-t</strong></td> 
   <td align="left">仅运行以逗号分隔的测试命令列表。</td> 
   <td align="left"></td> 
  </tr> 
  <tr> 
   <td align="left">14</td> 
   <td align="left"><strong>-I</strong></td> 
   <td align="left">Idle 模式。仅打开 N 个 idle 连接并等待。</td> 
   <td align="left"></td> 
  </tr> 
 </tbody> 
</table>

### 实例 ###

以下实例我们使用了多个参数来测试 redis 性能：

redis-benchmark -h 127.0.0.1 -p 6379 -t set,lpush -n 100000 -q
     
    SET: 146198.83 requests per second
    LPUSH: 145560.41 requests per second

以上实例中主机为 127.0.0.1，端口号为 6379，执行的命令为 set,lpush，请求数为 10000，通过 -q 参数让结果只显示每秒执行的请求数。

# Redis 客户端连接 #

Redis 通过监听一个 TCP 端口或者 Unix socket 的方式来接收来自客户端的连接，当一个连接建立后，Redis 内部会进行以下一些操作：

*  首先，客户端 socket 会被设置为非阻塞模式，因为 Redis 在网络事件处理上采用的是非阻塞多路复用模型。
 *  然后为这个 socket 设置 TCP\_NODELAY 属性，禁用 Nagle 算法
 *  然后创建一个可读的文件事件用于监听这个客户端 socket 的数据发送

--------------------

## 最大连接数 ##

在 Redis2.4 中，最大连接数是被直接硬编码在代码里面的，而在2.6版本中这个值变成可配置的。

maxclients 的默认值是 10000，你也可以在 redis.conf 中对这个值进行修改。

config get maxclients
    
    1) "maxclients"
    2) "10000"

### 实例 ###

以下实例我们在服务启动时设置最大连接数为 100000：

redis-server --maxclients 100000

--------------------

## 客户端命令 ##

<table> 
 <thead> 
  <tr> 
   <th align="left">S.N.</th> 
   <th align="left">命令</th> 
   <th align="left">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">1</td> 
   <td align="left"><strong>CLIENT LIST</strong></td> 
   <td align="left">返回连接到 redis 服务的客户端列表</td> 
  </tr> 
  <tr> 
   <td align="left">2</td> 
   <td align="left"><strong>CLIENT SETNAME</strong></td> 
   <td align="left">设置当前连接的名称</td> 
  </tr> 
  <tr> 
   <td align="left">3</td> 
   <td align="left"><strong>CLIENT GETNAME</strong></td> 
   <td align="left">获取通过 CLIENT SETNAME 命令设置的服务名称</td> 
  </tr> 
  <tr> 
   <td align="left">4</td> 
   <td align="left"><strong>CLIENT PAUSE</strong></td> 
   <td align="left">挂起客户端连接，指定挂起的时间以毫秒计</td> 
  </tr> 
  <tr> 
   <td align="left">5</td> 
   <td align="left"><strong>CLIENT KILL</strong></td> 
   <td align="left">关闭客户端连接</td> 
  </tr> 
 </tbody> 
</table>

# Redis 管道技术 #

Redis是一种基于客户端-服务端模型以及请求/响应协议的TCP服务。这意味着通常情况下一个请求会遵循以下步骤：

*  客户端向服务端发送一个查询请求，并监听Socket返回，通常是以阻塞模式，等待服务端响应。
 *  服务端处理命令，并将结果返回给客户端。

--------------------

## Redis 管道技术 ##

Redis 管道技术可以在服务端未响应时，客户端可以继续向服务端发送请求，并最终一次性读取所有服务端的响应。

### 实例 ###

查看 redis 管道，只需要启动 redis 实例并输入以下命令：

$(echo -en "PING\r\n SET w3ckey redis\r\nGET w3ckey\r\nINCR visitor\r\nINCR visitor\r\nINCR visitor\r\n"; sleep 10) | nc localhost 6379
     
    +PONG
    +OK
    redis
    :1
    :2
    :3:2:3

以上实例中我们通过使用 **PING** 命令查看redis服务是否可用， 之后我们们设置了 w3ckey 的值为 redis，然后我们获取 w3ckey 的值并使得 visitor 自增 3 次。

在返回的结果中我们可以看到这些命令一次性向 redis 服务提交，并最终一次性读取所有服务端的响应

--------------------

## 管道技术的优势 ##

管道技术最显著的优势是提高了 redis 服务的性能。

### 一些测试数据 ###

在下面的测试中，我们将使用Redis的Ruby客户端，支持管道技术特性，测试管道技术对速度的提升效果。

require 'rubygems' 
    require 'redis'
    def bench(descr) 
    start = Time.now 
    yield 
    puts "#{descr} #{Time.now-start} seconds" 
    end
    def without_pipelining 
    r = Redis.new 
    10000.times { 
            r.ping 
    } 
    end
    def with_pipelining 
    r = Redis.new 
    r.pipelined { 
            10000.times { 
                    r.ping 
            } 
    } 
    end
    bench("without pipelining") { 
            without_pipelining 
    } 
    bench("with pipelining") { 
            with_pipelining 
    }

从处于局域网中的Mac OS X系统上执行上面这个简单脚本的数据表明，开启了管道操作后，往返时延已经被改善得相当低了。

without pipelining 1.185238 seconds with pipelining 0.250783 seconds

如你所见，开启管道后，我们的速度效率提升了5倍。

# Redis 分区 #

分区是分割数据到多个Redis实例的处理过程，因此每个实例只保存key的一个子集。

### 分区的优势 ###

*  通过利用多台计算机内存的和值，允许我们构造更大的数据库。
 *  通过多核和多台计算机，允许我们扩展计算能力；通过多台计算机和网络适配器，允许我们扩展网络带宽。

### 分区的不足 ###

redis的一些特性在分区方面表现的不是很好：

*  涉及多个key的操作通常是不被支持的。举例来说，当两个set映射到不同的redis实例上时，你就不能对这两个set执行交集操作。
 *  涉及多个key的redis事务不能使用。
 *  当使用分区时，数据处理较为复杂，比如你需要处理多个rdb/aof文件，并且从多个实例和主机备份持久化文件。
 *  增加或删除容量也比较复杂。redis集群大多数支持在运行时增加、删除节点的透明数据平衡的能力，但是类似于客户端分区、代理等其他系统则不支持这项特性。然而，一种叫做presharding的技术对此是有帮助的。

--------------------

## 分区类型 ##

Redis 有两种类型分区。 假设有4个Redis实例 R0，R1，R2，R3，和类似user:1，user:2这样的表示用户的多个key，对既定的key有多种不同方式来选择这个key存放在哪个实例中。也就是说，有不同的系统来映射某个key到某个Redis服务。

### 范围分区 ###

最简单的分区方式是按范围分区，就是映射一定范围的对象到特定的Redis实例。

比如，ID从0到10000的用户会保存到实例R0，ID从10001到 20000的用户会保存到R1，以此类推。

这种方式是可行的，并且在实际中使用，不足就是要有一个区间范围到实例的映射表。这个表要被管理，同时还需要各 种对象的映射表，通常对Redis来说并非是好的方法。

### 哈希分区 ###

另外一种分区方法是hash分区。这对任何key都适用，也无需是object\_name:这种形式，像下面描述的一样简单：

*  用一个hash函数将key转换为一个数字，比如使用crc32 hash函数。对key foobar执行crc32(foobar)会输出类似93024922的整数。
 *  对这个整数取模，将其转化为0-3之间的数字，就可以将这个整数映射到4个Redis实例中的一个了。93024922 % 4 = 2，就是说key foobar应该被存到R2实例中。注意：取模操作是取除的余数，通常在多种编程语言中用%操作符实现。

# Java 使用 Redis #

## 安装 ##

开始在 Java 中使用 Redis 前， 我们需要确保已经安装了 redis 服务及 Java redis 驱动，且你的机器上能正常使用 Java。 Java的安装配置可以参考我们的 [Java开发环境配置][Java] 接下来让我们安装 Java redis 驱动：

*  首先你需要下载驱动包，[**下载 jedis.jar**][jedis.jar]，确保下载最新驱动包。
 *  在你的classpath中包含该驱动包。

--------------------

## 连接到 redis 服务 ##

import redis.clients.jedis.Jedis;
    public class RedisJava {
       public static void main(String[] args) {
          //连接本地的 Redis 服务
          Jedis jedis = new Jedis("localhost");
          System.out.println("Connection to server sucessfully");
          //查看服务是否运行
          System.out.println("Server is running: "+jedis.ping());
     }
    }

编译以上 Java 程序，确保驱动包的路径是正确的。

$javac RedisJava.java
    $java RedisJava
    Connection to server sucessfully
    Server is running: PONG
    
    Redis Java String Example

--------------------

## Redis Java String(字符串) 实例 ##

import redis.clients.jedis.Jedis;
    public class RedisStringJava {
       public static void main(String[] args) {
          //连接本地的 Redis 服务
          Jedis jedis = new Jedis("localhost");
          System.out.println("Connection to server sucessfully");
          //设置 redis 字符串数据
          jedis.set("w3ckey", "Redis tutorial");
         // 获取存储的数据并输出
         System.out.println("Stored string in redis:: "+ jedis.get("w3ckey"));
     }
    }

编译以上程序。

$javac RedisStringJava.java
    $java RedisStringJava
    Connection to server sucessfully
    Stored string in redis:: Redis tutorial

--------------------

## Redis Java List(列表) 实例 ##

import redis.clients.jedis.Jedis;
    public class RedisListJava {
       public static void main(String[] args) {
          //连接本地的 Redis 服务
          Jedis jedis = new Jedis("localhost");
          System.out.println("Connection to server sucessfully");
          //存储数据到列表中
          jedis.lpush("tutorial-list", "Redis");
          jedis.lpush("tutorial-list", "Mongodb");
          jedis.lpush("tutorial-list", "Mysql");
         // 获取存储的数据并输出
         List<String> list = jedis.lrange("tutorial-list", 0 ,5);
         for(int i=0; i<list.size(); i++) {
           System.out.println("Stored string in redis:: "+list.get(i));
         }
     }
    }

编译以上程序。

$javac RedisListJava.java
    $java RedisListJava
    Connection to server sucessfully
    Stored string in redis:: Redis
    Stored string in redis:: Mongodb
    Stored string in redis:: Mysql

--------------------

## Redis Java Keys 实例 ##

import redis.clients.jedis.Jedis;
    public class RedisKeyJava {
       public static void main(String[] args) {
          //连接本地的 Redis 服务
          Jedis jedis = new Jedis("localhost");
          System.out.println("Connection to server sucessfully");
          
         // 获取数据并输出
         List<String> list = jedis.keys("*");
         for(int i=0; i<list.size(); i++) {
           System.out.println("List of stored keys:: "+list.get(i));
         }
       }
    }

编译以上程序。

$javac RedisKeyJava.java
    $java RedisKeyJava
    Connection to server sucessfully
    List of stored keys:: tutorial-name
    List of stored keys:: tutorial-list

ain(String\[\] args) \{  
//连接本地的 Redis 服务  
Jedis jedis = new Jedis(“localhost”);  
System.out.println(“Connection to server sucessfully”);  
//存储数据到列表中  
jedis.lpush(“tutorial-list”, “Redis”);  
jedis.lpush(“tutorial-list”, “Mongodb”);  
jedis.lpush(“tutorial-list”, “Mysql”);  
// 获取存储的数据并输出  
List list = jedis.lrange(“tutorial-list”, 0 ,5);  
for(int i=0; i<list.size(); i++) \{  
System.out.println("Stored string in redis:: "+list.get(i));  
\}  
\}  
\}

编译以上程序。

$javac RedisListJava.java  
$java RedisListJava  
Connection to server sucessfully  
Stored string in redis:: Redis  
Stored string in redis:: Mongodb  
Stored string in redis:: Mysql

------
    
    ## Redis Java Keys 实例

import redis.clients.jedis.Jedis;  
public class RedisKeyJava \{  
public static void main(String\[\] args) \{  
//连接本地的 Redis 服务  
Jedis jedis = new Jedis(“localhost”);  
System.out.println(“Connection to server sucessfully”);

// 获取数据并输出
     List<String> list = jedis.keys("*");
     for(int i=0; i<list.size(); i++) {
       System.out.println("List of stored keys:: "+list.get(i));
     }

\}  
\}

编译以上程序。

$javac RedisKeyJava.java  
$java RedisKeyJava  
Connection to server sucessfully  
List of stored keys:: tutorial-name  
List of stored keys:: tutorial-list

# redis \# 不要绑定到本机,及bind 127.0.0.1

[http_code.google.com_p_redis_wiki_Benchmarks]: http://code.google.com/p/redis/wiki/Benchmarks
[pubsub1]: /images/20230528/357abeb96bfd4e928075403d52d0b69b.png
[pubsub2]: /images/20230528/836111fe62b14f48ab256fe4c37ce27f.png
[Java]: https://www.redis.net.cn/tutorial/8810.html
[jedis.jar]: https://www.redis.net.cn/tutorial/8811.html