php之Redis操作

关于key的操作：

$redis = new redis();  
$result = $redis->connect('127.0.0.1', 6379);  

1、获取所有key，不包括值；

 $redis ->keys("*");

2、获取一个或多个key的值，【不限制数据类型】；

$redis->mget([$key1,$key2]);//参数为数组；

3、设置指定key的生命周期；

$redis ->expire($key,30);//设置生命周期为30秒；

4、获取指定key的剩余生命周期；

$redis->tTl($key);

关于value的操作：

1、string类型

$key = 'user';
$redis->delete($key); 
$redis ->set($key,'11');

$redis ->setNx($key,3);    // 当$key不存在时设置才生效；如果存在则值仍然不变；
$redis ->decr($key);         // 当$key的值是数字时可以通过该方法自减1
$redis ->incr($key);          // 当$key的值是数字时可以通过该方法自增1
$redis ->delete($key);     //  删除指定键值
$redis ->getMultiple ([$key,'lx']);   //     获取多个键对应的值 返回值：返回包含所有键的值的数组
$redis ->get($key);          //  获取指定key的值
$redis ->exists($key);      // 判断键是否存在

2、list链表

$key = 'user';
$redis ->delete($key);    //  每次进来删除$key数据 用于测试
$redis ->lPush($key,1);  //  从列表头部添加元素
$redis ->rPush($key,2);  // 从列表尾部添加元素
$redis ->rPush($key,4);
$redis ->lPush($key,4); 
$redis ->lPop($key);  // 从链表头部删除一个元素，并且返回这个元素的值，由于这个特性是的list非常适合做高并发秒杀
$redis ->lRemove($key,2,3); // 删除$key中的2这个值，最多删除三个都为2的值；
$redis ->lSet($key,2,30);   // 将下标为2的元素设置为30；返回值：成功返回查找的值，失败false
$redis ->lGet($key,0);   // 获取指定下标的值 返回值：成功返回查找的值，失败false
$redis ->lTrim($key,0,1);  // 截取保留前两个值，返回值：成功返回查找的值，失败false；一般配合lGetRange使用
$redis ->lGetRange($key,0,-1);  // 获取所有list链表中$key的所有值【值可以重复】 返回值：成功返回查找的值，失败false
$redis ->lLen ($key);//统计元素个数 同$redis ->lsize ($key)一样 返回值：成功返回查找的值，失败false
个人总结：谁最后lpush说明第一个元素为谁；谁最后一个rpush代表最后一个元素为谁；

3、set集合 【和list不同的是 set不允许有同样的值】

$key1 = 'user1';
$key2 = 'user2';
$redis->delete($key1);
$redis->delete($key2);

$redis ->sAdd($key1,'2');// 为一个键添加一个值 返回值：成功返回true,失败false
$redis ->sAdd($key1,'1');
$redis ->sAdd($key2,'2');
$redis ->sAdd($key2,'3');

$redis ->sRemove($key,'1'); // 删除指定值 返回值：成功返回true,失败false
$redis ->sContains($key1,'3'); // 判断$key1中是否有指定值 返回值：成功返回true,失败false
$redis ->sSize($key1); // 返回集合中存储值的数量  返回值：成功返回数组个数，失败0
$redis ->sPop($key1); // 随机移除并返回key中的一个值 返回值：成功返回删除的值，失败false
$redis ->sUnion($key2,$key1); // 返回所有指定键的并集 返回值：成功返回合并后的集，失败false
$redis ->sInterStore ('user3',$key2,$key1); // 执行sInter命令并把结果储存到新建的集合中 返回值：成功返回，交集的个数，失败false
$redis ->sInter($key1,$key2); // 返回两个指定集合的交集 返回值：成功返回数组交集，失败false
$redis ->sUnionStore('user3',$key2,$key1); // 执行sunion命令并把结果储存到新建的变量中  返回值：成功返回，交集的个数，失败false 
$redis ->sMembers($key1); // 获取集合内所有值
$redis ->sisMember ($key1,2); // 如果成员元素2是集合$key1,的成员返回1,如果成员元素不是集合的成员,或key不存在返回0
$redis ->sDiffstore('user3',$key1,$key2); // 执行sdiff命令并把结果储存到新建的变量中。返回值：成功返回数字，失败false
$redis ->sdiff($key1,$key2); // 返回第一个集合中存在并在第二个集合中不存在的结果 返回值：成功返回数组，失败false  返回值：成功返回交集的个数，失败false 
$redis ->sort($key1); // 当集合内都为数值时返回排序之后的结果 只要有一个值不是数值都不返回结果
$redis ->sCard($key1); // 返回SET容器的成员数

4、hash对象 【可以理解为每一个key代表一条数据，同数据库中的行一样】

$key1 = 'user';
$key2 = 'user1';
$redis ->delete($key1);
$redis ->hSet($key1,'name','lx'); // hash中每一个key对应一个或者多个键值对；就好比mysql中的字段和值；而$key类似一条数据
$redis ->hSet($key1,'age','保密');
$redis ->hSet($key1,'sex','男');

$redis ->hMGet($key2,['name','age']);  //   获得哈希表中多个 key 的值
$redis ->hMSet($key2,['name'=>'lx','age'=>27]);// 给哈希表设置多个key的值

$redis ->hVals($key1); //  获得哈希表中所有的值 顺序是随机的
$redis ->hKeys($key1); // 获得哈希表中所有的key 顺序是随机的

$redis ->hDel($key1,'user1'); // 删除一个表中指定的key，如果hash表不存在或对应的key不存在，返回false

$redis ->hLen($key1); // 哈表中key的数量说白了就是记录的条数和数据库中的行一样
$redis ->hGet($key1,'user2');
$redis ->hSetNx($key1,'user2','lx');  // 当哈希表中不存在某key时，给该key设置一个值

$redis ->hExists($key1,'user1'); // 检查哈希key是否存在 返回值:存在返回 true, 不存在返回 false
$redis ->hGetAll($key2); // 获得一个哈希表中所有的key和value
$redis ->hIncrByFloat($key1,'user3',3.5); // 给哈希表中某key增加一个浮点数值,前提是key中已存在的值必须是数值类型
$redis ->hIncrBy($key1,'user3',3);// 给哈希表中某key增加一个整数值,前提是key中已存在的值必须是数值类型

实例：

<?php
header("content-type:text/html; charset=utf-8");
// 设置时区
function_exists('date_default_timezone_set') && date_default_timezone_set('PRC');
error_reporting(E_ALL);


$redis = new Redis();
$redis->connect('127.0.0.1', 6379);
$redis->select('5'); // 用户基本信息存在 '数据库5' 中

$isLogin = true; // 假如登陆了

// $site--网站   $accountId--用户id
$key_info = "site:{$site}:user:{$accountId}:base_info";

if ($redis->exists($key_info) && !$isLogin) {
    // hMGet获得哈希表中多个 key 的值
    $result = $redis->hMGet($key_info, ['iLicense', 'sIp']);
    $iLicense = intval($result['iLicense']); // int
    $sIp = $result['sIp']; // json string
} else {
    $sql = 'SELECT id,iAccountId,iLicense,sIp FROM dm.Licens WHERE iAccountId=?';
    $result = $this->query($sql, [$accountId]);
    if (count($result) > 0 && $result[0]) {
        $result = $result[0];
        $iLicense = intval($result['iLicense']); // int
        $sIp = $result['sIp']; // json string
    } else {
        $iLicense = 0; // int
        $sIp = '[]'; // json string
    }
    // // 给哈希表设置多个key的值  为hash表多个字段设定值
    $redis->hMset($key_info, ['iLicense' => $iLicense, 'sIp' => $sIp]);
}
$aIp = json_decode($sIp, true);

// 有license数量限制
if ($iLicense > 0) {
    // 实时连接键名
    $key_license = "site:{$site}:user:{$accountId}:license:*";
    $redis->select('6'); // [重要] 连接保存在redis的'数据库6'中
    // 已建立的连接
    $keys = $redis->keys($key_license);
    if (count($keys) >= $iLicense) {
        return [false, '在线license数已达到上限：' . $iLicense];
    }
}
return [true];

下面是php对Redis的封装[ 单例模式 ]：

<?php

/**
 * redis操作类
 * 说明，任何为false的串，存在redis中都是空串。
 * 只有在key不存在时，才会返回false。
 * 这点可用于防止缓存穿透
 */
class Redis
{
    private $redis;
    protected $dbId = 0; // 当前数据库ID号
    protected $auth; // 当前权限认证码,一般为空
    static private $_instance = array(); // 实例化的对象,单例模式 [ \iphp\db\Redis ]
    private $k;
    //连接属性数组
    protected $attr = array(
        // 连接超时时间，redis配置文件中默认为300秒
        'timeout' => 30,
        // 选择的数据库。
        'db_id' => 0,
    );
    protected $expireTime;// 什么时候重新建立连接
    protected $host; // 127.0.0.1(本地)
    protected $port; // 默认：6379


    private function __construct($config, $attr = array())
    {
        $this->attr = array_merge($this->attr, $attr);
        $this->redis = new Redis();
        $this->port = $config['port'] ? $config['port'] : 6379;
        $this->host = $config['host'];
        $this->redis->connect($this->host, $this->port, $this->attr['timeout']);

        if ($config['auth']) {
            $this->auth($config['auth']);
            $this->auth = $config['auth'];
        }

        $this->expireTime = time() + $this->attr['timeout'];
    }

    /**
     * 得到实例化的对象.
     * 为每个数据库建立一个连接
     * 如果连接超时，将会重新建立一个连接
     * @param array $config
     * @param int $dbId
     * @return \iphp\db\Redis
     */
    public static function getInstance($config, $attr = array())
    {
        //如果是一个字符串，将其认为是数据库的ID号。以简化写法。
        if (!is_array($attr)) {
            $dbId = $attr;
            $attr = array();
            $attr['db_id'] = $dbId;
        }

        $attr['db_id'] = $attr['db_id'] ? $attr['db_id'] : 0;


        $k = md5(implode('', $config) . $attr['db_id']);
        if (!(static::$_instance[$k] instanceof self)) {

            static::$_instance[$k] = new self($config, $attr);
            static::$_instance[$k]->k = $k;
            static::$_instance[$k]->dbId = $attr['db_id'];

            //如果不是0号库，选择一下数据库。
            if ($attr['db_id'] != 0) {
                static::$_instance[$k]->select($attr['db_id']);
            }
        } elseif (time() > static::$_instance[$k]->expireTime) {
            static::$_instance[$k]->close();
            static::$_instance[$k] = new self($config, $attr);
            static::$_instance[$k]->k = $k;
            static::$_instance[$k]->dbId = $attr['db_id'];

            //如果不是0号库，选择一下数据库。
            if ($attr['db_id'] != 0) {
                static::$_instance[$k]->select($attr['db_id']);
            }
        }
        return static::$_instance[$k];
    }

    private function __clone()
    {
        // ............
    }

    /**
     * 执行原生的redis操作
     * @return \Redis
     */
    public function getRedis()
    {
        return $this->redis;
    }

    /********************************* hash表操作函数 ********************************/

    /**
     * 得到hash表中一个字段的值
     * @param string $key 缓存key
     * @param string $field 字段
     * @return string|false
     */
    public function hGet($key, $field)
    {
        return $this->redis->hGet($key, $field);
    }

    /**
     * 为hash表设定一个字段的值
     * @param string $key 缓存key
     * @param string $field 字段
     * @param string $value 值。
     * @return bool
     */
    public function hSet($key, $field, $value)
    {
        return $this->redis->hSet($key, $field, $value);
    }

    /**
     * 判断hash表中，指定field是不是存在
     * @param string $key 缓存key
     * @param string $field 字段
     * @return bool
     */
    public function hExists($key, $field)
    {
        return $this->redis->hExists($key, $field);
    }

    /**
     * 删除hash表中指定字段 ,支持批量删除
     * @param string $key 缓存key
     * @param string $field 字段
     * @return int
     */
    public function hdel($key, $field)
    {
        $fieldArr = explode(',', $field);
        $delNum = 0;

        foreach ($fieldArr as $row) {
            $row = trim($row);
            $delNum += $this->redis->hDel($key, $row);
        }

        return $delNum;
    }

    /**
     * 返回hash表元素个数
     * @param string $key 缓存key
     * @return int|bool
     */
    public function hLen($key)
    {
        return $this->redis->hLen($key);
    }

    /**
     * 为hash表设定一个字段的值,如果字段存在，返回false
     * @param string $key 缓存key
     * @param string $field 字段
     * @param string $value 值。
     * @return bool
     */
    public function hSetNx($key, $field, $value)
    {
        return $this->redis->hSetNx($key, $field, $value);
    }

    /**
     * 为hash表多个字段设定值。
     * @param string $key
     * @param array $value
     * @return array|bool
     */
    public function hMset($key, $value)
    {
        if (!is_array($value))
            return false;
        return $this->redis->hMset($key, $value);
    }

    /**
     * 获取hash表多个字段设定值。
     * @param string $key
     * @param array|string $value string 以','号分隔字段
     * @return array|bool
     */
    public function hMget($key, $field)
    {
        if (!is_array($field))
            $field = explode(',', $field);
        return $this->redis->hMget($key, $field);
    }

    /**
     * 为hash表设这累加，可以负数
     * @param string $key
     * @param int $field
     * @param string $value
     * @return bool
     */
    public function hIncrBy($key, $field, $value)
    {
        $value = intval($value);
        return $this->redis->hIncrBy($key, $field, $value);
    }

    /**
     * 返回所有hash表的所有字段
     * @param string $key
     * @return array|bool
     */
    public function hKeys($key)
    {
        return $this->redis->hKeys($key);
    }

    /**
     * 返回所有hash表的字段值，为一个索引数组
     * @param string $key
     * @return array|bool
     */
    public function hVals($key)
    {
        return $this->redis->hVals($key);
    }

    /**
     * 返回所有hash表的字段值，为一个关联数组
     * @param string $key
     * @return array|bool
     */
    public function hGetAll($key)
    {
        return $this->redis->hGetAll($key);
    }

    /************************************** 有序集合操作 *******************************/

    /**
     * 给当前集合添加一个元素
     * 如果value已经存在，会更新order的值。
     * @param string $key
     * @param string $order 序号
     * @param string $value 值
     * @return bool
     */
    public function zAdd($key, $order, $value)
    {
        return $this->redis->zAdd($key, $order, $value);
    }

    /**
     * 给$value成员的order值，增加$num,可以为负数
     * @param string $key
     * @param string $num 序号
     * @param string $value 值
     * @return 返回新的order
     */
    public function zinCry($key, $num, $value)
    {
        return $this->redis->zinCry($key, $num, $value);
    }

    /**
     * 删除值为value的元素
     * @param string $key
     * @param stirng $value
     * @return bool
     */
    public function zRem($key, $value)
    {
        return $this->redis->zRem($key, $value);
    }

    /**
     * 集合以order递增排列后，0表示第一个元素，-1表示最后一个元素
     * @param string $key
     * @param int $start
     * @param int $end
     * @return array|bool
     */
    public function zRange($key, $start, $end)
    {
        return $this->redis->zRange($key, $start, $end);
    }

    /**
     * 集合以order递减排列后，0表示第一个元素，-1表示最后一个元素
     * @param string $key
     * @param int $start
     * @param int $end
     * @return array|bool
     */
    public function zRevRange($key, $start, $end)
    {
        return $this->redis->zRevRange($key, $start, $end);
    }

    /**
     * 集合以order递增排列后，返回指定order之间的元素。
     * min和max可以是-inf和+inf　表示最大值，最小值
     * @param string $key
     * @param int $start
     * @param int $end
     * @package array $option 参数
     *     withscores=>true，表示数组下标为Order值，默认返回索引数组
     *     limit=>array(0,1) 表示从0开始，取一条记录。
     * @return array|bool
     */
    public function zRangeByScore($key, $start = '-inf', $end = "+inf", $option = array())
    {
        return $this->redis->zRangeByScore($key, $start, $end, $option);
    }

    /**
     * 集合以order递减排列后，返回指定order之间的元素。
     * min和max可以是-inf和+inf　表示最大值，最小值
     * @param string $key
     * @param int $start
     * @param int $end
     * @package array $option 参数
     *     withscores=>true，表示数组下标为Order值，默认返回索引数组
     *     limit=>array(0,1) 表示从0开始，取一条记录。
     * @return array|bool
     */
    public function zRevRangeByScore($key, $start = '-inf', $end = "+inf", $option = array())
    {
        return $this->redis->zRevRangeByScore($key, $start, $end, $option);
    }

    /**
     * 返回order值在start end之间的数量
     * @param unknown $key
     * @param unknown $start
     * @param unknown $end
     */
    public function zCount($key, $start, $end)
    {
        return $this->redis->zCount($key, $start, $end);
    }

    /**
     * 返回值为value的order值
     * @param unknown $key
     * @param unknown $value
     */
    public function zScore($key, $value)
    {
        return $this->redis->zScore($key, $value);
    }

    /**
     * 返回集合以score递增加排序后，指定成员的排序号，从0开始。
     * @param unknown $key
     * @param unknown $value
     */
    public function zRank($key, $value)
    {
        return $this->redis->zRank($key, $value);
    }

    /**
     * 返回集合以score递增加排序后，指定成员的排序号，从0开始。
     * @param unknown $key
     * @param unknown $value
     */
    public function zRevRank($key, $value)
    {
        return $this->redis->zRevRank($key, $value);
    }

    /**
     * 删除集合中，score值在start end之间的元素　包括start end
     * min和max可以是-inf和+inf　表示最大值，最小值
     * @param unknown $key
     * @param unknown $start
     * @param unknown $end
     * @return 删除成员的数量。
     */
    public function zRemRangeByScore($key, $start, $end)
    {
        return $this->redis->zRemRangeByScore($key, $start, $end);
    }

    /**
     * 返回集合元素个数。
     * @param unknown $key
     */
    public function zCard($key)
    {
        return $this->redis->zCard($key);
    }


    /*********************************** 队列操作命令 *************************************/

    /**
     * 在队列尾部插入一个元素
     * @param unknown $key
     * @param unknown $value
     * 返回队列长度
     */
    public function rPush($key, $value)
    {
        return $this->redis->rPush($key, $value);
    }

    /**
     * 在队列尾部插入一个元素 如果key不存在，什么也不做
     * @param unknown $key
     * @param unknown $value
     * 返回队列长度
     */
    public function rPushx($key, $value)
    {
        return $this->redis->rPushx($key, $value);
    }

    /**
     * 在队列头部插入一个元素
     * @param unknown $key
     * @param unknown $value
     * 返回队列长度
     */
    public function lPush($key, $value)
    {
        return $this->redis->lPush($key, $value);
    }

    /**
     * 在队列头插入一个元素 如果key不存在，什么也不做
     * @param unknown $key
     * @param unknown $value
     * 返回队列长度
     */
    public function lPushx($key, $value)
    {
        return $this->redis->lPushx($key, $value);
    }

    /**
     * 返回队列长度
     * @param unknown $key
     */
    public function lLen($key)
    {
        return $this->redis->lLen($key);
    }

    /**
     * 返回队列指定区间的元素
     * @param unknown $key
     * @param unknown $start
     * @param unknown $end
     */
    public function lRange($key, $start, $end)
    {
        return $this->redis->lrange($key, $start, $end);
    }

    /**
     * 返回队列中指定索引的元素
     * @param unknown $key
     * @param unknown $index
     */
    public function lIndex($key, $index)
    {
        return $this->redis->lIndex($key, $index);
    }

    /**
     * 设定队列中指定index的值。
     * @param unknown $key
     * @param unknown $index
     * @param unknown $value
     */
    public function lSet($key, $index, $value)
    {
        return $this->redis->lSet($key, $index, $value);
    }

    /**
     * 删除值为vaule的count个元素
     * PHP-REDIS扩展的数据顺序与命令的顺序不太一样，不知道是不是bug
     * count>0 从尾部开始
     *  >0　从头部开始
     *  =0　删除全部
     * @param unknown $key
     * @param unknown $count
     * @param unknown $value
     */
    public function lRem($key, $count, $value)
    {
        return $this->redis->lRem($key, $value, $count);
    }

    /**
     * 删除并返回队列中的头元素。
     * @param unknown $key
     */
    public function lPop($key)
    {
        return $this->redis->lPop($key);
    }

    /**
     * 删除并返回队列中的尾元素
     * @param unknown $key
     */
    public function rPop($key)
    {
        return $this->redis->rPop($key);
    }

    /***************************** redis字符串操作命令 ***************************************************/

    /**
     * 设置一个key
     * @param unknown $key
     * @param unknown $value
     */
    public function set($key, $value)
    {
        return $this->redis->set($key, $value);
    }

    /**
     * 得到一个key
     * @param unknown $key
     */
    public function get($key)
    {
        return $this->redis->get($key);
    }

    /**
     * 设置一个有过期时间的key
     * @param unknown $key
     * @param unknown $expire
     * @param unknown $value
     */
    public function setex($key, $expire, $value)
    {
        return $this->redis->setex($key, $expire, $value);
    }


    /**
     * 设置一个key,如果key存在,不做任何操作.
     * @param unknown $key
     * @param unknown $value
     */
    public function setnx($key, $value)
    {
        return $this->redis->setnx($key, $value);
    }

    /**
     * 批量设置key
     * @param unknown $arr
     */
    public function mset($arr)
    {
        return $this->redis->mset($arr);
    }

    /******************************* redis　无序集合操作命令 *****************************/

    /**
     * 返回集合中所有元素
     * @param unknown $key
     */
    public function sMembers($key)
    {
        return $this->redis->sMembers($key);
    }

    /**
     * 求2个集合的差集
     * @param unknown $key1
     * @param unknown $key2
     */
    public function sDiff($key1, $key2)
    {
        return $this->redis->sDiff($key1, $key2);
    }

    /**
     * 添加集合。由于版本问题，扩展不支持批量添加。这里做了封装
     * @param unknown $key
     * @param string|array $value
     */
    public function sAdd($key, $value)
    {
        if (!is_array($value))
            $arr = array($value);
        else
            $arr = $value;
        foreach ($arr as $row)
            $this->redis->sAdd($key, $row);
    }

    /**
     * 返回无序集合的元素个数
     * @param unknown $key
     */
    public function scard($key)
    {
        return $this->redis->scard($key);
    }

    /**
     * 从集合中删除一个元素
     * @param unknown $key
     * @param unknown $value
     */
    public function srem($key, $value)
    {
        return $this->redis->srem($key, $value);
    }

    /************************************* redis管理操作命令 *****************************************/

    /**
     * 选择数据库
     * @param int $dbId 数据库ID号
     * @return bool
     */
    public function select($dbId)
    {
        $this->dbId = $dbId;
        return $this->redis->select($dbId);
    }

    /**
     * 清空当前数据库
     * @return bool
     */
    public function flushDB()
    {
        return $this->redis->flushDB();
    }

    /**
     * 返回当前库状态
     * @return array
     */
    public function info()
    {
        return $this->redis->info();
    }

    /**
     * 同步保存数据到磁盘
     */
    public function save()
    {
        return $this->redis->save();
    }

    /**
     * 异步保存数据到磁盘
     */
    public function bgSave()
    {
        return $this->redis->bgSave();
    }

    /**
     * 返回最后保存到磁盘的时间
     */
    public function lastSave()
    {
        return $this->redis->lastSave();
    }

    /**
     * 返回key,支持*多个字符，?一个字符
     * 只有*　表示全部
     * @param string $key
     * @return array
     */
    public function keys($key)
    {
        return $this->redis->keys($key);
    }

    /**
     * 删除指定key
     * @param unknown $key
     */
    public function del($key)
    {
        return $this->redis->del($key);
    }

    /**
     * 判断一个key值是不是存在
     * @param unknown $key
     */
    public function exists($key)
    {
        return $this->redis->exists($key);
    }

    /**
     * 为一个key设定过期时间 单位为秒
     * @param unknown $key
     * @param unknown $expire
     */
    public function expire($key, $expire)
    {
        return $this->redis->expire($key, $expire);
    }

    /**
     * 返回一个key还有多久过期，单位秒
     * @param unknown $key
     */
    public function ttl($key)
    {
        return $this->redis->ttl($key);
    }

    /**
     * 设定一个key什么时候过期，time为一个时间戳
     * @param unknown $key
     * @param unknown $time
     */
    public function exprieAt($key, $time)
    {
        return $this->redis->expireAt($key, $time);
    }

    /**
     * 关闭服务器链接
     */
    public function close()
    {
        return $this->redis->close();
    }

    /**
     * 关闭所有连接
     */
    public static function closeAll()
    {
        foreach (static::$_instance as $o) {
            if ($o instanceof self)
                $o->close();
        }
    }

    /** 这里不关闭连接，因为session写入会在所有对象销毁之后。
     * public function __destruct()
     * {
     * return $this->redis->close();
     * }
     **/
    /**
     * 返回当前数据库key数量
     */
    public function dbSize()
    {
        return $this->redis->dbSize();
    }

    /**
     * 返回一个随机key
     */
    public function randomKey()
    {
        return $this->redis->randomKey();
    }

    /**
     * 得到当前数据库ID
     * @return int
     */
    public function getDbId()
    {
        return $this->dbId;
    }

    /**
     * 返回当前密码
     */
    public function getAuth()
    {
        return $this->auth;
    }

    public function getHost()
    {
        return $this->host;
    }

    public function getPort()
    {
        return $this->port;
    }

    public function getConnInfo()
    {
        return array(
            'host' => $this->host,
            'port' => $this->port,
            'auth' => $this->auth
        );
    }


    /********************************************* 事务的相关方法 ************************************************/

    /**
     * 监控key,就是一个或多个key添加一个乐观锁
     * 在此期间如果key的值如果发生的改变，刚不能为key设定值
     * 可以重新取得Key的值。
     * @param unknown $key
     */
    public function watch($key)
    {
        return $this->redis->watch($key);
    }

    /**
     * 取消当前链接对所有key的watch
     *  EXEC 命令或 DISCARD 命令先被执行了的话，那么就不需要再执行 UNWATCH 了
     */
    public function unwatch()
    {
        return $this->redis->unwatch();
    }

    /**
     * 开启一个事务
     * 事务的调用有两种模式Redis::MULTI和Redis::PIPELINE，
     * 默认是Redis::MULTI模式，
     * Redis::PIPELINE管道模式速度更快，但没有任何保证原子性有可能造成数据的丢失
     */
    public function multi($type = \Redis::MULTI)
    {
        return $this->redis->multi($type);
    }

    /**
     * 执行一个事务
     * 收到 EXEC 命令后进入事务执行，事务中任意命令执行失败，其余的命令依然被执行
     */
    public function exec()
    {
        return $this->redis->exec();
    }

    /**
     * 回滚一个事务
     */
    public function discard()
    {
        return $this->redis->discard();
    }

    /**
     * 测试当前链接是不是已经失效
     * 没有失效返回+PONG
     * 失效返回false
     */
    public function ping()
    {
        return $this->redis->ping();
    }

    public function auth($auth)
    {
        return $this->redis->auth($auth);
    }

    /********************************* 自定义的方法,用于简化操作 ************************************/

    /**
     * 得到一组的ID号
     * @param unknown $prefix
     * @param unknown $ids
     */
    public function hashAll($prefix, $ids)
    {
        if ($ids == false)
            return false;
        if (is_string($ids))
            $ids = explode(',', $ids);
        $arr = array();
        foreach ($ids as $id) {
            $key = $prefix . '.' . $id;
            $res = $this->hGetAll($key);
            if ($res != false)
                $arr[] = $res;
        }

        return $arr;
    }

    /**
     * 生成一条消息，放在redis数据库中。使用0号库。
     * @param string|array $msg
     */
    public function pushMessage($lkey, $msg)
    {
        if (is_array($msg)) {
            $msg = json_encode($msg);
        }
        $key = md5($msg);

        //如果消息已经存在，删除旧消息，已当前消息为准
        //echo $n=$this->lRem($lkey, 0, $key)."\n";
        //重新设置新消息
        $this->lPush($lkey, $key);
        $this->setex($key, 3600, $msg);
        return $key;
    }


    /**
     * 得到条批量删除key的命令
     * @param unknown $keys
     * @param unknown $dbId
     */
    public function delKeys($keys, $dbId)
    {
        $redisInfo = $this->getConnInfo();
        $cmdArr = array(
            'redis-cli',
            '-a',
            $redisInfo['auth'],
            '-h',
            $redisInfo['host'],
            '-p',
            $redisInfo['port'],
            '-n',
            $dbId,
        );
        $redisStr = implode(' ', $cmdArr);
        $cmd = "{$redisStr} KEYS \"{$keys}\" | xargs {$redisStr} del";
        return $cmd;
    }
}