• Redis持久化

    本文内容来源于Redis 作者博文,Redis作者说,他看到的所有针对Redis的讨论中,对Redis持久化 的误解是最大的,于是他写了一篇长文来对Redis的持久化进行了系统性的论述。

    什么是持久化,简单来讲就是将数据放到断电后数据不会丢失的设备中。也就是我们通常理解的硬盘上。

    写操作的流程

    首先我们来看一下数据库在进行写操作时到底做了哪些事,主要有下面五个过程。

    1. 客户端向服务端发送写操作(数据在客户端的内存中)
    2. 数据库服务端接收到写请求的数据(数据在服务端的内存中)
    3. 服务端调用write(2) 这个系统调用,将数据往磁盘上写(数据在系统内存的缓冲区中)
    4. 操作系统将缓冲区中的数据转移到磁盘控制器上(数据在磁盘缓存中)
    5. 磁盘控制器将数据写到磁盘的物理介质中(数据真正落到磁盘上)

    写操作大致有上面5个流程,下面我们结合上面的5个流程看一下各种级别的故障。

    • 当数据库系统故障时,这时候系统内核还是OK的,那么此时只要我们执行完了第3步,那么数据就是安全的,因为后续操作系统会来完成后面几步,保证数据最终会落到磁盘上。
    • 当系统断电,这时候上面5项中提到的所有缓存都会失效,并且数据库和操作系统都会停止工作。所以只有当数据在完成第5步后,机器断电才能保证数据不丢失,在上述四步中的数据都会丢失。

    通过上面5步的了解,可能我们会希望搞清下面一些问题:

    • 数据库多长时间调用一次write(2),将数据写到内核缓冲区
    • 内核多长时间会将系统缓冲区中的数据写到磁盘控制器
    • 磁盘控制器又在什么时候把缓存中的数据写到物理介质上

    对于第一个问题,通常数据库层面会进行全面控制。而对第二个问题,操作系统有其默认的策略,但是我们也可以通过POSIX API提供的fsync系列命令强制操作系统将数据从内核区写到磁盘控制器上。对于第三个问题,好像数据库已经无法触及,但实际上,大多数情况下磁盘缓存是被设置关闭的。或者是只开启为读缓存,也就是写操作不会进行缓存,直接写到磁盘。建议的做法是仅仅当你的磁盘设备有备用电池时才开启写缓存。

    所谓数据损坏,就是数据无法恢复,上面我们讲的都是如何保证数据是确实写到磁盘上去,但是写到磁盘上可能并不意味着数据不会损坏。比如我们可能一次写请求会进行两次不同的写操作,当意外发生时,可能会导致一次写操作安全完成,但是另一次还没有进行。如果数据库的数据文件结构组织不合理,可能就会导致数据完全不能恢复的状况出现。

    这里通常也有三种策略来组织数据,以防止数据文件损坏到无法恢复的情况:

    1. 第一种是最粗糙的处理,就是不通过数据的组织形式保证数据的可恢复性。而是通过配置数据同步备份的方式,在数据文件损坏后通过数据备份来进行恢复。实际上MongoDB在不开启journaling日志,通过配置Replica Sets时就是这种情况。
    2. 另一种是在上面基础上添加一个操作日志,每次操作时记一下操作的行为,这样我们可以通过操作日志来进行数据恢复。因为操作日志是顺序追加的方式写的,所以不会出现操作日志也无法恢复的情况。这也类似于MongoDB开启了journaling日志的情况。
    3. 更保险的做法是数据库不进行老数据的修改,只是以追加方式去完成写操作,这样数据本身就是一份日志,这样就永远不会出现数据无法恢复的情况了。实际上CouchDB就是此做法的优秀范例。

    RDB快照

    下面我们说一下Redis的第一个持久化策略,RDB快照。Redis支持将当前数据的快照存成一个数据文件的持久化机制。而一个持续写入的数据库如何生成快照呢。Redis借助了fork命令的copy on write机制。在生成快照时,将当前进程fork出一个子进程,然后在子进程中循环所有的数据,将数据写成为RDB文件。

    我们可以通过Redis的save指令来配置RDB快照生成的时机,比如你可以配置当10分钟以内有100次写入就生成快照,也可以配置当1小时内有1000次写入就生成快照,也可以多个规则一起实施。这些规则的定义就在Redis的配置文件中,你也可以通过Redis的CONFIG SET命令在Redis运行时设置规则,不需要重启Redis。

    Redis的RDB文件不会坏掉,因为其写操作是在一个新进程中进行的,当生成一个新的RDB文件时,Redis生成的子进程会先将数据写到一个临时文件中,然后通过原子性rename系统调用将临时文件重命名为RDB文件,这样在任何时候出现故障,Redis的RDB文件都总是可用的。

    同时,Redis的RDB文件也是Redis主从同步内部实现中的一环。

    但是,我们可以很明显的看到,RDB有他的不足,就是一旦数据库出现问题,那么我们的RDB文件中保存的数据并不是全新的,从上次RDB文件生成到Redis停机这段时间的数据全部丢掉了。在某些业务下,这是可以忍受的,我们也推荐这些业务使用RDB的方式进行持久化,因为开启RDB的代价并不高。但是对于另外一些对数据安全性要求极高的应用,无法容忍数据丢失的应用,RDB就无能为力了,所以Redis引入了另一个重要的持久化机制:AOF 日志。

    AOF日志

    aof日志的全称是append only file,从名字上我们就能看出来,它是一个追加写入的日志文件。与一般数据库的binlog不同的是,AOF文件是可识别的纯文本,它的内容就是一个个的Redis标准命令。比如我们进行如下实验,使用Redis2.6版本,在启动命令参数中设置开启aof功能:

    ./redis-server --appendonly yes

    然后我们执行如下的命令:

    redis 127.0.0.1:6379> set key1 Hello
    OK
    redis 127.0.0.1:6379> append key1 " World!"
    (integer) 12
    redis 127.0.0.1:6379> del key1
    (integer) 1
    redis 127.0.0.1:6379> del non_existing_key
    (integer) 0

    这时我们查看AOF日志文件,就会得到如下内容:

    $ cat appendonly.aof
    *2
    $6
    SELECT
    $1
    0
    *3
    $3
    set
    $4
    key1
    $5
    Hello
    *3
    $6
    append
    $4
    key1
    $7
     World!
    *2
    $3
    del
    $4
    key1

    可以看到,写操作都生成了一条相应的命令作为日志。其中值得注意的是最后一个del命令,它并没有被记录在AOF日志中,这是因为Redis判断出这个命令不会对当前数据集做出修改。所以不需要记录这个无用的写命令。另外AOF日志也不是完全按客户端的请求来生成日志的,比如命令INCRBYFLOAT在记AOF日志时就被记成一条SET记录,因为浮点数操作可能在不同的系统上会不同,所以为了避免同一份日志在不同的系统上生成不同的数据集,所以这里只将操作后的结果通过SET来记录。

    AOF重写

    你可以会想,每一条写命令都生成一条日志,那么AOF文件是不是会很大?答案是肯定的,AOF文件会越来越大,所以Redis又提供了一个功能,叫做AOF rewrite。其功能就是重新生成一份AOF文件,新的AOF文件中一条记录的操作只会有一次,而不像一份老文件那样,可能记录了对同一个值的多次操作。其生成过程和RDB类似,也是fork一个进程,直接遍历数据,写入新的AOF临时文件。在写入新文件的过程中,所有的写操作日志还是会写到原来老的AOF文件中,同时还会记录在内存缓冲区中。当重完操作完成后,会将所有缓冲区中的日志一次性写入到临时文件中。然后调用原子性的rename命令用新的AOF文件取代老的AOF文件。

    从上面的流程我们能够看到,RDB和AOF操作都是顺序IO操作,性能都很高。而同时在通过RDB文件或者AOF日志进行数据库恢复的时候,也是顺序的读取数据加载到内存中。所以也不会造成磁盘的随机读。

    AOF可靠性设置

    AOF是一个写文件操作,其目的是将操作日志写到磁盘上,所以它也同样会遇到我们上面说的写操作的5个流程。那么写AOF的操作安全性又有多高呢。实际上这是可以设置的,在Redis中对AOF调用write(2)写入后,何时再调用fsync将其写到磁盘上,通过appendfsync 选项来控制,下面appendfsync的三个设置项,安全强度逐渐变强。

    appendfsync no

    当设置appendfsync为no的时候,Redis不会主动调用fsync去将AOF日志内容同步到磁盘,所以这一切就完全依赖于操作系统的调试了。对大多数Linux操作系统,是每30秒进行一次fsync,将缓冲区中的数据写到磁盘上。

    appendfsync everysec

    当设置appendfsync为everysec的时候,Redis会默认每隔一秒进行一次fsync调用,将缓冲区中的数据写到磁盘。但是当这一次的fsync调用时长超过1秒时。Redis会采取延迟fsync的策略,再等一秒钟。也就是在两秒后再进行fsync,这一次的fsync就不管会执行多长时间都会进行。这时候由于在fsync时文件描述符会被阻塞,所以当前的写操作就会阻塞。 所以,结论就是,在绝大多数情况下,Redis会每隔一秒进行一次fsync。在最坏的情况下,两秒钟会进行一次fsync操作。

    这一操作在大多数数据库系统中被称为group commit,就是组合多次写操作的数据,一次性将日志写到磁盘。

    appednfsync always

    当设置appendfsync为always时,每一次写操作都会调用一次fsync,这时数据是最安全的,当然,由于每次都会执行fsync,所以其性能也会受到影响。

    对于pipelining有什么不同

    对于pipelining的操作,其具体过程是客户端一次性发送N个命令,然后等待这N个命令的返回结果被一起返回。通过采用pipilining就意味着放弃了对每一个命令的返回值确认。由于在这种情况下,N个命令是在同一个执行过程中执行的。所以当设置appendfsync为everysec时,可能会有一些偏差,因为这N个命令可能执行时间超过1秒甚至2秒。但是可以保证的是,最长时间不会超过这N个命令的执行时间和。

    与postgreSQL和MySQL的比较

    这一块就不多说了,由于上面操作系统层面的数据安全已经讲了很多,所以其实不同的数据库在实现上都大同小异。 总之最后的结论就是,在Redis开启AOF的情况下,其单机数据安全性并不比这些成熟的SQL数据库弱。

    这些持久化的数据有什么用,当然是用于重启后的数据恢复。 Redis是一个内存数据库,无论是RDB还是AOF,都只是其保证数据恢复的措施。 所以Redis在利用RDB和AOF进行恢复的时候,都会读取RDB或AOF文件,重新加载到内存中。 相对于MySQL等数据库的启动时间来说,会长很多,因为MySQL本来是不需要将数据加载到内存中的。

    但是相对来说,MySQL启动后提供服务时,其被访问的热数据也会慢慢加载到内存中,通常我们称之为预热,而在预热完成前,其性能都不会太高。而Redis的好处是一次性将数据加载到内存中,一次性预热。这样只要Redis启动完成,那么其提供服务的速度都是非常快的。

    而在利用RDB和利用AOF启动上,其启动时间有一些差别。RDB的启动时间会更短,原因有两个,一是RDB文件中每一条数据只有一条记录,不会像AOF日志那样可能有一条数据的多次操作记录。所以每条数据只需要写一次就行了。另一个原因是RDB文件的存储格式和Redis数据在内存中的编码格式是一致的,不需要再进行数据编码工作。在CPU消耗上要远小于AOF日志的加载。

    好了,大概内容就说到这里。更详细完整的版本请看Redis作者的博文:Redis persistence demystified。本文如有描述不周之处,就大家指正。

  • PHP-redis中文文档

    phpredis是php的一个扩展,效率是相当高有链表排序功能,对创建内存级的模块业务关系很有用;以下是redis官方提供的命令使用技巧:

    下载地址如下:

    https://github.com/owlient/phpredis(支持redis 2.0.4)

    Redis::__construct构造函数
    $redis = new Redis();

    connect, open 链接redis服务
    参数
    host
    : string,服务地址
    port
    : int,端口号
    timeout
    : float,链接时长 (可选, 默认为 0 ,不限链接时间)
    注: 在redis.conf中也有时间,默认为300

    pconnect, popen 不会主动关闭的链接
    参考上面

    setOption 设置redis模式

    getOption 查看redis设置的模式

    ping 查看连接状态

    get 得到某个key的值(string值)
    如果该key不存在,return false

    set 写入key 和 value(string值)
    如果写入成功,return ture

    setex 带生存时间的写入值
    $redis->setex(‘key’, 3600, ‘value’); // sets key → value, with 1h TTL.

    setnx 判断是否重复的,写入值
    $redis->setnx(‘key’, ‘value’);
    $redis->setnx(‘key’, ‘value’);

    delete  删除指定key的值
    返回已经删除key的个数(长整数)
    $redis->delete(‘key1’, ‘key2’);
    $redis->delete(array(‘key3’, ‘key4’, ‘key5’));

    ttl
    得到一个key的生存时间

    persist
    移除生存时间到期的key
    如果key到期 true 如果不到期 false

    mset (redis版本1.1以上才可以用)
    同时给多个key赋值
    $redis->mset(array(‘key0’ => ‘value0’, ‘key1’ => ‘value1’));

    multi, exec, discard
    进入或者退出事务模式
    参数可选Redis::MULTI或Redis::PIPELINE. 默认是 Redis::MULTI
    Redis::MULTI:将多个操作当成一个事务执行
    Redis::PIPELINE:让(多条)执行命令简单的,更加快速的发送给服务器,但是没有任何原子性的保证
    discard:删除一个事务
    返回值
    multi(),返回一个redis对象,并进入multi-mode模式,一旦进入multi-mode模式,以后调用的所有方法都会返回相同的对象,只到exec()方法被调用。

    watch, unwatch (代码测试后,不能达到所说的效果)
    监测一个key的值是否被其它的程序更改。如果这个key在watch 和 exec (方法)间被修改,这个 MULTI/EXEC 事务的执行将失败(return false)
    unwatch  取消被这个程序监测的所有key
    参数,一对key的列表
    $redis->watch(‘x’);

    $ret = $redis->multi() ->incr(‘x’) ->exec();

    subscribe *
    方法回调。注意,该方法可能在未来里发生改变

    publish *
    发表内容到某一个通道。注意,该方法可能在未来里发生改变

    exists
    判断key是否存在。存在 true 不在 false

    incr, incrBy
    key中的值进行自增1,如果填写了第二个参数,者自增第二个参数所填的值
    $redis->incr(‘key1’);
    $redis->incrBy(‘key1’, 10);

    decr, decrBy
    做减法,使用方法同incr

    getMultiple
    传参
    由key组成的数组
    返回参数
    如果key存在返回value,不存在返回false
    $redis->set(‘key1’, ‘value1’); $redis->set(‘key2’, ‘value2’); $redis->set(‘key3’, ‘value3’); $redis->getMultiple(array(‘key1’, ‘key2’, ‘key3’));
    $redis->lRem(‘key1’, ‘A’, 2);
    $redis->lRange(‘key1’, 0, -1);

    list相关操作
    lPush
    $redis->lPush(key, value);
    在名称为key的list左边(头)添加一个值为value的 元素

    rPush
    $redis->rPush(key, value);
    在名称为key的list右边(尾)添加一个值为value的 元素

    lPushx/rPushx
    $redis->lPushx(key, value);
    在名称为key的list左边(头)/右边(尾)添加一个值为value的元素,如果value已经存在,则不添加

    lPop/rPop
    $redis->lPop(‘key’);
    输出名称为key的list左(头)起/右(尾)起的第一个元素,删除该元素

    blPop/brPop
    $redis->blPop(‘key1’, ‘key2’, 10);
    lpop命令的block版本。即当timeout为0时,若遇到名称为key i的list不存在或该list为空,则命令结束。如果timeout>0,则遇到上述情况时,等待timeout秒,如果问题没有解决,则对keyi+1开始的list执行pop操作

    lSize
    $redis->lSize(‘key’);
    返回名称为key的list有多少个元素

    lIndex, lGet
    $redis->lGet(‘key’, 0);
    返回名称为key的list中index位置的元素

    lSet
    $redis->lSet(‘key’, 0, ‘X’);
    给名称为key的list中index位置的元素赋值为value

    lRange, lGetRange
    $redis->lRange(‘key1’, 0, -1);
    返回名称为key的list中start至end之间的元素(end为 -1 ,返回所有)

    lTrim, listTrim
    $redis->lTrim(‘key’, start, end);
    截取名称为key的list,保留start至end之间的元素

    lRem, lRemove
    $redis->lRem(‘key’, ‘A’, 2);
    删除count个名称为key的list中值为value的元素。count为0,删除所有值为value的元素,count>0从头至尾删除count个值为value的元素,count<0从尾到头删除|count|个值为value的元素

    lInsert
    在名称为为key的list中,找到值为pivot 的value,并根据参数Redis::BEFORE | Redis::AFTER,来确定,newvalue 是放在 pivot 的前面,或者后面。如果key不存在,不会插入,如果 pivot不存在,return -1
    $redis->delete(‘key1’); $redis->lInsert(‘key1’, Redis::AFTER, ‘A’, ‘X’); $redis->lPush(‘key1’, ‘A’); $redis->lPush(‘key1’, ‘B’); $redis->lPush(‘key1’, ‘C’); $redis->lInsert(‘key1’, Redis::BEFORE, ‘C’, ‘X’);
    $redis->lRange(‘key1’, 0, -1);
    $redis->lInsert(‘key1’, Redis::AFTER, ‘C’, ‘Y’);
    $redis->lRange(‘key1’, 0, -1);
    $redis->lInsert(‘key1’, Redis::AFTER, ‘W’, ‘value’);

    rpoplpush
    返回并删除名称为srckey的list的尾元素,并将该元素添加到名称为dstkey的list的头部
    $redis->delete(‘x’, ‘y’);
    $redis->lPush(‘x’, ‘abc’); $redis->lPush(‘x’, ‘def’); $redis->lPush(‘y’, ‘123’); $redis->lPush(‘y’, ‘456’); // move the last of x to the front of y. var_dump($redis->rpoplpush(‘x’, ‘y’));
    var_dump($redis->lRange(‘x’, 0, -1));
    var_dump($redis->lRange(‘y’, 0, -1));

    string(3) “abc”
    array(1) { [0]=> string(3) “def” }
    array(3) { [0]=> string(3) “abc” [1]=> string(3) “456” [2]=> string(3) “123” }

    SET操作相关
    sAdd
    向名称为key的set中添加元素value,如果value存在,不写入,return false
    $redis->sAdd(key , value);

    sRem, sRemove
    删除名称为key的set中的元素value
    $redis->sAdd(‘key1’ , ‘set1’);
    $redis->sAdd(‘key1’ , ‘set2’);
    $redis->sAdd(‘key1’ , ‘set3’);
    $redis->sRem(‘key1’, ‘set2’);

    sMove
    将value元素从名称为srckey的集合移到名称为dstkey的集合
    $redis->sMove(seckey, dstkey, value);

    sIsMember, sContains
    名称为key的集合中查找是否有value元素,有ture 没有 false
    $redis->sIsMember(key, value);

    sCard, sSize
    返回名称为key的set的元素个数

    sPop
    随机返回并删除名称为key的set中一个元素

    sRandMember
    随机返回名称为key的set中一个元素,不删除

    sInter
    求交集

    sInterStore
    求交集并将交集保存到output的集合
    $redis->sInterStore(‘output’, ‘key1’, ‘key2’, ‘key3’)

    sUnion
    求并集
    $redis->sUnion(‘s0’, ‘s1’, ‘s2’);
    s0,s1,s2 同时求并集

    sUnionStore
    求并集并将并集保存到output的集合
    $redis->sUnionStore(‘output’, ‘key1’, ‘key2’, ‘key3’);

    sDiff
    求差集

    sDiffStore
    求差集并将差集保存到output的集合

    sMembers, sGetMembers
    返回名称为key的set的所有元素

    sort
    排序,分页等
    参数
    ‘by’ => ‘some_pattern_*’,
    ‘limit’ => array(0, 1),
    ‘get’ => ‘some_other_pattern_*’ or an array of patterns,
    ‘sort’ => ‘asc’ or ‘desc’,
    ‘alpha’ => TRUE,
    ‘store’ => ‘external-key’
    例子
    $redis->delete(‘s’); $redis->sadd(‘s’, 5); $redis->sadd(‘s’, 4); $redis->sadd(‘s’, 2); $redis->sadd(‘s’, 1); $redis->sadd(‘s’, 3);
    var_dump($redis->sort(‘s’)); // 1,2,3,4,5
    var_dump($redis->sort(‘s’, array(‘sort’ => ‘desc’))); // 5,4,3,2,1
    var_dump($redis->sort(‘s’, array(‘sort’ => ‘desc’, ‘store’ => ‘out’))); // (int)5

    string命令
    getSet
    返回原来key中的值,并将value写入key
    $redis->set(‘x’, ’42’);
    $exValue = $redis->getSet(‘x’, ‘lol’); // return ’42’, replaces x by ‘lol’
    $newValue = $redis->get(‘x’)’ // return ‘lol’

    append
    string,名称为key的string的值在后面加上value
    $redis->set(‘key’, ‘value1’);
    $redis->append(‘key’, ‘value2’);
    $redis->get(‘key’);

    getRange (方法不存在)
    返回名称为key的string中start至end之间的字符
    $redis->set(‘key’, ‘string value’);
    $redis->getRange(‘key’, 0, 5);
    $redis->getRange(‘key’, -5, -1);

    setRange (方法不存在)
    改变key的string中start至end之间的字符为value
    $redis->set(‘key’, ‘Hello world’);
    $redis->setRange(‘key’, 6, “redis”);
    $redis->get(‘key’);

    strlen
    得到key的string的长度
    $redis->strlen(‘key’);

    getBit/setBit
    返回2进制信息

    zsetsorted set)操作相关
    zAdd(key, score, member):向名称为key的zset中添加元素member,score用于排序。如果该元素已经存在,则根据score更新该元素的顺序。
    $redis->zAdd(‘key’, 1, ‘val1’);
    $redis->zAdd(‘key’, 0, ‘val0’);
    $redis->zAdd(‘key’, 5, ‘val5’);
    $redis->zRange(‘key’, 0, -1); // array(val0, val1, val5)

    zRange(key, start, end,withscores):返回名称为key的zset(元素已按score从小到大排序)中的index从start到end的所有元素
    $redis->zAdd(‘key1’, 0, ‘val0’);
    $redis->zAdd(‘key1’, 2, ‘val2’);
    $redis->zAdd(‘key1’, 10, ‘val10’);
    $redis->zRange(‘key1’, 0, -1); // with scores $redis->zRange(‘key1’, 0, -1, true);

    zDelete, zRem
    zRem(key, member) :删除名称为key的zset中的元素member
    $redis->zAdd(‘key’, 0, ‘val0’);
    $redis->zAdd(‘key’, 2, ‘val2’);
    $redis->zAdd(‘key’, 10, ‘val10’);
    $redis->zDelete(‘key’, ‘val2’);
    $redis->zRange(‘key’, 0, -1);

    zRevRange(key, start, end,withscores):返回名称为key的zset(元素已按score从大到小排序)中的index从start到end的所有元素.withscores: 是否输出socre的值,默认false,不输出
    $redis->zAdd(‘key’, 0, ‘val0’);
    $redis->zAdd(‘key’, 2, ‘val2’);
    $redis->zAdd(‘key’, 10, ‘val10’);
    $redis->zRevRange(‘key’, 0, -1); // with scores $redis->zRevRange(‘key’, 0, -1, true);

    zRangeByScore, zRevRangeByScore
    $redis->zRangeByScore(key, star, end, array(withscores, limit ));
    返回名称为key的zset中score >= star且score <= end的所有元素

    zCount
    $redis->zCount(key, star, end);
    返回名称为key的zset中score >= star且score <= end的所有元素的个数

    zRemRangeByScore, zDeleteRangeByScore
    $redis->zRemRangeByScore(‘key’, star, end);
    删除名称为key的zset中score >= star且score <= end的所有元素,返回删除个数

    zSize, zCard
    返回名称为key的zset的所有元素的个数

    zScore
    $redis->zScore(key, val2);
    返回名称为key的zset中元素val2的score

    zRank, zRevRank
    $redis->zRevRank(key, val);
    返回名称为key的zset(元素已按score从小到大排序)中val元素的rank(即index,从0开始),若没有val元素,返回“null”。zRevRank 是从大到小排序

    zIncrBy
    $redis->zIncrBy(‘key’, increment, ‘member’);
    如果在名称为key的zset中已经存在元素member,则该元素的score增加increment;否则向集合中添加该元素,其score的值为increment

    zUnion/zInter
    参数
    keyOutput
    arrayZSetKeys
    arrayWeights
    aggregateFunction
    Either “SUM”, “MIN”, or “MAX”: defines the behaviour to use on duplicate entries during the zUnion.
    对N个zset求并集和交集,并将最后的集合保存在dstkeyN中。对于集合中每一个元素的score,在进行AGGREGATE运算前,都要乘以对于的WEIGHT参数。如果没有提供WEIGHT,默认为1。默认的AGGREGATE是SUM,即结果集合中元素的score是所有集合对应元素进行SUM运算的值,而MIN和MAX是指,结果集合中元素的score是所有集合对应元素中最小值和最大值。

    Hash操作
    hSet
    $redis->hSet(‘h’, ‘key1’, ‘hello’);
    向名称为h的hash中添加元素key1—>hello

    hGet
    $redis->hGet(‘h’, ‘key1’);
    返回名称为h的hash中key1对应的value(hello)

    hLen
    $redis->hLen(‘h’);
    返回名称为h的hash中元素个数

    hDel
    $redis->hDel(‘h’, ‘key1’);
    删除名称为h的hash中键为key1的域

    hKeys
    $redis->hKeys(‘h’);
    返回名称为key的hash中所有键

    hVals
    $redis->hVals(‘h’)
    返回名称为h的hash中所有键对应的value

    hGetAll
    $redis->hGetAll(‘h’);
    返回名称为h的hash中所有的键(field)及其对应的value

    hExists
    $redis->hExists(‘h’, ‘a’);
    名称为h的hash中是否存在键名字为a的域

    hIncrBy
    $redis->hIncrBy(‘h’, ‘x’, 2);
    将名称为h的hash中x的value增加2

    hMset
    $redis->hMset(‘user:1’, array(‘name’ => ‘Joe’, ‘salary’ => 2000));
    向名称为key的hash中批量添加元素

    hMGet
    $redis->hmGet(‘h’, array(‘field1’, ‘field2’));
    返回名称为h的hash中field1,field2对应的value

    redis 操作相关
    flushDB
    清空当前数据库

    flushAll
    清空所有数据库

    randomKey
    随机返回key空间的一个key
    $key = $redis->randomKey();

    select
    选择一个数据库
    move
    转移一个key到另外一个数据库
    $redis->select(0); // switch to DB 0
    $redis->set(‘x’, ’42’); // write 42 to x
    $redis->move(‘x’, 1); // move to DB 1
    $redis->select(1); // switch to DB 1
    $redis->get(‘x’); // will return 42

    rename, renameKey
    给key重命名
    $redis->set(‘x’, ’42’);
    $redis->rename(‘x’, ‘y’);
    $redis->get(‘y’); // → 42
    $redis->get(‘x’); // → `FALSE`

    renameNx
    与remane类似,但是,如果重新命名的名字已经存在,不会替换成功

    setTimeout, expire
    设定一个key的活动时间(s)
    $redis->setTimeout(‘x’, 3);

    expireAt
    key存活到一个unix时间戳时间
    $redis->expireAt(‘x’, time() + 3);

    keys, getKeys
    返回满足给定pattern的所有key
    $keyWithUserPrefix = $redis->keys(‘user*’);

    dbSize
    查看现在数据库有多少key
    $count = $redis->dbSize();

    auth
    密码认证
    $redis->auth(‘foobared’);

    bgrewriteaof
    使用aof来进行数据库持久化
    $redis->bgrewriteaof();

    slaveof
    选择从服务器
    $redis->slaveof(‘10.0.1.7’, 6379);

    save
    将数据同步保存到磁盘

    bgsave
    将数据异步保存到磁盘

    lastSave
    返回上次成功将数据保存到磁盘的Unix时戳

    info
    返回redis的版本信息等详情

    type
    返回key的类型值
    string: Redis::REDIS_STRING
    set: Redis::REDIS_SET
    list: Redis::REDIS_LIST
    zset: Redis::REDIS_ZSET
    hash: Redis::REDIS_HASH
    other: Redis::REDIS_NOT_FOUND

  • predis操作大全

    redis是php连接redis的操作库,由于它完全使用php编写,大量使用命名空间以及闭包等功能,只支持php5.3以上版本,故实测性能一般,每秒25000次读写,相信改换c语言编写的php扩展后性能会大幅提升(比如使用C扩展phpredis https://github.com/owlient/phpredis)。

    将session数据存放到redis也很简单:
    session.save_handler = redis
    session.save_path = “tcp://127.0.0.1:6379″

    以下是汇总一些操作,并不断更新。

    //使用autoload加载相关库,这边重点就是为了require $file;
    spl_autoload_register(function($class) {
    $file = __DIR__.’/lib/Predis/’.$class.’.php’;
    if (file_exists($file)) {
    require $file;
    return true;
    }
    });

    //配置连接的IP、端口、以及相应的数据库
    $server = array(
    ‘host’     => ‘127.0.0.1’,
    ‘port’     => 6379,
    ‘database’ => 15
    );
    $redis = new Client($server);

    //普通set/get操作
    $redis->set(‘library’, ‘predis’);
    $retval = $redis->get(‘library’);
    echo $retval; //显示 ‘predis’

    //setex set一个存储时效
    $redis->setex(‘str’, 10, ‘bar’); //表示存储有效期为10秒

    //setnx/msetnx相当于add操作,不会覆盖已有值
    $redis->setnx(‘foo’,12); //true
    $redis->setnx(‘foo’,34); //false

    //getset操作,set的变种,结果返回替换前的值
    $redis->getset(‘foo’,56);//返回34

    // incrby/incr/decrby/decr 对值的递增和递减
    $redis->incr(‘foo’); //foo为57
    $redis->incrby(‘foo’,2); //foo为59

    //exists检测是否存在某值
    $redis->exists(‘foo’);//true

    //del 删除
    $redis->del(‘foo’);//true

    //type 类型检测,字符串返回string,列表返回 list,set表返回set/zset,hash表返回hash
    $redis->type(‘foo’);//不存在,返回none
    $redis->set(‘str’,’test’);
    $redis->type(‘str’); //字符串,返回string

    //append 连接到已存在字符串
    $redis->append(‘str’,’_123′); //返回累加后的字符串长度8,此进str为 ‘test_123’

    //setrange 部分替换操作
    $redis->setrange(‘str’,0,’abc’); //返回3,参数2为0时等同于set操作
    $redis->setrange(‘str’,2,’cd’);//返回4,表示从第2个字符后替换,这时’str’为’abcd’

    //substr 部分获取操作
    $redis->substr(‘str’,0,2);//表示从第0个起,取到第2个字符,共3个,返回’abc’

    //strlen 获取字符串长度
    $redis->strlen(‘str’); //返回4

    //setbit/getbit 位存储和获取
    $redis->setbit(‘binary’,31,1);  //表示在第31位存入1,这边可能会有大小端问题?不过没关系,getbit 应该不会有问题
    $redis->getbit(‘binary’,31);    //返回1

    //keys 模糊查找功能,支持*号以及?号(匹配一个字符)
    $redis->set(‘foo1’,123);
    $redis->set(‘foo2’,456);
    $redis->keys(‘foo*’); //返回foo1和foo2的array
    $redis->keys(‘f?o?’);  //同上

    //randomkey 随机返回一个key
    $redis->randomkey(); //可能是返回 ‘foo1’或者是’foo2’及其它任何一存在redis的key

    //rename/renamenx 对key进行改名,所不同的是renamenx不允许改成已存在的key
    $redis->rename(‘str’,’str2′); //把原先命名为’str’的key改成了’str2′

    //expire 设置key-value的时效性,ttl 获取剩余有效期,persist 重新设置为永久存储
    $redis->expire(‘foo’, 1); //设置有效期为1秒
    $redis->ttl(‘foo’); //返回有效期值1s
    $redis->expire(‘foo’); //取消expire行为

    //dbsize 返回redis当前数据库的记录总数
    $redis->dbsize();

    //rpush/rpushx 有序列表操作,从队列后插入元素
    //lpush/lpushx 和rpush/rpushx的区别是插入到队列的头部,同上,’x’含义是只对已存在的key进行操作
    $redis->rpush(‘fooList’, ‘bar1’); //返回一个列表的长度1
    $redis->lpush(‘fooList’, ‘bar0’); //返回一个列表的长度2
    $redis->rpushx(‘fooList’, ‘bar2’); //返回3,rpushx只对已存在的队列做添加,否则返回0
    //llen返回当前列表长度
    $redis->llen(‘fooList’);//3

    //lrange 返回队列中一个区间的元素
    $redis->lrange(‘fooList’,0,1); //返回数组包含第0个至第1个共2个元素
    $redis->lrange(‘fooList’,0,-1);//返回第0个至倒数第一个,相当于返回所有元素,注意redis中很多时候会用到负数,下同

    //lindex 返回指定顺序位置的list元素
    $redis->lindex(‘fooList’,1); //返回’bar1′

    //lset 修改队列中指定位置的value
    $redis->lset(‘fooList’,1,’123′);//修改位置1的元素,返回true

    //lrem 删除队列中左起指定数量的字符
    $redis->lrem(‘fooList’,1,’_’); //删除队列中左起(右起使用-1)1个字符’_'(若有)

    //lpop/rpop 类似栈结构地弹出(并删除)最左或最右的一个元素
    $redis->lpop(‘fooList’); //’bar0′
    $redis->rpop(‘fooList’); //’bar2′

    //ltrim 队列修改,保留左边起若干元素,其余删除
    $redis->ltrim(‘fooList’, 0,1); //保留左边起第0个至第1个元素

    //rpoplpush 从一个队列中pop出元素并push到另一个队列
    $redis->rpush(‘list1′,’ab0’);
    $redis->rpush(‘list1′,’ab1’);
    $redis->rpush(‘list2′,’ab2’);
    $redis->rpush(‘list2′,’ab3’);
    $redis->rpoplpush(‘list1′,’list2’);//结果list1 =>array(‘ab0’),list2 =>array(‘ab1′,’ab2′,’ab3’)
    $redis->rpoplpush(‘list2′,’list2’);//也适用于同一个队列,把最后一个元素移到头部list2 =>array(‘ab3′,’ab1′,’ab2’)

    //linsert 在队列的中间指定元素前或后插入元素
    $redis->linsert(‘list2’, ‘before’,’ab1′,’123′); //表示在元素’ab1’之前插入’123′
    $redis->linsert(‘list2’, ‘after’,’ab1′,’456′);   //表示在元素’ab1’之后插入’456′

    //blpop/brpop 阻塞并等待一个列队不为空时,再pop出最左或最右的一个元素(这个功能在php以外可以说非常好用)
    //brpoplpush 同样是阻塞并等待操作,结果同rpoplpush一样
    $redis->blpop(‘list3’,10); //如果list3为空则一直等待,直到不为空时将第一元素弹出,10秒后超时