当前位置:首页 > PHP教程 > php高级应用 > 列表

PHP实现的Redis操作通用类示例

发布:smiling 来源: PHP粉丝网  添加日期:2021-10-05 13:53:37 浏览: 评论:0 

这篇文章主要介绍了PHP实现的Redis操作通用类,结合实例形式分析了php实现的redis连接、队列、集合、hash表、事务等相关操作封装技巧,需要的朋友可以参考下。

本文实例讲述了PHP实现的Redis操作通用类,分享给大家供大家参考,具体如下:

找到一个比较全的Redis PHP操作类库,分享给大家

  1. <?php 
  2. /** 
  3.  * redis操作类 
  4.  * 说明,任何为false的串,存在redis中都是空串。 
  5.  * 只有在key不存在时,才会返回false。 
  6.  * 这点可用于防止缓存穿透 
  7.  * 
  8.  */ 
  9. class Redis 
  10.   private $redis
  11.   //当前数据库ID号 
  12.   protected $dbId=0; 
  13.   //当前权限认证码 
  14.   protected $auth
  15.   /** 
  16.    * 实例化的对象,单例模式. 
  17.    * @var \iphp\db\Redis 
  18.    */ 
  19.   static private $_instance=array(); 
  20.   private $k
  21.   //连接属性数组 
  22.   protected $attr=array
  23.     //连接超时时间,redis配置文件中默认为300秒 
  24.     'timeout'=>30, 
  25.     //选择的数据库。 
  26.     'db_id'=>0, 
  27.   ); 
  28.   //什么时候重新建立连接 
  29.   protected $expireTime
  30.   protected $host
  31.   protected $port
  32.   private function __construct($config,$attr=array()) 
  33.   { 
  34.     $this->attr    =  array_merge($this->attr,$attr); 
  35.     $this->redis  =  new Redis(); 
  36.     $this->port    =  $config['port'] ? $config['port'] : 6379; 
  37.     $this->host    =  $config['host']; 
  38.     $this->redis->connect($this->host, $this->port, $this->attr['timeout']); 
  39.     if($config['auth']) 
  40.     { 
  41.       $this->auth($config['auth']); 
  42.       $this->auth  =  $config['auth']; 
  43.     } 
  44.     $this->expireTime  =  time() + $this->attr['timeout']; 
  45.   } 
  46.   /** 
  47.    * 得到实例化的对象. 
  48.    * 为每个数据库建立一个连接 
  49.    * 如果连接超时,将会重新建立一个连接 
  50.    * @param array $config 
  51.    * @param int $dbId 
  52.    * @return \iphp\db\Redis 
  53.    */ 
  54.   public static function getInstance($config$attr = array()) 
  55.   { 
  56.     //如果是一个字符串,将其认为是数据库的ID号。以简化写法。 
  57.     if(!is_array($attr)) 
  58.     { 
  59.       $dbId  =  $attr
  60.       $attr  =  array(); 
  61.       $attr['db_id']  =  $dbId
  62.     } 
  63.     $attr['db_id']  =  $attr['db_id'] ? $attr['db_id'] : 0; 
  64.     $k  =  md5(implode(''$config).$attr['db_id']); 
  65.     if(! (static::$_instance[$k] instanceof self)) 
  66.     { 
  67.       static::$_instance[$k] = new self($config,$attr); 
  68.       static::$_instance[$k]->k    =  $k
  69.       static::$_instance[$k]->dbId  =  $attr['db_id']; 
  70.       //如果不是0号库,选择一下数据库。 
  71.       if($attr['db_id'] != 0){ 
  72.         static::$_instance[$k]->select($attr['db_id']); 
  73.       } 
  74.     } 
  75.     elseif( time() > static::$_instance[$k]->expireTime) 
  76.     { 
  77.       static::$_instance[$k]->close(); 
  78.       static::$_instance[$k]     =   new self($config,$attr); 
  79.       static::$_instance[$k]->k  =  $k
  80.       static::$_instance[$k]->dbId=  $attr['db_id']; 
  81.       //如果不是0号库,选择一下数据库。 
  82.       if($attr['db_id']!=0){ 
  83.         static::$_instance[$k]->select($attr['db_id']); 
  84.       } 
  85.     } 
  86.     return static::$_instance[$k]; 
  87.   } 
  88.   private function __clone(){} 
  89.   /** 
  90.    * 执行原生的redis操作 
  91.    * @return \Redis 
  92.    */ 
  93.   public function getRedis() 
  94.   { 
  95.     return $this->redis; 
  96.   } 
  97.   /*****************hash表操作函数*******************/ 
  98.   /** 
  99.    * 得到hash表中一个字段的值 
  100.    * @param string $key 缓存key 
  101.    * @param string $field 字段 
  102.    * @return string|false 
  103.    */ 
  104.   public function hGet($key,$field
  105.   { 
  106.     return $this->redis->hGet($key,$field); 
  107.   } 
  108.   /** 
  109.    * 为hash表设定一个字段的值 
  110.    * @param string $key 缓存key 
  111.    * @param string $field 字段 
  112.    * @param string $value 值。 
  113.    * @return bool  
  114.    */ 
  115.   public function hSet($key,$field,$value
  116.   { 
  117.     return $this->redis->hSet($key,$field,$value); 
  118.   } 
  119.   /** 
  120.    * 判断hash表中,指定field是不是存在 
  121.    * @param string $key 缓存key 
  122.    * @param string $field 字段 
  123.    * @return bool 
  124.    */ 
  125.   public function hExists($key,$field
  126.   { 
  127.     return $this->redis->hExists($key,$field); 
  128.   } 
  129.   /** 
  130.    * 删除hash表中指定字段 ,支持批量删除 
  131.    * @param string $key 缓存key 
  132.    * @param string $field 字段 
  133.    * @return int 
  134.    */ 
  135.   public function hdel($key,$field
  136.   { 
  137.     $fieldArr=explode(',',$field); 
  138.     $delNum=0; 
  139.     foreach($fieldArr as $row
  140.     { 
  141.       $row=trim($row); 
  142.       $delNum+=$this->redis->hDel($key,$row); 
  143.     } 
  144.     return $delNum
  145.   } 
  146.   /** 
  147.    * 返回hash表元素个数 
  148.    * @param string $key 缓存key 
  149.    * @return int|bool 
  150.    */ 
  151.   public function hLen($key
  152.   { 
  153.     return $this->redis->hLen($key); 
  154.   } 
  155.   /** 
  156.    * 为hash表设定一个字段的值,如果字段存在,返回false 
  157.    * @param string $key 缓存key 
  158.    * @param string $field 字段 
  159.    * @param string $value 值。 
  160.    * @return bool 
  161.    */ 
  162.   public function hSetNx($key,$field,$value
  163.   { 
  164.     return $this->redis->hSetNx($key,$field,$value); 
  165.   } 
  166.   /** 
  167.    * 为hash表多个字段设定值。 
  168.    * @param string $key 
  169.    * @param array $value 
  170.    * @return array|bool 
  171.    */ 
  172.   public function hMset($key,$value
  173.   { 
  174.     if(!is_array($value)) 
  175.       return false; 
  176.     return $this->redis->hMset($key,$value);  
  177.   } 
  178.   /** 
  179.    * 为hash表多个字段设定值。 
  180.    * @param string $key 
  181.    * @param array|string $value string以','号分隔字段 
  182.    * @return array|bool 
  183.    */ 
  184.   public function hMget($key,$field
  185.   { 
  186.     if(!is_array($field)) 
  187.       $field=explode(','$field); 
  188.     return $this->redis->hMget($key,$field); 
  189.   } 
  190.   /** 
  191.    * 为hash表设这累加,可以负数 
  192.    * @param string $key 
  193.    * @param int $field 
  194.    * @param string $value 
  195.    * @return bool 
  196.    */ 
  197.   public function hIncrBy($key,$field,$value
  198.   { 
  199.     $value=intval($value); 
  200.     return $this->redis->hIncrBy($key,$field,$value); 
  201.   } 
  202.   /** 
  203.    * 返回所有hash表的所有字段 
  204.    * @param string $key 
  205.    * @return array|bool 
  206.    */ 
  207.   public function hKeys($key
  208.   { 
  209.     return $this->redis->hKeys($key); 
  210.   } 
  211.   /** 
  212.    * 返回所有hash表的字段值,为一个索引数组 
  213.    * @param string $key 
  214.    * @return array|bool 
  215.    */ 
  216.   public function hVals($key
  217.   { 
  218.     return $this->redis->hVals($key); 
  219.   } 
  220.   /** 
  221.    * 返回所有hash表的字段值,为一个关联数组 
  222.    * @param string $key 
  223.    * @return array|bool 
  224.    */ 
  225.   public function hGetAll($key
  226.   { 
  227.     return $this->redis->hGetAll($key); 
  228.   } 
  229.   /*********************有序集合操作*********************/ 
  230.   /** 
  231.    * 给当前集合添加一个元素 
  232.    * 如果value已经存在,会更新order的值。 
  233.    * @param string $key 
  234.    * @param string $order 序号 
  235.    * @param string $value 值 
  236.    * @return bool 
  237.    */ 
  238.   public function zAdd($key,$order,$value
  239.   { 
  240.     return $this->redis->zAdd($key,$order,$value);   
  241.   } 
  242.   /** 
  243.    * 给$value成员的order值,增加$num,可以为负数 
  244.    * @param string $key 
  245.    * @param string $num 序号 
  246.    * @param string $value 值 
  247.    * @return 返回新的order 
  248.    */ 
  249.   public function zinCry($key,$num,$value
  250.   { 
  251.     return $this->redis->zinCry($key,$num,$value); 
  252.   } 
  253.   /** 
  254.    * 删除值为value的元素 
  255.    * @param string $key 
  256.    * @param stirng $value 
  257.    * @return bool 
  258.    */ 
  259.   public function zRem($key,$value
  260.   { 
  261.     return $this->redis->zRem($key,$value); 
  262.   } 
  263.   /** 
  264.    * 集合以order递增排列后,0表示第一个元素,-1表示最后一个元素 
  265.    * @param string $key 
  266.    * @param int $start 
  267.    * @param int $end 
  268.    * @return array|bool 
  269.    */ 
  270.   public function zRange($key,$start,$end
  271.   { 
  272.     return $this->redis->zRange($key,$start,$end); 
  273.   } 
  274.   /** 
  275.    * 集合以order递减排列后,0表示第一个元素,-1表示最后一个元素 
  276.    * @param string $key 
  277.    * @param int $start 
  278.    * @param int $end 
  279.    * @return array|bool 
  280.    */ 
  281.   public function zRevRange($key,$start,$end
  282.   { 
  283.     return $this->redis->zRevRange($key,$start,$end); 
  284.   } 
  285.   /** 
  286.    * 集合以order递增排列后,返回指定order之间的元素。 
  287.    * min和max可以是-inf和+inf 表示最大值,最小值 
  288.    * @param string $key 
  289.    * @param int $start 
  290.    * @param int $end 
  291.    * @package array $option 参数 
  292.    *   withscores=>true,表示数组下标为Order值,默认返回索引数组 
  293.    *   limit=>array(0,1) 表示从0开始,取一条记录。 
  294.    * @return array|bool 
  295.    */ 
  296.   public function zRangeByScore($key,$start='-inf',$end="+inf",$option=array()) 
  297.   { 
  298.     return $this->redis->zRangeByScore($key,$start,$end,$option); 
  299.   } 
  300.   /** 
  301.    * 集合以order递减排列后,返回指定order之间的元素。 
  302.    * min和max可以是-inf和+inf 表示最大值,最小值 
  303.    * @param string $key 
  304.    * @param int $start 
  305.    * @param int $end 
  306.    * @package array $option 参数 
  307.    *   withscores=>true,表示数组下标为Order值,默认返回索引数组 
  308.    *   limit=>array(0,1) 表示从0开始,取一条记录。 
  309.    * @return array|bool 
  310.    */ 
  311.   public function zRevRangeByScore($key,$start='-inf',$end="+inf",$option=array()) 
  312.   { 
  313.     return $this->redis->zRevRangeByScore($key,$start,$end,$option); 
  314.   } 
  315.   /** 
  316.    * 返回order值在start end之间的数量 
  317.    * @param unknown $key 
  318.    * @param unknown $start 
  319.    * @param unknown $end 
  320.    */ 
  321.   public function zCount($key,$start,$end
  322.   { 
  323.     return $this->redis->zCount($key,$start,$end); 
  324.   } 
  325.   /** 
  326.    * 返回值为value的order值 
  327.    * @param unknown $key 
  328.    * @param unknown $value 
  329.    */ 
  330.   public function zScore($key,$value
  331.   { 
  332.     return $this->redis->zScore($key,$value); 
  333.   } 
  334.   /** 
  335.    * 返回集合以score递增加排序后,指定成员的排序号,从0开始。 
  336.    * @param unknown $key 
  337.    * @param unknown $value 
  338.    */ 
  339.   public function zRank($key,$value
  340.   { 
  341.     return $this->redis->zRank($key,$value); 
  342.   } 
  343.   /** 
  344.    * 返回集合以score递增加排序后,指定成员的排序号,从0开始。 
  345.    * @param unknown $key 
  346.    * @param unknown $value 
  347.    */ 
  348.   public function zRevRank($key,$value
  349.   { 
  350.     return $this->redis->zRevRank($key,$value); 
  351.   } 
  352.   /** 
  353.    * 删除集合中,score值在start end之间的元素 包括start end 
  354.    * min和max可以是-inf和+inf 表示最大值,最小值 
  355.    * @param unknown $key 
  356.    * @param unknown $start 
  357.    * @param unknown $end 
  358.    * @return 删除成员的数量。 
  359.    */ 
  360.   public function zRemRangeByScore($key,$start,$end
  361.   { 
  362.     return $this->redis->zRemRangeByScore($key,$start,$end); 
  363.   } 
  364.   /** 
  365.    * 返回集合元素个数。 
  366.    * @param unknown $key 
  367.    */ 
  368.   public function zCard($key
  369.   { 
  370.     return $this->redis->zCard($key); 
  371.   } 
  372.   /*********************队列操作命令************************/ 
  373.   /** 
  374.    * 在队列尾部插入一个元素 
  375.    * @param unknown $key 
  376.    * @param unknown $value 
  377.    * 返回队列长度 
  378.    */ 
  379.   public function rPush($key,$value
  380.   { 
  381.     return $this->redis->rPush($key,$value);  
  382.   } 
  383.   /** 
  384.    * 在队列尾部插入一个元素 如果key不存在,什么也不做 
  385.    * @param unknown $key 
  386.    * @param unknown $value 
  387.    * 返回队列长度 
  388.    */ 
  389.   public function rPushx($key,$value
  390.   { 
  391.     return $this->redis->rPushx($key,$value); 
  392.   } 
  393.   /** 
  394.    * 在队列头部插入一个元素 
  395.    * @param unknown $key 
  396.    * @param unknown $value 
  397.    * 返回队列长度 
  398.    */ 
  399.   public function lPush($key,$value
  400.   { 
  401.     return $this->redis->lPush($key,$value); 
  402.   } 
  403.   /** 
  404.    * 在队列头插入一个元素 如果key不存在,什么也不做 
  405.    * @param unknown $key 
  406.    * @param unknown $value 
  407.    * 返回队列长度 
  408.    */ 
  409.   public function lPushx($key,$value
  410.   { 
  411.     return $this->redis->lPushx($key,$value); 
  412.   } 
  413.   /** 
  414.    * 返回队列长度 
  415.    * @param unknown $key 
  416.    */ 
  417.   public function lLen($key
  418.   { 
  419.     return $this->redis->lLen($key);  
  420.   } 
  421.   /** 
  422.    * 返回队列指定区间的元素 
  423.    * @param unknown $key 
  424.    * @param unknown $start 
  425.    * @param unknown $end 
  426.    */ 
  427.   public function lRange($key,$start,$end
  428.   { 
  429.     return $this->redis->lrange($key,$start,$end); 
  430.   } 
  431.   /** 
  432.    * 返回队列中指定索引的元素 
  433.    * @param unknown $key 
  434.    * @param unknown $index 
  435.    */ 
  436.   public function lIndex($key,$index
  437.   { 
  438.     return $this->redis->lIndex($key,$index); 
  439.   } 
  440.   /** 
  441.    * 设定队列中指定index的值。 
  442.    * @param unknown $key 
  443.    * @param unknown $index 
  444.    * @param unknown $value 
  445.    */ 
  446.   public function lSet($key,$index,$value
  447.   { 
  448.     return $this->redis->lSet($key,$index,$value); 
  449.   } 
  450.   /** 
  451.    * 删除值为vaule的count个元素 
  452.    * PHP-REDIS扩展的数据顺序与命令的顺序不太一样,不知道是不是bug 
  453.    * count>0 从尾部开始 
  454.    * >0 从头部开始 
  455.    * =0 删除全部 
  456.    * @param unknown $key 
  457.    * @param unknown $count 
  458.    * @param unknown $value 
  459.    */ 
  460.   public function lRem($key,$count,$value
  461.   { 
  462.     return $this->redis->lRem($key,$value,$count); 
  463.   } 
  464.   /** 
  465.    * 删除并返回队列中的头元素。 
  466.    * @param unknown $key 
  467.    */ 
  468.   public function lPop($key
  469.   { 
  470.     return $this->redis->lPop($key); 
  471.   } 
  472.   /** 
  473.    * 删除并返回队列中的尾元素 
  474.    * @param unknown $key 
  475.    */ 
  476.   public function rPop($key
  477.   { 
  478.     return $this->redis->rPop($key); 
  479.   } 
  480.   /*************redis字符串操作命令*****************/ 
  481.   /** 
  482.    * 设置一个key 
  483.    * @param unknown $key 
  484.    * @param unknown $value 
  485.    */ 
  486.   public function set($key,$value
  487.   { 
  488.     return $this->redis->set($key,$value); 
  489.   } 
  490.   /** 
  491.    * 得到一个key 
  492.    * @param unknown $key 
  493.    */ 
  494.   public function get($key
  495.   { 
  496.     return $this->redis->get($key); 
  497.   } 
  498.   /** 
  499.    * 设置一个有过期时间的key 
  500.    * @param unknown $key 
  501.    * @param unknown $expire 
  502.    * @param unknown $value 
  503.    */ 
  504.   public function setex($key,$expire,$value
  505.   { 
  506.     return $this->redis->setex($key,$expire,$value); 
  507.   } 
  508.   /** 
  509.    * 设置一个key,如果key存在,不做任何操作. 
  510.    * @param unknown $key 
  511.    * @param unknown $value 
  512.    */ 
  513.   public function setnx($key,$value
  514.   { 
  515.     return $this->redis->setnx($key,$value); 
  516.   } 
  517.   /** 
  518.    * 批量设置key 
  519.    * @param unknown $arr 
  520.    */ 
  521.   public function mset($arr
  522.   { 
  523.     return $this->redis->mset($arr); 
  524.   } 
  525.   /*************redis 无序集合操作命令*****************/ 
  526.   /** 
  527.    * 返回集合中所有元素 
  528.    * @param unknown $key 
  529.    */ 
  530.   public function sMembers($key
  531.   { 
  532.     return $this->redis->sMembers($key); 
  533.   } 
  534.   /** 
  535.    * 求2个集合的差集 
  536.    * @param unknown $key1 
  537.    * @param unknown $key2 
  538.    */ 
  539.   public function sDiff($key1,$key2
  540.   { 
  541.     return $this->redis->sDiff($key1,$key2); 
  542.   } 
  543.   /** 
  544.    * 添加集合。由于版本问题,扩展不支持批量添加。这里做了封装 
  545.    * @param unknown $key 
  546.    * @param string|array $value 
  547.    */ 
  548.   public function sAdd($key,$value
  549.   { 
  550.     if(!is_array($value)) 
  551.       $arr=array($value); 
  552.     else 
  553.       $arr=$value
  554.     foreach($arr as $row
  555.       $this->redis->sAdd($key,$row); 
  556.   } 
  557.   /** 
  558.    * 返回无序集合的元素个数 
  559.    * @param unknown $key 
  560.    */ 
  561.   public function scard($key
  562.   { 
  563.     return $this->redis->scard($key); 
  564.   } 
  565.   /** 
  566.    * 从集合中删除一个元素 
  567.    * @param unknown $key 
  568.    * @param unknown $value 
  569.    */ 
  570.   public function srem($key,$value
  571.   { 
  572.     return $this->redis->srem($key,$value); 
  573.   } 
  574.   /*************redis管理操作命令*****************/ 
  575.   /** 
  576.    * 选择数据库 
  577.    * @param int $dbId 数据库ID号 
  578.    * @return bool 
  579.    */ 
  580.   public function select($dbId
  581.   { 
  582.     $this->dbId=$dbId
  583.     return $this->redis->select($dbId); 
  584.   } 
  585.   /** 
  586.    * 清空当前数据库 
  587.    * @return bool 
  588.    */ 
  589.   public function flushDB() 
  590.   { 
  591.     return $this->redis->flushDB(); 
  592.   } 
  593.   /** 
  594.    * 返回当前库状态 
  595.    * @return array 
  596.    */ 
  597.   public function info() 
  598.   { 
  599.     return $this->redis->info(); 
  600.   } 
  601.   /** 
  602.    * 同步保存数据到磁盘 
  603.    */ 
  604.   public function save() 
  605.   { 
  606.     return $this->redis->save(); 
  607.   } 
  608.   /** 
  609.    * 异步保存数据到磁盘 
  610.    */ 
  611.   public function bgSave() 
  612.   { 
  613.     return $this->redis->bgSave(); 
  614.   } 
  615.   /** 
  616.    * 返回最后保存到磁盘的时间 
  617.    */ 
  618.   public function lastSave() 
  619.   { 
  620.     return $this->redis->lastSave(); 
  621.   } 
  622.   /** 
  623.    * 返回key,支持*多个字符,?一个字符 
  624.    * 只有* 表示全部 
  625.    * @param string $key 
  626.    * @return array 
  627.    */ 
  628.   public function keys($key
  629.   { 
  630.     return $this->redis->keys($key); 
  631.   } 
  632.   /** 
  633.    * 删除指定key 
  634.    * @param unknown $key 
  635.    */ 
  636.   public function del($key
  637.   { 
  638.     return $this->redis->del($key); 
  639.   } 
  640.   /** 
  641.    * 判断一个key值是不是存在 
  642.    * @param unknown $key 
  643.    */ 
  644.   public function exists($key
  645.   { 
  646.     return $this->redis->exists($key); 
  647.   } 
  648.   /** 
  649.    * 为一个key设定过期时间 单位为秒 
  650.    * @param unknown $key 
  651.    * @param unknown $expire 
  652.    */ 
  653.   public function expire($key,$expire
  654.   { 
  655.     return $this->redis->expire($key,$expire); 
  656.   } 
  657.   /** 
  658.    * 返回一个key还有多久过期,单位秒 
  659.    * @param unknown $key 
  660.    */ 
  661.   public function ttl($key
  662.   { 
  663.     return $this->redis->ttl($key); 
  664.   } 
  665.   /** 
  666.    * 设定一个key什么时候过期,time为一个时间戳 
  667.    * @param unknown $key 
  668.    * @param unknown $time 
  669.    */ 
  670.   public function exprieAt($key,$time
  671.   { 
  672.     return $this->redis->expireAt($key,$time); 
  673.   } 
  674.   /** 
  675.    * 关闭服务器链接 
  676.    */ 
  677.   public function close() 
  678.   { 
  679.     return $this->redis->close(); 
  680.   } 
  681.   /** 
  682.    * 关闭所有连接 
  683.    */ 
  684.   public static function closeAll() 
  685.   { 
  686.     foreach(static::$_instance as $o
  687.     { 
  688.       if($o instanceof self) 
  689.         $o->close(); 
  690.     } 
  691.   } 
  692.   /** 这里不关闭连接,因为session写入会在所有对象销毁之后。 
  693.   public function __destruct() 
  694.   { 
  695.     return $this->redis->close(); 
  696.   } 
  697.   **/ 
  698.   /** 
  699.    * 返回当前数据库key数量 
  700.    */ 
  701.   public function dbSize() 
  702.   { 
  703.     return $this->redis->dbSize(); 
  704.   } 
  705.   /** 
  706.    * 返回一个随机key 
  707.    */ 
  708.   public function randomKey() 
  709.   { 
  710.     return $this->redis->randomKey(); 
  711.   } 
  712.   /** 
  713.    * 得到当前数据库ID 
  714.    * @return int 
  715.    */ 
  716.   public function getDbId() 
  717.   { 
  718.     return $this->dbId; 
  719.   } 
  720.   /** 
  721.    * 返回当前密码 
  722.    */ 
  723.   public function getAuth() 
  724.   { 
  725.     return $this->auth; 
  726.   } 
  727.   public function getHost() 
  728.   { 
  729.     return $this->host; 
  730.   } 
  731.   public function getPort() 
  732.   { 
  733.     return $this->port; 
  734.   } 
  735.   public function getConnInfo() 
  736.   { 
  737.     return array
  738.       'host'=>$this->host, 
  739.       'port'=>$this->port, 
  740.       'auth'=>$this->auth 
  741.     ); 
  742.   } 
  743.   /*********************事务的相关方法************************/ 
  744.   /** 
  745.    * 监控key,就是一个或多个key添加一个乐观锁 
  746.    * 在此期间如果key的值如果发生的改变,刚不能为key设定值 
  747.    * 可以重新取得Key的值。 
  748.    * @param unknown $key 
  749.    */ 
  750.   public function watch($key
  751.   { 
  752.     return $this->redis->watch($key); 
  753.   } 
  754.   /** 
  755.    * 取消当前链接对所有key的watch 
  756.    * EXEC 命令或 DISCARD 命令先被执行了的话,那么就不需要再执行 UNWATCH 了 
  757.    */ 
  758.   public function unwatch() 
  759.   { 
  760.     return $this->redis->unwatch(); 
  761.   } 
  762.   /** 
  763.    * 开启一个事务 
  764.    * 事务的调用有两种模式Redis::MULTI和Redis::PIPELINE, 
  765.    * 默认是Redis::MULTI模式, 
  766.    * Redis::PIPELINE管道模式速度更快,但没有任何保证原子性有可能造成数据的丢失 
  767.    */ 
  768.   public function multi($type=\Redis::MULTI) 
  769.   { 
  770.     return $this->redis->multi($type); 
  771.   } 
  772.   /** 
  773.    * 执行一个事务 
  774.    * 收到 EXEC 命令后进入事务执行,事务中任意命令执行失败,其余的命令依然被执行 
  775.    */ 
  776.   public function exec() 
  777.   { 
  778.     return $this->redis->exec(); 
  779.   } 
  780.   /** 
  781.    * 回滚一个事务 
  782.    */ 
  783.   public function discard() 
  784.   { 
  785.     return $this->redis->discard(); 
  786.   } 
  787.   /** 
  788.    * 测试当前链接是不是已经失效 
  789.    * 没有失效返回+PONG 
  790.    * 失效返回false 
  791.    */ 
  792.   public function ping() 
  793.   { 
  794.     return $this->redis->ping(); 
  795.   } 
  796.   public function auth($auth
  797.   { 
  798.     return $this->redis->auth($auth); 
  799.   } 
  800.   /*********************自定义的方法,用于简化操作************************/ 
  801.   /** 
  802.    * 得到一组的ID号 
  803.    * @param unknown $prefix 
  804.    * @param unknown $ids 
  805.    */ 
  806.   public function hashAll($prefix,$ids
  807.   { 
  808.     if($ids==false) 
  809.       return false; 
  810.     if(is_string($ids)) 
  811.       $ids=explode(','$ids); 
  812.     $arr=array(); 
  813.     foreach($ids as $id
  814.     { 
  815.       $key=$prefix.'.'.$id
  816.       $res=$this->hGetAll($key); 
  817.       if($res!=false) 
  818.         $arr[]=$res
  819.     } 
  820.     return $arr
  821.   } 
  822.   /** 
  823.    * 生成一条消息,放在redis数据库中。使用0号库。 
  824.    * @param string|array $msg 
  825.    */ 
  826.   public function pushMessage($lkey,$msg
  827.   { 
  828.     if(is_array($msg)){ 
  829.       $msg  =  json_encode($msg); 
  830.     } 
  831.     $key  =  md5($msg); 
  832.     //如果消息已经存在,删除旧消息,已当前消息为准 
  833.     //echo $n=$this->lRem($lkey, 0, $key)."\n"; 
  834.     //重新设置新消息 
  835.     $this->lPush($lkey$key); 
  836.     $this->setex($key, 3600, $msg); 
  837.     return $key
  838.   } 
  839.   /** 
  840.    * 得到条批量删除key的命令 
  841.    * @param unknown $keys 
  842.    * @param unknown $dbId 
  843.    */ 
  844.   public function delKeys($keys,$dbId
  845.   { 
  846.     $redisInfo=$this->getConnInfo(); 
  847.     $cmdArr=array
  848.       'redis-cli'
  849.       '-a'
  850.       $redisInfo['auth'], 
  851.       '-h'
  852.       $redisInfo['host'], 
  853.       '-p'
  854.       $redisInfo['port'], 
  855.       '-n'
  856.       $dbId
  857.     ); 
  858.     $redisStr=implode(' '$cmdArr); 
  859.     $cmd="{$redisStr} KEYS \"{$keys}\" | xargs {$redisStr} del"
  860.     return $cmd
  861.   } 
  862. }

Tags: Redis通用类

分享到: