Redis word bak

发布时间:2017-2-23 22:29:54 编辑:www.fx114.net 分享查询网我要评论
本篇文章主要介绍了"Redis word bak ",主要涉及到Redis word bak 方面的内容,对于Redis word bak 感兴趣的同学可以参考一下。

Redis word bak

@font-face { font-family: "Arial"; [email protected] { font-family: "Courier New"; [email protected] { font-family: "Times"; [email protected] { font-family: "Geneva"; [email protected] { font-family: "Tms Rmn"; [email protected] { font-family: "Helv"; [email protected] { font-family: "MS Serif"; [email protected] { font-family: "MS Sans Serif"; [email protected] { font-family: "New York"; [email protected] { font-family: "System"; [email protected] { font-family: "Wingdings"; [email protected] { font-family: "MS 明朝"; [email protected] { font-family: "바탕"; [email protected] { font-family: "宋体"; [email protected] { font-family: "新細明體"; [email protected] { font-family: "MS ゴシック"; [email protected] { font-family: "Century"; [email protected] { font-family: "Verdana"; [email protected] { font-family: "Angsana New"; [email protected] { font-family: "Cordia New"; [email protected] { font-family: "Mangal"; [email protected] { font-family: "Latha"; [email protected] { font-family: "Sylfaen"; [email protected] { font-family: "Vrinda"; [email protected] { font-family: "Raavi"; [email protected] { font-family: "Shruti"; [email protected] { font-family: "Sendnya"; [email protected] { font-family: "Gautami"; [email protected] { font-family: "Tunga"; [email protected] { font-family: "Estrangelo Edessa"; [email protected] { font-family: "Cambria Math"; [email protected] { font-family: "@宋体"; [email protected] { font-family: "Calibri Light"; [email protected] { font-family: "Calibri"; [email protected] { font-family: "@MS 明朝"; [email protected] { font-family: "@MS ゴシック"; [email protected] { font-family: "Microsoft YaHei"; [email protected] { font-family: "Consolas"; [email protected] { font-family: "Helvetica Neue"; [email protected] { font-family: "SimSun"; [email protected] { font-family: "@SimSun"; [email protected] { font-family: "@Microsoft YaHei"; }p.MsoNormal, li.MsoNormal, div.MsoNormal { margin: 0cm 0cm 0.0001pt; text-align: justify; font-size: 12pt; font-family: Calibri; }h1 { margin: 17pt 0cm 16.5pt; text-align: justify; line-height: 240%; page-break-after: avoid; font-size: 22pt; font-family: Calibri; }h2 { margin: 13pt 0cm; text-align: justify; line-height: 173%; page-break-after: avoid; font-size: 16pt; font-family: "Calibri Light"; }h3 { margin: 13pt 0cm; text-align: justify; line-height: 173%; page-break-after: avoid; font-size: 16pt; font-family: Calibri; }p.MsoDocumentMap, li.MsoDocumentMap, div.MsoDocumentMap { margin: 0cm 0cm 0.0001pt; text-align: justify; font-size: 12pt; font-family: "Times New Roman"; }span.a { font-family: "Times New Roman"; }span.msoIns { text-decoration: underline; color: teal; }span.msoDel { text-decoration: line-through; color: red; }.MsoChpDefault { font-family: Calibri; }div.WordSection1 { }ol { margin-bottom: 0cm; }ul { margin-bottom: 0cm; }

概述

简介

Redis 是完全开源免费的,遵守BSD协议,是一个高性能的key-value数据库。

 

Redis 与其他 key - value 缓存产品有以下三个特点:

Redis支持数据的持久化,可以将内存中的数据保持在磁盘中,重启的时候可以再次加载进行使用。

Redis不仅仅支持简单的key-value类型的数据,同时还提供list,set,zset,hash等数据结构的存储。

Redis支持数据的备份,即master-slave模式的数据备份。

 

 

优势

性能极高 – Redis能读的速度是110000次/s,写的速度是81000次/s 。

丰富的数据类型 – Redis支持二进制案例的 Strings, Lists, Hashes, Sets 及 Ordered Sets 数据类型操作。

原子 – Redis的所有操作都是原子性的,同时Redis还支持对几个操作全并后的原子性执行。

丰富的特性 – Redis还支持 publish/subscribe, 通知, key 过期等等特性。

 

与其他key-value存储的不同

Redis有着更为复杂的数据结构并且提供对他们的原子性操作,这是一个不同于其他数据库的进化路径。Redis的数据类型都是基于基本数据结构的同时对程序员透明,无需进行额外的抽象。

Redis运行在内存中但是可以持久化到磁盘,所以在对不同数据集进行高速读写时需要权衡内存,应为数据量不能大于硬件内存。在内存数据库方面的另一个优点是,相比在磁盘上相同的复杂的数据结构,在内存中操作起来非常简单,这样Redis可以做很多内部复杂性很强的事情。同时,在磁盘格式方面他们是紧凑的以追加的方式产生的,因为他们并不需要进行随机访问。

安装

1、下载安装包

2、解压

3、安装

make && make install

make是编译,make install是安装,可以指定安装路径

make PREFIX=/use/local/redis install

PREFIX用于指定安装路径

4、验证

除了执行PATH路径下的命令外,也可以去 src 目录下(推荐这个)

在:/usr/local/bin 下,会有 redis-server 一般此目录已经加入PATH了

redis-server 使用默认配置启动refis服务

指定配置文件的方式启动:

    redis-server redis.conf

    配置文件默认在安装目录下

新开一个窗口,redis-cli 使用默认配置连接Redis服务

执行ping,显示PONG,说明成功了

4、关闭服务

在进入 redis-cli 的情况下,直接shutdown命令,

或者使用kill命令

 

登陆服务器

redis-cli  或者  redis-cli -h 127.0.0.1 -p 6379

配置:redis.conf

设置配置信息

1、去修改配置文件

2、通过config set命令修改

config set key value 

3、获取配信息

config get key

 

详细配置项

redis.conf 配置项说明如下:

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

    daemonize no

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

    pidfile /var/run/redis.pid

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

    port 6379

4. 绑定的主机地址

    bind 127.0.0.1

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

    timeout 300

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

    loglevel verbose

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

    logfile stdout

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

    databases 16

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

    save <seconds> <changes>

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

    save 900 1

    save 300 10

    save 60 10000

    分别表示900秒(15分钟)内有1个更改,300秒(5分钟)内有10个更改以及60秒内有10000个更改。

 

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

    rdbcompression yes

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

    dbfilename dump.rdb

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

    dir ./

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

    slaveof <masterip> <masterport>

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

    masterauth <master-password>

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

    requirepass foobared

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

    maxclients 128

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

    maxmemory <bytes>

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

    appendonly no

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

     appendfilename appendonly.aof

20. 指定更新日志条件,共有3个可选值: 

    no:表示等操作系统进行数据缓存同步到磁盘(快) 

    always:表示每次更新操作后手动调用fsync()将数据写到磁盘(慢,安全) 

    everysec:表示每秒同步一次(折衷,默认值)

    appendfsync everysec

 

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

     vm-enabled no

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

     vm-swap-file /tmp/redis.swap

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

     vm-max-memory 0

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

     vm-page-size 32

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

     vm-pages 134217728

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

     vm-max-threads 4

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

    glueoutputbuf yes

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

    hash-max-zipmap-entries 64

    hash-max-zipmap-value 512

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

    activerehashing yes

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

    include /path/to/local.conf

 

数据类型

Redis数据类型

Redis支持五种数据类型:string(字符串),hash(哈希),list(列表),set(集合)及zset(sorted set:有序集合)。

 

String(字符串)

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

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

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

 

redis 127.0.0.1:6379> SET name "w3cschool.cc"

OK

redis 127.0.0.1:6379> GET name

"w3cschool.cc"

 

Hash(哈希)

Redis hash 是一个键值对集合。

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

 

 

redis 127.0.0.1:6379> HMSET user:1 username w3cschool.cc password w3cschool.cc points 200

 

OK

 

redis 127.0.0.1:6379> HGETALL user:1

 

1) "username"

 

2) "w3cschool.cc"

 

3) "password"

 

4) "w3cschool.cc"

 

5) "points"

 

6) "200"

 

redis 127.0.0.1:6379>

 

 

 

以上实例中 hash 数据类型存储了包含用户脚本信息的用户对象。 实例中我们使用了 Redis HMSET, HGETALL 命令,user:1 为键值。

每个 hash 可以存储 232 - 1 键值对(40多亿)。

 

List(列表)

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

 

 

redis 127.0.0.1:6379> lpush w3cschool.cc redis

 

(integer) 1

 

redis 127.0.0.1:6379> lpush w3cschool.cc mongodb

 

(integer) 2

 

redis 127.0.0.1:6379> lpush w3cschool.cc rabitmq

 

(integer) 3

 

redis 127.0.0.1:6379> lrange w3cschool.cc 0 10

 

1) "rabitmq"

 

2) "mongodb"

 

3) "redis"

 

redis 127.0.0.1:6379>

 

 

 

列表最多可存储 232 - 1 元素 (4294967295, 每个列表可存储40多亿)。

 

Set(集合)

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

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

sadd 命令

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

 

 

redis 127.0.0.1:6379> sadd w3cschool.cc redis

 

(integer) 1

 

redis 127.0.0.1:6379> sadd w3cschool.cc mongodb

 

(integer) 1

 

redis 127.0.0.1:6379> sadd w3cschool.cc rabitmq

 

(integer) 1

 

redis 127.0.0.1:6379> sadd w3cschool.cc rabitmq

 

(integer) 0

 

redis 127.0.0.1:6379> smembers w3cschool.cc

 

 

 

1) "rabitmq"

 

2) "mongodb"

 

3) "redis"

 

 

 

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

集合中最大的成员数为 232 - 1 (4294967295, 每个集合可存储40多亿个成员)。

 

zset(sorted set:有序集合)

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

 

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

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

zadd 命令

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

 

 

redis 127.0.0.1:6379> zadd w3cschool.cc 0 redis

 

(integer) 1

 

redis 127.0.0.1:6379> zadd w3cschool.cc 0 mongodb

 

(integer) 1

 

redis 127.0.0.1:6379> zadd w3cschool.cc 0 rabitmq

 

(integer) 1

 

redis 127.0.0.1:6379> zadd w3cschool.cc 0 rabitmq

 

(integer) 0

 

redis 127.0.0.1:6379> ZRANGEBYSCORE w3cschool.cc 0 1000

 

 

 

1) "redis"

 

2) "mongodb"

 

3) "rabitmq"

 

客户端命令

Redis客户端命令

 

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

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

语法

Redis 客户端的基本语法为:

 

$ redis-cli

 

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

 

 

$redis-cli

 

redis 127.0.0.1:6379>

 

redis 127.0.0.1:6379> PING

 

 

 

PONG

 

 

 

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

 

在远程服务上执行命令

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

 

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

 

 

$redis-cli -h 127.0.0.1 -p 6379 -a "mypass"

 

redis 127.0.0.1:6379>

 

redis 127.0.0.1:6379> PING

 

 

 

PONG

 

 

 

基本操作

http://www.runoob.com/redis/redis-tutorial.html

这里就不累述了

集群安装

所有的 Redis 节点在集群中互联,内部使用二进制协议优化速度和带宽

节点的 fail,是通过集群中超过半数的节点检测失效时才生效。也就是说,集群中有半数以上的节点无法连接上某个节点,那么这个节点就被判定 fail

 

客户端连接集群中的任意一台机器,都可以访问整个集群的数据,因为节点之间会跳转

 

新的数据,怎么确定添加到集群中的哪台机器呢?

答:Redis 内置了16384个哈希槽,当需要在集群中添加数据的时候,对 Key使用 CRC16算法计算出一个结果,然后将结果对16384取余。

这样,每个 Key 都对应到了0~16383中的一个数字,Redis根据节点数量,大致均等的将哈希槽映射到节点上。

可以理解成集群中的每台 Redis 服务器,都均匀分配了一些槽,Key 的计算结果属于哪个槽,那个槽属于哪台服务器,就将数据存储在哪台服务器上

 

安装集群需要 ruby 支持

需要 redis 第三方接口支持:Mac 下执行一遍 sudo gem install redis 

 

下面通过一个实例演示Redis 集群的安装

这里在同一台服务器用不同的端口表示不同的redis服务器,如下:

主节点:

192.168.101.3:7001 

192.168.101.3:7002 

192.168.101.3:7003

从节点:

192.168.101.3:7004 

192.168.101.3:7005 

192.168.101.3:7006

 

 

我这里在一台机器上,通过端口,模拟不同的 Redis 服务器,实际环境中,一般是通过不同机器,也就是 ip 来确定的

1、安装单机版 Redis

2、创建一个文件夹 - redis-cluster

这个文件夹保存所有通过端口区分的集群中的 Redis服务器

 

创建redis-cluster目录,其下创建7001、7002......7006目录,

 

将redis安装目录bin下的文件拷贝到每个700X目录内,同时将redis源码目录src下的redis-trib.rb拷贝到redis-cluster目录下。

修改每个700X目录下的redis.conf配置文件:

 

port XXXX

#bind 192.168.101.3

cluster-enabled yes 

 

 

3、如果是真实的集群环境,则不需要步骤二。直接启动每个节点

分别进入7001、7002、...7006目录,执行:

./redis-server ./redis.conf

 

查看redis进程:

 

4、启动集群

./redis-trib.rb create --replicas 1 192.168.101.3:7001 192.168.101.3:7002 192.168.101.3:7003 192.168.101.3:7004 192.168.101.3:7005  192.168.101.3:7006

 

 

说明:

redis集群至少需要3个主节点,每个主节点有一个从节点总共6个节点

replicas指定为1表示每个主节点有一个从节点

 

注意:

如果执行时报如下错误:

[ERR] Node XXXXXX is not empty. Either the node already knows other nodes (check with CLUSTER NODES) or contains some key in database 0

解决方法是删除生成的配置文件nodes.conf,如果不行则说明现在创建的结点包括了旧集群的结点信息,需要删除redis的持久化文件后再重启redis,比如:appendonly.aof、dump.rdb

 

5、查询集群信息

 

./redis-cli -c -h 192.168.101.3 -p 7001 ,其中-c表示以集群方式连接redis-h指定ip地址,-p指定端口号

 

cluster nodes 查询集群结点信息

 

cluster info 查询集群状态信息

 

其他集群中的操作

1、添加主节点

集群创建成功后可以向集群中添加节点,下面是添加一个master主节点 

添加7007结点,参考集群结点规划章节添加一个“7007”目录作为新节点。

 

./redis-trib.rb add-node  192.168.101.3:7007 192.168.101.3:7001

查看集群结点发现7007已添加到集群中:

cluster nodes

 

 

 

2、Hash槽重新分配

添加完主节点需要对主节点进行hash槽分配这样该主节才可以存储数据。

redis集群有16384个槽,集群中的每个结点分配自已槽,通过查看集群结点可以看到槽占用情况。

 

给刚添加的7007结点分配槽:

 

 

第一步:连接上集群

./redis-trib.rb reshard 192.168.101.3:7001(连接集群中任意一个可用结点都行)

 

第二步:输入要分配的槽数量

 

输入 500表示要分配500个槽

 

第三步:输入接收槽的结点id

 

这里准备给7007分配槽,通过cluster nodes查看7007结点id为15b809eadae88955e36bcdbb8144f61bbbaf38fb

输入:15b809eadae88955e36bcdbb8144f61bbbaf38fb

 

 

第四步:输入源结点id

 

这里输入all

 

 

第五步:输入yes开始移动槽到目标结点id

 

3、添加从节点

集群创建成功后可以向集群中添加节点,下面是添加一个slave从节点。

添加7008从结点,将7008作为7007的从结点。

 

./redis-trib.rb add-node --slave --master-id 主节点id 添加节点的ip和端口集群中已存在节点ip和端口

 

 

执行如下命令:

./redis-trib.rb add-node --slave --master-id cad9f7413ec6842c971dbcc2c48b4ca959eb5db4  192.168.101.3:7008 192.168.101.3:7001

cad9f7413ec6842c971dbcc2c48b4ca959eb5db4  是7007结点的id,可通过cluster nodes查看。

 

注意:如果原来该结点在集群中的配置信息已经生成cluster-config-file指定的配置文件中(如果cluster-config-file没有指定则默认为nodes.conf),这时可能会报错:

[ERR] Node XXXXXX is not empty. Either the node already knows other nodes (check with CLUSTER NODES) or contains some key in database 0

解决方法是删除生成的配置文件nodes.conf,删除后再执行./redis-trib.rb add-node指令

查看集群中的结点,刚添加的7008为7007的从节点:

 

4、删除节点

./redis-trib.rb del-node 127.0.0.1:7005 4b45eb75c8b428fbd77ab979b85080146a9bc017

 

删除已经占有hash槽的结点会失败,报错如下:

[ERR] Node 127.0.0.1:7005 is not empty! Reshard data away and try again.

 

需要将该结点占用的hash槽分配出去(参考hash槽重新分配章节)。

Java操作Redis

 

// 连接redis集群

    @Test

    public void testJedisCluster() {

 

        JedisPoolConfig config = new JedisPoolConfig();

        // 最大连接数

        config.setMaxTotal(30);

        // 最大连接空闲数

        config.setMaxIdle(2);

 

        //集群结点

        Set<HostAndPort> jedisClusterNode = new HashSet<HostAndPort>();

        jedisClusterNode.add(new HostAndPort("192.168.101.3", 7001));

        jedisClusterNode.add(new HostAndPort("192.168.101.3", 7002));

        jedisClusterNode.add(new HostAndPort("192.168.101.3", 7003));

        jedisClusterNode.add(new HostAndPort("192.168.101.3", 7004));

        jedisClusterNode.add(new HostAndPort("192.168.101.3", 7005));

        jedisClusterNode.add(new HostAndPort("192.168.101.3", 7006));

        JedisCluster jc = new JedisCluster(jedisClusterNode, config);

       

        JedisCluster jcd = new JedisCluster(jedisClusterNode);

        jcd.set("name", "zhangsan");

        String value = jcd.get("name");

        System.out.println(value);

    }

/Users/sherry/WorkPath/Git/Web/redisDemo/src/main/java/org/zln/utils/JedisUtils.java

 

package org.zln.utils;

 

import org.apache.commons.lang3.StringUtils;

import org.apache.logging.log4j.LogManager;

import org.apache.logging.log4j.Logger;

import redis.clients.jedis.Jedis;

import redis.clients.jedis.JedisPool;

import redis.clients.jedis.JedisPoolConfig;

 

 

/**

 * Created by sherry on 16/9/13.

 */

public class JedisUtils {

 

 

    private static Logger logger = LogManager.getLogger();

    private static JedisPool pool = null;

 

    private static final String URL = "127.0.0.1";

    private static final int PORT = 6379;

 

    private static Jedis jedis = null;

    static {

        pool = new JedisPool(new JedisPoolConfig(), URL,PORT);

 

 

    }

 

    public static Jedis getRedisCon(String password){

        jedis = pool.getResource();

        if (StringUtils.isNotEmpty(password)){

            logger.info("以密码:"+password+" 登陆 redis");

            jedis.auth(password);

        }

        logger.info(jedis.ping());

        return jedis;

    }

 

    public static void closeRedisCon(Jedis jedis){

        if (jedis!=null){

            jedis.close();

        }

    }

 

 

    public static void closeApp(){

        //关闭应用程序的时候执行

        pool.destroy();

    }

 

 

}

 

 

/Users/sherry/WorkPath/Git/Web/redisDemo/src/main/java/org/zln/main/JedisMain.java

 

package org.zln.main;

 

import org.apache.logging.log4j.LogManager;

import org.apache.logging.log4j.Logger;

import org.zln.utils.JedisUtils;

import redis.clients.jedis.Jedis;

 

import java.io.*;

import java.util.*;

 

/**

 * Created by sherry on 16/9/13.

 */

public class JedisMain {

 

    private static Logger logger = LogManager.getLogger();

 

    public static void main(String[] args) {

        Jedis jedis = JedisUtils.getRedisCon("");

//        stringTest(jedis);

//

//        listTest(jedis);

//

//        mapTest(jedis);

//

//        objTest(jedis);

 

        objListTest(jedis);

//        将这个Jedis实例归还给JedisPool。

        JedisUtils.closeRedisCon(jedis);

 

    }

 

    /**

     * 对象列表

     * @param jedis

     */

    private static void objListTest(Jedis jedis) {

        Person person1 = new Person("name1",1);

        Person person2 = new Person("name2",2);

        Person person3 = new Person("name3",3);

        Person person4 = new Person("name4",4);

 

        List<Person> persons = new ArrayList<>();

        persons.add(person1);

        persons.add(person2);

        persons.add(person3);

        persons.add(person4);

 

        try {

            for (Person person:persons){

                ByteArrayOutputStream bos =  new ByteArrayOutputStream();

                ObjectOutputStream oos =  new ObjectOutputStream(bos);

                oos.writeObject(person);

                byte [] byteArray = bos.toByteArray();

                oos.close();

                bos.close();

 

                logger.info("写入对象:"+person);

                jedis.lpush("persons".getBytes(),byteArray);

            }

 

            List<byte[]> personsBytes = jedis.lrange("persons".getBytes(),0,10);

            for (byte[] bs:personsBytes){

                ByteArrayInputStream bis =  new ByteArrayInputStream(bs);

 

                ObjectInputStream inputStream =  new ObjectInputStream(bis);

 

                Person readObject = (Person) inputStream.readObject();

 

                logger.info( " 读取对象 \t" + readObject.toString());

 

                inputStream.close();

 

                bis.close();

            }

 

        } catch (IOException|ClassNotFoundException e) {

            e.printStackTrace();

        }

 

        jedis.del("persons".getBytes());

 

 

    }

 

    /**

     * 存储对象

     * @param jedis

     */

    private static void objTest(Jedis jedis) {

 

        Person person = new Person();

        person.setAge(27);

        person.setName("卡卡卡");

 

        ByteArrayOutputStream bos =  new ByteArrayOutputStream();

 

        try {

            ObjectOutputStream oos =  new ObjectOutputStream(bos);

            oos.writeObject(person);

 

            byte [] byteArray = bos.toByteArray();

            oos.close();

            bos.close();

 

            String setObjectRet = jedis.set(person.getName().getBytes(), byteArray);

 

            logger.info( " set object return \t" + setObjectRet);

 

            byte [] bs = jedis.get( person.getName().getBytes());

 

            ByteArrayInputStream bis =  new ByteArrayInputStream(bs);

 

            ObjectInputStream inputStream =  new ObjectInputStream(bis);

 

            Person readObject = (Person) inputStream.readObject();

 

            logger.info( " read object \t" + readObject.toString());

 

            inputStream.close();

 

            bis.close();

 

        } catch (IOException|ClassNotFoundException e) {

            e.printStackTrace();

        }

 

        jedis.del(person.getName());

    }

 

    /**

     * 存储 Map

     * @param jedis

     */

    private static void mapTest(Jedis jedis) {

        Map<String,String> user =  new HashMap<String,String>();

        user.put( "name" ,  "cd" );

        user.put( "password" ,  "123456" );

 

        jedis.hmset("user",user);

        // mapkey 个数

        System.out.println(String.format ( "len:%d" , jedis.hlen( "user" )));

//map中的所有键值

        System.out.println(String.format ( "keys: %s" , jedis.hkeys( "user" ) ));

//map中的所有value

        System.out.println(String.format ( "values: %s" , jedis.hvals( "user" ) ));

//取出map中的name字段值

        List<String> rsmap = jedis.hmget( "user" ,  "name" , "password" );

        System.out.println(rsmap);

//删除map中的某一个键值 password

        jedis.hdel( "user" ,  "password" );

        System.out.println(jedis.hmget( "user" ,  "name" ,  "password" ));

 

        jedis.del("user");

    }

 

    /**

     * 存储列表

     * @param jedis

     */

    private static void listTest(Jedis jedis) {

        jedis.lpush("tutorial-list", "Redis");

        jedis.lpush("tutorial-list", "Mongodb");

        jedis.lpush("tutorial-list", "Mysql");

        // 获取存储的数据并输出

        List<String> list = jedis.lrange("tutorial-list", 0 ,5);

        for(int i=0; i<list.size(); i++) {

            System.out.println("Stored string in redis:: "+list.get(i));

        }

        jedis.del("tutorial-list");

    }

 

    /**

     * 存储字符串

     * @param jedis

     */

    private static void stringTest(Jedis jedis) {

        //一次次添加

        jedis.set("string1","一号字符串");

        jedis.set("string2","二号字符串");

        jedis.set("string3","三号字符串");

        jedis.set("string4","四号字符串");

 

        logger.info("获取string1:"+jedis.get("string1"));

        //在已有 key 上,对 value 进行新增

        jedis.append("string1","添加新字符串");

        logger.info("获取string1:"+jedis.get("string1"));

 

 

        //一次性添加多个键值对

        jedis.mset("s1","v1","s2","v2","s3","v3");

        logger.info("获取s1:"+jedis.get("s1"));

 

        for (Iterator<String> iterator = jedis.keys("*").iterator();iterator.hasNext();){

            String key = iterator.next();

            logger.info(key+":"+jedis.get(key));

            jedis.del(key);

        }

 

    }

}

 

与Spring集成

pom构建:

 

[html] view plain copy

 

print?

1 <modelVersion>4.0.0</modelVersion>  

2 <groupId>com.x.redis</groupId>  

3 <artifactId>springredis</artifactId>  

4 <version>0.0.1-SNAPSHOT</version>  

5   

6 <dependencies>  

7     <dependency>  

8         <groupId>org.springframework.data</groupId>  

9         <artifactId>spring-data-redis</artifactId>  

10              <version>1.0.2.RELEASE</version>  

11          </dependency>  

12          <dependency>  

13              <groupId>org.springframework</groupId>  

14              <artifactId>spring-test</artifactId>  

15              <version>3.1.2.RELEASE</version>  

16              <scope>test</scope>  

17          </dependency>  

18            

19          <dependency>  

20              <groupId>redis.clients</groupId>  

21              <artifactId>jedis</artifactId>  

22              <version>2.1.0</version>  

23          </dependency>  

24            

25           <dependency>  

26              <groupId>junit</groupId>  

27              <artifactId>junit</artifactId>  

28              <version>4.8.2</version>  

29              <scope>test</scope>  

30          </dependency>  

31      </dependencies>  

 

spring配置文件(applicationContext.xml):

 

[html] view plain copy

 

print?

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

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

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

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

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

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

7     xsi:schemaLocation="  

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

9             http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">  

10        

11          <context:property-placeholder location="classpath:redis.properties" />  

12        

13          <bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">  

14              <property name="maxIdle" value="${redis.maxIdle}" />  

15              <property name="maxActive" value="${redis.maxActive}" />  

16              <property name="maxWait" value="${redis.maxWait}" />  

17              <property name="testOnBorrow" value="${redis.testOnBorrow}" />  

18          </bean>  

19            

20          <bean id="connectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory"  

21              p:host-name="${redis.host}" p:port="${redis.port}" p:password="${redis.pass}"  p:pool-config-ref="poolConfig"/>  

22            

23          <bean id="redisTemplate" class="org.springframework.data.redis.core.StringRedisTemplate">  

24              <property name="connectionFactory"   ref="connectionFactory" />  

25          </bean>         

26            

27          <bean id="userDao" class="com.x.dao.impl.UserDao" />   

28      </beans>  

redis.properties

 

 

[html] view plain copy

 

print?

1 # Redis settings  

2 redis.host=localhost  

3 redis.port=6379  

4 redis.pass=java2000_wl  

5   

6   

7 redis.maxIdle=300  

8 redis.maxActive=600  

9 redis.maxWait=1000  

10      redis.testOnBorrow=true  

 

java代码:

 

[java] view plain copy

 

print?

1 package com.x.entity;  

2   

3 import java.io.Serializable;  

4   

5 /**  

6  * @author http://blog.csdn.net/java2000_wl  

7  * @version <b>1.0</b>  

8  */   

9 public class User implements Serializable {  

10            

11          private static final long serialVersionUID = -6011241820070393952L;  

12        

13          private String id;  

14            

15          private String name;  

16            

17          private String password;  

18        

19          /** 

20           * <br>------------------------------<br> 

21           */  

22          public User() {  

23                

24          }  

25            

26          /** 

27           * <br>------------------------------<br> 

28           */  

29          public User(String id, String name, String password) {  

30              super();  

31              this.id = id;  

32              this.name = name;  

33              this.password = password;  

34          }  

35        

36          /** 

37           * 获得id 

38           * @return the id 

39           */  

40          public String getId() {  

41              return id;  

42          }  

43        

44          /** 

45           * 设置id 

46           * @param id the id to set 

47           */  

48          public void setId(String id) {  

49              this.id = id;  

50          }  

51        

52          /** 

53           * 获得name 

54           * @return the name 

55           */  

56          public String getName() {  

57              return name;  

58          }  

59        

60          /** 

61           * 设置name 

62           * @param name the name to set 

63           */  

64          public void setName(String name) {  

65              this.name = name;  

66          }  

67        

68          /** 

69           * 获得password 

70           * @return the password 

71           */  

72          public String getPassword() {  

73              return password;  

74          }  

75        

76          /** 

77           * 设置password 

78           * @param password the password to set 

79           */  

80          public void setPassword(String password) {  

81              this.password = password;  

82          }  

83      }  

[java] view plain copy

 

print?

1 package com.x.dao;  

2   

3 import org.springframework.beans.factory.annotation.Autowired;  

4 import org.springframework.data.redis.core.RedisTemplate;  

5 import org.springframework.data.redis.serializer.RedisSerializer;  

6   

7 /**  

8  * AbstractBaseRedisDao 

9  * @author http://blog.csdn.net/java2000_wl  

10       * @version <b>1.0</b>  

11       */   

12      public abstract class AbstractBaseRedisDao<K, V> {  

13            

14          @Autowired  

15          protected RedisTemplate<K, V> redisTemplate;  

16        

17          /** 

18           * 设置redisTemplate 

19           * @param redisTemplate the redisTemplate to set 

20           */  

21          public void setRedisTemplate(RedisTemplate<K, V> redisTemplate) {  

22              this.redisTemplate = redisTemplate;  

23          }  

24            

25          /** 

26           * 获取 RedisSerializer 

27           * <br>------------------------------<br> 

28           */  

29          protected RedisSerializer<String> getRedisSerializer() {  

30              return redisTemplate.getStringSerializer();  

31          }  

32      }  

[java] view plain copy

 

print?

1 package com.x.dao;  

2   

3 import java.util.List;  

4   

5 import com.x.entity.User;  

6   

7 /**  

8  * @author http://blog.csdn.net/java2000_wl  

9  * @version <b>1.0</b>  

10       */   

11      public interface IUserDao {  

12            

13          /** 

14           * 新增 

15           * <br>------------------------------<br> 

16           * @param user 

17           * @return 

18           */  

19          boolean add(User user);  

20            

21          /** 

22           * 批量新增 使用pipeline方式 

23           * <br>------------------------------<br> 

24           * @param list 

25           * @return 

26           */  

27          boolean add(List<User> list);  

28            

29          /** 

30           * 删除 

31           * <br>------------------------------<br> 

32           * @param key 

33           */  

34          void delete(String key);  

35            

36          /** 

37           * 删除多个 

38           * <br>------------------------------<br> 

39           * @param keys 

40           */  

41          void delete(List<String> keys);  

42            

43          /** 

44           * 修改 

45           * <br>------------------------------<br> 

46           * @param user 

47           * @return  

48           */  

49          boolean update(User user);  

50        

51          /** 

52           * 通过key获取 

53           * <br>------------------------------<br> 

54           * @param keyId 

55           * @return  

56           */  

57          User get(String keyId);  

58      }  

[java] view plain copy

 

print?

1 package com.x.dao.impl;  

2   

3 import java.util.ArrayList;  

4 import java.util.List;  

5   

6 import org.springframework.dao.DataAccessException;  

7 import org.springframework.data.redis.connection.RedisConnection;  

8 import org.springframework.data.redis.core.RedisCallback;  

9 import org.springframework.data.redis.serializer.RedisSerializer;  

10      import org.springframework.util.Assert;  

11        

12      import com.x.dao.AbstractBaseRedisDao;  

13      import com.x.dao.IUserDao;  

14      import com.x.entity.User;  

15        

16      /**  

17       * Dao 

18       * @author http://blog.csdn.net/java2000_wl  

19       * @version <b>1.0</b>  

20       */   

21      public class UserDao extends AbstractBaseRedisDao<String, User> implements IUserDao {  

22        

23          /**  

24           * 新增 

25           *<br>------------------------------<br> 

26           * @param user 

27           * @return 

28           */  

29          public boolean add(final User user) {  

30              boolean result = redisTemplate.execute(new RedisCallback<Boolean>() {  

31                  public Boolean doInRedis(RedisConnection connection)  

32                          throws DataAccessException {  

33                      RedisSerializer<String> serializer = getRedisSerializer();  

34                      byte[] key  = serializer.serialize(user.getId());  

35                      byte[] name = serializer.serialize(user.getName());  

36                      return connection.setNX(key, name);  

37                  }  

38              });  

39              return result;  

40          }  

41            

42          /** 

43           * 批量新增 使用pipeline方式   

44           *<br>------------------------------<br> 

45           [email protected] list 

46           [email protected] 

47           */  

48          public boolean add(final List<User> list) {  

49              Assert.notEmpty(list);  

50              boolean result = redisTemplate.execute(new RedisCallback<Boolean>() {  

51                  public Boolean doInRedis(RedisConnection connection)  

52                          throws DataAccessException {  

53                      RedisSerializer<String> serializer = getRedisSerializer();  

54                      for (User user : list) {  

55                          byte[] key  = serializer.serialize(user.getId());  

56                          byte[] name = serializer.serialize(user.getName());  

57                          connection.setNX(key, name);  

58                      }  

59                      return true;  

60                  }  

61              }, falsetrue);  

62              return result;  

63          }  

64            

65          /**  

66           * 删除 

67           * <br>------------------------------<br> 

68           * @param key 

69           */  

70          public void delete(String key) {  

71              List<String> list = new ArrayList<String>();  

72              list.add(key);  

73              delete(list);  

74          }  

75        

76          /** 

77           * 删除多个 

78           * <br>------------------------------<br> 

79           * @param keys 

80           */  

81          public void delete(List<String> keys) {  

82              redisTemplate.delete(keys);  

83          }  

84        

85          /** 

86           * 修改  

87           * <br>------------------------------<br> 

88           * @param user 

89           * @return  

90           */  

91          public boolean update(final User user) {  

92              String key = user.getId();  

93              if (get(key) == null) {  

94                  throw new NullPointerException("数据行不存在, key = " + key);  

95              }  

96              boolean result = redisTemplate.execute(new RedisCallback<Boolean>() {  

97                  public Boolean doInRedis(RedisConnection connection)  

98                          throws DataAccessException {  

99                      RedisSerializer<String> serializer = getRedisSerializer();  

100                    byte[] key  = serializer.serialize(user.getId());  

101                    byte[] name = serializer.serialize(user.getName());  

102                    connection.set(key, name);  

103                    return true;  

104                }  

105            });  

106            return result;  

107        }  

108      

109        /**  

110         * 通过key获取 

111         * <br>------------------------------<br> 

112         * @param keyId 

113         * @return 

114         */  

115        public User get(final String keyId) {  

116            User result = redisTemplate.execute(new RedisCallback<User>() {  

117                public User doInRedis(RedisConnection connection)  

118                        throws DataAccessException {  

119                    RedisSerializer<String> serializer = getRedisSerializer();  

120                    byte[] key = serializer.serialize(keyId);  

121                    byte[] value = connection.get(key);  

122                    if (value == null) {  

123                        return null;  

124                    }  

125                    String name = serializer.deserialize(value);  

126                    return new User(keyId, name, null);  

127                }  

128            });  

129            return result;  

130        }  

131    }  

[java] view plain copy

 

print?

1 import java.util.ArrayList;  

2 import java.util.List;  

3   

4 import junit.framework.Assert;  

5   

6 import org.junit.Test;  

7 import org.springframework.beans.factory.annotation.Autowired;  

8 import org.springframework.test.context.ContextConfiguration;  

9 import org.springframework.test.context.junit4.AbstractJUnit4SpringContextTests;  

10        

11      import com.x.dao.IUserDao;  

12      import com.x.entity.User;  

13        

14      /**  

15       * 测试 

16       * @author http://blog.csdn.net/java2000_wl  

17       * @version <b>1.0</b>  

18       */    

19      @ContextConfiguration(locations = {"classpath*:applicationContext.xml"})  

20      public class RedisTest extends AbstractJUnit4SpringContextTests {  

21            

22          @Autowired  

23          private IUserDao userDao;  

24            

25          /** 

26           * 新增 

27           * <br>------------------------------<br> 

28           */  

29          @Test  

30          public void testAddUser() {  

31              User user = new User();  

32              user.setId("user1");  

33              user.setName("java2000_wl");  

34              boolean result = userDao.add(user);  

35              Assert.assertTrue(result);  

36          }  

37            

38          /** 

39           * 批量新增 普通方式 

40           * <br>------------------------------<br> 

41           */  

42          @Test  

43          public void testAddUsers1() {  

44              List<User> list = new ArrayList<User>();  

45              for (int i = 10; i < 50000; i++) {  

46                  User user = new User();  

47                  user.setId("user" + i);  

48                  user.setName("java2000_wl" + i);  

49                  list.add(user);  

50              }  

51              long begin = System.currentTimeMillis();  

52              for (User user : list) {  

53                  userDao.add(user);  

54              }  

55              System.out.println(System.currentTimeMillis() -  begin);  

56          }  

57            

58          /** 

59           * 批量新增 pipeline方式 

60           * <br>------------------------------<br> 

61           */  

62          @Test  

63          public void testAddUsers2() {  

64              List<User> list = new ArrayList<User>();  

65              for (int i = 10; i < 1500000; i++) {  

66                  User user = new User();  

67                  user.setId("user" + i);  

68                  user.setName("java2000_wl" + i);  

69                  list.add(user);  

70              }  

71              long begin = System.currentTimeMillis();  

72              boolean result = userDao.add(list);  

73              System.out.println(System.currentTimeMillis() - begin);  

74              Assert.assertTrue(result);  

75          }  

76            

77          /** 

78           * 修改 

79           * <br>------------------------------<br> 

80           */  

81          @Test  

82          public void testUpdate() {  

83              User user = new User();  

84              user.setId("user1");  

85              user.setName("new_password");  

86              boolean result = userDao.update(user);  

87              Assert.assertTrue(result);  

88          }  

89            

90          /** 

91           * 通过key删除单个 

92           * <br>------------------------------<br> 

93           */  

94          @Test  

95          public void testDelete() {  

96              String key = "user1";  

97              userDao.delete(key);  

98          }  

99            

100        /** 

101         * 批量删除 

102         * <br>------------------------------<br> 

103         */  

104        @Test  

105        public void testDeletes() {  

106            List<String> list = new ArrayList<String>();  

107            for (int i = 0; i < 10; i++) {  

108                list.add("user" + i);  

109            }  

110            userDao.delete(list);  

111        }  

112          

113        /** 

114         * 获取 

115         * <br>------------------------------<br> 

116         */  

117        @Test  

118        public void testGetUser() {  

119            String id = "user1";  

120            User user = userDao.get(id);  

121            Assert.assertNotNull(user);  

122            Assert.assertEquals(user.getName(), "java2000_wl");  

123        }  

124      

125        /** 

126         * 设置userDao 

127         * @param userDao the userDao to set 

128         */  

129        public void setUserDao(IUserDao userDao) {  

130            this.userDao = userDao;  

131        }  

132    }  

-----------------------上述有点混乱,下面记录重要的Redis信息----------------------------

1、什么是Redis?

       Redis是数据库,不是简单的缓存

      

2、如何安装Redis?

       见上

       默认情况下安装完毕后,在/usr/local/bin/目录下和安装目录的src目录下,会产生几个命令文件,分别是

       redis-server:Redis的服务器操作命令,用于Redis服务器的启停

       redis-cli:Redis的客户端命令,用于连接Redis服务器,并进行各项操作

       redis-benchmark:Redis的性能测试工具

       redis-check-aof:检查aof日志的工具

       redis-check-dump:检查rdb日志的工具

3、如何启动Redis服务?

       使用redis-server命令,指定一个redis.conf配置文件进行启动即可

       如:redis-server redis.conf

4、如何连接Redis服务器?

       使用redis-cli命令

       例如:redis-cli -h ip -p port

       如何直接  redis-cli,则默认连接127.0.0.1的6379端口

5、如何添加/获取数据?

能够操作的数据类型包括  字符串、列表、集合、有序集合、哈希、位图、超重对数

Redis的键是二进制安全的,可以使用任何的二进制序列作为键

键的最大值是512MB

       String(字符串)

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

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

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

实例

redis 127.0.0.1:6379> SET name "runoob"

OK

redis 127.0.0.1:6379> GET name

"runoob"

在以上实例中我们使用了 Redis 的 SET 和 GET 命令。键为 name,对应的值为 runoob。

注意:一个键最大能存储512MB。

 

    Hash(哈希)

Redis hash 是一个键值对集合。

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

实例

127.0.0.1:6379> HMSET user:1 username runoob password runoob points 200

OK

127.0.0.1:6379> HGETALL user:1

1) "username"

2) "runoob"

3) "password"

4) "runoob"

5) "points"

6) "200"

以上实例中 hash 数据类型存储了包含用户脚本信息的用户对象。 实例中我们使用了 Redis HMSET, HGETALL 命令,user:1 为键值。

每个 hash 可以存储 232 -1 键值对(40多亿)。

 

 

    List(列表)

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

实例

redis 127.0.0.1:6379> lpush runoob redis

(integer) 1

redis 127.0.0.1:6379> lpush runoob mongodb

(integer) 2

redis 127.0.0.1:6379> lpush runoob rabitmq

(integer) 3

redis 127.0.0.1:6379> lrange runoob 0 10

1) "rabitmq"

2) "mongodb"

3) "redis"

redis 127.0.0.1:6379>

列表最多可存储 232 - 1 元素 (4294967295, 每个列表可存储40多亿)。

 

    Set(集合)

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

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

sadd 命令

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

sadd key member

实例

redis 127.0.0.1:6379> sadd runoob redis

(integer) 1

redis 127.0.0.1:6379> sadd runoob mongodb

(integer) 1

redis 127.0.0.1:6379> sadd runoob rabitmq

(integer) 1

redis 127.0.0.1:6379> sadd runoob rabitmq

(integer) 0

redis 127.0.0.1:6379> smembers runoob

 

1) "rabitmq"

2) "mongodb"

3) "redis"

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

集合中最大的成员数为 232 - 1(4294967295, 每个集合可存储40多亿个成员)。

 

    zset(sorted set:有序集合)

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

 

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

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

zadd 命令

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

zadd key score member

实例

redis 127.0.0.1:6379> zadd runoob 0 redis

(integer) 1

redis 127.0.0.1:6379> zadd runoob 0 mongodb

(integer) 1

redis 127.0.0.1:6379> zadd runoob 0 rabitmq

(integer) 1

redis 127.0.0.1:6379> zadd runoob 0 rabitmq

(integer) 0

redis 127.0.0.1:6379> ZRANGEBYSCORE runoob 0 1000

 

1) "redis"

2) "mongodb"

3) "rabitmq"

6、如何操作Key?

上一篇:使用pt-stalk分析MySQL的性能波动 (转)
下一篇:在线还原数据库备份文件

相关文章

关键词: Redis word bak

相关评论