>백엔드 개발 >PHP 튜토리얼 >php操作redies封装的类_PHP教程

php操作redies封装的类_PHP教程

WBOY
WBOY원래의
2016-07-13 09:54:51983검색

php操作redies封装的类

 

 

<!--?php
/**
 * Redis 操作,支持 Master/Slave 的负载集群
 *
 * @author jackluo
 */
class RedisCluster{
       
    // 是否使用 M/S 的读写集群方案
    private $_isUseCluster = false;
       
    // Slave 句柄标记
    private $_sn = 0;
       
    // 服务器连接句柄
    private $_linkHandle = array(
        &#39;master&#39;=-->null,// 只支持一台 Master
        &#39;slave&#39;=>array(),// 可以有多台 Slave
    );
       
    /**
     * 构造函数
     *
     * @param boolean $isUseCluster 是否采用 M/S 方案
     */
    public function __construct($isUseCluster=false){
        $this->_isUseCluster = $isUseCluster;
    }
       
    /**
     * 连接服务器,注意:这里使用长连接,提高效率,但不会自动关闭
     *
     * @param array $config Redis服务器配置
     * @param boolean $isMaster 当前添加的服务器是否为 Master 服务器
     * @return boolean
     */
    public function connect($config=array(&#39;host&#39;=>&#39;127.0.0.1&#39;,&#39;port&#39;=>6379), $isMaster=true){
        // default port
        if(!isset($config[&#39;port&#39;])){
            $config[&#39;port&#39;] = 6379;
        }
        // 设置 Master 连接
        if($isMaster){
            $this->_linkHandle[&#39;master&#39;] = new Redis();
            $ret = $this->_linkHandle[&#39;master&#39;]->pconnect($config[&#39;host&#39;],$config[&#39;port&#39;]);
        }else{
            // 多个 Slave 连接
            $this->_linkHandle[&#39;slave&#39;][$this->_sn] = new Redis();
            $ret = $this->_linkHandle[&#39;slave&#39;][$this->_sn]->pconnect($config[&#39;host&#39;],$config[&#39;port&#39;]);
            ++$this->_sn;
        }
        return $ret;
    }
       
    /**
     * 关闭连接
     *
     * @param int $flag 关闭选择 0:关闭 Master 1:关闭 Slave 2:关闭所有
     * @return boolean
     */
    public function close($flag=2){
        switch($flag){
            // 关闭 Master
            case 0:
                $this->getRedis()->close();
            break;
            // 关闭 Slave
            case 1:
                for($i=0; $i<$this->_sn; ++$i){
                    $this->_linkHandle[&#39;slave&#39;][$i]->close();
                }
            break;
            // 关闭所有
            case 1:
                $this->getRedis()->close();
                for($i=0; $i<$this->_sn; ++$i){
                    $this->_linkHandle[&#39;slave&#39;][$i]->close();
                }
            break;
        }
        return true;
    }
       
    /**
     * 得到 Redis 原始对象可以有更多的操作
     *
     * @param boolean $isMaster 返回服务器的类型 true:返回Master false:返回Slave
     * @param boolean $slaveOne 返回的Slave选择 true:负载均衡随机返回一个Slave选择 false:返回所有的Slave选择
     * @return redis object
     */
    public function getRedis($isMaster=true,$slaveOne=true){
        // 只返回 Master
        if($isMaster){
            return $this->_linkHandle[&#39;master&#39;];
        }else{
            return $slaveOne ? $this->_getSlaveRedis() : $this->_linkHandle[&#39;slave&#39;];
        }
    }
       
    /**
     * 写缓存
     *
     * @param string $key 组存KEY
     * @param string $value 缓存值
     * @param int $expire 过期时间, 0:表示无过期时间
     */
    public function set($key, $value, $expire=0){
        // 永不超时
        if($expire == 0){
            $ret = $this->getRedis()->set($key, $value);
        }else{
            $ret = $this->getRedis()->setex($key, $expire, $value);
        }
        return $ret;
    }
       
    /**
     * 读缓存
     *
     * @param string $key 缓存KEY,支持一次取多个 $key = array(&#39;key1&#39;,&#39;key2&#39;)
     * @return string || boolean  失败返回 false, 成功返回字符串
     */
    public function get($key){
        // 是否一次取多个值
        $func = is_array($key) ? &#39;mGet&#39; : &#39;get&#39;;
        // 没有使用M/S
        if(! $this->_isUseCluster){
            return $this->getRedis()->{$func}($key);
        }
        // 使用了 M/S
        return $this->_getSlaveRedis()->{$func}($key);
    }
    
 
/*
    // magic function
    public function __call($name,$arguments){
        return call_user_func($name,$arguments);    
    }
*/
    /**
     * 条件形式设置缓存,如果 key 不存时就设置,存在时设置失败
     *
     * @param string $key 缓存KEY
     * @param string $value 缓存值
     * @return boolean
     */
    public function setnx($key, $value){
        return $this->getRedis()->setnx($key, $value);
    }
       
    /**
     * 删除缓存
     *
     * @param string || array $key 缓存KEY,支持单个健:"key1" 或多个健:array(&#39;key1&#39;,&#39;key2&#39;)
     * @return int 删除的健的数量
     */
    public function remove($key){
        // $key => "key1" || array(&#39;key1&#39;,&#39;key2&#39;)
        return $this->getRedis()->delete($key);
    }
       
    /**
     * 值加加操作,类似 ++$i ,如果 key 不存在时自动设置为 0 后进行加加操作
     *
     * @param string $key 缓存KEY
     * @param int $default 操作时的默认值
     * @return int 操作后的值
     */
    public function incr($key,$default=1){
        if($default == 1){
            return $this->getRedis()->incr($key);
        }else{
            return $this->getRedis()->incrBy($key, $default);
        }
    }
       
    /**
     * 值减减操作,类似 --$i ,如果 key 不存在时自动设置为 0 后进行减减操作
     *
     * @param string $key 缓存KEY
     * @param int $default 操作时的默认值
     * @return int 操作后的值
     */
    public function decr($key,$default=1){
        if($default == 1){
            return $this->getRedis()->decr($key);
        }else{
            return $this->getRedis()->decrBy($key, $default);
        }
    }
       
    /**
     * 添空当前数据库
     *
     * @return boolean
     */
    public function clear(){
        return $this->getRedis()->flushDB();
    }
       
    /* =================== 以下私有方法 =================== */
       
    /**
     * 随机 HASH 得到 Redis Slave 服务器句柄
     *
     * @return redis object
     */
    private function _getSlaveRedis(){
        // 就一台 Slave 机直接返回
        if($this->_sn <= 1){
            return $this->_linkHandle[&#39;slave&#39;][0];
        }
        // 随机 Hash 得到 Slave 的句柄
        $hash = $this->_hashId(mt_rand(), $this->_sn);
        return $this->_linkHandle[&#39;slave&#39;][$hash];
    }
       
    /**
     * 根据ID得到 hash 后 0~m-1 之间的值
     *
     * @param string $id
     * @param int $m
     * @return int
     */
    private function _hashId($id,$m=10)
    {
        //把字符串K转换为 0~m-1 之间的一个值作为对应记录的散列地址
        $k = md5($id);
        $l = strlen($k);
        $b = bin2hex($k);
        $h = 0;
        for($i=0;$i<$l;$i++)
        {
            //相加模式HASH
            $h += substr($b,$i*2,2);
        }
        $hash = ($h*1)%$m;
        return $hash;
    }

    /**
     *    lpush
     */
    public function lpush($key,$value){
        return $this->getRedis()->lpush($key,$value);
    }

    /**
     *    add lpop
     */
    public function lpop($key){
        return $this->getRedis()->lpop($key);
    }
    /**
     * lrange
     */
    public function lrange($key,$start,$end){
        return $this->getRedis()->lrange($key,$start,$end);    
    }

    /**
     *    set hash opeation
     */
    public function hset($name,$key,$value){
        if(is_array($value)){
            return $this->getRedis()->hset($name,$key,serialize($value));    
        }
        return $this->getRedis()->hset($name,$key,$value);
    }
    /**
     *    get hash opeation
     */
    public function hget($name,$key = null,$serialize=true){
        if($key){
            $row = $this->getRedis()->hget($name,$key);
            if($row && $serialize){
                unserialize($row);
            }
            return $row;
        }
        return $this->getRedis()->hgetAll($name);
    }

    /**
     *    delete hash opeation
     */
    public function hdel($name,$key = null){
        if($key){
            return $this->getRedis()->hdel($name,$key);
        }
        return $this->getRedis()->hdel($name);
    }
    /**
     * Transaction start
     */
    public function multi(){
        return $this->getRedis()->multi();    
    }
    /**
     * Transaction send
     */

    public function exec(){
        return $this->getRedis()->exec();    
    }


       
}// End Class
       
// ================= TEST DEMO =================
       
// 只有一台 Redis 的应用
$redis = new RedisCluster();
$redis->connect(array(&#39;host&#39;=>&#39;127.0.0.1&#39;,&#39;port&#39;=>6379));


//*
$cron_id = 10001;
$CRON_KEY = &#39;CRON_LIST&#39;; //
$PHONE_KEY = &#39;PHONE_LIST:&#39;.$cron_id;//

//cron info
$cron = $redis->hget($CRON_KEY,$cron_id);
if(empty($cron)){
    
    $cron = array(&#39;id&#39;=>10,&#39;name&#39;=>&#39;jackluo&#39;);//mysql data
    $redis->hset($CRON_KEY,$cron_id,$cron); // set redis    
}
//phone list
$phone_list = $redis->lrange($PHONE_KEY,0,-1);
print_r($phone_list);
if(empty($phone_list)){
    $phone_list =explode(&#39;,&#39;,&#39;13228191831,18608041585&#39;);    //mysql data
    //join  list
    if($phone_list){
        $redis->multi();
        foreach ($phone_list as $phone) {
            $redis->lpush($PHONE_KEY,$phone);            
        }
        $redis->exec();
    }
}

print_r($phone_list);


/*$list = $redis->hget($cron_list,);

var_dump($list);*/
//*/


//$redis->set(&#39;id&#39;,35);

/*
    $redis->lpush(&#39;test&#39;,&#39;1111&#39;);
    $redis->lpush(&#39;test&#39;,&#39;2222&#39;);
    $redis->lpush(&#39;test&#39;,&#39;3333&#39;);

    $list = $redis->lrange(&#39;test&#39;,0,-1);
    print_r($list);
    $lpop = $redis->lpop(&#39;test&#39;);
    print_r($lpop);
    $lpop = $redis->lpop(&#39;test&#39;);
    print_r($lpop);
    $lpop = $redis->lpop(&#39;test&#39;);
    print_r($lpop);
*/
//    var_dump($redis->get(&#39;id&#39;));


 

www.bkjia.comtruehttp://www.bkjia.com/PHPjc/995651.htmlTechArticlephp操作redies封装的类 null,// 只支持一台 Master slave=array(),// 可以有多台 Slave ); /** * 构造函数 * * @param boolean $isUseCluster 是否采用 M/S 方案 */...
성명:
본 글의 내용은 네티즌들의 자발적인 기여로 작성되었으며, 저작권은 원저작자에게 있습니다. 본 사이트는 이에 상응하는 법적 책임을 지지 않습니다. 표절이나 침해가 의심되는 콘텐츠를 발견한 경우 admin@php.cn으로 문의하세요.