php封装redis负载均衡类

 $array = array(
      'master' => array(
          "redis://127.0.0.1:6379?timeout=1",
      ),
      'slave'  => array(
          "redis://127.0.0.1:6479?timeout=1",
          "redis://127.0.0.1:6579?timeout=1",
      )
  );

 $redis = RedisServer::instance($array);
 $redis->set("aaaa","aaaa") //将会把数据缓存到.127.0.0.1:6379中
 $redis->get("aaaa")//将会用127.0.0.1:6479或者127.0.0.1:6579中读取.从而实现读写分离

 <?php

 /**
  *  redis负载均衡
  *
  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  *
  * $array = array(
  *      'master' => array(
  *          "redis://127.0.0.1:6379?timeout=1",
  *      ),
  *      'slave'  => array(
  *          "redis://127.0.0.1:6479?timeout=1",
  *          "redis://127.0.0.1:6579?timeout=1",
  *      )
  *  );
  *
  * $redis = RedisServer::instance($array);
  * $redis->set("aaaa","aaaa") //将会把数据缓存到.127.0.0.1:6379中
  * $redis->get("aaaa")//将会用127.0.0.1:6479或者127.0.0.1:6579中读取.从而实现读写分离
  *
  *
  *
  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  *
  * 如果本类报找不到方法.但是redis中存在改方法.请在列成员$methodMap中加入对应的方法.如果是缓存数据.设置为true,读取数据.设置为false
  *
  *
  *
  * Class RedisServer
  * @author 136045277#qq.com
  */
 class RedisServer
 {
     private static $masterServers = array();
     private static $slaveServers = array();

     private static $masterLength = 0;
     private static $slaveLength = 0;

     private static $serverConfigs = array();
     private static $dbIndex = null;
     private static $instance = null;

     private static $prohibitMap = array(
         'slaveof', 'config'
     );

     private static $methodMap = array (
         'del' => true,
         'set' => true,
         'get' => false,
         'ttl' => false,
         'hget' => false,
         'incr' => true,
         'lpop' => true,
         'rpop' => true,
         'spop' => true,
         'decr' => true,
         'ping' => true,
         'info' => false,
         'type' => false,
         'hlen' => false,
         'sadd' => true,
         'keys' => false,
         'mset' => true,
         'exec' => true,
         'hdel' => true,
         'auth' => true,
         'srem' => true,
         'hset' => true,
         'zrem' => true,
         'scan' => false,
         'dump' => false,
         'zset' => true,
         'move' => true,
         'save' => true,
         'lrem' => true,
         'lset' => true,
         'lget' => false,
         'sort' => false,
         'hmget' => false,
         'ltrim' => true,
         'hvals' => false,
         'hkeys' => false,
         'brpop' => true,
         'lpush' => true,
         'rpush' => true,
         'smove' => true,
         'setex' => true,
         'watch' => true,
         'multi' => true,
         'bitop' => true,
         'setnx' => true,
         'zrank' => false,
         'sscan' => false,
         'hscan' => false,
         'scard' => false,
         'hmset' => true,
         'zsize' => false,
         'ssize' => false,
         'lsize' => false,
         'zscan' => false,
         'blpop' => true,
         'sdiff' => false,
         'zcard' => false,
         'exists' => false,
         'zrange' => false,
         'lindex' => false,
         'getbit' => false,
         'sunion' => false,
         'sinter' => false,
         'strlen' => false,
         'decrby' => true,
         'object' => false,
         'incrby' => true,
         'zinter' => true,
         'getset' => true,
         'lrange' => true,
         'append' => true,
         'lpushx' => true,
         'zscore' => false,
         'dbsize' => false,
         'zcount' => false,
         'zunion' => true,
         'expire' => true,
         'config' => true,
         'rename' => true,
         'setbit' => true,
         'delete' => true,
         'zincrby' => true,
         'lremove' => true,
         'sremove' => true,
         'linsert' => true,
         'hincrby' => true,
         'flushdb' => true,
         'migrate' => true,
         'hgetall' => false,
         'unwatch' => true,
         'hexists' => false,
         'zdelete' => false,
         'discard' => true,
         'getkeys' => false,
         'persist' => true,
         'setrange' => true,
         'renamenx' => true,
         'getrange' => false,
         'bitcount' => false,
         'smembers' => true,
         'expireat' => true,
         'lastsave' => true,
         'listtrim' => true,
         'flushall' => true,
         'zrevrank' => false,
         'sismember' => false,
         'zrevrange' => false,
         'randomkey' => false,
         'rpoplpush' => true,
         'scontains' => false,
         'lgetrange' => false,
         'renamekey' => true,
         'sdiffstore' => true,
         'settimeout' => true,
         'sgetmembers' => true,
         'sinterstore' => true,
         'srandmember' => false,
         'sunionstore' => true,
         'getmultiple' => false,
         'bgrewriteaof' => true,
         'zrangebyscore' => false,
         'zrevrangebyscore' => false,
         'zremrangebyscore' => true,
         'zdeleterangebyscore' => true,
     );

     private function __construct()
     {
     }

     /**
      * redis初始化
      * 配置
      * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
      *
      * $array = array(
      *      'master' => array(
      *          "redis://127.0.0.1:6379?timeout=1",
      *      ),
      *      'slave'  => array(
      *          "redis://127.0.0.1:6479?timeout=1",
      *          "redis://127.0.0.1:6579?timeout=1",
      *      )
      *  );
      *
      * $redis = RedisServer::instance($array);
      *
      * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
      *
      *
      *
      * @param array $configs
      * @return null|RedisServer
      */
     public static function instance(array $configs)
     {
         if (self::$instance === null) {
             self::$instance = new self();
             foreach ($configs['master'] as $master) {
                 $connect = self::$instance->parseStr($master);
                 self::$instance->addMaster($connect[0], $connect[1], $connect[2]);
             }
             foreach ($configs['slave'] as $master) {
                 $connect = self::$instance->parseStr($master);
                 self::$instance->addSlave($connect[0], $connect[1], $connect[2]);
             }
         }
         return self::$instance;
     }

     private function parseStr($string)
     {
         $urls = parse_url($string);
         $array[] = $urls['host'];
         $array[] = isset($urls['port']) ? $urls['port'] : 6379;
         $array[] = 1;
         return $array;
     }

     public function addMaster($host, $port = 6379, $timeout = 0.0)
     {
         self::$masterLength++;
         self::$serverConfigs['master'][] = [$host, $port, $timeout];
     }

     public function addSlave($host, $port = 6379, $timeout = 0.0)
     {
         self::$slaveLength++;
         self::$serverConfigs['slave'][] = [$host, $port, $timeout];
     }

     /**
      * @param null $key
      * @param bool|true $isMaster
      * @return \Redis
      */
     protected function getRedis($key = null, $isMaster = true)
     {
         empty($key) && $key = uniqid(true);
         list($length, $server) = $isMaster ? [self::$masterLength, &self::$masterServers] : [self::$slaveLength, &self::$slaveServers];
         $index = $this->getHostByHash($key, $length);
         if (!isset($server[$index])) {
             $connect = $isMaster ? self::$serverConfigs['master'][$index] : self::$serverConfigs['slave'][$index];
             $server[$index] = new \Redis();
             $server[$index]->connect($connect[0], $connect[1], $connect[2]);
             if (self::$dbIndex !== null) {
                 $server[$index]->select($index);
             }
             /*if (!$isMaster) {
                 $server[$index]->slaveof(self::$serverConfigs['master'][0][0], self::$serverConfigs['master'][0][1]);
             }*/
         }
         return $server[$index];
     }

     private function getHostByHash($key, $n)
     {
         if ($n < 2) return 0;
         $id = sprintf("%u", crc32($key));
         $m = base_convert(intval(fmod($id, $n)), 10, $n);
         return $m{0};
     }

     public function __call($method, $args)
     {
         if (in_array(strtolower($method), self::$prohibitMap)) {
             $this->prohibit($method);
         } elseif (isset(self::$methodMap[strtolower($method)])) {
             return call_user_func_array(array($this->getRedis(null, self::$methodMap[strtolower($method)]), $method), $args);
         }
         trigger_error("Call to undefined method " . __CLASS__ . "::{$method}() ", E_USER_ERROR);
     }

     /**
      * 禁用slaveof方法
      */
     private function prohibit($method)
     {
         trigger_error("Call to prohibit access method " . __CLASS__ . "::{$method}() ", E_USER_ERROR);
     }

     public function select($dbIndex)
     {
         foreach (self::$masterServers as &$master) {
             $master->select($dbIndex);
         }
         unset($master);
         foreach (self::$slaveServers as &$slave) {
             $slave->select($dbIndex);
         }
         self::$dbIndex = $dbIndex;
         unset($slave);
     }

 }