PHP operates the class encapsulated by redies

/**
 * Redis operation, supporting Master/Slave load cluster
 *
 * @author jackluo
*/
class RedisCluster{

 // Whether to use the M/S read-write cluster solution
 private $_isUseCluster = false;

 // Slave handle tag
 private $_sn = 0;

 // Server connection handle
 private $_linkHandle = array(
 'master'=>null,// Only supports one Master
 'slave'=>array(),// Yes There are multiple Slave
 );

 /**
 * Constructor
 *
 * @param boolean $isUseCluster Whether to use the M/S scheme
*/
 public function __construct($isUseCluster=false){
 $this->_isUseCluster = $isUseCluster;
 }

 /**
 * Connect to the server, note: long connections are used here to improve efficiency, but will not automatically close
 *
 * @param array $config Redis server configuration
 * @param boolean $isMaster Whether the currently added server is a Master server
 * @ return boolean
* /
 public function connect($config=array('host'=>'127.0.0.1','port'=>6379), $isMaster=true){
 // default port
 if(!isset($ config['port'])){
 $config['port'] = 6379;
 }
 // Set Master connection
 if($isMaster){
 $this->_linkHandle['master'] = new Redis ();
 $ret = $this->_linkHandle['master']->pconnect($config['host'],$config['port']);
 }else{
 // Multiple Slave Connection
 $this->_linkHandle['slave'][$this->_sn] = new Redis();
 $ret = $this->_linkHandle['slave'][$this->_sn] ->pconnect($config['host'],$config['port']);
 ++$this->_sn;
 }
 return $ret;
 }

 /**
 * Close connection
 *
 * @param int $flag Close selection 0: Close Master 1: Close Slave 2: Close all
 * @return boolean
* /
 public function close($flag=2){
 switch($flag){
 // Close Master
 case 0:
 $this->getRedis()->close();
 break;
 // Close Slave
 case 1:
 for($i=0; $i<$this->_sn; ++$i){
 $this->_linkHandle['slave'][$i]->close ();
 }
 break;
 // Close all
 case 1:
 $this->getRedis()->close();
 for($i=0; $i<$this->_sn ; ++$i){
 $this->_linkHandle['slave'][$i]->close();
 }
 break;
 }
 return true;
 }

 /**
 * Get the original Redis object to have more operations
 *
 * @param boolean $isMaster Returns the type of server true: Returns Master false: Returns Slave
 * @param boolean $slaveOne Returns Slave selection true: Load balancing returns randomly A Slave selection false: Return all Slave selections
 * @return redis object
*/
 public function getRedis($isMaster=true,$slaveOne=true){
 // Only return Master
 if($isMaster){
 return $this->_linkHandle['master'];
 }else{
 return $slaveOne ? $this->_getSlaveRedis() : $this->_linkHandle['slave'];
 }
 }

 /**
 * Write cache
 *
 * @param string $key group storage KEY
 * @param string $value cache value
 * @param int $expire expiration time, 0: means no expiration time
*/
 public function set($key, $value , $expire=0){
 // Never timeout
 if($expire == 0){
 $ret = $this->getRedis()->set($key, $value);
 }else {
 $ret = $this->getRedis()->setex($key, $expire, $value);
 }
 return $ret;
 }

 /**
 * Read cache
 *
 * @param string $key Cache KEY, support fetching multiple $keys at one time = array('key1','key2')
 * @return string || boolean Return false on failure, return string on success
*/
 public function get($key){
 // Whether to get multiple values ​​at once
 $func = is_array($key) ? 'mGet' : 'get';
 // No M/S is used
 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);
    }
*/
    /**
 * Conditional form to set the cache. If the key does not exist, it will be set. If it exists, the setting will fail.
 *
 * @param string $key cache KEY
 * @param string $value cache value
 * @return boolean
*/
    public function setnx($key, $value){
        return $this->getRedis()->setnx($key, $value);
    }

    /**
 * Delete cache
 *
 * @param string || array $key cache KEY, supports single key: "key1" or multiple keys: array('key1','key2')
 * @return int deleted key Quantity
*/
    public function remove($key){
        // $key => "key1" || array('key1','key2')
        return $this->getRedis()->delete($key);
    }

    /**
 * Value addition operation, similar to ++$i, if the key does not exist, it is automatically set to 0 and then the addition operation is performed
 *
 * @param string $key Cache KEY
 * @param int $default The default value during operation
 * @return int　Value after operation
*/
    public function incr($key,$default=1){
        if($default == 1){
            return $this->getRedis()->incr($key);
        }else{
            return $this->getRedis()->incrBy($key, $default);
        }
    }

    /**
 * Value subtraction operation, similar to --$i, if the key does not exist, it will be automatically set to 0 and then subtracted.
 *
 * @param string $key Cache KEY
 * @param int $default Default value during operation
 * @return int　Value after operation
*/
    public function decr($key,$default=1){
        if($default == 1){
            return $this->getRedis()->decr($key);
        }else{
            return $this->getRedis()->decrBy($key, $default);
        }
    }

    /**
 * Empty the current database
 *
 * @return boolean
*/
    public function clear(){
        return $this->getRedis()->flushDB();
    }

    /* =================== 以下私有方法 =================== */

    /**
 * Random HASH to get the Redis Slave server handle
 *
 * @return redis object
*/
    private function _getSlaveRedis(){
        // 就一台 Slave 机直接返回
        if($this->_sn <= 1){
            return $this->_linkHandle['slave'][0];
        }
        // 随机 Hash 得到 Slave 的句柄
        $hash = $this->_hashId(mt_rand(), $this->_sn);
        return $this->_linkHandle['slave'][$hash];
    }

    /**
 * Get the value between 0～m-1 after hashing based on ID
 *
 * @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('host'=>'127.0.0.1','port'=>6379));


//*
$cron_id = 10001;
$CRON_KEY = 'CRON_LIST'; //
$PHONE_KEY = 'PHONE_LIST:'.$cron_id;//

//cron info
$cron = $redis->hget($CRON_KEY,$cron_id);
if(empty($cron)){

    $cron = array('id'=>10,'name'=>'jackluo');//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(',','13228191831,18608041585');    //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('id',35);

/*
    $redis->lpush('test','1111');
    $redis->lpush('test','2222');
    $redis->lpush('test','3333');

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

php, redies