redis命令说明

逃离我推掉我的手 2022-04-13 14:26 253阅读 0赞

1.  **redis介绍**
    
    1.  **什么是NoSQL**

NoSQL，泛指非关系型的数据库，NoSQL即Not-Only SQL，它可以作为关系型数据库的良好补充。随着互联网web2.0网站的兴起，非关系型的数据库现在成了一个极其热门的新领域，非关系数据库产品的发展非常迅速。而传统的关系数据库在应付web2.0网站，特别是超大规模和高并发类型的web2.0纯动态网站已经显得力不从心，暴露了很多难以克服的问题，例如：

1、High performance - 对数据库高并发读写的需求

web2.0网站要根据用户个性化信息来实时生成动态页面和提供动态信息，所以基本上无法使用动态页面静态化技术，因此数据库并发负载非常高，往往要达到每秒上万次读写请求。关系数据库应付上万次SQL查询还勉强顶得住，但是应付上万次SQL写数据请求，硬盘IO就已经无法承受了。其实对于普通的BBS网站，往往也存在对高并发写请求的需求，例如网站的实时统计在线用户状态，记录热门帖子的点击次数，投票计数等，因此这是一个相当普遍的需求。

2、Huge Storage - 对海量数据的高效率存储和访问的需求

类似Facebook，twitter，Friendfeed这样的网站，每天用户产生海量的用户动态，以Friendfeed为例，一个月就达到了2.5亿条用户动态，对于关系数据库来说，在一张2.5亿条记录的表里面进行SQL查询，效率是极其低下乃至不可忍受的。再例如大型web网站的用户登录系统，例如腾讯，盛大，动辄数以亿计的帐号，关系数据库也很难应付。

3、High Scalability && High Availability- 对数据库的高可扩展性和高可用性的需求

在基于web的架构当中，数据库是最难进行横向扩展的，当一个应用系统的用户量和访问量与日俱增的时候，数据库却没有办法像web server和app server那样简单的通过添加更多的硬件和服务节点来扩展性能和负载能力。对于很多需要提供24小时不间断服务的网站来说，对数据库系统进行升级和扩展是非常痛苦的事情，往往需要停机维护和数据迁移。

NoSQL数据库的产生就是为了解决大规模数据集合多重数据种类带来的挑战，尤其是大数据应用难题。

一些主流的NOSQL产品：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3N0YXJfb2Zfc2NpZW5jZQ_size_16_color_FFFFFF_t_70][]

NoSQL数据库的四大分类如下：

1.  键值(Key-Value)存储数据库

相关产品： Tokyo Cabinet/Tyrant、Redis、Voldemort、Berkeley DB

典型应用： 内容缓存，主要用于处理大量数据的高访问负载。

数据模型： 一系列键值对

优势： 快速查询

劣势： 存储的数据缺少结构化

1.  列存储数据库

相关产品：CouchDB、MongoDB

典型应用：Web应用（与Key-Value类似，Value是结构化的）

数据模型： 一系列键值对

优势：数据结构要求不严格

劣势：查询性能不高，而且缺乏统一的查询语法

1.  图形(Graph)数据库

相关数据库：Neo4J、InfoGrid、Infinite Graph

典型应用：社交网络

数据模型：图结构

优势：利用图结构相关算法。

劣势：需要对整个图做计算才能得出结果，不容易做分布式的集群方案。

1.  1.  **redis历史发展**

2008年，意大利的一家创业公司Merzia推出了一款基于MySQL的网站实时统计系统LLOOGG，然而没过多久该公司的创始人 Salvatore Sanfilippo便 对MySQL的性能感到失望，于是他决定亲自为LLOOGG量身定做一个数据库，并于2009年开发完成，这个数据库就是Redis。 不过Salvatore Sanfilippo并不满足只将Redis用于LLOOGG这一款产品，而是希望更多的人使用它，于是在同一年Salvatore Sanfilippo将Redis开源发布，并开始和Redis的另一名主要的代码贡献者Pieter Noordhuis一起继续着Redis的开发，直到今天。

Salvatore Sanfilippo自己也没有想到，短短的几年时间，Redis就拥有了庞大的用户群体。Hacker News在2012年发布了一份数据库的使用情况调查，结果显示有近12%的公司在使用Redis。国内如新浪微博、街旁网、知乎网，国外如GitHub、Stack Overflow、Flickr等都是Redis的用户。

VMware公司从2010年开始赞助Redis的开发， Salvatore Sanfilippo和Pieter Noordhuis也分别在3月和5月加入VMware，全职开发Redis。

1.  1.  **什么是redis**

Redis是用C语言开发的一个开源的高性能键值对（key-value）数据库。它通过提供多种键值数据类型来适应不同场景下的存储需求，目前为止Redis支持的键值数据类型如下：

字符串类型    String  json

散列类型        Map

列表类型        List

集合类型        set

有序集合类型。    sortSet

1.  1.  **redis的应用场景**

缓存（数据查询、短连接、新闻内容、商品内容等等）。（最多使用）

分布式集群架构中的session分离。

聊天室的在线好友列表。

任务队列。（秒杀、抢购、12306等等）

应用排行榜。

网站访问统计。

数据过期处理（可以精确到毫秒）

1.  1.  **redis和memcached相比独特之处:**

1．redis可以用来做存储(storge), 而memccached是用来做缓存(cache)

这个特点主要因为其有”持久化”的功能.

2． 存储的数据有”结构”,对于memcached来说,存储的数据,只有1种类型--”字符串”,而         redis则可以存储字符串,链表,哈希结构,集合,有序集合.

**Redis****的优势：**  
      和其他NoSQL产品相比，Redis的易用性极高，因此对于那些有类似产品使用经验的         开发者来说，一两天，甚至是几个小时之后就可以利用Redis来搭建自己的平台了。  
      在解决了很多通用性问题的同时，也为一些个性化问题提供了相关的解决方案，如 索         引引擎、统计排名、消息队列服务等。

1:数据结构丰富

2:持久化

3:支持简单事务

4:主从配置方便

1.  **jedis**
    
    1.  **jedis介绍**

Redis不仅是使用命令来操作，现在基本上主流的语言都有客户端支持，比如java、C、C\#、C++、php、Node.js、Go等。

在官方网站里列一些Java的客户端，有Jedis、Redisson、Jredis、JDBC-Redis、等其中官方推荐使用Jedis和Redisson。 在企业中用的最多的就是Jedis，下面我们就重点学习下Jedis。

Jedis同样也是托管在github上，地址：[https://github.com/xetorthio/jedis][https_github.com_xetorthio_jedis]

1.  1.  1.  **jedis与spring整合**

配置spring配置文件spring-redis.xml

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:mvc="http://www.springframework.org/schema/mvc"

xmlns:context="http://www.springframework.org/schema/context"

xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"

xsi:schemaLocation="http://www.springframework.org/schema/beans

http://www.springframework.org/schema/beans/spring-beans-3.2.xsd

http://www.springframework.org/schema/mvc

http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd

http://www.springframework.org/schema/context

http://www.springframework.org/schema/context/spring-context-3.2.xsd

http://www.springframework.org/schema/aop

http://www.springframework.org/schema/aop/spring-aop-3.2.xsd

http://www.springframework.org/schema/tx

http://www.springframework.org/schema/tx/spring-tx-3.2.xsd ">

</bean>

<constructor-arg name="poolConfig" ref="jedisPoolConfig"/>

<constructor-arg name="host" value="127.0.0.1"/>

<constructor-arg name="port" value="6379"/>

</bean>

</beans>

1.  **数据类型--string**
    
    1.  **redis string介绍**

redis中没有使用C语言的字符串表示，而是自定义一个数据结构叫**SDS****（simple dynamic string****）即简单动态字符串**。

c语言对字符串的存储是使用字符数组，遇到'\\0'字符则认为字符串结束，redis的字符串可以存储任何类型的数据，因为任何类型数据都可以表示成二进制，sds结构中的char buf\[\]就是存储了二进制数据。

1.  1.  **命令**

1. SET/GET/APPEND/STRLEN:  
   * **/> redis-cli**   **\#**执行**Redis**客户端工具。*  
    redis 127.0.0.1:6379> *exists mykey**                 **\#**判断该键是否存在，存在返回**1**，否则返回**0**。*  
    (integer) 0  
    redis 127.0.0.1:6379>* append mykey "hello"*      *\#**该键并不存在，因此**append**命令返回当前**Value**的长度。*  
    (integer) 5  
    redis 127.0.0.1:6379> *append mykey " world"** **\#**该键已经存在，因此返回追加后**Value**的长度。*  
    (integer) 11  
    redis 127.0.0.1:6379> *get mykey             **\#**通过**get**命令获取该键，以判断**append**的结果。*  
    "hello world"  
    redis 127.0.0.1:6379> *set mykey "this is a test"* *\#**通过**set**命令为键设置新值，并覆盖原有值。*  
    OK  
    redis 127.0.0.1:6379> *get mykey*  
    "this is a test"  
    redis 127.0.0.1:6379> *strlen mykey**     \#**获取指定**Key**的字符长度，等效于**C**库中**strlen**函数。*  
    (integer) 14  
  
    2. INCR/DECR/INCRBY/DECRBY:  
    redis 127.0.0.1:6379> *set mykey 20*     *\#**设置**Key**的值为**20*  
    OK  
    redis 127.0.0.1:6379> *incr mykey*     *    \#**该**Key**的值递增**1*  
    (integer) 21  
    redis 127.0.0.1:6379> *decr mykey**    **    \#**该**Key**的值递减**1*  
    (integer) 20  
    redis 127.0.0.1:6379> *del mykey**          **\#**删除已有键。*  
    (integer) 1  
    redis 127.0.0.1:6379> *decr mykey**  **\#**对空值执行递减操作，其原值被设定为**0**，递减后的值为**-1*  
    (integer) -1  
    redis 127.0.0.1:6379> *del mykey *    
    (integer) 1  
    redis 127.0.0.1:6379>* incr mykey**   **\#**对空值执行递增操作，其原值被设定为**0**，递增后的值为**1*  
    (integer) 1  
    redis 127.0.0.1:6379> *set mykey hello* *\#**将该键的**Value**设置为不能转换为整型的普通字符串。*  
    OK  
    redis 127.0.0.1:6379> *incr mykey**      **\#**在该键上再次执行递增操作时，**Redis**将报告错误信息。*  
    (error) ERR value is not an integer or out of range  
    redis 127.0.0.1:6379> *set mykey 10*  
    OK  
    redis 127.0.0.1:6379> *decrby mykey 5*   
    (integer) 5  
    redis 127.0.0.1:6379> *incrby mykey 10*  
    (integer) 15

set key value \[ex 秒数\] / \[px 毫秒数\]

如: set a 1 ex 10 , 10秒有效

Set a 1 px 9000  , 9秒有效

注: 如果ex,px同时写,以后面的有效期为准

如 set a 1 ex 100 px 9000, 实际有效期是9000毫秒

3. GETSET：  
    redis 127.0.0.1:6379> *incr mycounter**      **\#**将计数器的值原子性的递增**1*  
    (integer) 1  
*    \#**在获取计数器原有值的同时，并将其设置为新值，这两个操作原子性的同时完成。*  
    redis 127.0.0.1:6379> *getset mycounter 0 *   
    "1"  
    redis 127.0.0.1:6379> *get mycounter*       *\#**查看设置后的结果。*  
    "0"  
              
    4. SETEX:  
    redis 127.0.0.1:6379> *setex mykey 10 "hello" **  **\#**设置指定**Key**的过期时间为**10**秒。*  
    OK      
    *\#**通过**ttl**命令查看一下指定**Key**的剩余存活时间**(**秒数**)**，**0**表示已经过期，**-1**表示永不过期。*  
    redis 127.0.0.1:6379> *ttl mykey*                         
    (integer) 4  
    redis 127.0.0.1:6379> *get mykey *          *\#**在该键的存活期内我们仍然可以获取到它的**Value**。*  
    "hello"  
    redis 127.0.0.1:6379> *ttl mykey*                *\#**该**ttl**命令的返回值显示，该**Key**已经过期。*  
    (integer) 0  
    redis 127.0.0.1:6379> *get mykey*              *\#**获取已过期的**Key**将返回**nil**。*  
    (nil)  
  
   5. SETNX:  
    redis 127.0.0.1:6379> *del mykey**                      **\#**删除该键，以便于下面的测试验证。*  
    (integer) 1  
    redis 127.0.0.1:6379> *setnx mykey "hello"**        **\#**该键并不存在，因此该命令执行成功。*  
    (integer) 1  
    redis 127.0.0.1:6379> *setnx mykey "world"**  **\#**该键已经存在，因此本次设置没有产生任何效果。*  
    (integer) 0  
    redis 127.0.0.1:6379> *get mykey*        *\#**从结果可以看出，返回的值仍为第一次设置的值。*  
    "hello"  
  
    6. SETRANGE/GETRANGE:  
    redis 127.0.0.1:6379> *set mykey "hello world" *      *\#**设定初始值。*  
    OK  
    redis 127.0.0.1:6379> *setrange mykey 6 dd*  *\#**从第六个字节开始替换**2**个字节**(dd**只有**2**个**                                                                              * *字节**)*  
    (integer) 11  
    redis 127.0.0.1:6379> *get mykey**                         **\#**查看替换后的值。*  
    "hello ddrld"  
    redis 127.0.0.1:6379> *setrange mykey 20 dd*        *\#offset**已经超过该**Key**原有值的长度了，**                                                                                   * *该命令将会在末尾补**0**。*  
    (integer) 22  
    redis 127.0.0.1:6379> *get mykey*                           *\#**查看补**0**后替换的结果。*  
    "hello ddrld\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00dd"  
    redis 127.0.0.1:6379> *del mykey*                         *\#**删除该**Key**。*  
    (integer) 1  
    redis 127.0.0.1:6379> *setrange mykey 2 dd*         *\#**替换空值。*  
    (integer) 4  
    redis 127.0.0.1:6379> *get mykey*                        *\#**查看替换空值后的结果。*  
    "\\x00\\x00dd"     
    redis 127.0.0.1:6379> *set mykey "0123456789"**   **\#**设置新值。*  
    OK  
    redis 127.0.0.1:6379> *getrange mykey 1 2**      **\#**截取该键的**Value**，从第一个字节开始，到第* *                                                                     * *二个字节结束。*  
    "12"  
    redis 127.0.0.1:6379> *getrange mykey 1 20**   **\#20**已经超过**Value**的总长度，因此将截取第**                                                                              * *一个字节后面的所有字节。*  
    "123456789"

1.  1.  **应用场景**

1亿个用户, 每个用户 登陆/做任意操作  ,记为 今天活跃,否则记为不活跃

每周评出: 有奖活跃用户: 连续7天活动

每月评,等等...

思路:

Userid   dt  active

1        2013-07-27  1

1       2013-0726   1

如果是放在表中, 1:表急剧增大,2:要用group ,sum运算,计算较慢

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3N0YXJfb2Zfc2NpZW5jZQ_size_16_color_FFFFFF_t_70 1][]

1: 记录用户登陆:

每天按日期生成一个位图, 用户登陆后,把user\_id位上的bit值置为1

2: 把1周的位图  and 计算,

位上为1的,即是连续登陆的用户

1.  **数据类型--hash**
    
    1.  **使用string的问题**

假设有User对象以JSON序列化的形式存储到Redis中，User对象有id，username、password、age、name等属性，存储的过程如下：

保存、更新：

User对象 à json(string) à redis

如果在业务上只是更新age属性，其他的属性并不做更新我应该怎么做呢？ 如果仍然采用上边的方法在传输、处理时会造成资源浪费，下边讲的hash可以很好的解决这个问题。

1.  1.  **redis hash介绍**

hash叫散列类型，它提供了字段和字段值的映射。字段值只能是字符串类型，不支持散列类型、集合类型等其它类型。如下：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3N0YXJfb2Zfc2NpZW5jZQ_size_16_color_FFFFFF_t_70 2][]

1.  1.  **命令**
        
        1.  **赋值**

*HSET key field value* *一次只能设置一个字段值*

*127.0.0.1:6379> hset user username zhangsan*

*(integer) 1*

*-----------------------------*

*HMSET key field value \[field value ...\]            * *一次可以设置多个字段值*

*127.0.0.1:6379> hmset user username lisi age 20*

*OK*

1.  1.  1.  **取值**

*HGET key field                  * *一次只能获取一个字段值*

*127.0.0.1:6379> hget user username*

*"zhangsan“*

*----------------------------*

*HMGET key field \[field ...\]      * *一次可以获取多个字段值*

*127.0.0.1:6379> hmget user username age*

*1) "20"*

*2) "lisi"*

*----------------------------*

*HGETALL key*

*127.0.0.1:6379> hgetall user*

*1) "age"*

*2) "20"*

*3) "username"*

*4) "lisi"*

1.  1.  1.  **删除字段**

**可以删除一个或多个字段，返回值是被删除的字段个数**

*HDEL key field \[field ...\]*

*127.0.0.1:6379> hdel user age*

*(integer) 1*

*127.0.0.1:6379> hdel user age name*

*(integer) 0*

*127.0.0.1:6379> hdel user age username*

*(integer) 1*

1.  1.  1.  **增加数字**

*HINCRBY key field increment*

*127.0.0.1:6379> hincrby user age 2       * *将用户的年龄加2*

*(integer) 22*

*127.0.0.1:6379> hget user age               * *获取用户的年龄*

*"22“*

1.  1.  1.  **判断字段是否存在**

*HEXISTS key field*

*127.0.0.1:6379> hexists user age           * *查看user**中是否有age**字段*

*(integer) 1*

*127.0.0.1:6379> hexists user name* *查看user**中是否有name**字段*

*(integer) 0*

*HSETNX key field value*

当**字段**不存在时赋值，类似HSET，区别在于如果字段已经存在，该命令不执行任何操作。

*127.0.0.1:6379> hsetnx user age 30      * *如果user**中没有age**字段则设置age**值为30**，否则不做任何操作*

*(integer) 0*

1.  1.  1.  **只获取字段名或字段值**

*HKEYS key*

*HVALS key*

*127.0.0.1:6379> hmset user age 20 name lisi*

*OK*

*127.0.0.1:6379> hkeys user*

*1) "age"*

*2) "name"*

*127.0.0.1:6379> hvals user*

*1) "20"*

*2) "lisi"*

1.  1.  1.  **获取字段数量**

*HLEN key*

*127.0.0.1:6379> hlen user*

*(integer) 2*

1.  1.  **应用**
        
        1.  **商品信息**

商品id、商品名称、商品描述、商品库存、商品好评

定义商品信息的key：

商品1001的信息在 redis中的key为：items:1001

存储商品信息

192.168.101.3:7003> HMSET items:1001 id 3 name apple price 999.9

获取商品信息

192.168.101.3:7003> HGET items:1001 id

"3"

192.168.101.3:7003> HGETALL items:1001

1) "id"

2) "3"

3) "name"

4) "apple"

5) "price"

6) "999.9"

1.  **数据类型--list**
    
    1.  **ArrayList与LinkedList的区别**

ArrayList使用数组方式存储数据，所以根据索引查询数据速度快，而新增或者删除元素时需要设计到位移操作，所以比较慢。

LinkedList使用双向链接方式存储数据，每个元素都记录前后元素的指针，所以插入、删除数据时只是更改前后元素的指针指向即可，速度非常快，然后通过下标查询元素时需要从头开始索引，所以比较慢，但是如果查询前几个元素或后几个元素速度比较快。

1.  1.  **redis list介绍**

列表类型（list）可以存储一个有序的字符串列表，常用的操作是向列表两端添加元素，或者获得列表的某一个片段。

列表类型内部是使用双向链表（double linked list）实现的，所以向列表两端添加元素的时间复杂度为0(1)，获取越接近两端的元素速度就越快。这意味着即使是一个有几千万个元素的列表，获取头部或尾部的10条记录也是极快的。

设计一个字符串类：客户有时需要知道字符串的长度。  
所以有两种设计GetLength（）函数的方法  
1。每次客户询问长度，都用循环检测串长，即for(i=0;str\[i\]!=0;++i)  
这样效率低 时间复杂度O(n)  
2 每次串内容改变时计算长度，算好后存起来，以后客户需要知道字符串的长度就直接把变量值返回，这样效率高 时间复杂度O(1)

1.  1.  **命令**
        
        1.  **向列表两端增加元素。**

*LPUSH key value \[value ...\]*

*RPUSH key value \[value ...\]*

*向列表左边增加元素*

*127.0.0.1:6379> lpush list:a 1 2 3*

*(integer) 3*

*向列表右边增加元素*

*127.0.0.1:6379> rpush list:a 4 5 6*

*(integer) 6*

1.  1.  1.  **查看列表**

*LRANGE key start stop*

LRANGE命令是列表类型最常用的命令之一，获取列表中的某一片段，将返回start、stop之间的所有元素（包含两端的元素），索引从0开始。索引可以是负数，如：“-1”代表最后边的一个元素。

*127.0.0.1:6379> lrange list:a 0 2*

*1) "3"*

*2) "2"*

*3) "1"*

1.  1.  1.  **从列表两端弹出元素**

*LPOP key*

*RPOP key*

LPOP命令从列表左边弹出一个元素，会分两步完成，第一步是将列表左边的元素从列表中移除，第二步是返回被移除的元素值。

127.0.0.1:6379> lpop list:a

"3“

127.0.0.1:6379> rpop list:a

"6“

1.  1.  1.  **获取列表中元素的个数**

*LLEN key*

*127.0.0.1:6379> llen list:a*

*(integer) 6*

1.  1.  1.  **删除列表中指定的值**

*LREM key count value*

LREM命令会删除列表中前count个值为value的元素，返回实际删除的元素个数。根据count值的不同，该命令的执行方式会有所不同：

1.  当count>0时， LREM会从列表左边开始删除。
2.  当count<0时， LREM会从列表后边开始删除。
3.  当count=0时， LREM删除所有值为value的元素。

* \#**为后面的示例准备测试数据。*  
    redis 127.0.0.1:6379> *lpush mykey a b c d a c*  
    (integer) 6  
*    \#**从头部**(left)**向尾部**(right)**变量链表，删除**2**个值等于**a**的元素，返回值为实际删除的数量。*  
    redis 127.0.0.1:6379>* lrem mykey 2 a*  
    (integer) 2  
*    \#**看出删除后链表中的全部元素。*  
    redis 127.0.0.1:6379>* lrange mykey 0 -1*  
    1) "c"  
    2) "d"  
    3) "c"  
    4) "b"

1.  1.  1.  **获得/设置指定索引的元素值**

LINDEX key index

LSET key index value

* \#**获取索引值为**1(**头部的第二个元素**)**的元素值。*  
    redis 127.0.0.1:6379>* lindex mykey 1*  
    "d"  
*    \#**将索引值为**1(**头部的第二个元素**)**的元素值设置为新值**e**。*  
    redis 127.0.0.1:6379>* lset mykey 1 e*  
    OK  
*    \#**查看是否设置成功。*  
    redis 127.0.0.1:6379>* lindex mykey 1*  
    "e"  
*    \#**索引值**6**超过了链表中元素的数量，该命令返回**nil**。*  
    redis 127.0.0.1:6379>* lindex mykey 6*  
    (nil)  
*    \#**设置的索引值**6**超过了链表中元素的数量，设置失败，该命令返回错误信息。*  
    redis 127.0.0.1:6379> *lset mykey 6 hh*  
    (error) ERR index out of range  
*    \#**仅保留索引值**0**到**2**之间的**3**个元素，注意第**0**个和第**2**个元素均被保留。*  
    redis 127.0.0.1:6379>* ltrim mykey 0 2*  
    OK  
*    \#**查看**trim**后的结果。*  
    redis 127.0.0.1:6379>* lrange mykey 0 -1*  
    1) "c"  
    2) "e"  
    3) "c"

1.  1.  1.  **向列表中插入元素**

*LINSERT key BEFORE|AFTER pivot value*

该命令首先会在列表中从左到右查找值为pivot的元素，然后根据第二个参数是BEFORE还是AFTER来决定将value插入到该元素的前面还是后面。

*\#**删除该键便于后面的测试。*  
    redis 127.0.0.1:6379>* del mykey*  
    (integer) 1  
*    \#**为后面的示例准备测试数据。*  
    redis 127.0.0.1:6379> *lpush mykey a b c d e*  
    (integer) 5  
 *   \#**在**a**的前面插入新元素**a1**。*  
    redis 127.0.0.1:6379>* linsert mykey before a a1*  
    (integer) 6  
*    \#**查看是否插入成功，从结果看已经插入。注意**lindex**的**index**值是**0-based**。*  
    redis 127.0.0.1:6379> *lindex mykey 0*  
    "e"  
*    \#**在**e**的后面插入新元素**e2**，从返回结果看已经插入成功。*  
    redis 127.0.0.1:6379>* linsert mykey after e e2*  
    (integer) 7  
*    \#**再次查看是否插入成功。*  
    redis 127.0.0.1:6379>* lindex mykey 1*  
    "e2"  
*    \#**在不存在的元素之前或之后插入新元素，该命令操作失败，并返回**-1**。*  
    redis 127.0.0.1:6379> *linsert mykey after k a*  
    (integer) -1  
*    \#**为不存在的**Key**插入新元素，该命令操作失败，返回**0**。*  
    redis 127.0.0.1:6379>* linsert mykey1 after a a2*  
    (integer) 0

1.  将元素从一个列表转移到另一个列表中

*RPOPLPUSH source destination*

* \#**删除该键，以便于后面的测试。*  
    redis 127.0.0.1:6379>* del mykey*  
    (integer) 1  
*    \#**从链表的尾部插入参数中给出的**values**，插入顺序是从左到右依次插入。*  
    redis 127.0.0.1:6379> *rpush mykey a b c d*  
    (integer) 4  
*    \#**通过**lrange**的可以获悉**rpush**在插入多值时的插入顺序。*  
    redis 127.0.0.1:6379>* lrange mykey 0 -1*  
    1) "a"  
    2) "b"  
    3) "c"  
    4) "d"  
*    \#**该键已经存在并且包含**4**个元素，**rpushx**命令将执行成功，并将元素**e**插入到链表的尾部。*  
    redis 127.0.0.1:6379> *rpushx mykey e*  
    (integer) 5  
*   \#**通过**lindex**命令可以看出之前的**rpushx**命令确实执行成功，因为索引值为**4**的元素已经是新元素了。*  
    redis 127.0.0.1:6379> *lindex mykey 4*  
    "e"  
*    \#**由于**mykey2**键并不存在，因此该命令不会插入数据，其返回值为**0**。*  
    redis 127.0.0.1:6379> *rpushx mykey2 e*  
    (integer) 0  
*    \#**在执行**rpoplpush**命令前，先看一下**mykey**中链表的元素有哪些，注意他们的位置关系。*  
    redis 127.0.0.1:6379> *lrange mykey 0 -1*  
    1) "a"  
    2) "b"  
    3) "c"  
    4) "d"  
    5) "e"  
*    \#**将**mykey**的尾部元素**e**弹出，同时再插入到**mykey2**的头部**(**原子性的完成这两步操作**)**。*  
    redis 127.0.0.1:6379>* rpoplpush mykey mykey2*  
    "e"  
*    \#**通过**lrange**命令查看**mykey**在弹出尾部元素后的结果。*  
    redis 127.0.0.1:6379>* lrange mykey 0 -1*  
    1) "a"  
    2) "b"  
    3) "c"  
    4) "d"  
*    \#**通过**lrange**命令查看**mykey2**在插入元素后的结果。*  
    redis 127.0.0.1:6379> *lrange mykey2 0 -1*  
    1) "e"  
*    \#**将**source**和**destination**设为同一键，将**mykey**中的尾部元素移到其头部。*  
    redis 127.0.0.1:6379> *rpoplpush mykey mykey*  
    "d"  
*    \#**查看移动结果。*  
    redis 127.0.0.1:6379>* lrange mykey 0 -1*  
    1) "d"  
    2) "a"  
    3) "b"  
    4) "c"

1.  1.  **应用**
        
        1.  **商品评论列表**

思路：

在redis中创建商品评论列表

用户发布商品评论，将评论信息转成json存储到list中。

用户在页面查询评论列表，从redis中取出json数据展示到页面。

定义商品评论列表key：

商品编号为1001的商品评论key：items: comment:1001

192.168.56.143:6379> LPUSH items:comment:1001 '\{"id":1,"name":"sa","date":1430295077289\}'

1.  **数据类型--set**
    
    1.  **redis set介绍**

在集合中的每个元素都是不同的，且没有顺序。

集合类型和列表类型的对比：

![20181129212057363.png][]

集合类型的常用操作是向集合中加入或删除元素、判断某个元素是否存在等，由于集合类型的Redis内部是使用值为空的散列表实现，所有这些操作的时间复杂度都为0(1)。

Redis还提供了多个集合之间的交集、并集、差集的运算。

1.  1.  **命令**

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.  1.  **应用范围：**

1). 可以使用Redis的Set数据类型跟踪一些唯一性数据，比如访问某一博客的唯一IP地址信息。对于此场景，我们仅需在每次访问该博客时将访问者的IP存入Redis中，Set数据类型会自动保证IP地址的唯一性。

2). 充分利用Set类型的服务端聚合操作方便、高效的特性，可以用于维护数据对象之间的关联关系。比如所有购买某一电子设备的客户ID被存储在一个指定的Set中，而购买另外一种电子产品的客户ID被存储在另外一个Set中，如果此时我们想获取有哪些客户同时购买了这两种商品时，Set的intersections命令就可以充分发挥它的方便和效率的优势了。

1.  **数据类型--sorted set**
    
    1.  **redis sorted set介绍**

在集合类型的基础上有序集合类型为集合中的每个元素都关联一个分数，这使得我们不仅可以完成插入、删除和判断元素是否存在在集合中，还能够获得分数最高或最低的前N个元素、获取指定分数范围内的元素等与分数有关的操作。

在某些方面有序集合和列表类型有些相似。

1、二者都是有序的。

2、二者都可以获得某一范围的元素。

但是，二者有着很大区别：

1、列表类型是通过链表实现的，获取靠近两端的数据速度极快，而当元素增多后，访问中间数据的速度会变慢。

2、有序集合类型使用散列表实现，所有即使读取位于中间部分的数据也很快。

3、列表中不能简单的调整某个元素的位置，但是有序集合可以（通过更改分数实现）

4、有序集合要比列表类型更耗内存。

1.  1.  **命令**

1. ZADD/ZCARD/ZCOUNT/ZREM/ZINCRBY/ZSCORE/ZRANGE/ZRANK:  
*    \#**在**Shell**的命令行下启动**Redis**客户端工具。*  
    /> *redis-cli*  
*    \#**添加一个分数为**1**的成员。*  
    redis 127.0.0.1:6379>* zadd myzset 1 "one"*  
    (integer) 1  
*    \#**添加两个分数分别是**2**和**3**的两个成员。*  
    redis 127.0.0.1:6379> *zadd myzset 2 "two" 3 "three"*  
    (integer) 2  
*    \#0**表示第一个成员，**-1**表示最后一个成员。**WITHSCORES**选项表示返回的结果中包含每个成员及其分数，否则只返回成员。*  
    redis 127.0.0.1:6379> *zrange myzset 0 -1 WITHSCORES*  
    1) "one"  
    2) "1"  
    3) "two"  
    4) "2"  
    5) "three"  
    6) "3"  
*    \#**获取成员**one**在**Sorted-Set**中的位置索引值。**0**表示第一个位置。*  
    redis 127.0.0.1:6379> *zrank myzset one*  
    (integer) 0  
*    \#**成员**four**并不存在，因此返回**nil**。*  
    redis 127.0.0.1:6379> *zrank myzset four*  
    (nil)  
*    \#**获取**myzset**键中成员的数量。**    *  
    redis 127.0.0.1:6379>* zcard myzset*  
    (integer) 3  
*    \#**返回与**myzset**关联的**Sorted-Set**中，分数满足表达式**1 <= score <= 2**的成员的数量。*  
    redis 127.0.0.1:6379> *zcount myzset 1 2*  
    (integer) 2  
*    \#**删除成员**one**和**two**，返回实际删除成员的数量。*  
    redis 127.0.0.1:6379> *zrem myzset one two*  
    (integer) 2  
*    \#**查看是否删除成功。*  
    redis 127.0.0.1:6379> *zcard myzset*  
    (integer) 1  
*    \#**获取成员**three**的分数。返回值是字符串形式。*  
    redis 127.0.0.1:6379> *zscore myzset three*  
    "3"  
*    \#**由于成员**two**已经被删除，所以该命令返回**nil**。*  
    redis 127.0.0.1:6379> *zscore myzset two*  
    (nil)  
*    \#**将成员**one**的分数增加**2**，并返回该成员更新后的分数。*  
    redis 127.0.0.1:6379> *zincrby myzset 2 one*  
    "3"  
*    \#**将成员**one**的分数增加**-1**，并返回该成员更新后的分数。*  
    redis 127.0.0.1:6379> *zincrby myzset -1 one*  
    "2"  
*    \#**查看在更新了成员的分数后是否正确。*  
    redis 127.0.0.1:6379> *zrange myzset 0 -1 WITHSCORES*  
    1) "one"  
    2) "2"  
    3) "two"  
    4) "2"  
    5) "three"  
    6) "3"  
   2. ZRANGEBYSCORE/ZREMRANGEBYRANK/ZREMRANGEBYSCORE  
    redis 127.0.0.1:6379> *del myzset*  
    (integer) 1  
    redis 127.0.0.1:6379> *zadd myzset 1 one 2 two 3 three 4 four*  
    (integer) 4  
 *   \#**获取分数满足表达式**1 <= score <= 2**的成员。*  
    redis 127.0.0.1:6379>* zrangebyscore myzset 1 2*  
    1) "one"  
    2) "two"  
*    \#**获取分数满足表达式**1 < score <= 2**的成员。*  
    redis 127.0.0.1:6379> *zrangebyscore myzset (1 2*  
    1) "two"  
*    \#-inf**表示第一个成员，**+inf**表示最后一个成员，**limit**后面的参数用于限制返回成员的自己，*  
*    \#2**表示从位置索引**(0-based)**等于**2**的成员开始，取后面**3**个成员。*  
    redis 127.0.0.1:6379> *zrangebyscore myzset -inf +inf limit 2 3*  
    1) "three"  
    2) "four"  
*    \#**删除分数满足表达式**1 <= score <= 2**的成员，并返回实际删除的数量。*  
    redis 127.0.0.1:6379> *zremrangebyscore myzset 1 2*  
    (integer) 2  
*    \#**看出一下上面的删除是否成功。*  
    redis 127.0.0.1:6379> *zrange myzset 0 -1*  
    1) "three"  
    2) "four"  
*    \#**删除位置索引满足表达式**0 <= rank <= 1**的成员。*  
    redis 127.0.0.1:6379> *zremrangebyrank myzset 0 1*  
    (integer) 2  
*    \#**查看上一条命令是否删除成功。*  
    redis 127.0.0.1:6379> *zcard myzset*  
    (integer) 0  
        
   3. ZREVRANGE/ZREVRANGEBYSCORE/ZREVRANK:  
*    \#**为后面的示例准备测试数据。*  
    redis 127.0.0.1:6379> *del myzset*  
    (integer) 0  
    redis 127.0.0.1:6379> *zadd myzset 1 one 2 two 3 three 4 fou*r  
    (integer) 4  
*    \#**以位置索引从高到低的方式获取并返回此区间内的成员。*  
    redis 127.0.0.1:6379> *zrevrange myzset 0 -1 WITHSCORES*  
    1) "four"  
    2) "4"  
    3) "three"  
    4) "3"  
    5) "two"  
    6) "2"  
    7) "one"  
    8) "1"  
 *   \#**由于是从高到低的排序，所以位置等于**0**的是**four**，**1**是**three**，并以此类推。*  
    redis 127.0.0.1:6379> *zrevrange myzset 1 3*  
    1) "three"  
    2) "two"  
    3) "one"  
*    \#**由于是从高到低的排序，所以**one**的位置是**3**。*  
    redis 127.0.0.1:6379> *zrevrank myzset one*  
    (integer) 3  
*    \#**由于是从高到低的排序，所以**four**的位置是**0**。*  
    redis 127.0.0.1:6379> *zrevrank myzset four*  
    (integer) 0  
*    \#**获取分数满足表达式**3 >= score >= 0**的成员，并以相反的顺序输出，即从高到底的顺序。*  
    redis 127.0.0.1:6379> *zrevrangebyscore myzset 3 0*  
    1) "three"  
    2) "two"  
    3) "one"  
*    \#**该命令支持**limit**选项，其含义等同于**zrangebyscore**中的该选项，只是在计算位置时按照相反的顺序计算和获取。*  
    redis 127.0.0.1:6379>* zrevrangebyscore myzset 4 0 limit 1 2*  
    1) "three"  
    2) "two"

1.  1.  **应用**

根据商品销售量对商品进行排行显示，定义sorted set集合，商品销售量为元素的分数。

定义商品销售排行榜key：items:sellsort

写入商品销售量：

商品编号1001的销量是9，商品编号1002的销量是10

192.168.101.3:7007> ZADD items:sellsort 9 1001 10 1002

商品编号1001的销量加1

192.168.101.3:7001> ZINCRBY items:sellsort 1 1001

商品销量前10名：

192.168.101.3:7001> ZRANGE items:sellsort 0 9 withscores

1.  **keys命令**

有3个通配符 \*, ? ,\[\]

\*: 通配任意多个字符   ?: 通配单个字符  \[\] 通配括号内的字符

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**进程**,**打开了不止一个数据库**,* *默认打开**16**个数据库**,**从**0**到**15**编号**,*

*如果想打开更多数据库**,**可以从配置文件修改**)*  
    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)

1.  **服务器命令**

1.  ping

测试连接是否存活

redis 127.0.0.1:6379> ping

PONG

//执行下面命令之前，我们停止redis 服务器

redis 127.0.0.1:6379> ping

Could not connect to Redis at 127.0.0.1:6379: Connection refused

//执行下面命令之前，我们启动redis 服务器

not connected> ping

PONG

redis 127.0.0.1:6379>

第一个ping 时，说明此连接正常

第二个ping 之前，我们将redis 服务器停止，那么ping 是失败的

第三个ping 之前，我们将redis 服务器启动，那么ping 是成功的

1.  echo

在命令行打印一些内容

redis 127.0.0.1:6379> echo HongWan

"HongWan"

redis 127.0.0.1:6379>

1.  select

选择数据库。Redis 数据库编号从0~15，我们可以选择任意一个数据库来进行数据的存取。

redis 127.0.0.1:6379> select 1

redis 127.0.0.1:6379\[1\]> select 16

(error) ERR invalid DB index

redis 127.0.0.1:6379\[16\]>

当选择16 时，报错，说明没有编号为16 的这个数据库

1.  quit

退出连接。

redis 127.0.0.1:6379> quit

1.  dbsize

返回当前数据库中key 的数目。

redis 127.0.0.1:6379> dbsize

(integer) 18

redis 127.0.0.1:6379>

结果说明此库中有18 个key

1.  info

获取服务器的信息和统计。

redis 127.0.0.1:6379> info

redis\_version:2.2.12

redis\_git\_sha1:00000000

redis\_git\_dirty:0

arch\_bits:32

multiplexing\_api:epoll

process\_id:28480

uptime\_in\_seconds:2515

uptime\_in\_days:0

1.  flushdb

删除当前选择数据库中的所有key。

redis 127.0.0.1:6379> dbsize

(integer) 18

redis 127.0.0.1:6379> flushdb

redis 127.0.0.1:6379> dbsize

(integer) 0

redis 127.0.0.1:6379>

在本例中我们将0 号数据库中的key 都清除了。

1.  flushall

删除所有数据库中的所有key。

redis 127.0.0.1:6379\[1\]> dbsize

(integer) 1

redis 127.0.0.1:6379\[1\]> select 0

redis 127.0.0.1:6379> flushall

redis 127.0.0.1:6379> select 1

redis 127.0.0.1:6379\[1\]> dbsize

(integer) 0

redis 127.0.0.1:6379\[1\]>

在本例中我们先查看了一个1 号数据库中有一个key，然后我切换到0 号库执行flushall 命令，结果1 号库中的key 也被清除了，说是此命令工作正常。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3N0YXJfb2Zfc2NpZW5jZQ_size_16_color_FFFFFF_t_70]: /images/20220413/203d643bcea84c8c8cfb451901af29b2.png
[https_github.com_xetorthio_jedis]: https://github.com/xetorthio/jedis
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3N0YXJfb2Zfc2NpZW5jZQ_size_16_color_FFFFFF_t_70 1]: /images/20220413/bc9f969a960e46b38943e40fab040a13.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3N0YXJfb2Zfc2NpZW5jZQ_size_16_color_FFFFFF_t_70 2]: /images/20220413/073e76032fd94d358c7ea0a3ab788e7f.png
[20181129212057363.png]: /images/20220413/f9a136fdb6e943f88e310c6be257c1c5.png