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数据库。

可以从官网下载该软件，现在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

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

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

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

redis的数据类型

redis是key-value形式的nosql数据库，其数据类型如下：
redis入门——客户端篇-编程知识网

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

常用命令

redis入门——客户端篇-编程知识网

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-1unsigned long sizemask;// 该哈希表已有节点数量unsigned long used;
} dictht;// 字典
typedef struct dict {// 类型特定函数...// 私有数据void *privdata;// 哈希表dictht ht[2];// rehash索引// 当rehash不在进行时，值为-1int trehashidx;
} dict;

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

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

redis入门——客户端篇-编程知识网

命令实例

  • 添加元素
    • 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
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>

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
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> expire n 100
(integer) 1
127.0.0.1:6401>
  • 查看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设计与实现》