redis入门——客户端篇

心已赠人 2022-07-14 06:50 171阅读 0赞

# redis入门——客户端篇 #

@(Redis)\[redis, 入门, 客户端命令, jdeis\]

*  redis入门客户端篇
    
     *  redis的客户端
        
         *  redis-cli
         *  redis-desktop-manager
         *  jedis
     *  redis客户端的使用以redis-cli为例
        
         *  redis的数据类型
     *  redis的各个数据类型的常用命令
        
         *  常用命令
         *  String
            
             *  基本介绍
             *  命令实例
                
                 *  字符整数命令
                 *  二进制命令
         *  List
            
             *  基本介绍
             *  命令实例
         *  Hash
            
             *  基本介绍
             *  命令实例
         *  Set
            
             *  基本介绍
             *  命令实例
                
                 *  基本命令
                 *  集合命令
         *  SortedSet
            
             *  基本介绍
             *  命令实例
         *  Key
            
             *  基本介绍
             *  命令实例
     *  jedis基本使用
        
         *  jedis工具类
         *  jedis使用案例

## redis的客户端 ##

### redis-cli ###

`redis-cli`是redis自带的客户端，是功能最完善的，不过因为其是基于命令行的，不是特别直观。

使用`redis-cli`命令默认连接`127.0.0.1(localhost)`在`6379`端口的服务。可以通过一些参数来指定主机和端口。  
\- `- h`：指定连接服务器的ip地址。  
\- `- p`：指定redis服务的端口号

PS：比如在《redis入门——安装篇》中使用`redis-cli`关闭`6401`端口号上的redis服务时，就使用了`- p`参数。

如果我想连接服务器主机IP为`127.0.0.1`上的`6401`端口的redis服务，可以通过如下命令访问：

[root@iZ28xuvyce3Z bin]# ./redis-cli -h 127.0.0.1 -p 6401
    127.0.0.1:6401>

### redis-desktop-manager ###

redis-desktop-manager是一个第三方跨平台redis的客户端，提供了图形化界面的方式操作redis数据库。

可以从[官网][Link 1]下载该软件，现在mac os和Ubuntu版的直装版需要订阅才能获取，不过可以通过获取源代码的方式，本地编译，具体官网有教程。windows和其他Linux，像是cent os目前还是免费提供直装版的。

使用rdm连接redis服务器时需要注意防火墙是否开启端口，如果只是测试环境，可以把防火墙关闭。具体操作如下

*  防火墙开启对应端口

[root@iZ28xuvyce3Z bin]# vim /etc/sysconfig/iptables

-A INPUT -p tcp -m state --state NEW -m tcp --dport 6401 -j ACCEPT

[root@iZ28xuvyce3Z bin]# service iptables restart

*  关闭防火墙

[root@iZ28xuvyce3Z bin]# service iptables stop
    Redirecting to /bin/systemctl stop  iptables.service
    [root@iZ28xuvyce3Z bin]# chkconfig iptables off

### jedis ###

下载地址：[GitHub:jedis][GitHub_jedis]

在java程序中可以使用Jedis和JedisPool操作redis。

关于Jedis的使用，在接下来的博文中会有简单的入门案例。

## redis客户端的使用（以redis-cli为例） ##

### redis的数据类型 ###

redis是key-value形式的nosql数据库，其数据类型如下：  
![这里写图片描述][20161201003925257]

## redis的各个数据类型的常用命令 ##

### 常用命令 ###

![这里写图片描述][20161201003749942]

### String ###

#### 基本介绍 ####

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

struct sdshdr {
        //字符串长度
        unsigned int len;
        //buf数组中未使用的字节数量
        unsigned int free;
        //用于保存字符串
        char buf[];
    };

在Redis中，key和value中的string类型都是使用sds来实现的。

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

redis的字符串是二进制安全的，什么是二进制安全？简单理解就是存入什么数据取出的还是什么数据。redis中的sds不像c语言处理字符串那样遇到’\\0’字符则认证字符串结束，它不会对存储进去的二进制数据进行处理，存入什么数据取出还是什么数据。

#### 命令实例 ####

##### 字符整数命令 #####

*  添加  
    
    
     *  `SET key value [EX seconds] [PX milliseconds] [NX|XX]`

127.0.0.1:6401> set name Switch
    OK
    127.0.0.1:6401>

*  获取  
    
    
     *  `GET key`

127.0.0.1:6401> get name
    "Switch"
    127.0.0.1:6401>

*  自增整数一  
    
    
     *  `INCR key`  
        
        
         *  当存储的字符串是整数时，可以使用该命令自增。
         *  作为计数器使用、生成主键。

127.0.0.1:6401> set time 10
    OK
    127.0.0.1:6401> get time
    "10"
    127.0.0.1:6401> incr time
    (integer) 11
    127.0.0.1:6401> incr time
    (integer) 12
    127.0.0.1:6401>

*  自增指定整数  
    
    
     *  `INCRBY key increment`  
        
        
         *  指定整数为负数，则为减去相应整数

127.0.0.1:6401> incrby time 5
    (integer) 17
    127.0.0.1:6401> incrby time -2
    (integer) 15
    127.0.0.1:6401>

*  自减整数一  
    
    
     *  `DECR key`

127.0.0.1:6401> decr time
    (integer) 14
    127.0.0.1:6401> decr time
    (integer) 13
    127.0.0.1:6401>

*  自减指定整数  
    
    
     *  `DECRBY key decrement`

127.0.0.1:6401> decrby time 6
    (integer) 7
    127.0.0.1:6401> decrby time 3
    (integer) 4
    127.0.0.1:6401>

*  同时设置获取多个值  
    
    
     *  `MSET key value [key value ...]`
     *  `MGET key [key ...]`

127.0.0.1:6401> mset age 20 city "北京"
    OK
    127.0.0.1:6401> mget age city
    1) "20"
    2) "\xe5\x8c\x97\xe4\xba\xac"
    127.0.0.1:6401>

PS：存入Redis中的汉字，在`redis-cli`中是以编码的方式获取的，其本身还是对应汉字。在java中使用jedis获取时，则是相应汉字。

*  获取字符串长度  
    
    
     *  `STRLEN key`

127.0.0.1:6401> get name
    "Switch"
    127.0.0.1:6401> strlen name
    (integer) 6
    127.0.0.1:6401>

*  向字符串尾部追加值  
    
    
     *  `APPEND key value`

127.0.0.1:6401> get name
    "Switch"
    127.0.0.1:6401> append name " Kity"
    (integer) 11
    127.0.0.1:6401> get name
    "Switch Kity"
    127.0.0.1:6401> get n
    (nil)
    127.0.0.1:6401> append n 123456
    (integer) 6
    127.0.0.1:6401> get n
    "123456"
    127.0.0.1:6401>

PS：可以看出，当附加的key不存在时，则`append`和`set`功能一样。

##### 二进制命令 #####

*  设置或清除指定偏移量上的位  
    
    
     *  `SETBIT key offset value`

127.0.0.1:6401> setbit bit 100 1
    (integer) 0
    127.0.0.1:6401>

*  获取指定偏移量上的位

127.0.0.1:6401> getbit bit 100
    (integer) 1
    127.0.0.1:6401> getbit bit 1
    (integer) 0
    127.0.0.1:6401> get bit
    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\b"
    127.0.0.1:6401>

*  计算给定字符串中，被设置为1的比特位的数量

127.0.0.1:6401> get name
    "Switch Kity"
    127.0.0.1:6401> bitcount name
    (integer) 43
    127.0.0.1:6401> get bit
    "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\b"
    127.0.0.1:6401> bitcount bit
    (integer) 1
    127.0.0.1:6401>

还有两个二进制命令：  
一个是`BITOP`，具体命令为`BITOP operation destkey key [key ...]`，其功能是：对一个或多个保存二进制位的字符串 key 进行位元操作，并将结果保存到 destkey 上。  
还有一个是`BITFIELD`，具体命令为`BITFIELD key [GET type offset] [SET type offset value] [INCRBY type offset increment] [OVERFLOW WRAP|SAT|FAIL]`，其功能是将一个 Redis 字符串看作是一个由二进制位组成的数组， 并对这个数组中储存的长度不同的整数进行访问。

这两个命令想了解，可以查官方文档。

### List ###

#### 基本介绍 ####

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

在Redis中散列表类型实现方式有两种，一种是压缩列表（zip list），一种是双向链表（double linked list）。压缩列表适用于包含少量值，且值要么就是小整数值，要么就是长度比较短的字符串。双向链表则是压缩列表不适用时使用。这里只讨论双向链表作为底层实现。

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

注意：Redis的双向链表实现是双向无环链表，也就是说表头的`prev`和表尾的`next`指针都为`NULL`。

因为列表类型内部使用的双向链表，所以完全可以通过该类型实现栈、队列、双端队列等数据结构。

*  DLL的数据结构

// 链表节点
    typedef struct listNode {
        // 前置节点
        struct listNode *prev;
        // 后置节点
        struct listNode *next;
        // 节点的值
        void *value;
    }listNode;
    
    // 双向链表
    struct list {
        // 表头节点
        listNode *head;
        // 表尾结点
        listNode *tail;
        // 链表所包含的节点数量
        unsigned long len;
        // 一些函数
        ...
    }

#### 命令实例 ####

*  从左边向list中添加元素  
    
    
     *  `LPUSH key value [value ...]`

127.0.0.1:6401> lpush names "Switch" "Kity" "TOM"
    (integer) 3
    127.0.0.1:6401> lrange names 0 -1
    1) "TOM"
    2) "Kity"
    3) "Switch"
    127.0.0.1:6401>

*  从右边向list添加元素  
    
    
     *  `RPUSH key value [value ...]`

127.0.0.1:6401> rpush names2 "Switch" "Kity" "TOM"
    (integer) 3
    127.0.0.1:6401> lrange names2 0 -1
    1) "Switch"
    2) "Kity"
    3) "TOM"
    127.0.0.1:6401>

PS：从上面连个命令可以看出，`lpush`是向表头结点添加元素，`rpush`是向表尾结点添加元素。

*  从list左边取一个元素  
    
    
     *  `LPOP key`

127.0.0.1:6401> lrange names2 0 -1
    1) "Switch"
    2) "Kity"
    3) "TOM"
    127.0.0.1:6401> lpop names2
    "Switch"
    127.0.0.1:6401> lrange names2 0 -1
    1) "Kity"
    2) "TOM"
    127.0.0.1:6401>

*  从list右边取一个元素  
    
    
     *  `RPOP key`

127.0.0.1:6401> lrange names2 0 -1
    1) "Kity"
    2) "TOM"
    127.0.0.1:6401> rpop names2
    "TOM"
    127.0.0.1:6401> lrange names2 0 -1
    1) "Kity"
    127.0.0.1:6401>

*  查询元素列表  
    
    
     *  `LRANGE key start stop`

127.0.0.1:6401> lrange names 0 1
    1) "TOM"
    2) "Kity"
    127.0.0.1:6401> lrange names 0 2
    1) "TOM"
    2) "Kity"
    3) "Switch"
    127.0.0.1:6401> lrange names 0 -1
    1) "TOM"
    2) "Kity"
    3) "Switch"
    127.0.0.1:6401>

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

*  查看列表的长度  
    
    
     *  `LLEN key`

127.0.0.1:6401> lrange names 0 -1
    1) "TOM"
    2) "Kity"
    3) "Switch"
    127.0.0.1:6401> llen names
    (integer) 3
    127.0.0.1:6401>

*  删除列表中指定的值  
    
    
     *  `LREM key count value`

127.0.0.1:6401> lrange names 0 -1
    1) "TOM"
    2) "Kity"
    3) "Switch"
    4) "TOM"
    5) "TOM"
    6) "TOM"
    127.0.0.1:6401> lrem names 2 "TOM"
    (integer) 2
    127.0.0.1:6401> lrange names 0 -1
    1) "Kity"
    2) "Switch"
    3) "TOM"
    4) "TOM"
    127.0.0.1:6401>

LREM命令会删除列表中前count个值为value的元素，返回实际删除的元素个数。根据count值的不同，该命令的执行方式会有所不同：  
\- count > 0 : 从表头开始向表尾搜索，移除与 value 相等的元素，数量为 count 。  
\- count < 0 : 从表尾开始向表头搜索，移除与 value 相等的元素，数量为 count 的绝对值。  
\- count = 0 : 移除表中所有与 value 相等的值。

*  获得/设置指定索引的元素值  
    
    
     *  `LINDEX key index`
     *  `LSET key index value`

127.0.0.1:6401> lrange names 0 -1
    1) "Kity"
    2) "Switch"
    3) "TOM"
    4) "TOM"
    127.0.0.1:6401> lindex names 2
    "TOM"
    127.0.0.1:6401> lset names 2 "JOHN"
    OK
    127.0.0.1:6401> lrange names 0 -1
    1) "Kity"
    2) "Switch"
    3) "JOHN"
    4) "TOM"
    127.0.0.1:6401>

*  只保留列表指定片段，指定范围和LRANGE一致  
    
    
     *  `LTRIM key start stop`

127.0.0.1:6401> lrange l:list 0 -1
    1) "6"
    2) "5"
    3) "0"
    4) "2"
    127.0.0.1:6401> ltrim l:list 0 2
    OK
    127.0.0.1:6401> lrange l:list 0 -1
    1) "6"
    2) "5"
    3) "0"

*  向列表中插入元素  
    
    
     *  `LINSERT key BEFORE|AFTER pivot value`

127.0.0.1:6401> lrange list 0 -1
    1) "3"
    2) "2"
    3) "1"
    127.0.0.1:6401> linsert list after 3 4
    (integer) 4
    127.0.0.1:6401> lrange list 0 -1
    1) "3"
    2) "4"
    3) "2"
    4) "1"

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

*  将元素从一个列表转移到另一个列表中
 *  `RPOPLPUSH source destination`

127.0.0.1:6401> rpoplpush list newlist 
    "1"
    127.0.0.1:6401> lrange newlist 0 -1
    1) "1"
    127.0.0.1:6401> lrange list 0 -1
    1) "3"
    2) "4"
    3) "2"

### Hash ###

#### 基本介绍 ####

散列类型（hash）它提供了键和值的映射。

注意：这里的键是散列类型里面的键，而不是在Redis中标识这个散列的键。也就是说，一个Redis键指向的散列类型里面有多个键值对。

值只能是字符串类型，不支持散列类型、集合类型等其它类型。为什么值不支持其他类型了，这是因为Redis设计者处于简单、高效考虑，不去支持这种复杂类型的嵌套。且使用这五种值类型，已经能满足绝大部分需求了。

在Redis中散列类型实现方式有两种、一种是压缩列表（zip list），一种是字典（dictionary），压缩列表适用于当散列中所有键和值的内容要么就是小整数，要么就是短字符串的情况。使用字典则是其他情况。这里只讨论字典作为底层实现。

*  字典的数据结构

// 哈希表节点
    typedef struct dictEntry {
        // 键
        void *key;
        // 值
        union {
            void *val;
            unit64_t u64;
            int64_t s64;
        } v;
        // 指向下个哈希表节点，形成链表
        struct dictEntry *next;
    } dictEntry;
    
    // 哈希表
    typedef struct dictht {
        // 哈希表数组
        dictEntry **table;
        // 哈希表大小
        unsigned long size;
        // 哈希表大小掩码，用于计算索引值
        // 总是等于size-1
        unsigned long sizemask;
        // 该哈希表已有节点数量
        unsigned long used;
    } dictht;
    
    // 字典
    typedef struct dict {
        // 类型特定函数
        ...
        // 私有数据
        void *privdata;
        // 哈希表
        dictht ht[2];
        // rehash索引
        // 当rehash不在进行时，值为-1
        int trehashidx;
    } dict;

字典之所以有持有两个哈希表的原因是因为，在使用一张哈希表的时候，将键值对存入这张使用的表的时候，同时存入另一张表，这样渐进式的rehash，可以将时间复杂度平摊到每次操作上。

hash表节点之所以有一个指向下个哈希表节点的指针是因为，hash算法不可能做到完美hash，即每个存入值hash值都不相同。那么，就有可能发生冲突，这时候就需要解决键冲突问题了。Redis中的哈希表采用的是链地址法，也就是说，每个hash值相同的键，通过链表相连接。

![这里写图片描述][20161201003509642]

#### 命令实例 ####

*  添加元素  
    
    
     *  `HSET key field value`

127.0.0.1:6401> hset customer:1 name "Switch"
    (integer) 1
    127.0.0.1:6401> hset customer:1 age "20"
    (integer) 1
    127.0.0.1:6401> hset customer:1 gender "male"
    (integer) 1
    127.0.0.1:6401>

*  获取元素  
    
    
     *  `HGET key field`

127.0.0.1:6401> hget customer:1 name
    "Switch"
    127.0.0.1:6401> hget customer:1 age
    "20"
    127.0.0.1:6401> hget customer:1 gender
    "male"
    127.0.0.1:6401>

*  批量添加元素  
    
    
     *  `HMSET key field value [field value ...]`

127.0.0.1:6401> hmset customer:2 name "Kity" age "21" gender "female"
    OK
    127.0.0.1:6401>

*  批量获取数据  
    
    
     *  `HMGET key field [field ...]`

127.0.0.1:6401> hmget customer:2 name age gender
    1) "Kity"
    2) "21"
    3) "female"
    127.0.0.1:6401> hmget customer:1 name age gender
    1) "Switch"
    2) "20"
    3) "male"
    127.0.0.1:6401>

*  删除指定域  
    
    
     *  `HDEL key field [field ...]`

127.0.0.1:6401> hmset customer:3 name "TOM" age "21" gender "male"
    
    OK
    127.0.0.1:6401> hmget customer:3 name age gender
    1) "TOM"
    2) "21"
    3) "male"
    127.0.0.1:6401> hdel customer:3 name
    (integer) 1
    127.0.0.1:6401>

*  获取所有域和域对应的值  
    
    
     *  `HGETALL key`

127.0.0.1:6401> hgetall customer:1
    1) "name"
    2) "Switch"
    3) "age"
    4) "20"
    5) "gender"
    6) "male"
    127.0.0.1:6401>

*  获取所有域  
    
    
     *  `HKEYS key`

127.0.0.1:6401> hkeys customer:1
    1) "name"
    2) "age"
    3) "gender"
    127.0.0.1:6401>

*  获取所有域对应的值  
    
    
     *  `HVALS key`

127.0.0.1:6401> hvals customer:1
    1) "Switch"
    2) "20"
    3) "male"
    127.0.0.1:6401> hvals customer:2
    1) "Kity"
    2) "21"
    3) "female"
    127.0.0.1:6401>

*  给值加上增量  
    
    
     *  `HINCRBY key field increment`

127.0.0.1:6401> hget customer:1 money
    "200"
    127.0.0.1:6401> hincrby customer:1 money 100
    (integer) 300
    127.0.0.1:6401> hget customer:1 money
    "300"
    127.0.0.1:6401>

*  判断域是否存在  
    
    
     *  `HEXISTS key field`

127.0.0.1:6401> hkeys customer:1
    1) "name"
    2) "age"
    3) "gender"
    4) "money"
    127.0.0.1:6401> hexists customer:1 name
    (integer) 1
    127.0.0.1:6401> hexists customer:1 n
    (integer) 0
    127.0.0.1:6401>

*  获取域的数量  
    
    
     *  `HLEN key`

127.0.0.1:6401> hkeys customer:1
    1) "name"
    2) "age"
    3) "gender"
    4) "money"
    127.0.0.1:6401> hkeys customer:2
    1) "name"
    2) "age"
    3) "gender"
    127.0.0.1:6401> hkeys customer:3
    1) "age"
    2) "gender"
    127.0.0.1:6401> hlen customer:1
    (integer) 4
    127.0.0.1:6401> hlen customer:2
    (integer) 3
    127.0.0.1:6401> hlen customer:3
    (integer) 2
    127.0.0.1:6401>

### Set ###

#### 基本介绍 ####

在集合（Set）类型中元素是无序和不同的。由此可以推测出，我们需要存储一些不需要顺序，且各个唯一的数据时，集合就是种不错的类型。

集合类型的底层实现有两种，一种是整数集合（int set），一种是字典。当集合所有对象都是整数值且元素个数不超过512个时，会使用整数集合。其他情况都是使用字典，这里也只讨论字典情况。

字典的数据类型在散列类型的介绍中已经给出，这里不再赘述。

集合类型使用字典的方式和散列使用的方式略有不同，集合只使用字典的键，而字典的值全部是被设置为NULL。也就是说集合只使用`dictEntry`中的key。

#### 命令实例 ####

##### 基本命令 #####

*  向集合中添加元素  
    
    
     *  `SADD key member [member ...]`

127.0.0.1:6401> sadd sname "Switch" "Kity" "TOM"
    (integer) 3
    127.0.0.1:6401> smembers sname
    1) "Kity"
    2) "TOM"
    3) "Switch"
    127.0.0.1:6401>

*  从集合中删除元素  
    
    
     *  `SREM key member [member ...]`

127.0.0.1:6401> srem sname "TOM"
    (integer) 1
    127.0.0.1:6401> smembers sname
    1) "Kity"
    2) "Switch"
    127.0.0.1:6401>

*  返回集合中的所有元素  
    
    
     *  `SMEMBERS key`

127.0.0.1:6401> smembers sname
    1) "Kity"
    2) "Switch"
    127.0.0.1:6401>

*  判断元素是否在集合中  
    
    
     *  `SISMEMBER key member`

127.0.0.1:6401> smembers sname
    1) "Kity"
    2) "Switch"
    127.0.0.1:6401> sismember sname "SWITCH"
    (integer) 0
    127.0.0.1:6401> sismember sname "TOM"
    (integer) 0
    127.0.0.1:6401> sismember sname "Switch"
    (integer) 1
    127.0.0.1:6401>

*  获取集合中元素的数量  
    
    
     *  `SCARD key`

127.0.0.1:6401> smembers sname
    1) "Kity"
    2) "Switch"
    127.0.0.1:6401> scard sname
    (integer) 2
    127.0.0.1:6401>

##### 集合命令 #####

*  集合的交集  
    
    
     *  SINTER key \[key …\]

127.0.0.1:6401> smembers sname
    1) "Kity"
    2) "Switch"
    127.0.0.1:6401> smembers sname2
    1) "JACK"
    2) "Switch"
    3) "JOHN"
    4) "TOM"
    127.0.0.1:6401> sinter sname sname2
    1) "Switch"
    127.0.0.1:6401>

*  集合的并集  
    
    
     *  `SUNION key [key ...]`

127.0.0.1:6401> smembers sname
    1) "Kity"
    2) "Switch"
    127.0.0.1:6401> smembers sname2
    1) "JACK"
    2) "Switch"
    3) "JOHN"
    4) "TOM"
    127.0.0.1:6401> sunion sname sname2
    1) "JACK"
    2) "Kity"
    3) "JOHN"
    4) "Switch"
    5) "TOM"
    127.0.0.1:6401>

*  集合的差集  
    
    
     *  `SDIFF key [key ...]`

127.0.0.1:6401> smembers sname
    1) "Kity"
    2) "Switch"
    127.0.0.1:6401> smembers sname2
    1) "JACK"
    2) "Switch"
    3) "JOHN"
    4) "TOM"
    127.0.0.1:6401> sdiff sname sname2
    1) "Kity"
    127.0.0.1:6401>

集合还有三个命令，分别是`SINTERSTORE`、`SUNIONSTORE`、`SDIFFSTORE`。其作用都是做了集合运算之后，将结果存入一个指定集合。

三个命令分别是：  
\- `SINTERSTORE destination key [key ...]`  
\- `SUNIONSTORE destination key [key ...]`  
\- `SDIFFSTORE destination key [key ...]`

这里只给出一个命令的实例，其余两个都差不多。

127.0.0.1:6401> smembers sname
    1) "Kity"
    2) "Switch"
    127.0.0.1:6401> smembers sname2
    1) "JACK"
    2) "Switch"
    3) "JOHN"
    4) "TOM"
    127.0.0.1:6401> sunionstore sname3 sname sname2
    (integer) 5
    127.0.0.1:6401> smembers sname3
    1) "JACK"
    2) "Kity"
    3) "JOHN"
    4) "Switch"
    5) "TOM"
    127.0.0.1:6401>

### SortedSet ###

#### 基本介绍 ####

有序集合（SortedSet）类型是在集合的基础上，为集合中的每个元素关联了一个分数（Score），通过这样的机制，不仅可以完成对集合元素的插入、删除、判重。还可以通过分数获取有序集合中最高或者最低的前N个元素、获取指定分数范围内的元素等。

有序集合类型的底层实现有两种，一种是压缩列表，一种是跳跃表（skip list）。因为两者的复杂性，这里都不介绍。如果想要了解，可以参考该博文底部的参考文档书籍。

#### 命令实例 ####

*  向有序集合中添加元素  
    
    
     *  `ZADD key score member [[score member] [score member] ...]`

127.0.0.1:6401> zadd zname 100 "Switch" 200 "Kity"
    (integer) 2
    127.0.0.1:6401> zrange zname 0 -1 withscores
    1) "Switch"
    2) "100"
    3) "Kity"
    4) "200"
    127.0.0.1:6401>

*  从有序集合中删除元素  
    
    
     *  `ZREM key member [member ...]`

127.0.0.1:6401> zrange zname 0 -1 withscores
    1) "Switch"
    2) "100"
    3) "Kity"
    4) "200"
    127.0.0.1:6401> zrem zname "Switch"
    (integer) 1
    127.0.0.1:6401> zrange zname 0 -1 withscores
    1) "Kity"
    2) "200"
    127.0.0.1:6401>

*  查看有序集合中的元素(顺序)  
    
    
     *  `ZRANGE key start stop [WITHSCORES]`

127.0.0.1:6401> zadd zname 100 "Switch" 300 "Tom" 400 "Card"
    (integer) 3
    127.0.0.1:6401> zrange zname 0 -1
    1) "Switch"
    2) "Kity"
    3) "Tom"
    4) "Card"
    127.0.0.1:6401> zrange zname 0 -1 withscores
    1) "Switch"
    2) "100"
    3) "Kity"
    4) "200"
    5) "Tom"
    6) "300"
    7) "Card"
    8) "400"
    127.0.0.1:6401> zrange zname 0 2
    1) "Switch"
    2) "Kity"
    3) "Tom"
    127.0.0.1:6401>

*  查看有序集合中的元素(逆序)  
    
    
     *  `ZREVRANGE key start stop [WITHSCORES]`

127.0.0.1:6401> zrevrange zname 0 -1
    1) "Card"
    2) "Tom"
    3) "Kity"
    4) "Switch"
    127.0.0.1:6401> zrevrange zname 0 -1 withscores
    1) "Card"
    2) "400"
    3) "Tom"
    4) "300"
    5) "Kity"
    6) "200"
    7) "Switch"
    8) "100"
    127.0.0.1:6401> zrevrange zname 0 1 
    1) "Card"
    2) "Tom"
    127.0.0.1:6401>

*  获取指定分数范围内的成员数量  
    
    
     *  `ZCOUNT key min max`

127.0.0.1:6401> zrange zname 0 -1 withscores
    1) "Switch"
    2) "100"
    3) "Kity"
    4) "200"
    5) "Tom"
    6) "300"
    7) "Card"
    8) "400"
    127.0.0.1:6401> zcount zname 150 350
    (integer) 2
    127.0.0.1:6401> zcount zname 57 165
    (integer) 1
    127.0.0.1:6401>

*  获取元素的排名(正序)  
    
    
     *  `ZRANK key member`

127.0.0.1:6401> zrange zname 0 -1 withscores
    1) "Switch"
    2) "100"
    3) "Kity"
    4) "200"
    5) "Tom"
    6) "300"
    7) "Card"
    8) "400"
    127.0.0.1:6401> zrank zname "Switch"
    (integer) 0
    127.0.0.1:6401>

*  获取元素的排名(逆序)  
    
    
     *  `ZREVRANK key member`

127.0.0.1:6401> zrange zname 0 -1 withscores
    1) "Switch"
    2) "100"
    3) "Kity"
    4) "200"
    5) "Tom"
    6) "300"
    7) "Card"
    8) "400"
    127.0.0.1:6401> zrevrank zname "Switch"
    (integer) 3
    127.0.0.1:6401>

*  获取元素的分数  
    
    
     *  `ZSCORE key member`

127.0.0.1:6401> zrange zname 0 -1 withscores
    1) "Switch"
    2) "100"
    3) "Kity"
    4) "200"
    5) "Tom"
    6) "300"
    7) "Card"
    8) "400"
    127.0.0.1:6401> zscore zname "Switch"
    "100"
    127.0.0.1:6401>

*  增加元素的分数  
    
    
     *  `ZINCRBY key increment member`

127.0.0.1:6401> zrange zname 0 -1 withscores
    1) "Switch"
    2) "100"
    3) "Kity"
    4) "200"
    5) "Tom"
    6) "300"
    7) "Card"
    8) "400"
    127.0.0.1:6401> zincrby zname 66 "Card"
    "466"
    127.0.0.1:6401> zrange zname 0 -1 withscores
    1) "Switch"
    2) "100"
    3) "Kity"
    4) "200"
    5) "Tom"
    6) "300"
    7) "Card"
    8) "466"
    127.0.0.1:6401>

*  获取成员数量  
    
    
     *  `ZCARD key`

127.0.0.1:6401> zrange zname 0 -1 withscores
    1) "Switch"
    2) "100"
    3) "Kity"
    4) "200"
    5) "Tom"
    6) "300"
    7) "Card"
    8) "466"
    127.0.0.1:6401> zcard zname
    (integer) 4
    127.0.0.1:6401>

### Key ###

#### 基本介绍 ####

键（key）是字符串类型，它的概念很好理解，就是Redis数据库中上述五种对象的索引。在Redis中，其数据库整体的底层就是在散列类型里面介绍的字典。由此，可以得出一个结论，键的操作是通用的。也就是说，任何键的操作，比如删除，更新，对任何的值类型都是一样的。

#### 命令实例 ####

*  获取所有符合给定模式的key  
    
    
     *  `KEYS pattern`

KEYS \* 匹配数据库中所有 key 。  
KEYS h?llo 匹配 hello ， hallo 和 hxllo 等。  
KEYS h\*llo 匹配 hllo 和 heeeeello 等。  
KEYS h\[ae\]llo 匹配 hello 和 hallo ，但不匹配 hillo 。

特殊符号用 \\ 隔开

*  删除指定的key  
    
    
     *  `DEL key [key ...]`

127.0.0.1:6401> keys *
     1) "time"
     2) "city"
     3) "bii"
     4) "bi"
     5) "names"
     6) "name"
     7) "zname"
     8) "sname2"
     9) "age"
    10) "customer:3"
    11) "customer:2"
    12) "n"
    13) "names2"
    14) "sname"
    15) "customer:1"
    16) "sname3"
    17) "bit"
    127.0.0.1:6401> del time city bii bi
    (integer) 4
    127.0.0.1:6401> keys *
     1) "names"
     2) "name"
     3) "zname"
     4) "sname2"
     5) "age"
     6) "customer:3"
     7) "customer:2"
     8) "n"
     9) "names2"
    10) "sname"
    11) "customer:1"
    12) "sname3"
    13) "bit"
    127.0.0.1:6401>

*  检查给定key是否存在  
    
    
     *  `EXISTS key`

127.0.0.1:6401> keys *
     1) "names"
     2) "name"
     3) "zname"
     4) "sname2"
     5) "age"
     6) "customer:3"
     7) "customer:2"
     8) "n"
     9) "names2"
    10) "sname"
    11) "customer:1"
    12) "sname3"
    13) "bit"
    127.0.0.1:6401> exists names
    (integer) 1
    127.0.0.1:6401> exists aaa
    (integer) 0
    127.0.0.1:6401>

*  查看key所存储值的类型  
    
    
     *  `TYPE key`

127.0.0.1:6401> keys *
     1) "names"
     2) "name"
     3) "zname"
     4) "sname2"
     5) "age"
     6) "customer:3"
     7) "customer:2"
     8) "n"
     9) "names2"
    10) "sname"
    11) "customer:1"
    12) "sname3"
    13) "bit"
    127.0.0.1:6401> type names
    list
    127.0.0.1:6401> type age
    string
    127.0.0.1:6401> type customer:1
    hash
    127.0.0.1:6401> type sname
    set
    127.0.0.1:6401> type zname
    zset
    127.0.0.1:6401>

*  设置key的有效期  
    
    
     *  `EXPIRE key seconds`

*  查看key的过期时间  
    
    
     *  `TTL key`

127.0.0.1:6401> ttl n
    (integer) 22
    127.0.0.1:6401> ttl names
    (integer) -1
    127.0.0.1:6401> ttl aaaa
    (integer) -2
    127.0.0.1:6401>

当 key 不存在时，返回 -2 。  
当 key 存在但没有设置剩余生存时间时，返回 -1 。  
否则，以秒为单位，返回 key 的剩余生存时间。

*  将key的有效期设为永不过期  
    
    
     *  `PERSIST key`

127.0.0.1:6401> keys *
     1) "names"
     2) "name"
     3) "zname"
     4) "sname2"
     5) "age"
     6) "customer:3"
     7) "customer:2"
     8) "names2"
     9) "sname"
    10) "customer:1"
    11) "sname3"
    12) "bit"
    127.0.0.1:6401> expire bit 100
    (integer) 1
    127.0.0.1:6401> ttl bit
    (integer) 83
    127.0.0.1:6401> persist bit
    (integer) 1
    127.0.0.1:6401> ttl bit
    (integer) -1
    127.0.0.1:6401>

*  更改key的名字  
    
    
     *  `RENAME key newkey`

127.0.0.1:6401> keys *n*
    1) "names"
    2) "name"
    3) "zname"
    4) "sname2"
    5) "names2"
    6) "sname"
    7) "sname3"
    127.0.0.1:6401> rename sname3 sname4
    OK
    127.0.0.1:6401> keys *n*
    1) "names"
    2) "name"
    3) "zname"
    4) "sname2"
    5) "sname4"
    6) "names2"
    7) "sname"
    127.0.0.1:6401>

## jedis基本使用 ##

### jedis工具类 ###

package com.pc.mystore.utils;
    
    import java.io.IOException;
    import java.io.InputStream;
    import java.util.Properties;
    
    import redis.clients.jedis.Jedis;
    import redis.clients.jedis.JedisPool;
    import redis.clients.jedis.JedisPoolConfig;
    
    /** * Redis的工具类 * * @author Switch * @data 2016年11月4日 * @version V1.0 */
    public class JedisUtils { 
        private static JedisPool jedisPool = null;
        private static JedisPoolConfig poolConfig = null;
        static {
            // 静态块初始化Jedis连接池
            // 连接池配置信息
            poolConfig = new JedisPoolConfig();
            // 配置最大连接时
            poolConfig.setMaxTotal(20);
            // 配置最大空闲连接数
            poolConfig.setMaxIdle(2);
    
            try {
                // 获取配置文件
                InputStream inputStream = JedisUtils.class.getClassLoader().getResourceAsStream("jedis-config.properties");
                Properties props = new Properties();
                props.load(inputStream);
                // 获取主机名
                String host = props.getProperty("host");
                // 获取端口号
                Integer port = Integer.valueOf(props.getProperty("port"));
                jedisPool = new JedisPool(poolConfig, host, port);
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
    
        /** * 获得Redis连接 * * @return jedis对象 */
        public static Jedis getJedis() {
            return jedisPool.getResource();
        }
    
        /** * 释放Redis连接回连接池 * * @param jedis * jedis对象 */
        public static void release(Jedis jedis) {
            jedis.close();
        }
    
        public static void main(String[] args) {
            Jedis jedis = getJedis();
            jedis.set("name", "Switch");
            System.out.println(jedis.get("name"));
        }
    }

配置文件：`jedis-config.properties`

# jedis配置文件
    host=192.168.128.130
    port=6379

### jedis使用案例 ###

CategoryServiceInter categoryService = new CategoryServiceImpl();
    
    public String findCategories(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        // 获取缓存中的商品分类信息
        Jedis jedis = JedisUtils.getJedis();
        String categoryList = jedis.get("categoryList");
    
        // 如果缓存中没有，则去数据库中查询，再设置到Redis中，释放连接
        if (categoryList == null) {
            categoryList = categoryService.findCategoriesAjax();
            jedis.set("categoryList", categoryList);
        }
        // 释放Jedis连接
        JedisUtils.release(jedis);
    
        // 返回ajax格式商品分类信息
        response.getWriter().write(categoryList);
    
        return null;
    }

——参考《Redis命令参考》  
——参考《Redis设计与实现》

[Link 1]: https://redisdesktop.com/
[GitHub_jedis]: https://github.com/xetorthio/jedis
[20161201003925257]: /images/20220714/3f2aa9f42663489ba4cad2b1910ac9c2.png
[20161201003749942]: /images/20220714/dc3b275943054e109964323ad216e4b7.png
[20161201003509642]: /images/20220714/baebf1badef3452fb71901b9eb7797a5.png