Redis学习手册

一、概述：       在Redis中，我们可以将Set类型看作为没有排序的字符集合，和List类型一样，我们也可以在该类型的数据值上执行添加、删除或判断某一元素是否存在等操作。需要说明的是，这些操作的时间复杂度为O(1)，即常量时间内完成次操作。Set可包含的最大元素数量是4294967295。       和List类型不同的是，Set集合中不允许出现重复的元素，这一点和C++标准库中的set容器是完全相同的。换句话说，如果多次添加相同元素，Set中将仅保留该元素的一份拷贝。和List类型相比，Set类型在功能上还存在着一个非常重要的特性，即在服务器端完成多个Sets之间的聚合计算操作，如unions、intersections和differences。由于这些操作均在服务端完成，因此效率极高，而且也节省了大量的网络IO开销。 二、相关命令列表：

返回Set中所有的成员。

三、命令示例：    1. SADD/SMEMBERS/SCARD/SISMEMBER:     #在Shell命令行下启动Redis的客户端程序。     /> redis-cli     #插入测试数据，由于该键myset之前并不存在，因此参数中的三个成员都被正常插入。     redis 127.0.0.1:6379> sadd myset a b c     (integer) 3     #由于参数中的a在myset中已经存在，因此本次操作仅仅插入了d和e两个新成员。     redis 127.0.0.1:6379> sadd myset a d e     (integer) 2     #判断a是否已经存在，返回值为1表示存在。     redis 127.0.0.1:6379> sismember myset a     (integer) 1     #判断f是否已经存在，返回值为0表示不存在。     redis 127.0.0.1:6379> sismember myset f     (integer) 0     #通过smembers命令查看插入的结果，从结果可以，输出的顺序和插入顺序无关。     redis 127.0.0.1:6379> smembers myset     1) "c"     2) "d"     3) "a"     4) "b"     5) "e"     #获取Set集合中元素的数量。     redis 127.0.0.1:6379> scard myset     (integer) 5     2. SPOP/SREM/SRANDMEMBER/SMOVE:     #删除该键，便于后面的测试。     redis 127.0.0.1:6379> del myset     (integer) 1     #为后面的示例准备测试数据。     redis 127.0.0.1:6379> sadd myset a b c d     (integer) 4     #查看Set中成员的位置。     redis 127.0.0.1:6379> smembers myset     1) "c"     2) "d"     3) "a"     4) "b"     #从结果可以看出，该命令确实是随机的返回了某一成员。     redis 127.0.0.1:6379> srandmember myset     "c"     #Set中尾部的成员b被移出并返回，事实上b并不是之前插入的第一个或最后一个成员。     redis 127.0.0.1:6379> spop myset     "b"     #查看移出后Set的成员信息。     redis 127.0.0.1:6379> smembers myset     1) "c"     2) "d"     3) "a"     #从Set中移出a、d和f三个成员，其中f并不存在，因此只有a和d两个成员被移出，返回为2。     redis 127.0.0.1:6379> srem myset a d f     (integer) 2     #查看移出后的输出结果。     redis 127.0.0.1:6379> smembers myset     1) "c"     #为后面的smove命令准备数据。     redis 127.0.0.1:6379> sadd myset a b     (integer) 2     redis 127.0.0.1:6379> sadd myset2 c d     (integer) 2     #将a从myset移到myset2，从结果可以看出移动成功。     redis 127.0.0.1:6379> smove myset myset2 a     (integer) 1     #再次将a从myset移到myset2，由于此时a已经不是myset的成员了，因此移动失败并返回0。     redis 127.0.0.1:6379> smove myset myset2 a     (integer) 0     #分别查看myset和myset2的成员，确认移动是否真的成功。     redis 127.0.0.1:6379> smembers myset     1) "b"     redis 127.0.0.1:6379> smembers myset2     1) "c"     2) "d"     3) "a"    3. SDIFF/SDIFFSTORE/SINTER/SINTERSTORE:     #为后面的命令准备测试数据。     redis 127.0.0.1:6379> sadd myset a b c d     (integer) 4     redis 127.0.0.1:6379> sadd myset2 c     (integer) 1     redis 127.0.0.1:6379> sadd myset3 a c e     (integer) 3     #myset和myset2相比，a、b和d三个成员是两者之间的差异成员。再用这个结果继续和myset3进行差异比较，b和d是myset3不存在的成员。     redis 127.0.0.1:6379> sdiff myset myset2 myset3     1) "d"     2) "b"     #将3个集合的差异成员存在在diffkey关联的Set中，并返回插入的成员数量。     redis 127.0.0.1:6379> sdiffstore diffkey myset myset2 myset3     (integer) 2     #查看一下sdiffstore的操作结果。     redis 127.0.0.1:6379> smembers diffkey     1) "d"     2) "b"     #从之前准备的数据就可以看出，这三个Set的成员交集只有c。     redis 127.0.0.1:6379> sinter myset myset2 myset3     1) "c"     #将3个集合中的交集成员存储到与interkey关联的Set中，并返回交集成员的数量。     redis 127.0.0.1:6379> sinterstore interkey myset myset2 myset3     (integer) 1     #查看一下sinterstore的操作结果。     redis 127.0.0.1:6379> smembers interkey     1) "c"     #获取3个集合中的成员的并集。         redis 127.0.0.1:6379> sunion myset myset2 myset3     1) "b"     2) "c"     3) "d"     4) "e"     5) "a"     #将3个集合中成员的并集存储到unionkey关联的set中，并返回并集成员的数量。     redis 127.0.0.1:6379> sunionstore unionkey myset myset2 myset3     (integer) 5     #查看一下suiionstore的操作结果。     redis 127.0.0.1:6379> smembers unionkey     1) "b"     2) "c"     3) "d"     4) "e"     5) "a" 四、应用范围：       1). 可以使用Redis的Set数据类型跟踪一些唯一性数据，比如访问某一博客的唯一IP地址信息。对于此场景，我们仅需在每次访问该博客时将访问者的IP存入Redis中，Set数据类型会自动保证IP地址的唯一性。       2). 充分利用Set类型的服务端聚合操作方便、高效的特性，可以用于维护数据对象之间的关联关系。比如所有购买某一电子设备的客户ID被存储在一个指定的Set中，而购买另外一种电子产品的客户ID被存储在另外一个Set中，如果此时我们想获取有哪些客户同时购买了这两种商品时，Set的intersections命令就可以充分发挥它的方便和效率的优势了。

一、概述：     Sorted-Sets和Sets类型极为相似，它们都是字符串的集合，都不允许重复的成员出现在一个Set中。它们之间的主要差别是Sorted-Sets中的每一个成员都会有一个分数(score)与之关联，Redis正是通过分数来为集合中的成员进行从小到大的排序。然而需要额外指出的是，尽管Sorted-Sets中的成员必须是唯一的，但是分数(score)却是可以重复的。     在Sorted-Set中添加、删除或更新一个成员都是非常快速的操作，其时间复杂度为集合中成员数量的对数。由于Sorted-Sets中的成员在集合中的位置是有序的，因此，即便是访问位于集合中部的成员也仍然是非常高效的。事实上，Redis所具有的这一特征在很多其它类型的数据库中是很难实现的，换句话说，在该点上要想达到和Redis同样的高效，在其它数据库中进行建模是非常困难的。 二、相关命令列表：

一、概述：       在该系列的前几篇博客中，主要讲述的是与Redis数据类型相关的命令，如String、List、Set、Hashes和Sorted-Set。这些命令都具有一个共同点，即所有的操作都是针对与Key关联的Value的。而该篇博客将主要讲述与Key相关的Redis命令。学习这些命令对于学习Redis是非常重要的基础，也是能够充分挖掘Redis潜力的利器。       在该篇博客中，我们将一如既往的给出所有相关命令的明细列表和典型示例，以便于我们现在的学习和今后的查阅。 二、相关命令列表：

三、命令示例：    1. KEYS/RENAME/DEL/EXISTS/MOVE/RENAMENX:     #在Shell命令行下启动Redis客户端工具。     /> redis-cli     #清空当前选择的数据库，以便于对后面示例的理解。     redis 127.0.0.1:6379> flushdb     OK     #添加String类型的模拟数据。     redis 127.0.0.1:6379> set mykey 2     OK     redis 127.0.0.1:6379> set mykey2 "hello"     OK     #添加Set类型的模拟数据。     redis 127.0.0.1:6379> sadd mysetkey 1 2 3     (integer) 3     #添加Hash类型的模拟数据。     redis 127.0.0.1:6379> hset mmtest username "stephen"     (integer) 1     #根据参数中的模式，获取当前数据库中符合该模式的所有key，从输出可以看出，该命令在执行时并不区分与Key关联的Value类型。     redis 127.0.0.1:6379> keys my*     1) "mysetkey"     2) "mykey"     3) "mykey2"     #删除了两个Keys。     redis 127.0.0.1:6379> del mykey mykey2     (integer) 2     #查看一下刚刚删除的Key是否还存在，从返回结果看，mykey确实已经删除了。     redis 127.0.0.1:6379> exists mykey     (integer) 0     #查看一下没有删除的Key，以和上面的命令结果进行比较。     redis 127.0.0.1:6379> exists mysetkey     (integer) 1     #将当前数据库中的mysetkey键移入到ID为1的数据库中，从结果可以看出已经移动成功。     redis 127.0.0.1:6379> move mysetkey 1     (integer) 1     #打开ID为1的数据库。     redis 127.0.0.1:6379> select 1     OK     #查看一下刚刚移动过来的Key是否存在，从返回结果看已经存在了。     redis 127.0.0.1:6379[1]> exists mysetkey     (integer) 1     #在重新打开ID为0的缺省数据库。     redis 127.0.0.1:6379[1]> select 0     OK     #查看一下刚刚移走的Key是否已经不存在，从返回结果看已经移走。     redis 127.0.0.1:6379> exists mysetkey     (integer) 0     #准备新的测试数据。         redis 127.0.0.1:6379> set mykey "hello"     OK     #将mykey改名为mykey1     redis 127.0.0.1:6379> rename mykey mykey1     OK     #由于mykey已经被重新命名，再次获取将返回nil。     redis 127.0.0.1:6379> get mykey     (nil)     #通过新的键名获取。     redis 127.0.0.1:6379> get mykey1     "hello"     #由于mykey已经不存在了，所以返回错误信息。     redis 127.0.0.1:6379> rename mykey mykey1     (error) ERR no such key     #为renamenx准备测试key     redis 127.0.0.1:6379> set oldkey "hello"     OK     redis 127.0.0.1:6379> set newkey "world"     OK     #由于newkey已经存在，因此该命令未能成功执行。     redis 127.0.0.1:6379> renamenx oldkey newkey     (integer) 0     #查看newkey的值，发现它也没有被renamenx覆盖。     redis 127.0.0.1:6379> get newkey     "world"             2. PERSIST/EXPIRE/EXPIREAT/TTL:         #为后面的示例准备的测试数据。     redis 127.0.0.1:6379> set mykey "hello"     OK     #将该键的超时设置为100秒。     redis 127.0.0.1:6379> expire mykey 100     (integer) 1     #通过ttl命令查看一下还剩下多少秒。     redis 127.0.0.1:6379> ttl mykey     (integer) 97     #立刻执行persist命令，该存在超时的键变成持久化的键，即将该Key的超时去掉。     redis 127.0.0.1:6379> persist mykey     (integer) 1     #ttl的返回值告诉我们，该键已经没有超时了。     redis 127.0.0.1:6379> ttl mykey     (integer) -1     #为后面的expire命令准备数据。     redis 127.0.0.1:6379> del mykey     (integer) 1     redis 127.0.0.1:6379> set mykey "hello"     OK     #设置该键的超时被100秒。     redis 127.0.0.1:6379> expire mykey 100     (integer) 1     #用ttl命令看一下当前还剩下多少秒，从结果中可以看出还剩下96秒。     redis 127.0.0.1:6379> ttl mykey     (integer) 96     #重新更新该键的超时时间为20秒，从返回值可以看出该命令执行成功。     redis 127.0.0.1:6379> expire mykey 20     (integer) 1     #再用ttl确认一下，从结果中可以看出果然被更新了。     redis 127.0.0.1:6379> ttl mykey     (integer) 17     #立刻更新该键的值，以使其超时无效。     redis 127.0.0.1:6379> set mykey "world"     OK     #从ttl的结果可以看出，在上一条修改该键的命令执行后，该键的超时也无效了。     redis 127.0.0.1:6379> ttl mykey     (integer) -1    3. TYPE/RANDOMKEY/SORT:     #由于mm键在数据库中不存在，因此该命令返回none。     redis 127.0.0.1:6379> type mm     none     #mykey的值是字符串类型，因此返回string。     redis 127.0.0.1:6379> type mykey     string     #准备一个值是set类型的键。     redis 127.0.0.1:6379> sadd mysetkey 1 2     (integer) 2     #mysetkey的键是set，因此返回字符串set。     redis 127.0.0.1:6379> type mysetkey     set     #返回数据库中的任意键。     redis 127.0.0.1:6379> randomkey     "oldkey"     #清空当前打开的数据库。     redis 127.0.0.1:6379> flushdb     OK     #由于没有数据了，因此返回nil。     redis 127.0.0.1:6379> randomkey     (nil)

一、概述：       和众多其它数据库一样，Redis作为NoSQL数据库也同样提供了事务机制。在Redis中，MULTI/EXEC/DISCARD/WATCH这四个命令是我们实现事务的基石。相信对有关系型数据库开发经验的开发者而言这一概念并不陌生，即便如此，我们还是会简要的列出Redis中事务的实现特征：       1). 在事务中的所有命令都将会被串行化的顺序执行，事务执行期间，Redis不会再为其它客户端的请求提供任何服务，从而保证了事物中的所有命令被原子的执行。       2). 和关系型数据库中的事务相比，在Redis事务中如果有某一条命令执行失败，其后的命令仍然会被继续执行。       3). 我们可以通过MULTI命令开启一个事务，有关系型数据库开发经验的人可以将其理解为"BEGIN TRANSACTION"语句。在该语句之后执行的命令都将被视为事务之内的操作，最后我们可以通过执行EXEC/DISCARD命令来提交/回滚该事务内的所有操作。这两个Redis命令可被视为等同于关系型数据库中的COMMIT/ROLLBACK语句。       4). 在事务开启之前，如果客户端与服务器之间出现通讯故障并导致网络断开，其后所有待执行的语句都将不会被服务器执行。然而如果网络中断事件是发生在客户端执行EXEC命令之后，那么该事务中的所有命令都会被服务器执行。       5). 当使用Append-Only模式时，Redis会通过调用系统函数write将该事务内的所有写操作在本次调用中全部写入磁盘。然而如果在写入的过程中出现系统崩溃，如电源故障导致的宕机，那么此时也许只有部分数据被写入到磁盘，而另外一部分数据却已经丢失。Redis服务器会在重新启动时执行一系列必要的一致性检测，一旦发现类似问题，就会立即退出并给出相应的错误提示。此时，我们就要充分利用Redis工具包中提供的redis-check-aof工具，该工具可以帮助我们定位到数据不一致的错误，并将已经写入的部分数据进行回滚。修复之后我们就可以再次重新启动Redis服务器了。 二、相关命令列表：

三、命令示例：    1. 事务被正常执行：     #在Shell命令行下执行Redis的客户端工具。     /> redis-cli     #在当前连接上启动一个新的事务。     redis 127.0.0.1:6379> multi     OK     #执行事务中的第一条命令，从该命令的返回结果可以看出，该命令并没有立即执行，而是存于事务的命令队列。     redis 127.0.0.1:6379> incr t1     QUEUED     #又执行一个新的命令，从结果可以看出，该命令也被存于事务的命令队列。     redis 127.0.0.1:6379> incr t2     QUEUED     #执行事务命令队列中的所有命令，从结果可以看出，队列中命令的结果得到返回。     redis 127.0.0.1:6379> exec     1) (integer) 1     2) (integer) 1             2. 事务中存在失败的命令：     #开启一个新的事务。     redis 127.0.0.1:6379> multi     OK     #设置键a的值为string类型的3。     redis 127.0.0.1:6379> set a 3     QUEUED     #从键a所关联的值的头部弹出元素，由于该值是字符串类型，而lpop命令仅能用于List类型，因此在执行exec命令时，该命令将会失败。     redis 127.0.0.1:6379> lpop a     QUEUED     #再次设置键a的值为字符串4。     redis 127.0.0.1:6379> set a 4     QUEUED     #获取键a的值，以便确认该值是否被事务中的第二个set命令设置成功。     redis 127.0.0.1:6379> get a     QUEUED     #从结果中可以看出，事务中的第二条命令lpop执行失败，而其后的set和get命令均执行成功，这一点是Redis的事务与关系型数据库中的事务之间最为重要的差别。     redis 127.0.0.1:6379> exec     1) OK     2) (error) ERR Operation against a key holding the wrong kind of value     3) OK     4) "4"    3. 回滚事务：     #为键t2设置一个事务执行前的值。     redis 127.0.0.1:6379> set t2 tt     OK     #开启一个事务。     redis 127.0.0.1:6379> multi     OK     #在事务内为该键设置一个新值。     redis 127.0.0.1:6379> set t2 ttnew     QUEUED     #放弃事务。     redis 127.0.0.1:6379> discard     OK     #查看键t2的值，从结果中可以看出该键的值仍为事务开始之前的值。     redis 127.0.0.1:6379> get t2     "tt" 四、WATCH命令和基于CAS的乐观锁：       在Redis的事务中，WATCH命令可用于提供CAS(check-and-set)功能。假设我们通过WATCH命令在事务执行之前监控了多个Keys，倘若在WATCH之后有任何Key的值发生了变化，EXEC命令执行的事务都将被放弃，同时返回Null multi-bulk应答以通知调用者事务执行失败。例如，我们再次假设Redis中并未提供incr命令来完成键值的原子性递增，如果要实现该功能，我们只能自行编写相应的代码。其伪码如下：       val = GET mykey       val = val + 1       SET mykey $val       以上代码只有在单连接的情况下才可以保证执行结果是正确的，因为如果在同一时刻有多个客户端在同时执行该段代码，那么就会出现多线程程序中经常出现的一种错误场景--竞态争用(race condition)。比如，客户端A和B都在同一时刻读取了mykey的原有值，假设该值为10，此后两个客户端又均将该值加一后set回Redis服务器，这样就会导致mykey的结果为11，而不是我们认为的12。为了解决类似的问题，我们需要借助WATCH命令的帮助，见如下代码：       WATCH mykey       val = GET mykey       val = val + 1       MULTI       SET mykey $val       EXEC       和此前代码不同的是，新代码在获取mykey的值之前先通过WATCH命令监控了该键，此后又将set命令包围在事务中，这样就可以有效的保证每个连接在执行EXEC之前，如果当前连接获取的mykey的值被其它连接的客户端修改，那么当前连接的EXEC命令将执行失败。这样调用者在判断返回值后就可以获悉val是否被重新设置成功。

一、请求应答协议和RTT：     Redis是一种典型的基于C/S模型的TCP服务器。在客户端与服务器的通讯过程中，通常都是客户端率先发起请求，服务器在接收到请求后执行相应的任务，最后再将获取的数据或处理结果以应答的方式发送给客户端。在此过程中，客户端都会以阻塞的方式等待服务器返回的结果。见如下命令序列：     Client: INCR X     Server: 1     Client: INCR X     Server: 2     Client: INCR X     Server: 3     Client: INCR X     Server: 4     在每一对请求与应答的过程中，我们都不得不承受网络传输所带来的额外开销。我们通常将这种开销称为RTT(Round Trip Time)。现在我们假设每一次请求与应答的RTT为250毫秒，而我们的服务器可以在一秒内处理100k的数据，可结果则是我们的服务器每秒至多处理4条请求。要想解决这一性能问题，我们该如何进行优化呢？      二、管线(pipelining)：     Redis在很早的版本中就已经提供了对命令管线的支持。在给出具体解释之前，我们先将上面的同步应答方式的例子改造为基于命令管线的异步应答方式，这样可以让大家有一个更好的感性认识。     Client: INCR X     Client: INCR X     Client: INCR X     Client: INCR X     Server: 1     Server: 2     Server: 3     Server: 4     从以上示例可以看出，客户端在发送命令之后，不用立刻等待来自服务器的应答，而是可以继续发送后面的命令。在命令发送完毕后，再一次性的读取之前所有命令的应答。这样便节省了同步方式中RTT的开销。     最后需要说明的是，如果Redis服务器发现客户端的请求是基于管线的，那么服务器端在接受到请求并处理之后，会将每条命令的应答数据存入队列，之后再发送到客户端。      三、Benchmark：     以下是来自Redis官网的测试用例和测试结果。需要说明的是，该测试是基于loopback(127.0.0.1)的，因此RTT所占用的时间相对较少，如果是基于实际网络接口，那么管线机制所带来的性能提升就更为显著了。

 1     require 'rubygems'
 2     require 'redis'
 3     
 4     def bench(descr)
 5         start = Time.now
 6         yield
 7         puts "#{descr} #{Time.now-start} seconds"
 8     end
 9     
10     def without_pipelining
11         r = Redis.new
12         10000.times {
13             r.ping
14         }
15     end
16     
17     def with_pipelining
18         r = Redis.new
19         r.pipelined {
20             10000.times {
21                 r.ping
22             }
23         }
24     end
25     
26     bench("without pipelining") {
27         without_pipelining
28     }
29     bench("with pipelining") {
30         with_pipelining
31     }
32     //without pipelining 1.185238 seconds
33     //with pipelining 0.250783 seconds　

在之前的博客中已经非常详细的介绍了Redis的各种操作命令、运行机制和服务器初始化参数配置。本篇博客是该系列博客中的最后一篇，在这里将给出基于Redis客户端组件访问并操作Redis服务器的代码示例。然而需要说明的是，由于Redis官方并未提供基于C接口的Windows平台客户端，因此下面的示例仅可运行于Linux/Unix平台。但是对于使用其它编程语言的开发者而言，如C#和Java，Redis则提供了针对这些语言的客户端组件，通过该方式，同样可以达到基于Windows平台与Redis服务器进行各种交互的目的。     该篇博客中使用的客户端来自于Redis官方网站，是Redis推荐的基于C接口的客户端组件，见如下链接：     https://github.com/antirez/hiredis     在下面的代码示例中，将给出两种最为常用的Redis命令操作方式，既普通调用方式和基于管线的调用方式。     注：在阅读代码时请留意注释。

  1 #include 
  2 #include 
  3 #include 
  4 #include 
  5 #include 
  6 #include 
  7 #include 
  8 
  9 void doTest()
 10 {
 11     int timeout = 10000;
 12     struct timeval tv;
 13     tv.tv_sec = timeout / 1000;
 14     tv.tv_usec = timeout * 1000;
 15     //以带有超时的方式链接Redis服务器，同时获取与Redis连接的上下文对象。
 16     //该对象将用于其后所有与Redis操作的函数。
 17     redisContext* c = redisConnectWithTimeout("192.168.149.137",6379,tv);
 18     if (c->err) {
 19         redisFree(c);
 20         return;
 21     }
 22     const char* command1 = "set stest1 value1";
 23     redisReply* r = (redisReply*)redisCommand(c,command1);
 24     //需要注意的是，如果返回的对象是NULL，则表示客户端和服务器之间出现严重错误，必须重新链接。
 25     //这里只是举例说明，简便起见，后面的命令就不再做这样的判断了。
 26     if (NULL == r) {
 27         redisFree(c);
 28         return;
 29     }
 30     //不同的Redis命令返回的数据类型不同，在获取之前需要先判断它的实际类型。
 31     //至于各种命令的返回值信息，可以参考Redis的官方文档，或者查看该系列博客的前几篇
 32     //有关Redis各种数据类型的博客。:)
 33     //字符串类型的set命令的返回值的类型是REDIS_REPLY_STATUS，然后只有当返回信息是"OK"
 34     //时，才表示该命令执行成功。后面的例子以此类推，就不再过多赘述了。
 35     if (!(r->type == REDIS_REPLY_STATUS && strcasecmp(r->str,"OK") == 0)) {
 36         printf("Failed to execute command[%s].\n",command1);
 37         freeReplyObject(r);
 38         redisFree(c);
 39         return;
 40     }
 41     //由于后面重复使用该变量，所以需要提前释放，否则内存泄漏。
 42     freeReplyObject(r);
 43     printf("Succeed to execute command[%s].\n",command1);
 44 
 45     const char* command2 = "strlen stest1";
 46     r = (redisReply*)redisCommand(c,command2);
 47     if (r->type != REDIS_REPLY_INTEGER) {
 48         printf("Failed to execute command[%s].\n",command2);
 49         freeReplyObject(r);
 50         redisFree(c);
 51         return;
 52     }
 53     int length = r->integer;
 54     freeReplyObject(r);
 55     printf("The length of 'stest1' is %d.\n",length);
 56     printf("Succeed to execute command[%s].\n",command2);
 57 
 58     const char* command3 = "get stest1";
 59     r = (redisReply*)redisCommand(c,command3);
 60     if (r->type != REDIS_REPLY_STRING) {
 61         printf("Failed to execute command[%s].\n",command3);
 62         freeReplyObject(r);
 63         redisFree(c);
 64         return;
 65     }
 66     printf("The value of 'stest1' is %s.\n",r->str);
 67     freeReplyObject(r);
 68     printf("Succeed to execute command[%s].\n",command3);
 69 
 70     const char* command4 = "get stest2";
 71     r = (redisReply*)redisCommand(c,command4);
 72     //这里需要先说明一下，由于stest2键并不存在，因此Redis会返回空结果，这里只是为了演示。
 73     if (r->type != REDIS_REPLY_NIL) {
 74         printf("Failed to execute command[%s].\n",command4);
 75         freeReplyObject(r);
 76         redisFree(c);
 77         return;
 78     }
 79     freeReplyObject(r);
 80     printf("Succeed to execute command[%s].\n",command4);
 81 
 82     const char* command5 = "mget stest1 stest2";
 83     r = (redisReply*)redisCommand(c,command5);
 84     //不论stest2存在与否，Redis都会给出结果，只是第二个值为nil。
 85     //由于有多个值返回，因为返回应答的类型是数组类型。
 86     if (r->type != REDIS_REPLY_ARRAY) {
 87         printf("Failed to execute command[%s].\n",command5);
 88         freeReplyObject(r);
 89         redisFree(c);
 90         //r->elements表示子元素的数量，不管请求的key是否存在，该值都等于请求是键的数量。
 91         assert(2 == r->elements);
 92         return;
 93     }
 94     for (int i = 0; i < r->elements; ++i) {
 95         redisReply* childReply = r->element[i];
 96         //之前已经介绍过，get命令返回的数据类型是string。
 97         //对于不存在key的返回值，其类型为REDIS_REPLY_NIL。
 98         if (childReply->type == REDIS_REPLY_STRING)
 99             printf("The value is %s.\n",childReply->str);
100     }
101     //对于每一个子应答，无需使用者单独释放，只需释放最外部的redisReply即可。
102     freeReplyObject(r);
103     printf("Succeed to execute command[%s].\n",command5);
104 
105     printf("Begin to test pipeline.\n");
106     //该命令只是将待发送的命令写入到上下文对象的输出缓冲区中，直到调用后面的
107     //redisGetReply命令才会批量将缓冲区中的命令写出到Redis服务器。这样可以
108     //有效的减少客户端与服务器之间的同步等候时间，以及网络IO引起的延迟。
109     //至于管线的具体性能优势，可以考虑该系列博客中的管线主题。
110     if (REDIS_OK != redisAppendCommand(c,command1)
111         || REDIS_OK != redisAppendCommand(c,command2)
112         || REDIS_OK != redisAppendCommand(c,command3)
113         || REDIS_OK != redisAppendCommand(c,command4)
114         || REDIS_OK != redisAppendCommand(c,command5)) {
115         redisFree(c);
116         return;
117     }
118 
119     redisReply* reply = NULL;
120     //对pipeline返回结果的处理方式，和前面代码的处理方式完全一直，这里就不再重复给出了。
121     if (REDIS_OK != redisGetReply(c,(void**)&reply)) {
122         printf("Failed to execute command[%s] with Pipeline.\n",command1);
123         freeReplyObject(reply);
124         redisFree(c);
125     }
126     freeReplyObject(reply);
127     printf("Succeed to execute command[%s] with Pipeline.\n",command1);
128 
129     if (REDIS_OK != redisGetReply(c,(void**)&reply)) {
130         printf("Failed to execute command[%s] with Pipeline.\n",command2);
131         freeReplyObject(reply);
132         redisFree(c);
133     }
134     freeReplyObject(reply);
135     printf("Succeed to execute command[%s] with Pipeline.\n",command2);
136 
137     if (REDIS_OK != redisGetReply(c,(void**)&reply)) {
138         printf("Failed to execute command[%s] with Pipeline.\n",command3);
139         freeReplyObject(reply);
140         redisFree(c);
141     }
142     freeReplyObject(reply);
143     printf("Succeed to execute command[%s] with Pipeline.\n",command3);
144 
145     if (REDIS_OK != redisGetReply(c,(void**)&reply)) {
146         printf("Failed to execute command[%s] with Pipeline.\n",command4);
147         freeReplyObject(reply);
148         redisFree(c);
149     }
150     freeReplyObject(reply);
151     printf("Succeed to execute command[%s] with Pipeline.\n",command4);
152 
153     if (REDIS_OK != redisGetReply(c,(void**)&reply)) {
154         printf("Failed to execute command[%s] with Pipeline.\n",command5);
155         freeReplyObject(reply);
156         redisFree(c);
157     }
158     freeReplyObject(reply);
159     printf("Succeed to execute command[%s] with Pipeline.\n",command5);
160     //由于所有通过pipeline提交的命令结果均已为返回，如果此时继续调用redisGetReply，
161     //将会导致该函数阻塞并挂起当前线程，直到有新的通过管线提交的命令结果返回。
162     //最后不要忘记在退出前释放当前连接的上下文对象。
163     redisFree(c);
164     return;
165 }
166 
167 int main() 
168 {
169     doTest();
170     return 0;
171 }
172 
173 //输出结果如下：
174 //Succeed to execute command[set stest1 value1].
175 //The length of 'stest1' is 6.
176 //Succeed to execute command[strlen stest1].
177 //The value of 'stest1' is value1.
178 //Succeed to execute command[get stest1].
179 //Succeed to execute command[get stest2].
180 //The value is value1.
181 //Succeed to execute command[mget stest1 stest2].
182 //Begin to test pipeline.
183 //Succeed to execute command[set stest1 value1] with Pipeline.
184 //Succeed to execute command[strlen stest1] with Pipeline.
185 //Succeed to execute command[get stest1] with Pipeline.
186 //Succeed to execute command[get stest2] with Pipeline.
187 //Succeed to execute command[mget stest1 stest2] with Pipeline.