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);
    }


}