澳门汽车玻璃厂家价格-2019东北三省三校四模试卷

首页

AD联系:507867812

澳门汽车玻璃厂家价格

时间:2019-11-16 05:01:00 作者:假日国际娱乐网页版 浏览量:82107

澳门汽车玻璃厂家价格Laravel框架实现redis集群的方法分析

本文实例讲述了Laravel框架实现redis集群的方法。分享给大家供大家参考,具体如下:

在app/config/database.php中配置如下:

'redis' => array( 'cluster' => true, 'default' => array( 'host' => '172.21.107.247', 'port' => 6379, ), 'redis1' => array( 'host' => '172.21.107.248', 'port' => 6379, ),

其中cluster选择为true,接下来就可以作集群使用了;

如果把session的driver设置为redis,则可以使用其集群功能了:

我们来看下session的实现,当我们在代码中这样写:

Session::put('test', 124);

实际的执行流程是这样的:

Illuminate\Support\Facades\SessionIlluminate\Support\Facades\FacadeIlluminate\Session\Facade::app['session']->putIlluminate\Session\Facade::app['session']为Illuminate\Session\SessionManagerIlluminate\Support\Manager::__call

Session会根据返回创建driver

$this->app['config']['session.driver']

即配置文件中配置的,这里我们配置为redis

Illuminate\Session\SessionManager::Illuminate\Session\SessionManager

最终由Illuminate\Session\Store来负责put的调用

而Store类负责存储的类是Illuminate\Session\CacheBasedSessionHandler

后者又将请求转发给$this->app['cache']->driver($driver)……经过一系列代码追查,存储类为Predis\Client\Database,看其构造函数:

public function __construct(array $servers = array()){ if (isset($servers['cluster']) && $servers['cluster']) { $this->clients = $this->createAggregateClient($servers); } else { $this->clients = $this->createSingleClients($servers); }}

如果设置为集群,则调用createAggregateClient方法

protected function createAggregateClient(array $servers){ $servers = array_except($servers, array('cluster')); return array('default' => new Client(array_values($servers)));}

这里会把所有服务器放在default组中

实际存数据的类是Predis\Client,这里有根据配置创建服务器的代码,具体可以自己看下;

Predis\Cluster\PredisClusterHashStrategy类负责计算key的hash,关键函数:

getHash

getKeyFromFirstArgument

而Predis\Cluster\Distribution\HashRing负责服务器环的维护,关键函数

addNodeToRing

get

hash

大概原理是这样,如执行以下redis命令

get ok

会将ok作crc32运算得到一个hash值

所有服务器按一定算法放到一个长度默认为128的数组中,每个服务器在其中占几项,由以下决定:

权重/总权重*总的服务器数量*128,可参考Predis\Cluster\Distribution\HashRing::addNodeToRing方法

每一项的hash值是按服务器ip:端口的格式,作crc32计算的

protected function addNodeToRing(&$ring, $node, $totalNodes, $replicas, $weightRatio){ $nodeObject = $node['object']; $nodeHash = $this->getNodeHash($nodeObject); $replicas = (int) round($weightRatio * $totalNodes * $replicas); for ($i = 0; $i < $replicas; $i++) { $key = crc32("$nodeHash:$i"); $ring[$key] = $nodeObject; }}

key的hash值也有了,服务器环也计算好了,剩下的就是查找了,二分法能较快的查找相应的服务器节点

更多关于Laravel相关内容感兴趣的读者可查看本站专题:《Laravel框架入门与进阶教程》、《php优秀开发框架总结》、《php面向对象程序设计入门教程》、《php+mysql数据库操作入门教程》及《php常见数据库操作技巧汇总》

希望本文所述对大家基于Laravel框架的PHP程序设计有所帮助。

Laravel框架实现redis集群的方法分析Laravel框架实现redis集群的方法分析

本文实例讲述了Laravel框架实现redis集群的方法。分享给大家供大家参考,具体如下:

在app/config/database.php中配置如下:

'redis' => array( 'cluster' => true, 'default' => array( 'host' => '172.21.107.247', 'port' => 6379, ), 'redis1' => array( 'host' => '172.21.107.248', 'port' => 6379, ),

其中cluster选择为true,接下来就可以作集群使用了;

如果把session的driver设置为redis,则可以使用其集群功能了:

我们来看下session的实现,当我们在代码中这样写:

Session::put('test', 124);

实际的执行流程是这样的:

Illuminate\Support\Facades\SessionIlluminate\Support\Facades\FacadeIlluminate\Session\Facade::app['session']->putIlluminate\Session\Facade::app['session']为Illuminate\Session\SessionManagerIlluminate\Support\Manager::__call

Session会根据返回创建driver

$this->app['config']['session.driver']

即配置文件中配置的,这里我们配置为redis

Illuminate\Session\SessionManager::Illuminate\Session\SessionManager

最终由Illuminate\Session\Store来负责put的调用

而Store类负责存储的类是Illuminate\Session\CacheBasedSessionHandler

后者又将请求转发给$this->app['cache']->driver($driver)……经过一系列代码追查,存储类为Predis\Client\Database,看其构造函数:

public function __construct(array $servers = array()){ if (isset($servers['cluster']) && $servers['cluster']) { $this->clients = $this->createAggregateClient($servers); } else { $this->clients = $this->createSingleClients($servers); }}

如果设置为集群,则调用createAggregateClient方法

protected function createAggregateClient(array $servers){ $servers = array_except($servers, array('cluster')); return array('default' => new Client(array_values($servers)));}

这里会把所有服务器放在default组中

实际存数据的类是Predis\Client,这里有根据配置创建服务器的代码,具体可以自己看下;

Predis\Cluster\PredisClusterHashStrategy类负责计算key的hash,关键函数:

getHash

getKeyFromFirstArgument

而Predis\Cluster\Distribution\HashRing负责服务器环的维护,关键函数

addNodeToRing

get

hash

大概原理是这样,如执行以下redis命令

get ok

会将ok作crc32运算得到一个hash值

所有服务器按一定算法放到一个长度默认为128的数组中,每个服务器在其中占几项,由以下决定:

权重/总权重*总的服务器数量*128,可参考Predis\Cluster\Distribution\HashRing::addNodeToRing方法

每一项的hash值是按服务器ip:端口的格式,作crc32计算的

protected function addNodeToRing(&$ring, $node, $totalNodes, $replicas, $weightRatio){ $nodeObject = $node['object']; $nodeHash = $this->getNodeHash($nodeObject); $replicas = (int) round($weightRatio * $totalNodes * $replicas); for ($i = 0; $i < $replicas; $i++) { $key = crc32("$nodeHash:$i"); $ring[$key] = $nodeObject; }}

key的hash值也有了,服务器环也计算好了,剩下的就是查找了,二分法能较快的查找相应的服务器节点

更多关于Laravel相关内容感兴趣的读者可查看本站专题:《Laravel框架入门与进阶教程》、《php优秀开发框架总结》、《php面向对象程序设计入门教程》、《php+mysql数据库操作入门教程》及《php常见数据库操作技巧汇总》

希望本文所述对大家基于Laravel框架的PHP程序设计有所帮助。

Laravel框架实现redis集群的方法分析Laravel框架实现redis集群的方法分析,见下图

本文实例讲述了Laravel框架实现redis集群的方法。分享给大家供大家参考,具体如下:

在app/config/database.php中配置如下:

'redis' => array( 'cluster' => true, 'default' => array( 'host' => '172.21.107.247', 'port' => 6379, ), 'redis1' => array( 'host' => '172.21.107.248', 'port' => 6379, ),

其中cluster选择为true,接下来就可以作集群使用了;

如果把session的driver设置为redis,则可以使用其集群功能了:

我们来看下session的实现,当我们在代码中这样写:

Session::put('test', 124);

实际的执行流程是这样的:

Illuminate\Support\Facades\SessionIlluminate\Support\Facades\FacadeIlluminate\Session\Facade::app['session']->putIlluminate\Session\Facade::app['session']为Illuminate\Session\SessionManagerIlluminate\Support\Manager::__call

Session会根据返回创建driver

$this->app['config']['session.driver']

即配置文件中配置的,这里我们配置为redis

Illuminate\Session\SessionManager::Illuminate\Session\SessionManager

最终由Illuminate\Session\Store来负责put的调用

而Store类负责存储的类是Illuminate\Session\CacheBasedSessionHandler

后者又将请求转发给$this->app['cache']->driver($driver)……经过一系列代码追查,存储类为Predis\Client\Database,看其构造函数:

public function __construct(array $servers = array()){ if (isset($servers['cluster']) && $servers['cluster']) { $this->clients = $this->createAggregateClient($servers); } else { $this->clients = $this->createSingleClients($servers); }}

如果设置为集群,则调用createAggregateClient方法

protected function createAggregateClient(array $servers){ $servers = array_except($servers, array('cluster')); return array('default' => new Client(array_values($servers)));}

这里会把所有服务器放在default组中

实际存数据的类是Predis\Client,这里有根据配置创建服务器的代码,具体可以自己看下;

Predis\Cluster\PredisClusterHashStrategy类负责计算key的hash,关键函数:

getHash

getKeyFromFirstArgument

而Predis\Cluster\Distribution\HashRing负责服务器环的维护,关键函数

addNodeToRing

get

hash

大概原理是这样,如执行以下redis命令

get ok

会将ok作crc32运算得到一个hash值

所有服务器按一定算法放到一个长度默认为128的数组中,每个服务器在其中占几项,由以下决定:

权重/总权重*总的服务器数量*128,可参考Predis\Cluster\Distribution\HashRing::addNodeToRing方法

每一项的hash值是按服务器ip:端口的格式,作crc32计算的

protected function addNodeToRing(&$ring, $node, $totalNodes, $replicas, $weightRatio){ $nodeObject = $node['object']; $nodeHash = $this->getNodeHash($nodeObject); $replicas = (int) round($weightRatio * $totalNodes * $replicas); for ($i = 0; $i < $replicas; $i++) { $key = crc32("$nodeHash:$i"); $ring[$key] = $nodeObject; }}

key的hash值也有了,服务器环也计算好了,剩下的就是查找了,二分法能较快的查找相应的服务器节点

更多关于Laravel相关内容感兴趣的读者可查看本站专题:《Laravel框架入门与进阶教程》、《php优秀开发框架总结》、《php面向对象程序设计入门教程》、《php+mysql数据库操作入门教程》及《php常见数据库操作技巧汇总》

希望本文所述对大家基于Laravel框架的PHP程序设计有所帮助。

Laravel框架实现redis集群的方法分析

本文实例讲述了Laravel框架实现redis集群的方法。分享给大家供大家参考,具体如下:

在app/config/database.php中配置如下:

'redis' => array( 'cluster' => true, 'default' => array( 'host' => '172.21.107.247', 'port' => 6379, ), 'redis1' => array( 'host' => '172.21.107.248', 'port' => 6379, ),

其中cluster选择为true,接下来就可以作集群使用了;

如果把session的driver设置为redis,则可以使用其集群功能了:

我们来看下session的实现,当我们在代码中这样写:

Session::put('test', 124);

实际的执行流程是这样的:

Illuminate\Support\Facades\SessionIlluminate\Support\Facades\FacadeIlluminate\Session\Facade::app['session']->putIlluminate\Session\Facade::app['session']为Illuminate\Session\SessionManagerIlluminate\Support\Manager::__call

Session会根据返回创建driver

$this->app['config']['session.driver']

即配置文件中配置的,这里我们配置为redis

Illuminate\Session\SessionManager::Illuminate\Session\SessionManager

最终由Illuminate\Session\Store来负责put的调用

而Store类负责存储的类是Illuminate\Session\CacheBasedSessionHandler

后者又将请求转发给$this->app['cache']->driver($driver)……经过一系列代码追查,存储类为Predis\Client\Database,看其构造函数:

public function __construct(array $servers = array()){ if (isset($servers['cluster']) && $servers['cluster']) { $this->clients = $this->createAggregateClient($servers); } else { $this->clients = $this->createSingleClients($servers); }}

如果设置为集群,则调用createAggregateClient方法

protected function createAggregateClient(array $servers){ $servers = array_except($servers, array('cluster')); return array('default' => new Client(array_values($servers)));}

这里会把所有服务器放在default组中

实际存数据的类是Predis\Client,这里有根据配置创建服务器的代码,具体可以自己看下;

Predis\Cluster\PredisClusterHashStrategy类负责计算key的hash,关键函数:

getHash

getKeyFromFirstArgument

而Predis\Cluster\Distribution\HashRing负责服务器环的维护,关键函数

addNodeToRing

get

hash

大概原理是这样,如执行以下redis命令

get ok

会将ok作crc32运算得到一个hash值

所有服务器按一定算法放到一个长度默认为128的数组中,每个服务器在其中占几项,由以下决定:

权重/总权重*总的服务器数量*128,可参考Predis\Cluster\Distribution\HashRing::addNodeToRing方法

每一项的hash值是按服务器ip:端口的格式,作crc32计算的

protected function addNodeToRing(&$ring, $node, $totalNodes, $replicas, $weightRatio){ $nodeObject = $node['object']; $nodeHash = $this->getNodeHash($nodeObject); $replicas = (int) round($weightRatio * $totalNodes * $replicas); for ($i = 0; $i < $replicas; $i++) { $key = crc32("$nodeHash:$i"); $ring[$key] = $nodeObject; }}

key的hash值也有了,服务器环也计算好了,剩下的就是查找了,二分法能较快的查找相应的服务器节点

更多关于Laravel相关内容感兴趣的读者可查看本站专题:《Laravel框架入门与进阶教程》、《php优秀开发框架总结》、《php面向对象程序设计入门教程》、《php+mysql数据库操作入门教程》及《php常见数据库操作技巧汇总》

希望本文所述对大家基于Laravel框架的PHP程序设计有所帮助。

,见下图

本文实例讲述了Laravel框架实现redis集群的方法。分享给大家供大家参考,具体如下:

在app/config/database.php中配置如下:

'redis' => array( 'cluster' => true, 'default' => array( 'host' => '172.21.107.247', 'port' => 6379, ), 'redis1' => array( 'host' => '172.21.107.248', 'port' => 6379, ),

其中cluster选择为true,接下来就可以作集群使用了;

如果把session的driver设置为redis,则可以使用其集群功能了:

我们来看下session的实现,当我们在代码中这样写:

Session::put('test', 124);

实际的执行流程是这样的:

Illuminate\Support\Facades\SessionIlluminate\Support\Facades\FacadeIlluminate\Session\Facade::app['session']->putIlluminate\Session\Facade::app['session']为Illuminate\Session\SessionManagerIlluminate\Support\Manager::__call

Session会根据返回创建driver

$this->app['config']['session.driver']

即配置文件中配置的,这里我们配置为redis

Illuminate\Session\SessionManager::Illuminate\Session\SessionManager

最终由Illuminate\Session\Store来负责put的调用

而Store类负责存储的类是Illuminate\Session\CacheBasedSessionHandler

后者又将请求转发给$this->app['cache']->driver($driver)……经过一系列代码追查,存储类为Predis\Client\Database,看其构造函数:

public function __construct(array $servers = array()){ if (isset($servers['cluster']) && $servers['cluster']) { $this->clients = $this->createAggregateClient($servers); } else { $this->clients = $this->createSingleClients($servers); }}

如果设置为集群,则调用createAggregateClient方法

protected function createAggregateClient(array $servers){ $servers = array_except($servers, array('cluster')); return array('default' => new Client(array_values($servers)));}

这里会把所有服务器放在default组中

实际存数据的类是Predis\Client,这里有根据配置创建服务器的代码,具体可以自己看下;

Predis\Cluster\PredisClusterHashStrategy类负责计算key的hash,关键函数:

getHash

getKeyFromFirstArgument

而Predis\Cluster\Distribution\HashRing负责服务器环的维护,关键函数

addNodeToRing

get

hash

大概原理是这样,如执行以下redis命令

get ok

会将ok作crc32运算得到一个hash值

所有服务器按一定算法放到一个长度默认为128的数组中,每个服务器在其中占几项,由以下决定:

权重/总权重*总的服务器数量*128,可参考Predis\Cluster\Distribution\HashRing::addNodeToRing方法

每一项的hash值是按服务器ip:端口的格式,作crc32计算的

protected function addNodeToRing(&$ring, $node, $totalNodes, $replicas, $weightRatio){ $nodeObject = $node['object']; $nodeHash = $this->getNodeHash($nodeObject); $replicas = (int) round($weightRatio * $totalNodes * $replicas); for ($i = 0; $i < $replicas; $i++) { $key = crc32("$nodeHash:$i"); $ring[$key] = $nodeObject; }}

key的hash值也有了,服务器环也计算好了,剩下的就是查找了,二分法能较快的查找相应的服务器节点

更多关于Laravel相关内容感兴趣的读者可查看本站专题:《Laravel框架入门与进阶教程》、《php优秀开发框架总结》、《php面向对象程序设计入门教程》、《php+mysql数据库操作入门教程》及《php常见数据库操作技巧汇总》

希望本文所述对大家基于Laravel框架的PHP程序设计有所帮助。

本文实例讲述了Laravel框架实现redis集群的方法。分享给大家供大家参考,具体如下:

在app/config/database.php中配置如下:

'redis' => array( 'cluster' => true, 'default' => array( 'host' => '172.21.107.247', 'port' => 6379, ), 'redis1' => array( 'host' => '172.21.107.248', 'port' => 6379, ),

其中cluster选择为true,接下来就可以作集群使用了;

如果把session的driver设置为redis,则可以使用其集群功能了:

我们来看下session的实现,当我们在代码中这样写:

Session::put('test', 124);

实际的执行流程是这样的:

Illuminate\Support\Facades\SessionIlluminate\Support\Facades\FacadeIlluminate\Session\Facade::app['session']->putIlluminate\Session\Facade::app['session']为Illuminate\Session\SessionManagerIlluminate\Support\Manager::__call

Session会根据返回创建driver

$this->app['config']['session.driver']

即配置文件中配置的,这里我们配置为redis

Illuminate\Session\SessionManager::Illuminate\Session\SessionManager

最终由Illuminate\Session\Store来负责put的调用

而Store类负责存储的类是Illuminate\Session\CacheBasedSessionHandler

后者又将请求转发给$this->app['cache']->driver($driver)……经过一系列代码追查,存储类为Predis\Client\Database,看其构造函数:

public function __construct(array $servers = array()){ if (isset($servers['cluster']) && $servers['cluster']) { $this->clients = $this->createAggregateClient($servers); } else { $this->clients = $this->createSingleClients($servers); }}

如果设置为集群,则调用createAggregateClient方法

protected function createAggregateClient(array $servers){ $servers = array_except($servers, array('cluster')); return array('default' => new Client(array_values($servers)));}

这里会把所有服务器放在default组中

实际存数据的类是Predis\Client,这里有根据配置创建服务器的代码,具体可以自己看下;

Predis\Cluster\PredisClusterHashStrategy类负责计算key的hash,关键函数:

getHash

getKeyFromFirstArgument

而Predis\Cluster\Distribution\HashRing负责服务器环的维护,关键函数

addNodeToRing

get

hash

大概原理是这样,如执行以下redis命令

get ok

会将ok作crc32运算得到一个hash值

所有服务器按一定算法放到一个长度默认为128的数组中,每个服务器在其中占几项,由以下决定:

权重/总权重*总的服务器数量*128,可参考Predis\Cluster\Distribution\HashRing::addNodeToRing方法

每一项的hash值是按服务器ip:端口的格式,作crc32计算的

protected function addNodeToRing(&$ring, $node, $totalNodes, $replicas, $weightRatio){ $nodeObject = $node['object']; $nodeHash = $this->getNodeHash($nodeObject); $replicas = (int) round($weightRatio * $totalNodes * $replicas); for ($i = 0; $i < $replicas; $i++) { $key = crc32("$nodeHash:$i"); $ring[$key] = $nodeObject; }}

key的hash值也有了,服务器环也计算好了,剩下的就是查找了,二分法能较快的查找相应的服务器节点

更多关于Laravel相关内容感兴趣的读者可查看本站专题:《Laravel框架入门与进阶教程》、《php优秀开发框架总结》、《php面向对象程序设计入门教程》、《php+mysql数据库操作入门教程》及《php常见数据库操作技巧汇总》

希望本文所述对大家基于Laravel框架的PHP程序设计有所帮助。

本文实例讲述了Laravel框架实现redis集群的方法。分享给大家供大家参考,具体如下:

在app/config/database.php中配置如下:

'redis' => array( 'cluster' => true, 'default' => array( 'host' => '172.21.107.247', 'port' => 6379, ), 'redis1' => array( 'host' => '172.21.107.248', 'port' => 6379, ),

其中cluster选择为true,接下来就可以作集群使用了;

如果把session的driver设置为redis,则可以使用其集群功能了:

我们来看下session的实现,当我们在代码中这样写:

Session::put('test', 124);

实际的执行流程是这样的:

Illuminate\Support\Facades\SessionIlluminate\Support\Facades\FacadeIlluminate\Session\Facade::app['session']->putIlluminate\Session\Facade::app['session']为Illuminate\Session\SessionManagerIlluminate\Support\Manager::__call

Session会根据返回创建driver

$this->app['config']['session.driver']

即配置文件中配置的,这里我们配置为redis

Illuminate\Session\SessionManager::Illuminate\Session\SessionManager

最终由Illuminate\Session\Store来负责put的调用

而Store类负责存储的类是Illuminate\Session\CacheBasedSessionHandler

后者又将请求转发给$this->app['cache']->driver($driver)……经过一系列代码追查,存储类为Predis\Client\Database,看其构造函数:

public function __construct(array $servers = array()){ if (isset($servers['cluster']) && $servers['cluster']) { $this->clients = $this->createAggregateClient($servers); } else { $this->clients = $this->createSingleClients($servers); }}

如果设置为集群,则调用createAggregateClient方法

protected function createAggregateClient(array $servers){ $servers = array_except($servers, array('cluster')); return array('default' => new Client(array_values($servers)));}

这里会把所有服务器放在default组中

实际存数据的类是Predis\Client,这里有根据配置创建服务器的代码,具体可以自己看下;

Predis\Cluster\PredisClusterHashStrategy类负责计算key的hash,关键函数:

getHash

getKeyFromFirstArgument

而Predis\Cluster\Distribution\HashRing负责服务器环的维护,关键函数

addNodeToRing

get

hash

大概原理是这样,如执行以下redis命令

get ok

会将ok作crc32运算得到一个hash值

所有服务器按一定算法放到一个长度默认为128的数组中,每个服务器在其中占几项,由以下决定:

权重/总权重*总的服务器数量*128,可参考Predis\Cluster\Distribution\HashRing::addNodeToRing方法

每一项的hash值是按服务器ip:端口的格式,作crc32计算的

protected function addNodeToRing(&$ring, $node, $totalNodes, $replicas, $weightRatio){ $nodeObject = $node['object']; $nodeHash = $this->getNodeHash($nodeObject); $replicas = (int) round($weightRatio * $totalNodes * $replicas); for ($i = 0; $i < $replicas; $i++) { $key = crc32("$nodeHash:$i"); $ring[$key] = $nodeObject; }}

key的hash值也有了,服务器环也计算好了,剩下的就是查找了,二分法能较快的查找相应的服务器节点

更多关于Laravel相关内容感兴趣的读者可查看本站专题:《Laravel框架入门与进阶教程》、《php优秀开发框架总结》、《php面向对象程序设计入门教程》、《php+mysql数据库操作入门教程》及《php常见数据库操作技巧汇总》

希望本文所述对大家基于Laravel框架的PHP程序设计有所帮助。

本文实例讲述了Laravel框架实现redis集群的方法。分享给大家供大家参考,具体如下:

在app/config/database.php中配置如下:

'redis' => array( 'cluster' => true, 'default' => array( 'host' => '172.21.107.247', 'port' => 6379, ), 'redis1' => array( 'host' => '172.21.107.248', 'port' => 6379, ),

其中cluster选择为true,接下来就可以作集群使用了;

如果把session的driver设置为redis,则可以使用其集群功能了:

我们来看下session的实现,当我们在代码中这样写:

Session::put('test', 124);

实际的执行流程是这样的:

Illuminate\Support\Facades\SessionIlluminate\Support\Facades\FacadeIlluminate\Session\Facade::app['session']->putIlluminate\Session\Facade::app['session']为Illuminate\Session\SessionManagerIlluminate\Support\Manager::__call

Session会根据返回创建driver

$this->app['config']['session.driver']

即配置文件中配置的,这里我们配置为redis

Illuminate\Session\SessionManager::Illuminate\Session\SessionManager

最终由Illuminate\Session\Store来负责put的调用

而Store类负责存储的类是Illuminate\Session\CacheBasedSessionHandler

后者又将请求转发给$this->app['cache']->driver($driver)……经过一系列代码追查,存储类为Predis\Client\Database,看其构造函数:

public function __construct(array $servers = array()){ if (isset($servers['cluster']) && $servers['cluster']) { $this->clients = $this->createAggregateClient($servers); } else { $this->clients = $this->createSingleClients($servers); }}

如果设置为集群,则调用createAggregateClient方法

protected function createAggregateClient(array $servers){ $servers = array_except($servers, array('cluster')); return array('default' => new Client(array_values($servers)));}

这里会把所有服务器放在default组中

实际存数据的类是Predis\Client,这里有根据配置创建服务器的代码,具体可以自己看下;

Predis\Cluster\PredisClusterHashStrategy类负责计算key的hash,关键函数:

getHash

getKeyFromFirstArgument

而Predis\Cluster\Distribution\HashRing负责服务器环的维护,关键函数

addNodeToRing

get

hash

大概原理是这样,如执行以下redis命令

get ok

会将ok作crc32运算得到一个hash值

所有服务器按一定算法放到一个长度默认为128的数组中,每个服务器在其中占几项,由以下决定:

权重/总权重*总的服务器数量*128,可参考Predis\Cluster\Distribution\HashRing::addNodeToRing方法

每一项的hash值是按服务器ip:端口的格式,作crc32计算的

protected function addNodeToRing(&$ring, $node, $totalNodes, $replicas, $weightRatio){ $nodeObject = $node['object']; $nodeHash = $this->getNodeHash($nodeObject); $replicas = (int) round($weightRatio * $totalNodes * $replicas); for ($i = 0; $i < $replicas; $i++) { $key = crc32("$nodeHash:$i"); $ring[$key] = $nodeObject; }}

key的hash值也有了,服务器环也计算好了,剩下的就是查找了,二分法能较快的查找相应的服务器节点

更多关于Laravel相关内容感兴趣的读者可查看本站专题:《Laravel框架入门与进阶教程》、《php优秀开发框架总结》、《php面向对象程序设计入门教程》、《php+mysql数据库操作入门教程》及《php常见数据库操作技巧汇总》

希望本文所述对大家基于Laravel框架的PHP程序设计有所帮助。

,如下图

本文实例讲述了Laravel框架实现redis集群的方法。分享给大家供大家参考,具体如下:

在app/config/database.php中配置如下:

'redis' => array( 'cluster' => true, 'default' => array( 'host' => '172.21.107.247', 'port' => 6379, ), 'redis1' => array( 'host' => '172.21.107.248', 'port' => 6379, ),

其中cluster选择为true,接下来就可以作集群使用了;

如果把session的driver设置为redis,则可以使用其集群功能了:

我们来看下session的实现,当我们在代码中这样写:

Session::put('test', 124);

实际的执行流程是这样的:

Illuminate\Support\Facades\SessionIlluminate\Support\Facades\FacadeIlluminate\Session\Facade::app['session']->putIlluminate\Session\Facade::app['session']为Illuminate\Session\SessionManagerIlluminate\Support\Manager::__call

Session会根据返回创建driver

$this->app['config']['session.driver']

即配置文件中配置的,这里我们配置为redis

Illuminate\Session\SessionManager::Illuminate\Session\SessionManager

最终由Illuminate\Session\Store来负责put的调用

而Store类负责存储的类是Illuminate\Session\CacheBasedSessionHandler

后者又将请求转发给$this->app['cache']->driver($driver)……经过一系列代码追查,存储类为Predis\Client\Database,看其构造函数:

public function __construct(array $servers = array()){ if (isset($servers['cluster']) && $servers['cluster']) { $this->clients = $this->createAggregateClient($servers); } else { $this->clients = $this->createSingleClients($servers); }}

如果设置为集群,则调用createAggregateClient方法

protected function createAggregateClient(array $servers){ $servers = array_except($servers, array('cluster')); return array('default' => new Client(array_values($servers)));}

这里会把所有服务器放在default组中

实际存数据的类是Predis\Client,这里有根据配置创建服务器的代码,具体可以自己看下;

Predis\Cluster\PredisClusterHashStrategy类负责计算key的hash,关键函数:

getHash

getKeyFromFirstArgument

而Predis\Cluster\Distribution\HashRing负责服务器环的维护,关键函数

addNodeToRing

get

hash

大概原理是这样,如执行以下redis命令

get ok

会将ok作crc32运算得到一个hash值

所有服务器按一定算法放到一个长度默认为128的数组中,每个服务器在其中占几项,由以下决定:

权重/总权重*总的服务器数量*128,可参考Predis\Cluster\Distribution\HashRing::addNodeToRing方法

每一项的hash值是按服务器ip:端口的格式,作crc32计算的

protected function addNodeToRing(&$ring, $node, $totalNodes, $replicas, $weightRatio){ $nodeObject = $node['object']; $nodeHash = $this->getNodeHash($nodeObject); $replicas = (int) round($weightRatio * $totalNodes * $replicas); for ($i = 0; $i < $replicas; $i++) { $key = crc32("$nodeHash:$i"); $ring[$key] = $nodeObject; }}

key的hash值也有了,服务器环也计算好了,剩下的就是查找了,二分法能较快的查找相应的服务器节点

更多关于Laravel相关内容感兴趣的读者可查看本站专题:《Laravel框架入门与进阶教程》、《php优秀开发框架总结》、《php面向对象程序设计入门教程》、《php+mysql数据库操作入门教程》及《php常见数据库操作技巧汇总》

希望本文所述对大家基于Laravel框架的PHP程序设计有所帮助。

本文实例讲述了Laravel框架实现redis集群的方法。分享给大家供大家参考,具体如下:

在app/config/database.php中配置如下:

'redis' => array( 'cluster' => true, 'default' => array( 'host' => '172.21.107.247', 'port' => 6379, ), 'redis1' => array( 'host' => '172.21.107.248', 'port' => 6379, ),

其中cluster选择为true,接下来就可以作集群使用了;

如果把session的driver设置为redis,则可以使用其集群功能了:

我们来看下session的实现,当我们在代码中这样写:

Session::put('test', 124);

实际的执行流程是这样的:

Illuminate\Support\Facades\SessionIlluminate\Support\Facades\FacadeIlluminate\Session\Facade::app['session']->putIlluminate\Session\Facade::app['session']为Illuminate\Session\SessionManagerIlluminate\Support\Manager::__call

Session会根据返回创建driver

$this->app['config']['session.driver']

即配置文件中配置的,这里我们配置为redis

Illuminate\Session\SessionManager::Illuminate\Session\SessionManager

最终由Illuminate\Session\Store来负责put的调用

而Store类负责存储的类是Illuminate\Session\CacheBasedSessionHandler

后者又将请求转发给$this->app['cache']->driver($driver)……经过一系列代码追查,存储类为Predis\Client\Database,看其构造函数:

public function __construct(array $servers = array()){ if (isset($servers['cluster']) && $servers['cluster']) { $this->clients = $this->createAggregateClient($servers); } else { $this->clients = $this->createSingleClients($servers); }}

如果设置为集群,则调用createAggregateClient方法

protected function createAggregateClient(array $servers){ $servers = array_except($servers, array('cluster')); return array('default' => new Client(array_values($servers)));}

这里会把所有服务器放在default组中

实际存数据的类是Predis\Client,这里有根据配置创建服务器的代码,具体可以自己看下;

Predis\Cluster\PredisClusterHashStrategy类负责计算key的hash,关键函数:

getHash

getKeyFromFirstArgument

而Predis\Cluster\Distribution\HashRing负责服务器环的维护,关键函数

addNodeToRing

get

hash

大概原理是这样,如执行以下redis命令

get ok

会将ok作crc32运算得到一个hash值

所有服务器按一定算法放到一个长度默认为128的数组中,每个服务器在其中占几项,由以下决定:

权重/总权重*总的服务器数量*128,可参考Predis\Cluster\Distribution\HashRing::addNodeToRing方法

每一项的hash值是按服务器ip:端口的格式,作crc32计算的

protected function addNodeToRing(&$ring, $node, $totalNodes, $replicas, $weightRatio){ $nodeObject = $node['object']; $nodeHash = $this->getNodeHash($nodeObject); $replicas = (int) round($weightRatio * $totalNodes * $replicas); for ($i = 0; $i < $replicas; $i++) { $key = crc32("$nodeHash:$i"); $ring[$key] = $nodeObject; }}

key的hash值也有了,服务器环也计算好了,剩下的就是查找了,二分法能较快的查找相应的服务器节点

更多关于Laravel相关内容感兴趣的读者可查看本站专题:《Laravel框架入门与进阶教程》、《php优秀开发框架总结》、《php面向对象程序设计入门教程》、《php+mysql数据库操作入门教程》及《php常见数据库操作技巧汇总》

希望本文所述对大家基于Laravel框架的PHP程序设计有所帮助。

Laravel框架实现redis集群的方法分析

如下图

本文实例讲述了Laravel框架实现redis集群的方法。分享给大家供大家参考,具体如下:

在app/config/database.php中配置如下:

'redis' => array( 'cluster' => true, 'default' => array( 'host' => '172.21.107.247', 'port' => 6379, ), 'redis1' => array( 'host' => '172.21.107.248', 'port' => 6379, ),

其中cluster选择为true,接下来就可以作集群使用了;

如果把session的driver设置为redis,则可以使用其集群功能了:

我们来看下session的实现,当我们在代码中这样写:

Session::put('test', 124);

实际的执行流程是这样的:

Illuminate\Support\Facades\SessionIlluminate\Support\Facades\FacadeIlluminate\Session\Facade::app['session']->putIlluminate\Session\Facade::app['session']为Illuminate\Session\SessionManagerIlluminate\Support\Manager::__call

Session会根据返回创建driver

$this->app['config']['session.driver']

即配置文件中配置的,这里我们配置为redis

Illuminate\Session\SessionManager::Illuminate\Session\SessionManager

最终由Illuminate\Session\Store来负责put的调用

而Store类负责存储的类是Illuminate\Session\CacheBasedSessionHandler

后者又将请求转发给$this->app['cache']->driver($driver)……经过一系列代码追查,存储类为Predis\Client\Database,看其构造函数:

public function __construct(array $servers = array()){ if (isset($servers['cluster']) && $servers['cluster']) { $this->clients = $this->createAggregateClient($servers); } else { $this->clients = $this->createSingleClients($servers); }}

如果设置为集群,则调用createAggregateClient方法

protected function createAggregateClient(array $servers){ $servers = array_except($servers, array('cluster')); return array('default' => new Client(array_values($servers)));}

这里会把所有服务器放在default组中

实际存数据的类是Predis\Client,这里有根据配置创建服务器的代码,具体可以自己看下;

Predis\Cluster\PredisClusterHashStrategy类负责计算key的hash,关键函数:

getHash

getKeyFromFirstArgument

而Predis\Cluster\Distribution\HashRing负责服务器环的维护,关键函数

addNodeToRing

get

hash

大概原理是这样,如执行以下redis命令

get ok

会将ok作crc32运算得到一个hash值

所有服务器按一定算法放到一个长度默认为128的数组中,每个服务器在其中占几项,由以下决定:

权重/总权重*总的服务器数量*128,可参考Predis\Cluster\Distribution\HashRing::addNodeToRing方法

每一项的hash值是按服务器ip:端口的格式,作crc32计算的

protected function addNodeToRing(&$ring, $node, $totalNodes, $replicas, $weightRatio){ $nodeObject = $node['object']; $nodeHash = $this->getNodeHash($nodeObject); $replicas = (int) round($weightRatio * $totalNodes * $replicas); for ($i = 0; $i < $replicas; $i++) { $key = crc32("$nodeHash:$i"); $ring[$key] = $nodeObject; }}

key的hash值也有了,服务器环也计算好了,剩下的就是查找了,二分法能较快的查找相应的服务器节点

更多关于Laravel相关内容感兴趣的读者可查看本站专题:《Laravel框架入门与进阶教程》、《php优秀开发框架总结》、《php面向对象程序设计入门教程》、《php+mysql数据库操作入门教程》及《php常见数据库操作技巧汇总》

希望本文所述对大家基于Laravel框架的PHP程序设计有所帮助。

,如下图

Laravel框架实现redis集群的方法分析Laravel框架实现redis集群的方法分析,见图

澳门汽车玻璃厂家价格

本文实例讲述了Laravel框架实现redis集群的方法。分享给大家供大家参考,具体如下:

在app/config/database.php中配置如下:

'redis' => array( 'cluster' => true, 'default' => array( 'host' => '172.21.107.247', 'port' => 6379, ), 'redis1' => array( 'host' => '172.21.107.248', 'port' => 6379, ),

其中cluster选择为true,接下来就可以作集群使用了;

如果把session的driver设置为redis,则可以使用其集群功能了:

我们来看下session的实现,当我们在代码中这样写:

Session::put('test', 124);

实际的执行流程是这样的:

Illuminate\Support\Facades\SessionIlluminate\Support\Facades\FacadeIlluminate\Session\Facade::app['session']->putIlluminate\Session\Facade::app['session']为Illuminate\Session\SessionManagerIlluminate\Support\Manager::__call

Session会根据返回创建driver

$this->app['config']['session.driver']

即配置文件中配置的,这里我们配置为redis

Illuminate\Session\SessionManager::Illuminate\Session\SessionManager

最终由Illuminate\Session\Store来负责put的调用

而Store类负责存储的类是Illuminate\Session\CacheBasedSessionHandler

后者又将请求转发给$this->app['cache']->driver($driver)……经过一系列代码追查,存储类为Predis\Client\Database,看其构造函数:

public function __construct(array $servers = array()){ if (isset($servers['cluster']) && $servers['cluster']) { $this->clients = $this->createAggregateClient($servers); } else { $this->clients = $this->createSingleClients($servers); }}

如果设置为集群,则调用createAggregateClient方法

protected function createAggregateClient(array $servers){ $servers = array_except($servers, array('cluster')); return array('default' => new Client(array_values($servers)));}

这里会把所有服务器放在default组中

实际存数据的类是Predis\Client,这里有根据配置创建服务器的代码,具体可以自己看下;

Predis\Cluster\PredisClusterHashStrategy类负责计算key的hash,关键函数:

getHash

getKeyFromFirstArgument

而Predis\Cluster\Distribution\HashRing负责服务器环的维护,关键函数

addNodeToRing

get

hash

大概原理是这样,如执行以下redis命令

get ok

会将ok作crc32运算得到一个hash值

所有服务器按一定算法放到一个长度默认为128的数组中,每个服务器在其中占几项,由以下决定:

权重/总权重*总的服务器数量*128,可参考Predis\Cluster\Distribution\HashRing::addNodeToRing方法

每一项的hash值是按服务器ip:端口的格式,作crc32计算的

protected function addNodeToRing(&$ring, $node, $totalNodes, $replicas, $weightRatio){ $nodeObject = $node['object']; $nodeHash = $this->getNodeHash($nodeObject); $replicas = (int) round($weightRatio * $totalNodes * $replicas); for ($i = 0; $i < $replicas; $i++) { $key = crc32("$nodeHash:$i"); $ring[$key] = $nodeObject; }}

key的hash值也有了,服务器环也计算好了,剩下的就是查找了,二分法能较快的查找相应的服务器节点

更多关于Laravel相关内容感兴趣的读者可查看本站专题:《Laravel框架入门与进阶教程》、《php优秀开发框架总结》、《php面向对象程序设计入门教程》、《php+mysql数据库操作入门教程》及《php常见数据库操作技巧汇总》

希望本文所述对大家基于Laravel框架的PHP程序设计有所帮助。

Laravel框架实现redis集群的方法分析Laravel框架实现redis集群的方法分析

本文实例讲述了Laravel框架实现redis集群的方法。分享给大家供大家参考,具体如下:

在app/config/database.php中配置如下:

'redis' => array( 'cluster' => true, 'default' => array( 'host' => '172.21.107.247', 'port' => 6379, ), 'redis1' => array( 'host' => '172.21.107.248', 'port' => 6379, ),

其中cluster选择为true,接下来就可以作集群使用了;

如果把session的driver设置为redis,则可以使用其集群功能了:

我们来看下session的实现,当我们在代码中这样写:

Session::put('test', 124);

实际的执行流程是这样的:

Illuminate\Support\Facades\SessionIlluminate\Support\Facades\FacadeIlluminate\Session\Facade::app['session']->putIlluminate\Session\Facade::app['session']为Illuminate\Session\SessionManagerIlluminate\Support\Manager::__call

Session会根据返回创建driver

$this->app['config']['session.driver']

即配置文件中配置的,这里我们配置为redis

Illuminate\Session\SessionManager::Illuminate\Session\SessionManager

最终由Illuminate\Session\Store来负责put的调用

而Store类负责存储的类是Illuminate\Session\CacheBasedSessionHandler

后者又将请求转发给$this->app['cache']->driver($driver)……经过一系列代码追查,存储类为Predis\Client\Database,看其构造函数:

public function __construct(array $servers = array()){ if (isset($servers['cluster']) && $servers['cluster']) { $this->clients = $this->createAggregateClient($servers); } else { $this->clients = $this->createSingleClients($servers); }}

如果设置为集群,则调用createAggregateClient方法

protected function createAggregateClient(array $servers){ $servers = array_except($servers, array('cluster')); return array('default' => new Client(array_values($servers)));}

这里会把所有服务器放在default组中

实际存数据的类是Predis\Client,这里有根据配置创建服务器的代码,具体可以自己看下;

Predis\Cluster\PredisClusterHashStrategy类负责计算key的hash,关键函数:

getHash

getKeyFromFirstArgument

而Predis\Cluster\Distribution\HashRing负责服务器环的维护,关键函数

addNodeToRing

get

hash

大概原理是这样,如执行以下redis命令

get ok

会将ok作crc32运算得到一个hash值

所有服务器按一定算法放到一个长度默认为128的数组中,每个服务器在其中占几项,由以下决定:

权重/总权重*总的服务器数量*128,可参考Predis\Cluster\Distribution\HashRing::addNodeToRing方法

每一项的hash值是按服务器ip:端口的格式,作crc32计算的

protected function addNodeToRing(&$ring, $node, $totalNodes, $replicas, $weightRatio){ $nodeObject = $node['object']; $nodeHash = $this->getNodeHash($nodeObject); $replicas = (int) round($weightRatio * $totalNodes * $replicas); for ($i = 0; $i < $replicas; $i++) { $key = crc32("$nodeHash:$i"); $ring[$key] = $nodeObject; }}

key的hash值也有了,服务器环也计算好了,剩下的就是查找了,二分法能较快的查找相应的服务器节点

更多关于Laravel相关内容感兴趣的读者可查看本站专题:《Laravel框架入门与进阶教程》、《php优秀开发框架总结》、《php面向对象程序设计入门教程》、《php+mysql数据库操作入门教程》及《php常见数据库操作技巧汇总》

希望本文所述对大家基于Laravel框架的PHP程序设计有所帮助。

本文实例讲述了Laravel框架实现redis集群的方法。分享给大家供大家参考,具体如下:

在app/config/database.php中配置如下:

'redis' => array( 'cluster' => true, 'default' => array( 'host' => '172.21.107.247', 'port' => 6379, ), 'redis1' => array( 'host' => '172.21.107.248', 'port' => 6379, ),

其中cluster选择为true,接下来就可以作集群使用了;

如果把session的driver设置为redis,则可以使用其集群功能了:

我们来看下session的实现,当我们在代码中这样写:

Session::put('test', 124);

实际的执行流程是这样的:

Illuminate\Support\Facades\SessionIlluminate\Support\Facades\FacadeIlluminate\Session\Facade::app['session']->putIlluminate\Session\Facade::app['session']为Illuminate\Session\SessionManagerIlluminate\Support\Manager::__call

Session会根据返回创建driver

$this->app['config']['session.driver']

即配置文件中配置的,这里我们配置为redis

Illuminate\Session\SessionManager::Illuminate\Session\SessionManager

最终由Illuminate\Session\Store来负责put的调用

而Store类负责存储的类是Illuminate\Session\CacheBasedSessionHandler

后者又将请求转发给$this->app['cache']->driver($driver)……经过一系列代码追查,存储类为Predis\Client\Database,看其构造函数:

public function __construct(array $servers = array()){ if (isset($servers['cluster']) && $servers['cluster']) { $this->clients = $this->createAggregateClient($servers); } else { $this->clients = $this->createSingleClients($servers); }}

如果设置为集群,则调用createAggregateClient方法

protected function createAggregateClient(array $servers){ $servers = array_except($servers, array('cluster')); return array('default' => new Client(array_values($servers)));}

这里会把所有服务器放在default组中

实际存数据的类是Predis\Client,这里有根据配置创建服务器的代码,具体可以自己看下;

Predis\Cluster\PredisClusterHashStrategy类负责计算key的hash,关键函数:

getHash

getKeyFromFirstArgument

而Predis\Cluster\Distribution\HashRing负责服务器环的维护,关键函数

addNodeToRing

get

hash

大概原理是这样,如执行以下redis命令

get ok

会将ok作crc32运算得到一个hash值

所有服务器按一定算法放到一个长度默认为128的数组中,每个服务器在其中占几项,由以下决定:

权重/总权重*总的服务器数量*128,可参考Predis\Cluster\Distribution\HashRing::addNodeToRing方法

每一项的hash值是按服务器ip:端口的格式,作crc32计算的

protected function addNodeToRing(&$ring, $node, $totalNodes, $replicas, $weightRatio){ $nodeObject = $node['object']; $nodeHash = $this->getNodeHash($nodeObject); $replicas = (int) round($weightRatio * $totalNodes * $replicas); for ($i = 0; $i < $replicas; $i++) { $key = crc32("$nodeHash:$i"); $ring[$key] = $nodeObject; }}

key的hash值也有了,服务器环也计算好了,剩下的就是查找了,二分法能较快的查找相应的服务器节点

更多关于Laravel相关内容感兴趣的读者可查看本站专题:《Laravel框架入门与进阶教程》、《php优秀开发框架总结》、《php面向对象程序设计入门教程》、《php+mysql数据库操作入门教程》及《php常见数据库操作技巧汇总》

希望本文所述对大家基于Laravel框架的PHP程序设计有所帮助。

Laravel框架实现redis集群的方法分析

本文实例讲述了Laravel框架实现redis集群的方法。分享给大家供大家参考,具体如下:

在app/config/database.php中配置如下:

'redis' => array( 'cluster' => true, 'default' => array( 'host' => '172.21.107.247', 'port' => 6379, ), 'redis1' => array( 'host' => '172.21.107.248', 'port' => 6379, ),

其中cluster选择为true,接下来就可以作集群使用了;

如果把session的driver设置为redis,则可以使用其集群功能了:

我们来看下session的实现,当我们在代码中这样写:

Session::put('test', 124);

实际的执行流程是这样的:

Illuminate\Support\Facades\SessionIlluminate\Support\Facades\FacadeIlluminate\Session\Facade::app['session']->putIlluminate\Session\Facade::app['session']为Illuminate\Session\SessionManagerIlluminate\Support\Manager::__call

Session会根据返回创建driver

$this->app['config']['session.driver']

即配置文件中配置的,这里我们配置为redis

Illuminate\Session\SessionManager::Illuminate\Session\SessionManager

最终由Illuminate\Session\Store来负责put的调用

而Store类负责存储的类是Illuminate\Session\CacheBasedSessionHandler

后者又将请求转发给$this->app['cache']->driver($driver)……经过一系列代码追查,存储类为Predis\Client\Database,看其构造函数:

public function __construct(array $servers = array()){ if (isset($servers['cluster']) && $servers['cluster']) { $this->clients = $this->createAggregateClient($servers); } else { $this->clients = $this->createSingleClients($servers); }}

如果设置为集群,则调用createAggregateClient方法

protected function createAggregateClient(array $servers){ $servers = array_except($servers, array('cluster')); return array('default' => new Client(array_values($servers)));}

这里会把所有服务器放在default组中

实际存数据的类是Predis\Client,这里有根据配置创建服务器的代码,具体可以自己看下;

Predis\Cluster\PredisClusterHashStrategy类负责计算key的hash,关键函数:

getHash

getKeyFromFirstArgument

而Predis\Cluster\Distribution\HashRing负责服务器环的维护,关键函数

addNodeToRing

get

hash

大概原理是这样,如执行以下redis命令

get ok

会将ok作crc32运算得到一个hash值

所有服务器按一定算法放到一个长度默认为128的数组中,每个服务器在其中占几项,由以下决定:

权重/总权重*总的服务器数量*128,可参考Predis\Cluster\Distribution\HashRing::addNodeToRing方法

每一项的hash值是按服务器ip:端口的格式,作crc32计算的

protected function addNodeToRing(&$ring, $node, $totalNodes, $replicas, $weightRatio){ $nodeObject = $node['object']; $nodeHash = $this->getNodeHash($nodeObject); $replicas = (int) round($weightRatio * $totalNodes * $replicas); for ($i = 0; $i < $replicas; $i++) { $key = crc32("$nodeHash:$i"); $ring[$key] = $nodeObject; }}

key的hash值也有了,服务器环也计算好了,剩下的就是查找了,二分法能较快的查找相应的服务器节点

更多关于Laravel相关内容感兴趣的读者可查看本站专题:《Laravel框架入门与进阶教程》、《php优秀开发框架总结》、《php面向对象程序设计入门教程》、《php+mysql数据库操作入门教程》及《php常见数据库操作技巧汇总》

希望本文所述对大家基于Laravel框架的PHP程序设计有所帮助。

本文实例讲述了Laravel框架实现redis集群的方法。分享给大家供大家参考,具体如下:

在app/config/database.php中配置如下:

'redis' => array( 'cluster' => true, 'default' => array( 'host' => '172.21.107.247', 'port' => 6379, ), 'redis1' => array( 'host' => '172.21.107.248', 'port' => 6379, ),

其中cluster选择为true,接下来就可以作集群使用了;

如果把session的driver设置为redis,则可以使用其集群功能了:

我们来看下session的实现,当我们在代码中这样写:

Session::put('test', 124);

实际的执行流程是这样的:

Illuminate\Support\Facades\SessionIlluminate\Support\Facades\FacadeIlluminate\Session\Facade::app['session']->putIlluminate\Session\Facade::app['session']为Illuminate\Session\SessionManagerIlluminate\Support\Manager::__call

Session会根据返回创建driver

$this->app['config']['session.driver']

即配置文件中配置的,这里我们配置为redis

Illuminate\Session\SessionManager::Illuminate\Session\SessionManager

最终由Illuminate\Session\Store来负责put的调用

而Store类负责存储的类是Illuminate\Session\CacheBasedSessionHandler

后者又将请求转发给$this->app['cache']->driver($driver)……经过一系列代码追查,存储类为Predis\Client\Database,看其构造函数:

public function __construct(array $servers = array()){ if (isset($servers['cluster']) && $servers['cluster']) { $this->clients = $this->createAggregateClient($servers); } else { $this->clients = $this->createSingleClients($servers); }}

如果设置为集群,则调用createAggregateClient方法

protected function createAggregateClient(array $servers){ $servers = array_except($servers, array('cluster')); return array('default' => new Client(array_values($servers)));}

这里会把所有服务器放在default组中

实际存数据的类是Predis\Client,这里有根据配置创建服务器的代码,具体可以自己看下;

Predis\Cluster\PredisClusterHashStrategy类负责计算key的hash,关键函数:

getHash

getKeyFromFirstArgument

而Predis\Cluster\Distribution\HashRing负责服务器环的维护,关键函数

addNodeToRing

get

hash

大概原理是这样,如执行以下redis命令

get ok

会将ok作crc32运算得到一个hash值

所有服务器按一定算法放到一个长度默认为128的数组中,每个服务器在其中占几项,由以下决定:

权重/总权重*总的服务器数量*128,可参考Predis\Cluster\Distribution\HashRing::addNodeToRing方法

每一项的hash值是按服务器ip:端口的格式,作crc32计算的

protected function addNodeToRing(&$ring, $node, $totalNodes, $replicas, $weightRatio){ $nodeObject = $node['object']; $nodeHash = $this->getNodeHash($nodeObject); $replicas = (int) round($weightRatio * $totalNodes * $replicas); for ($i = 0; $i < $replicas; $i++) { $key = crc32("$nodeHash:$i"); $ring[$key] = $nodeObject; }}

key的hash值也有了,服务器环也计算好了,剩下的就是查找了,二分法能较快的查找相应的服务器节点

更多关于Laravel相关内容感兴趣的读者可查看本站专题:《Laravel框架入门与进阶教程》、《php优秀开发框架总结》、《php面向对象程序设计入门教程》、《php+mysql数据库操作入门教程》及《php常见数据库操作技巧汇总》

希望本文所述对大家基于Laravel框架的PHP程序设计有所帮助。

本文实例讲述了Laravel框架实现redis集群的方法。分享给大家供大家参考,具体如下:

在app/config/database.php中配置如下:

'redis' => array( 'cluster' => true, 'default' => array( 'host' => '172.21.107.247', 'port' => 6379, ), 'redis1' => array( 'host' => '172.21.107.248', 'port' => 6379, ),

其中cluster选择为true,接下来就可以作集群使用了;

如果把session的driver设置为redis,则可以使用其集群功能了:

我们来看下session的实现,当我们在代码中这样写:

Session::put('test', 124);

实际的执行流程是这样的:

Illuminate\Support\Facades\SessionIlluminate\Support\Facades\FacadeIlluminate\Session\Facade::app['session']->putIlluminate\Session\Facade::app['session']为Illuminate\Session\SessionManagerIlluminate\Support\Manager::__call

Session会根据返回创建driver

$this->app['config']['session.driver']

即配置文件中配置的,这里我们配置为redis

Illuminate\Session\SessionManager::Illuminate\Session\SessionManager

最终由Illuminate\Session\Store来负责put的调用

而Store类负责存储的类是Illuminate\Session\CacheBasedSessionHandler

后者又将请求转发给$this->app['cache']->driver($driver)……经过一系列代码追查,存储类为Predis\Client\Database,看其构造函数:

public function __construct(array $servers = array()){ if (isset($servers['cluster']) && $servers['cluster']) { $this->clients = $this->createAggregateClient($servers); } else { $this->clients = $this->createSingleClients($servers); }}

如果设置为集群,则调用createAggregateClient方法

protected function createAggregateClient(array $servers){ $servers = array_except($servers, array('cluster')); return array('default' => new Client(array_values($servers)));}

这里会把所有服务器放在default组中

实际存数据的类是Predis\Client,这里有根据配置创建服务器的代码,具体可以自己看下;

Predis\Cluster\PredisClusterHashStrategy类负责计算key的hash,关键函数:

getHash

getKeyFromFirstArgument

而Predis\Cluster\Distribution\HashRing负责服务器环的维护,关键函数

addNodeToRing

get

hash

大概原理是这样,如执行以下redis命令

get ok

会将ok作crc32运算得到一个hash值

所有服务器按一定算法放到一个长度默认为128的数组中,每个服务器在其中占几项,由以下决定:

权重/总权重*总的服务器数量*128,可参考Predis\Cluster\Distribution\HashRing::addNodeToRing方法

每一项的hash值是按服务器ip:端口的格式,作crc32计算的

protected function addNodeToRing(&$ring, $node, $totalNodes, $replicas, $weightRatio){ $nodeObject = $node['object']; $nodeHash = $this->getNodeHash($nodeObject); $replicas = (int) round($weightRatio * $totalNodes * $replicas); for ($i = 0; $i < $replicas; $i++) { $key = crc32("$nodeHash:$i"); $ring[$key] = $nodeObject; }}

key的hash值也有了,服务器环也计算好了,剩下的就是查找了,二分法能较快的查找相应的服务器节点

更多关于Laravel相关内容感兴趣的读者可查看本站专题:《Laravel框架入门与进阶教程》、《php优秀开发框架总结》、《php面向对象程序设计入门教程》、《php+mysql数据库操作入门教程》及《php常见数据库操作技巧汇总》

希望本文所述对大家基于Laravel框架的PHP程序设计有所帮助。

本文实例讲述了Laravel框架实现redis集群的方法。分享给大家供大家参考,具体如下:

在app/config/database.php中配置如下:

'redis' => array( 'cluster' => true, 'default' => array( 'host' => '172.21.107.247', 'port' => 6379, ), 'redis1' => array( 'host' => '172.21.107.248', 'port' => 6379, ),

其中cluster选择为true,接下来就可以作集群使用了;

如果把session的driver设置为redis,则可以使用其集群功能了:

我们来看下session的实现,当我们在代码中这样写:

Session::put('test', 124);

实际的执行流程是这样的:

Illuminate\Support\Facades\SessionIlluminate\Support\Facades\FacadeIlluminate\Session\Facade::app['session']->putIlluminate\Session\Facade::app['session']为Illuminate\Session\SessionManagerIlluminate\Support\Manager::__call

Session会根据返回创建driver

$this->app['config']['session.driver']

即配置文件中配置的,这里我们配置为redis

Illuminate\Session\SessionManager::Illuminate\Session\SessionManager

最终由Illuminate\Session\Store来负责put的调用

而Store类负责存储的类是Illuminate\Session\CacheBasedSessionHandler

后者又将请求转发给$this->app['cache']->driver($driver)……经过一系列代码追查,存储类为Predis\Client\Database,看其构造函数:

public function __construct(array $servers = array()){ if (isset($servers['cluster']) && $servers['cluster']) { $this->clients = $this->createAggregateClient($servers); } else { $this->clients = $this->createSingleClients($servers); }}

如果设置为集群,则调用createAggregateClient方法

protected function createAggregateClient(array $servers){ $servers = array_except($servers, array('cluster')); return array('default' => new Client(array_values($servers)));}

这里会把所有服务器放在default组中

实际存数据的类是Predis\Client,这里有根据配置创建服务器的代码,具体可以自己看下;

Predis\Cluster\PredisClusterHashStrategy类负责计算key的hash,关键函数:

getHash

getKeyFromFirstArgument

而Predis\Cluster\Distribution\HashRing负责服务器环的维护,关键函数

addNodeToRing

get

hash

大概原理是这样,如执行以下redis命令

get ok

会将ok作crc32运算得到一个hash值

所有服务器按一定算法放到一个长度默认为128的数组中,每个服务器在其中占几项,由以下决定:

权重/总权重*总的服务器数量*128,可参考Predis\Cluster\Distribution\HashRing::addNodeToRing方法

每一项的hash值是按服务器ip:端口的格式,作crc32计算的

protected function addNodeToRing(&$ring, $node, $totalNodes, $replicas, $weightRatio){ $nodeObject = $node['object']; $nodeHash = $this->getNodeHash($nodeObject); $replicas = (int) round($weightRatio * $totalNodes * $replicas); for ($i = 0; $i < $replicas; $i++) { $key = crc32("$nodeHash:$i"); $ring[$key] = $nodeObject; }}

key的hash值也有了,服务器环也计算好了,剩下的就是查找了,二分法能较快的查找相应的服务器节点

更多关于Laravel相关内容感兴趣的读者可查看本站专题:《Laravel框架入门与进阶教程》、《php优秀开发框架总结》、《php面向对象程序设计入门教程》、《php+mysql数据库操作入门教程》及《php常见数据库操作技巧汇总》

希望本文所述对大家基于Laravel框架的PHP程序设计有所帮助。

Laravel框架实现redis集群的方法分析

Laravel框架实现redis集群的方法分析

本文实例讲述了Laravel框架实现redis集群的方法。分享给大家供大家参考,具体如下:

在app/config/database.php中配置如下:

'redis' => array( 'cluster' => true, 'default' => array( 'host' => '172.21.107.247', 'port' => 6379, ), 'redis1' => array( 'host' => '172.21.107.248', 'port' => 6379, ),

其中cluster选择为true,接下来就可以作集群使用了;

如果把session的driver设置为redis,则可以使用其集群功能了:

我们来看下session的实现,当我们在代码中这样写:

Session::put('test', 124);

实际的执行流程是这样的:

Illuminate\Support\Facades\SessionIlluminate\Support\Facades\FacadeIlluminate\Session\Facade::app['session']->putIlluminate\Session\Facade::app['session']为Illuminate\Session\SessionManagerIlluminate\Support\Manager::__call

Session会根据返回创建driver

$this->app['config']['session.driver']

即配置文件中配置的,这里我们配置为redis

Illuminate\Session\SessionManager::Illuminate\Session\SessionManager

最终由Illuminate\Session\Store来负责put的调用

而Store类负责存储的类是Illuminate\Session\CacheBasedSessionHandler

后者又将请求转发给$this->app['cache']->driver($driver)……经过一系列代码追查,存储类为Predis\Client\Database,看其构造函数:

public function __construct(array $servers = array()){ if (isset($servers['cluster']) && $servers['cluster']) { $this->clients = $this->createAggregateClient($servers); } else { $this->clients = $this->createSingleClients($servers); }}

如果设置为集群,则调用createAggregateClient方法

protected function createAggregateClient(array $servers){ $servers = array_except($servers, array('cluster')); return array('default' => new Client(array_values($servers)));}

这里会把所有服务器放在default组中

实际存数据的类是Predis\Client,这里有根据配置创建服务器的代码,具体可以自己看下;

Predis\Cluster\PredisClusterHashStrategy类负责计算key的hash,关键函数:

getHash

getKeyFromFirstArgument

而Predis\Cluster\Distribution\HashRing负责服务器环的维护,关键函数

addNodeToRing

get

hash

大概原理是这样,如执行以下redis命令

get ok

会将ok作crc32运算得到一个hash值

所有服务器按一定算法放到一个长度默认为128的数组中,每个服务器在其中占几项,由以下决定:

权重/总权重*总的服务器数量*128,可参考Predis\Cluster\Distribution\HashRing::addNodeToRing方法

每一项的hash值是按服务器ip:端口的格式,作crc32计算的

protected function addNodeToRing(&$ring, $node, $totalNodes, $replicas, $weightRatio){ $nodeObject = $node['object']; $nodeHash = $this->getNodeHash($nodeObject); $replicas = (int) round($weightRatio * $totalNodes * $replicas); for ($i = 0; $i < $replicas; $i++) { $key = crc32("$nodeHash:$i"); $ring[$key] = $nodeObject; }}

key的hash值也有了,服务器环也计算好了,剩下的就是查找了,二分法能较快的查找相应的服务器节点

更多关于Laravel相关内容感兴趣的读者可查看本站专题:《Laravel框架入门与进阶教程》、《php优秀开发框架总结》、《php面向对象程序设计入门教程》、《php+mysql数据库操作入门教程》及《php常见数据库操作技巧汇总》

希望本文所述对大家基于Laravel框架的PHP程序设计有所帮助。

Laravel框架实现redis集群的方法分析Laravel框架实现redis集群的方法分析

本文实例讲述了Laravel框架实现redis集群的方法。分享给大家供大家参考,具体如下:

在app/config/database.php中配置如下:

'redis' => array( 'cluster' => true, 'default' => array( 'host' => '172.21.107.247', 'port' => 6379, ), 'redis1' => array( 'host' => '172.21.107.248', 'port' => 6379, ),

其中cluster选择为true,接下来就可以作集群使用了;

如果把session的driver设置为redis,则可以使用其集群功能了:

我们来看下session的实现,当我们在代码中这样写:

Session::put('test', 124);

实际的执行流程是这样的:

Illuminate\Support\Facades\SessionIlluminate\Support\Facades\FacadeIlluminate\Session\Facade::app['session']->putIlluminate\Session\Facade::app['session']为Illuminate\Session\SessionManagerIlluminate\Support\Manager::__call

Session会根据返回创建driver

$this->app['config']['session.driver']

即配置文件中配置的,这里我们配置为redis

Illuminate\Session\SessionManager::Illuminate\Session\SessionManager

最终由Illuminate\Session\Store来负责put的调用

而Store类负责存储的类是Illuminate\Session\CacheBasedSessionHandler

后者又将请求转发给$this->app['cache']->driver($driver)……经过一系列代码追查,存储类为Predis\Client\Database,看其构造函数:

public function __construct(array $servers = array()){ if (isset($servers['cluster']) && $servers['cluster']) { $this->clients = $this->createAggregateClient($servers); } else { $this->clients = $this->createSingleClients($servers); }}

如果设置为集群,则调用createAggregateClient方法

protected function createAggregateClient(array $servers){ $servers = array_except($servers, array('cluster')); return array('default' => new Client(array_values($servers)));}

这里会把所有服务器放在default组中

实际存数据的类是Predis\Client,这里有根据配置创建服务器的代码,具体可以自己看下;

Predis\Cluster\PredisClusterHashStrategy类负责计算key的hash,关键函数:

getHash

getKeyFromFirstArgument

而Predis\Cluster\Distribution\HashRing负责服务器环的维护,关键函数

addNodeToRing

get

hash

大概原理是这样,如执行以下redis命令

get ok

会将ok作crc32运算得到一个hash值

所有服务器按一定算法放到一个长度默认为128的数组中,每个服务器在其中占几项,由以下决定:

权重/总权重*总的服务器数量*128,可参考Predis\Cluster\Distribution\HashRing::addNodeToRing方法

每一项的hash值是按服务器ip:端口的格式,作crc32计算的

protected function addNodeToRing(&$ring, $node, $totalNodes, $replicas, $weightRatio){ $nodeObject = $node['object']; $nodeHash = $this->getNodeHash($nodeObject); $replicas = (int) round($weightRatio * $totalNodes * $replicas); for ($i = 0; $i < $replicas; $i++) { $key = crc32("$nodeHash:$i"); $ring[$key] = $nodeObject; }}

key的hash值也有了,服务器环也计算好了,剩下的就是查找了,二分法能较快的查找相应的服务器节点

更多关于Laravel相关内容感兴趣的读者可查看本站专题:《Laravel框架入门与进阶教程》、《php优秀开发框架总结》、《php面向对象程序设计入门教程》、《php+mysql数据库操作入门教程》及《php常见数据库操作技巧汇总》

希望本文所述对大家基于Laravel框架的PHP程序设计有所帮助。

Laravel框架实现redis集群的方法分析

本文实例讲述了Laravel框架实现redis集群的方法。分享给大家供大家参考,具体如下:

在app/config/database.php中配置如下:

'redis' => array( 'cluster' => true, 'default' => array( 'host' => '172.21.107.247', 'port' => 6379, ), 'redis1' => array( 'host' => '172.21.107.248', 'port' => 6379, ),

其中cluster选择为true,接下来就可以作集群使用了;

如果把session的driver设置为redis,则可以使用其集群功能了:

我们来看下session的实现,当我们在代码中这样写:

Session::put('test', 124);

实际的执行流程是这样的:

Illuminate\Support\Facades\SessionIlluminate\Support\Facades\FacadeIlluminate\Session\Facade::app['session']->putIlluminate\Session\Facade::app['session']为Illuminate\Session\SessionManagerIlluminate\Support\Manager::__call

Session会根据返回创建driver

$this->app['config']['session.driver']

即配置文件中配置的,这里我们配置为redis

Illuminate\Session\SessionManager::Illuminate\Session\SessionManager

最终由Illuminate\Session\Store来负责put的调用

而Store类负责存储的类是Illuminate\Session\CacheBasedSessionHandler

后者又将请求转发给$this->app['cache']->driver($driver)……经过一系列代码追查,存储类为Predis\Client\Database,看其构造函数:

public function __construct(array $servers = array()){ if (isset($servers['cluster']) && $servers['cluster']) { $this->clients = $this->createAggregateClient($servers); } else { $this->clients = $this->createSingleClients($servers); }}

如果设置为集群,则调用createAggregateClient方法

protected function createAggregateClient(array $servers){ $servers = array_except($servers, array('cluster')); return array('default' => new Client(array_values($servers)));}

这里会把所有服务器放在default组中

实际存数据的类是Predis\Client,这里有根据配置创建服务器的代码,具体可以自己看下;

Predis\Cluster\PredisClusterHashStrategy类负责计算key的hash,关键函数:

getHash

getKeyFromFirstArgument

而Predis\Cluster\Distribution\HashRing负责服务器环的维护,关键函数

addNodeToRing

get

hash

大概原理是这样,如执行以下redis命令

get ok

会将ok作crc32运算得到一个hash值

所有服务器按一定算法放到一个长度默认为128的数组中,每个服务器在其中占几项,由以下决定:

权重/总权重*总的服务器数量*128,可参考Predis\Cluster\Distribution\HashRing::addNodeToRing方法

每一项的hash值是按服务器ip:端口的格式,作crc32计算的

protected function addNodeToRing(&$ring, $node, $totalNodes, $replicas, $weightRatio){ $nodeObject = $node['object']; $nodeHash = $this->getNodeHash($nodeObject); $replicas = (int) round($weightRatio * $totalNodes * $replicas); for ($i = 0; $i < $replicas; $i++) { $key = crc32("$nodeHash:$i"); $ring[$key] = $nodeObject; }}

key的hash值也有了,服务器环也计算好了,剩下的就是查找了,二分法能较快的查找相应的服务器节点

更多关于Laravel相关内容感兴趣的读者可查看本站专题:《Laravel框架入门与进阶教程》、《php优秀开发框架总结》、《php面向对象程序设计入门教程》、《php+mysql数据库操作入门教程》及《php常见数据库操作技巧汇总》

希望本文所述对大家基于Laravel框架的PHP程序设计有所帮助。

Laravel框架实现redis集群的方法分析

本文实例讲述了Laravel框架实现redis集群的方法。分享给大家供大家参考,具体如下:

在app/config/database.php中配置如下:

'redis' => array( 'cluster' => true, 'default' => array( 'host' => '172.21.107.247', 'port' => 6379, ), 'redis1' => array( 'host' => '172.21.107.248', 'port' => 6379, ),

其中cluster选择为true,接下来就可以作集群使用了;

如果把session的driver设置为redis,则可以使用其集群功能了:

我们来看下session的实现,当我们在代码中这样写:

Session::put('test', 124);

实际的执行流程是这样的:

Illuminate\Support\Facades\SessionIlluminate\Support\Facades\FacadeIlluminate\Session\Facade::app['session']->putIlluminate\Session\Facade::app['session']为Illuminate\Session\SessionManagerIlluminate\Support\Manager::__call

Session会根据返回创建driver

$this->app['config']['session.driver']

即配置文件中配置的,这里我们配置为redis

Illuminate\Session\SessionManager::Illuminate\Session\SessionManager

最终由Illuminate\Session\Store来负责put的调用

而Store类负责存储的类是Illuminate\Session\CacheBasedSessionHandler

后者又将请求转发给$this->app['cache']->driver($driver)……经过一系列代码追查,存储类为Predis\Client\Database,看其构造函数:

public function __construct(array $servers = array()){ if (isset($servers['cluster']) && $servers['cluster']) { $this->clients = $this->createAggregateClient($servers); } else { $this->clients = $this->createSingleClients($servers); }}

如果设置为集群,则调用createAggregateClient方法

protected function createAggregateClient(array $servers){ $servers = array_except($servers, array('cluster')); return array('default' => new Client(array_values($servers)));}

这里会把所有服务器放在default组中

实际存数据的类是Predis\Client,这里有根据配置创建服务器的代码,具体可以自己看下;

Predis\Cluster\PredisClusterHashStrategy类负责计算key的hash,关键函数:

getHash

getKeyFromFirstArgument

而Predis\Cluster\Distribution\HashRing负责服务器环的维护,关键函数

addNodeToRing

get

hash

大概原理是这样,如执行以下redis命令

get ok

会将ok作crc32运算得到一个hash值

所有服务器按一定算法放到一个长度默认为128的数组中,每个服务器在其中占几项,由以下决定:

权重/总权重*总的服务器数量*128,可参考Predis\Cluster\Distribution\HashRing::addNodeToRing方法

每一项的hash值是按服务器ip:端口的格式,作crc32计算的

protected function addNodeToRing(&$ring, $node, $totalNodes, $replicas, $weightRatio){ $nodeObject = $node['object']; $nodeHash = $this->getNodeHash($nodeObject); $replicas = (int) round($weightRatio * $totalNodes * $replicas); for ($i = 0; $i < $replicas; $i++) { $key = crc32("$nodeHash:$i"); $ring[$key] = $nodeObject; }}

key的hash值也有了,服务器环也计算好了,剩下的就是查找了,二分法能较快的查找相应的服务器节点

更多关于Laravel相关内容感兴趣的读者可查看本站专题:《Laravel框架入门与进阶教程》、《php优秀开发框架总结》、《php面向对象程序设计入门教程》、《php+mysql数据库操作入门教程》及《php常见数据库操作技巧汇总》

希望本文所述对大家基于Laravel框架的PHP程序设计有所帮助。

本文实例讲述了Laravel框架实现redis集群的方法。分享给大家供大家参考,具体如下:

在app/config/database.php中配置如下:

'redis' => array( 'cluster' => true, 'default' => array( 'host' => '172.21.107.247', 'port' => 6379, ), 'redis1' => array( 'host' => '172.21.107.248', 'port' => 6379, ),

其中cluster选择为true,接下来就可以作集群使用了;

如果把session的driver设置为redis,则可以使用其集群功能了:

我们来看下session的实现,当我们在代码中这样写:

Session::put('test', 124);

实际的执行流程是这样的:

Illuminate\Support\Facades\SessionIlluminate\Support\Facades\FacadeIlluminate\Session\Facade::app['session']->putIlluminate\Session\Facade::app['session']为Illuminate\Session\SessionManagerIlluminate\Support\Manager::__call

Session会根据返回创建driver

$this->app['config']['session.driver']

即配置文件中配置的,这里我们配置为redis

Illuminate\Session\SessionManager::Illuminate\Session\SessionManager

最终由Illuminate\Session\Store来负责put的调用

而Store类负责存储的类是Illuminate\Session\CacheBasedSessionHandler

后者又将请求转发给$this->app['cache']->driver($driver)……经过一系列代码追查,存储类为Predis\Client\Database,看其构造函数:

public function __construct(array $servers = array()){ if (isset($servers['cluster']) && $servers['cluster']) { $this->clients = $this->createAggregateClient($servers); } else { $this->clients = $this->createSingleClients($servers); }}

如果设置为集群,则调用createAggregateClient方法

protected function createAggregateClient(array $servers){ $servers = array_except($servers, array('cluster')); return array('default' => new Client(array_values($servers)));}

这里会把所有服务器放在default组中

实际存数据的类是Predis\Client,这里有根据配置创建服务器的代码,具体可以自己看下;

Predis\Cluster\PredisClusterHashStrategy类负责计算key的hash,关键函数:

getHash

getKeyFromFirstArgument

而Predis\Cluster\Distribution\HashRing负责服务器环的维护,关键函数

addNodeToRing

get

hash

大概原理是这样,如执行以下redis命令

get ok

会将ok作crc32运算得到一个hash值

所有服务器按一定算法放到一个长度默认为128的数组中,每个服务器在其中占几项,由以下决定:

权重/总权重*总的服务器数量*128,可参考Predis\Cluster\Distribution\HashRing::addNodeToRing方法

每一项的hash值是按服务器ip:端口的格式,作crc32计算的

protected function addNodeToRing(&$ring, $node, $totalNodes, $replicas, $weightRatio){ $nodeObject = $node['object']; $nodeHash = $this->getNodeHash($nodeObject); $replicas = (int) round($weightRatio * $totalNodes * $replicas); for ($i = 0; $i < $replicas; $i++) { $key = crc32("$nodeHash:$i"); $ring[$key] = $nodeObject; }}

key的hash值也有了,服务器环也计算好了,剩下的就是查找了,二分法能较快的查找相应的服务器节点

更多关于Laravel相关内容感兴趣的读者可查看本站专题:《Laravel框架入门与进阶教程》、《php优秀开发框架总结》、《php面向对象程序设计入门教程》、《php+mysql数据库操作入门教程》及《php常见数据库操作技巧汇总》

希望本文所述对大家基于Laravel框架的PHP程序设计有所帮助。

Laravel框架实现redis集群的方法分析

本文实例讲述了Laravel框架实现redis集群的方法。分享给大家供大家参考,具体如下:

在app/config/database.php中配置如下:

'redis' => array( 'cluster' => true, 'default' => array( 'host' => '172.21.107.247', 'port' => 6379, ), 'redis1' => array( 'host' => '172.21.107.248', 'port' => 6379, ),

其中cluster选择为true,接下来就可以作集群使用了;

如果把session的driver设置为redis,则可以使用其集群功能了:

我们来看下session的实现,当我们在代码中这样写:

Session::put('test', 124);

实际的执行流程是这样的:

Illuminate\Support\Facades\SessionIlluminate\Support\Facades\FacadeIlluminate\Session\Facade::app['session']->putIlluminate\Session\Facade::app['session']为Illuminate\Session\SessionManagerIlluminate\Support\Manager::__call

Session会根据返回创建driver

$this->app['config']['session.driver']

即配置文件中配置的,这里我们配置为redis

Illuminate\Session\SessionManager::Illuminate\Session\SessionManager

最终由Illuminate\Session\Store来负责put的调用

而Store类负责存储的类是Illuminate\Session\CacheBasedSessionHandler

后者又将请求转发给$this->app['cache']->driver($driver)……经过一系列代码追查,存储类为Predis\Client\Database,看其构造函数:

public function __construct(array $servers = array()){ if (isset($servers['cluster']) && $servers['cluster']) { $this->clients = $this->createAggregateClient($servers); } else { $this->clients = $this->createSingleClients($servers); }}

如果设置为集群,则调用createAggregateClient方法

protected function createAggregateClient(array $servers){ $servers = array_except($servers, array('cluster')); return array('default' => new Client(array_values($servers)));}

这里会把所有服务器放在default组中

实际存数据的类是Predis\Client,这里有根据配置创建服务器的代码,具体可以自己看下;

Predis\Cluster\PredisClusterHashStrategy类负责计算key的hash,关键函数:

getHash

getKeyFromFirstArgument

而Predis\Cluster\Distribution\HashRing负责服务器环的维护,关键函数

addNodeToRing

get

hash

大概原理是这样,如执行以下redis命令

get ok

会将ok作crc32运算得到一个hash值

所有服务器按一定算法放到一个长度默认为128的数组中,每个服务器在其中占几项,由以下决定:

权重/总权重*总的服务器数量*128,可参考Predis\Cluster\Distribution\HashRing::addNodeToRing方法

每一项的hash值是按服务器ip:端口的格式,作crc32计算的

protected function addNodeToRing(&$ring, $node, $totalNodes, $replicas, $weightRatio){ $nodeObject = $node['object']; $nodeHash = $this->getNodeHash($nodeObject); $replicas = (int) round($weightRatio * $totalNodes * $replicas); for ($i = 0; $i < $replicas; $i++) { $key = crc32("$nodeHash:$i"); $ring[$key] = $nodeObject; }}

key的hash值也有了,服务器环也计算好了,剩下的就是查找了,二分法能较快的查找相应的服务器节点

更多关于Laravel相关内容感兴趣的读者可查看本站专题:《Laravel框架入门与进阶教程》、《php优秀开发框架总结》、《php面向对象程序设计入门教程》、《php+mysql数据库操作入门教程》及《php常见数据库操作技巧汇总》

希望本文所述对大家基于Laravel框架的PHP程序设计有所帮助。

本文实例讲述了Laravel框架实现redis集群的方法。分享给大家供大家参考,具体如下:

在app/config/database.php中配置如下:

'redis' => array( 'cluster' => true, 'default' => array( 'host' => '172.21.107.247', 'port' => 6379, ), 'redis1' => array( 'host' => '172.21.107.248', 'port' => 6379, ),

其中cluster选择为true,接下来就可以作集群使用了;

如果把session的driver设置为redis,则可以使用其集群功能了:

我们来看下session的实现,当我们在代码中这样写:

Session::put('test', 124);

实际的执行流程是这样的:

Illuminate\Support\Facades\SessionIlluminate\Support\Facades\FacadeIlluminate\Session\Facade::app['session']->putIlluminate\Session\Facade::app['session']为Illuminate\Session\SessionManagerIlluminate\Support\Manager::__call

Session会根据返回创建driver

$this->app['config']['session.driver']

即配置文件中配置的,这里我们配置为redis

Illuminate\Session\SessionManager::Illuminate\Session\SessionManager

最终由Illuminate\Session\Store来负责put的调用

而Store类负责存储的类是Illuminate\Session\CacheBasedSessionHandler

后者又将请求转发给$this->app['cache']->driver($driver)……经过一系列代码追查,存储类为Predis\Client\Database,看其构造函数:

public function __construct(array $servers = array()){ if (isset($servers['cluster']) && $servers['cluster']) { $this->clients = $this->createAggregateClient($servers); } else { $this->clients = $this->createSingleClients($servers); }}

如果设置为集群,则调用createAggregateClient方法

protected function createAggregateClient(array $servers){ $servers = array_except($servers, array('cluster')); return array('default' => new Client(array_values($servers)));}

这里会把所有服务器放在default组中

实际存数据的类是Predis\Client,这里有根据配置创建服务器的代码,具体可以自己看下;

Predis\Cluster\PredisClusterHashStrategy类负责计算key的hash,关键函数:

getHash

getKeyFromFirstArgument

而Predis\Cluster\Distribution\HashRing负责服务器环的维护,关键函数

addNodeToRing

get

hash

大概原理是这样,如执行以下redis命令

get ok

会将ok作crc32运算得到一个hash值

所有服务器按一定算法放到一个长度默认为128的数组中,每个服务器在其中占几项,由以下决定:

权重/总权重*总的服务器数量*128,可参考Predis\Cluster\Distribution\HashRing::addNodeToRing方法

每一项的hash值是按服务器ip:端口的格式,作crc32计算的

protected function addNodeToRing(&$ring, $node, $totalNodes, $replicas, $weightRatio){ $nodeObject = $node['object']; $nodeHash = $this->getNodeHash($nodeObject); $replicas = (int) round($weightRatio * $totalNodes * $replicas); for ($i = 0; $i < $replicas; $i++) { $key = crc32("$nodeHash:$i"); $ring[$key] = $nodeObject; }}

key的hash值也有了,服务器环也计算好了,剩下的就是查找了,二分法能较快的查找相应的服务器节点

更多关于Laravel相关内容感兴趣的读者可查看本站专题:《Laravel框架入门与进阶教程》、《php优秀开发框架总结》、《php面向对象程序设计入门教程》、《php+mysql数据库操作入门教程》及《php常见数据库操作技巧汇总》

希望本文所述对大家基于Laravel框架的PHP程序设计有所帮助。

本文实例讲述了Laravel框架实现redis集群的方法。分享给大家供大家参考,具体如下:

在app/config/database.php中配置如下:

'redis' => array( 'cluster' => true, 'default' => array( 'host' => '172.21.107.247', 'port' => 6379, ), 'redis1' => array( 'host' => '172.21.107.248', 'port' => 6379, ),

其中cluster选择为true,接下来就可以作集群使用了;

如果把session的driver设置为redis,则可以使用其集群功能了:

我们来看下session的实现,当我们在代码中这样写:

Session::put('test', 124);

实际的执行流程是这样的:

Illuminate\Support\Facades\SessionIlluminate\Support\Facades\FacadeIlluminate\Session\Facade::app['session']->putIlluminate\Session\Facade::app['session']为Illuminate\Session\SessionManagerIlluminate\Support\Manager::__call

Session会根据返回创建driver

$this->app['config']['session.driver']

即配置文件中配置的,这里我们配置为redis

Illuminate\Session\SessionManager::Illuminate\Session\SessionManager

最终由Illuminate\Session\Store来负责put的调用

而Store类负责存储的类是Illuminate\Session\CacheBasedSessionHandler

后者又将请求转发给$this->app['cache']->driver($driver)……经过一系列代码追查,存储类为Predis\Client\Database,看其构造函数:

public function __construct(array $servers = array()){ if (isset($servers['cluster']) && $servers['cluster']) { $this->clients = $this->createAggregateClient($servers); } else { $this->clients = $this->createSingleClients($servers); }}

如果设置为集群,则调用createAggregateClient方法

protected function createAggregateClient(array $servers){ $servers = array_except($servers, array('cluster')); return array('default' => new Client(array_values($servers)));}

这里会把所有服务器放在default组中

实际存数据的类是Predis\Client,这里有根据配置创建服务器的代码,具体可以自己看下;

Predis\Cluster\PredisClusterHashStrategy类负责计算key的hash,关键函数:

getHash

getKeyFromFirstArgument

而Predis\Cluster\Distribution\HashRing负责服务器环的维护,关键函数

addNodeToRing

get

hash

大概原理是这样,如执行以下redis命令

get ok

会将ok作crc32运算得到一个hash值

所有服务器按一定算法放到一个长度默认为128的数组中,每个服务器在其中占几项,由以下决定:

权重/总权重*总的服务器数量*128,可参考Predis\Cluster\Distribution\HashRing::addNodeToRing方法

每一项的hash值是按服务器ip:端口的格式,作crc32计算的

protected function addNodeToRing(&$ring, $node, $totalNodes, $replicas, $weightRatio){ $nodeObject = $node['object']; $nodeHash = $this->getNodeHash($nodeObject); $replicas = (int) round($weightRatio * $totalNodes * $replicas); for ($i = 0; $i < $replicas; $i++) { $key = crc32("$nodeHash:$i"); $ring[$key] = $nodeObject; }}

key的hash值也有了,服务器环也计算好了,剩下的就是查找了,二分法能较快的查找相应的服务器节点

更多关于Laravel相关内容感兴趣的读者可查看本站专题:《Laravel框架入门与进阶教程》、《php优秀开发框架总结》、《php面向对象程序设计入门教程》、《php+mysql数据库操作入门教程》及《php常见数据库操作技巧汇总》

希望本文所述对大家基于Laravel框架的PHP程序设计有所帮助。

本文实例讲述了Laravel框架实现redis集群的方法。分享给大家供大家参考,具体如下:

在app/config/database.php中配置如下:

'redis' => array( 'cluster' => true, 'default' => array( 'host' => '172.21.107.247', 'port' => 6379, ), 'redis1' => array( 'host' => '172.21.107.248', 'port' => 6379, ),

其中cluster选择为true,接下来就可以作集群使用了;

如果把session的driver设置为redis,则可以使用其集群功能了:

我们来看下session的实现,当我们在代码中这样写:

Session::put('test', 124);

实际的执行流程是这样的:

Illuminate\Support\Facades\SessionIlluminate\Support\Facades\FacadeIlluminate\Session\Facade::app['session']->putIlluminate\Session\Facade::app['session']为Illuminate\Session\SessionManagerIlluminate\Support\Manager::__call

Session会根据返回创建driver

$this->app['config']['session.driver']

即配置文件中配置的,这里我们配置为redis

Illuminate\Session\SessionManager::Illuminate\Session\SessionManager

最终由Illuminate\Session\Store来负责put的调用

而Store类负责存储的类是Illuminate\Session\CacheBasedSessionHandler

后者又将请求转发给$this->app['cache']->driver($driver)……经过一系列代码追查,存储类为Predis\Client\Database,看其构造函数:

public function __construct(array $servers = array()){ if (isset($servers['cluster']) && $servers['cluster']) { $this->clients = $this->createAggregateClient($servers); } else { $this->clients = $this->createSingleClients($servers); }}

如果设置为集群,则调用createAggregateClient方法

protected function createAggregateClient(array $servers){ $servers = array_except($servers, array('cluster')); return array('default' => new Client(array_values($servers)));}

这里会把所有服务器放在default组中

实际存数据的类是Predis\Client,这里有根据配置创建服务器的代码,具体可以自己看下;

Predis\Cluster\PredisClusterHashStrategy类负责计算key的hash,关键函数:

getHash

getKeyFromFirstArgument

而Predis\Cluster\Distribution\HashRing负责服务器环的维护,关键函数

addNodeToRing

get

hash

大概原理是这样,如执行以下redis命令

get ok

会将ok作crc32运算得到一个hash值

所有服务器按一定算法放到一个长度默认为128的数组中,每个服务器在其中占几项,由以下决定:

权重/总权重*总的服务器数量*128,可参考Predis\Cluster\Distribution\HashRing::addNodeToRing方法

每一项的hash值是按服务器ip:端口的格式,作crc32计算的

protected function addNodeToRing(&$ring, $node, $totalNodes, $replicas, $weightRatio){ $nodeObject = $node['object']; $nodeHash = $this->getNodeHash($nodeObject); $replicas = (int) round($weightRatio * $totalNodes * $replicas); for ($i = 0; $i < $replicas; $i++) { $key = crc32("$nodeHash:$i"); $ring[$key] = $nodeObject; }}

key的hash值也有了,服务器环也计算好了,剩下的就是查找了,二分法能较快的查找相应的服务器节点

更多关于Laravel相关内容感兴趣的读者可查看本站专题:《Laravel框架入门与进阶教程》、《php优秀开发框架总结》、《php面向对象程序设计入门教程》、《php+mysql数据库操作入门教程》及《php常见数据库操作技巧汇总》

希望本文所述对大家基于Laravel框架的PHP程序设计有所帮助。

澳门汽车玻璃厂家价格

本文实例讲述了Laravel框架实现redis集群的方法。分享给大家供大家参考,具体如下:

在app/config/database.php中配置如下:

'redis' => array( 'cluster' => true, 'default' => array( 'host' => '172.21.107.247', 'port' => 6379, ), 'redis1' => array( 'host' => '172.21.107.248', 'port' => 6379, ),

其中cluster选择为true,接下来就可以作集群使用了;

如果把session的driver设置为redis,则可以使用其集群功能了:

我们来看下session的实现,当我们在代码中这样写:

Session::put('test', 124);

实际的执行流程是这样的:

Illuminate\Support\Facades\SessionIlluminate\Support\Facades\FacadeIlluminate\Session\Facade::app['session']->putIlluminate\Session\Facade::app['session']为Illuminate\Session\SessionManagerIlluminate\Support\Manager::__call

Session会根据返回创建driver

$this->app['config']['session.driver']

即配置文件中配置的,这里我们配置为redis

Illuminate\Session\SessionManager::Illuminate\Session\SessionManager

最终由Illuminate\Session\Store来负责put的调用

而Store类负责存储的类是Illuminate\Session\CacheBasedSessionHandler

后者又将请求转发给$this->app['cache']->driver($driver)……经过一系列代码追查,存储类为Predis\Client\Database,看其构造函数:

public function __construct(array $servers = array()){ if (isset($servers['cluster']) && $servers['cluster']) { $this->clients = $this->createAggregateClient($servers); } else { $this->clients = $this->createSingleClients($servers); }}

如果设置为集群,则调用createAggregateClient方法

protected function createAggregateClient(array $servers){ $servers = array_except($servers, array('cluster')); return array('default' => new Client(array_values($servers)));}

这里会把所有服务器放在default组中

实际存数据的类是Predis\Client,这里有根据配置创建服务器的代码,具体可以自己看下;

Predis\Cluster\PredisClusterHashStrategy类负责计算key的hash,关键函数:

getHash

getKeyFromFirstArgument

而Predis\Cluster\Distribution\HashRing负责服务器环的维护,关键函数

addNodeToRing

get

hash

大概原理是这样,如执行以下redis命令

get ok

会将ok作crc32运算得到一个hash值

所有服务器按一定算法放到一个长度默认为128的数组中,每个服务器在其中占几项,由以下决定:

权重/总权重*总的服务器数量*128,可参考Predis\Cluster\Distribution\HashRing::addNodeToRing方法

每一项的hash值是按服务器ip:端口的格式,作crc32计算的

protected function addNodeToRing(&$ring, $node, $totalNodes, $replicas, $weightRatio){ $nodeObject = $node['object']; $nodeHash = $this->getNodeHash($nodeObject); $replicas = (int) round($weightRatio * $totalNodes * $replicas); for ($i = 0; $i < $replicas; $i++) { $key = crc32("$nodeHash:$i"); $ring[$key] = $nodeObject; }}

key的hash值也有了,服务器环也计算好了,剩下的就是查找了,二分法能较快的查找相应的服务器节点

更多关于Laravel相关内容感兴趣的读者可查看本站专题:《Laravel框架入门与进阶教程》、《php优秀开发框架总结》、《php面向对象程序设计入门教程》、《php+mysql数据库操作入门教程》及《php常见数据库操作技巧汇总》

希望本文所述对大家基于Laravel框架的PHP程序设计有所帮助。

Laravel框架实现redis集群的方法分析Laravel框架实现redis集群的方法分析

本文实例讲述了Laravel框架实现redis集群的方法。分享给大家供大家参考,具体如下:

在app/config/database.php中配置如下:

'redis' => array( 'cluster' => true, 'default' => array( 'host' => '172.21.107.247', 'port' => 6379, ), 'redis1' => array( 'host' => '172.21.107.248', 'port' => 6379, ),

其中cluster选择为true,接下来就可以作集群使用了;

如果把session的driver设置为redis,则可以使用其集群功能了:

我们来看下session的实现,当我们在代码中这样写:

Session::put('test', 124);

实际的执行流程是这样的:

Illuminate\Support\Facades\SessionIlluminate\Support\Facades\FacadeIlluminate\Session\Facade::app['session']->putIlluminate\Session\Facade::app['session']为Illuminate\Session\SessionManagerIlluminate\Support\Manager::__call

Session会根据返回创建driver

$this->app['config']['session.driver']

即配置文件中配置的,这里我们配置为redis

Illuminate\Session\SessionManager::Illuminate\Session\SessionManager

最终由Illuminate\Session\Store来负责put的调用

而Store类负责存储的类是Illuminate\Session\CacheBasedSessionHandler

后者又将请求转发给$this->app['cache']->driver($driver)……经过一系列代码追查,存储类为Predis\Client\Database,看其构造函数:

public function __construct(array $servers = array()){ if (isset($servers['cluster']) && $servers['cluster']) { $this->clients = $this->createAggregateClient($servers); } else { $this->clients = $this->createSingleClients($servers); }}

如果设置为集群,则调用createAggregateClient方法

protected function createAggregateClient(array $servers){ $servers = array_except($servers, array('cluster')); return array('default' => new Client(array_values($servers)));}

这里会把所有服务器放在default组中

实际存数据的类是Predis\Client,这里有根据配置创建服务器的代码,具体可以自己看下;

Predis\Cluster\PredisClusterHashStrategy类负责计算key的hash,关键函数:

getHash

getKeyFromFirstArgument

而Predis\Cluster\Distribution\HashRing负责服务器环的维护,关键函数

addNodeToRing

get

hash

大概原理是这样,如执行以下redis命令

get ok

会将ok作crc32运算得到一个hash值

所有服务器按一定算法放到一个长度默认为128的数组中,每个服务器在其中占几项,由以下决定:

权重/总权重*总的服务器数量*128,可参考Predis\Cluster\Distribution\HashRing::addNodeToRing方法

每一项的hash值是按服务器ip:端口的格式,作crc32计算的

protected function addNodeToRing(&$ring, $node, $totalNodes, $replicas, $weightRatio){ $nodeObject = $node['object']; $nodeHash = $this->getNodeHash($nodeObject); $replicas = (int) round($weightRatio * $totalNodes * $replicas); for ($i = 0; $i < $replicas; $i++) { $key = crc32("$nodeHash:$i"); $ring[$key] = $nodeObject; }}

key的hash值也有了,服务器环也计算好了,剩下的就是查找了,二分法能较快的查找相应的服务器节点

更多关于Laravel相关内容感兴趣的读者可查看本站专题:《Laravel框架入门与进阶教程》、《php优秀开发框架总结》、《php面向对象程序设计入门教程》、《php+mysql数据库操作入门教程》及《php常见数据库操作技巧汇总》

希望本文所述对大家基于Laravel框架的PHP程序设计有所帮助。

本文实例讲述了Laravel框架实现redis集群的方法。分享给大家供大家参考,具体如下:

在app/config/database.php中配置如下:

'redis' => array( 'cluster' => true, 'default' => array( 'host' => '172.21.107.247', 'port' => 6379, ), 'redis1' => array( 'host' => '172.21.107.248', 'port' => 6379, ),

其中cluster选择为true,接下来就可以作集群使用了;

如果把session的driver设置为redis,则可以使用其集群功能了:

我们来看下session的实现,当我们在代码中这样写:

Session::put('test', 124);

实际的执行流程是这样的:

Illuminate\Support\Facades\SessionIlluminate\Support\Facades\FacadeIlluminate\Session\Facade::app['session']->putIlluminate\Session\Facade::app['session']为Illuminate\Session\SessionManagerIlluminate\Support\Manager::__call

Session会根据返回创建driver

$this->app['config']['session.driver']

即配置文件中配置的,这里我们配置为redis

Illuminate\Session\SessionManager::Illuminate\Session\SessionManager

最终由Illuminate\Session\Store来负责put的调用

而Store类负责存储的类是Illuminate\Session\CacheBasedSessionHandler

后者又将请求转发给$this->app['cache']->driver($driver)……经过一系列代码追查,存储类为Predis\Client\Database,看其构造函数:

public function __construct(array $servers = array()){ if (isset($servers['cluster']) && $servers['cluster']) { $this->clients = $this->createAggregateClient($servers); } else { $this->clients = $this->createSingleClients($servers); }}

如果设置为集群,则调用createAggregateClient方法

protected function createAggregateClient(array $servers){ $servers = array_except($servers, array('cluster')); return array('default' => new Client(array_values($servers)));}

这里会把所有服务器放在default组中

实际存数据的类是Predis\Client,这里有根据配置创建服务器的代码,具体可以自己看下;

Predis\Cluster\PredisClusterHashStrategy类负责计算key的hash,关键函数:

getHash

getKeyFromFirstArgument

而Predis\Cluster\Distribution\HashRing负责服务器环的维护,关键函数

addNodeToRing

get

hash

大概原理是这样,如执行以下redis命令

get ok

会将ok作crc32运算得到一个hash值

所有服务器按一定算法放到一个长度默认为128的数组中,每个服务器在其中占几项,由以下决定:

权重/总权重*总的服务器数量*128,可参考Predis\Cluster\Distribution\HashRing::addNodeToRing方法

每一项的hash值是按服务器ip:端口的格式,作crc32计算的

protected function addNodeToRing(&$ring, $node, $totalNodes, $replicas, $weightRatio){ $nodeObject = $node['object']; $nodeHash = $this->getNodeHash($nodeObject); $replicas = (int) round($weightRatio * $totalNodes * $replicas); for ($i = 0; $i < $replicas; $i++) { $key = crc32("$nodeHash:$i"); $ring[$key] = $nodeObject; }}

key的hash值也有了,服务器环也计算好了,剩下的就是查找了,二分法能较快的查找相应的服务器节点

更多关于Laravel相关内容感兴趣的读者可查看本站专题:《Laravel框架入门与进阶教程》、《php优秀开发框架总结》、《php面向对象程序设计入门教程》、《php+mysql数据库操作入门教程》及《php常见数据库操作技巧汇总》

希望本文所述对大家基于Laravel框架的PHP程序设计有所帮助。

Laravel框架实现redis集群的方法分析Laravel框架实现redis集群的方法分析

本文实例讲述了Laravel框架实现redis集群的方法。分享给大家供大家参考,具体如下:

在app/config/database.php中配置如下:

'redis' => array( 'cluster' => true, 'default' => array( 'host' => '172.21.107.247', 'port' => 6379, ), 'redis1' => array( 'host' => '172.21.107.248', 'port' => 6379, ),

其中cluster选择为true,接下来就可以作集群使用了;

如果把session的driver设置为redis,则可以使用其集群功能了:

我们来看下session的实现,当我们在代码中这样写:

Session::put('test', 124);

实际的执行流程是这样的:

Illuminate\Support\Facades\SessionIlluminate\Support\Facades\FacadeIlluminate\Session\Facade::app['session']->putIlluminate\Session\Facade::app['session']为Illuminate\Session\SessionManagerIlluminate\Support\Manager::__call

Session会根据返回创建driver

$this->app['config']['session.driver']

即配置文件中配置的,这里我们配置为redis

Illuminate\Session\SessionManager::Illuminate\Session\SessionManager

最终由Illuminate\Session\Store来负责put的调用

而Store类负责存储的类是Illuminate\Session\CacheBasedSessionHandler

后者又将请求转发给$this->app['cache']->driver($driver)……经过一系列代码追查,存储类为Predis\Client\Database,看其构造函数:

public function __construct(array $servers = array()){ if (isset($servers['cluster']) && $servers['cluster']) { $this->clients = $this->createAggregateClient($servers); } else { $this->clients = $this->createSingleClients($servers); }}

如果设置为集群,则调用createAggregateClient方法

protected function createAggregateClient(array $servers){ $servers = array_except($servers, array('cluster')); return array('default' => new Client(array_values($servers)));}

这里会把所有服务器放在default组中

实际存数据的类是Predis\Client,这里有根据配置创建服务器的代码,具体可以自己看下;

Predis\Cluster\PredisClusterHashStrategy类负责计算key的hash,关键函数:

getHash

getKeyFromFirstArgument

而Predis\Cluster\Distribution\HashRing负责服务器环的维护,关键函数

addNodeToRing

get

hash

大概原理是这样,如执行以下redis命令

get ok

会将ok作crc32运算得到一个hash值

所有服务器按一定算法放到一个长度默认为128的数组中,每个服务器在其中占几项,由以下决定:

权重/总权重*总的服务器数量*128,可参考Predis\Cluster\Distribution\HashRing::addNodeToRing方法

每一项的hash值是按服务器ip:端口的格式,作crc32计算的

protected function addNodeToRing(&$ring, $node, $totalNodes, $replicas, $weightRatio){ $nodeObject = $node['object']; $nodeHash = $this->getNodeHash($nodeObject); $replicas = (int) round($weightRatio * $totalNodes * $replicas); for ($i = 0; $i < $replicas; $i++) { $key = crc32("$nodeHash:$i"); $ring[$key] = $nodeObject; }}

key的hash值也有了,服务器环也计算好了,剩下的就是查找了,二分法能较快的查找相应的服务器节点

更多关于Laravel相关内容感兴趣的读者可查看本站专题:《Laravel框架入门与进阶教程》、《php优秀开发框架总结》、《php面向对象程序设计入门教程》、《php+mysql数据库操作入门教程》及《php常见数据库操作技巧汇总》

希望本文所述对大家基于Laravel框架的PHP程序设计有所帮助。

Laravel框架实现redis集群的方法分析Laravel框架实现redis集群的方法分析。

Laravel框架实现redis集群的方法分析

1.

本文实例讲述了Laravel框架实现redis集群的方法。分享给大家供大家参考,具体如下:

在app/config/database.php中配置如下:

'redis' => array( 'cluster' => true, 'default' => array( 'host' => '172.21.107.247', 'port' => 6379, ), 'redis1' => array( 'host' => '172.21.107.248', 'port' => 6379, ),

其中cluster选择为true,接下来就可以作集群使用了;

如果把session的driver设置为redis,则可以使用其集群功能了:

我们来看下session的实现,当我们在代码中这样写:

Session::put('test', 124);

实际的执行流程是这样的:

Illuminate\Support\Facades\SessionIlluminate\Support\Facades\FacadeIlluminate\Session\Facade::app['session']->putIlluminate\Session\Facade::app['session']为Illuminate\Session\SessionManagerIlluminate\Support\Manager::__call

Session会根据返回创建driver

$this->app['config']['session.driver']

即配置文件中配置的,这里我们配置为redis

Illuminate\Session\SessionManager::Illuminate\Session\SessionManager

最终由Illuminate\Session\Store来负责put的调用

而Store类负责存储的类是Illuminate\Session\CacheBasedSessionHandler

后者又将请求转发给$this->app['cache']->driver($driver)……经过一系列代码追查,存储类为Predis\Client\Database,看其构造函数:

public function __construct(array $servers = array()){ if (isset($servers['cluster']) && $servers['cluster']) { $this->clients = $this->createAggregateClient($servers); } else { $this->clients = $this->createSingleClients($servers); }}

如果设置为集群,则调用createAggregateClient方法

protected function createAggregateClient(array $servers){ $servers = array_except($servers, array('cluster')); return array('default' => new Client(array_values($servers)));}

这里会把所有服务器放在default组中

实际存数据的类是Predis\Client,这里有根据配置创建服务器的代码,具体可以自己看下;

Predis\Cluster\PredisClusterHashStrategy类负责计算key的hash,关键函数:

getHash

getKeyFromFirstArgument

而Predis\Cluster\Distribution\HashRing负责服务器环的维护,关键函数

addNodeToRing

get

hash

大概原理是这样,如执行以下redis命令

get ok

会将ok作crc32运算得到一个hash值

所有服务器按一定算法放到一个长度默认为128的数组中,每个服务器在其中占几项,由以下决定:

权重/总权重*总的服务器数量*128,可参考Predis\Cluster\Distribution\HashRing::addNodeToRing方法

每一项的hash值是按服务器ip:端口的格式,作crc32计算的

protected function addNodeToRing(&$ring, $node, $totalNodes, $replicas, $weightRatio){ $nodeObject = $node['object']; $nodeHash = $this->getNodeHash($nodeObject); $replicas = (int) round($weightRatio * $totalNodes * $replicas); for ($i = 0; $i < $replicas; $i++) { $key = crc32("$nodeHash:$i"); $ring[$key] = $nodeObject; }}

key的hash值也有了,服务器环也计算好了,剩下的就是查找了,二分法能较快的查找相应的服务器节点

更多关于Laravel相关内容感兴趣的读者可查看本站专题:《Laravel框架入门与进阶教程》、《php优秀开发框架总结》、《php面向对象程序设计入门教程》、《php+mysql数据库操作入门教程》及《php常见数据库操作技巧汇总》

希望本文所述对大家基于Laravel框架的PHP程序设计有所帮助。

本文实例讲述了Laravel框架实现redis集群的方法。分享给大家供大家参考,具体如下:

在app/config/database.php中配置如下:

'redis' => array( 'cluster' => true, 'default' => array( 'host' => '172.21.107.247', 'port' => 6379, ), 'redis1' => array( 'host' => '172.21.107.248', 'port' => 6379, ),

其中cluster选择为true,接下来就可以作集群使用了;

如果把session的driver设置为redis,则可以使用其集群功能了:

我们来看下session的实现,当我们在代码中这样写:

Session::put('test', 124);

实际的执行流程是这样的:

Illuminate\Support\Facades\SessionIlluminate\Support\Facades\FacadeIlluminate\Session\Facade::app['session']->putIlluminate\Session\Facade::app['session']为Illuminate\Session\SessionManagerIlluminate\Support\Manager::__call

Session会根据返回创建driver

$this->app['config']['session.driver']

即配置文件中配置的,这里我们配置为redis

Illuminate\Session\SessionManager::Illuminate\Session\SessionManager

最终由Illuminate\Session\Store来负责put的调用

而Store类负责存储的类是Illuminate\Session\CacheBasedSessionHandler

后者又将请求转发给$this->app['cache']->driver($driver)……经过一系列代码追查,存储类为Predis\Client\Database,看其构造函数:

public function __construct(array $servers = array()){ if (isset($servers['cluster']) && $servers['cluster']) { $this->clients = $this->createAggregateClient($servers); } else { $this->clients = $this->createSingleClients($servers); }}

如果设置为集群,则调用createAggregateClient方法

protected function createAggregateClient(array $servers){ $servers = array_except($servers, array('cluster')); return array('default' => new Client(array_values($servers)));}

这里会把所有服务器放在default组中

实际存数据的类是Predis\Client,这里有根据配置创建服务器的代码,具体可以自己看下;

Predis\Cluster\PredisClusterHashStrategy类负责计算key的hash,关键函数:

getHash

getKeyFromFirstArgument

而Predis\Cluster\Distribution\HashRing负责服务器环的维护,关键函数

addNodeToRing

get

hash

大概原理是这样,如执行以下redis命令

get ok

会将ok作crc32运算得到一个hash值

所有服务器按一定算法放到一个长度默认为128的数组中,每个服务器在其中占几项,由以下决定:

权重/总权重*总的服务器数量*128,可参考Predis\Cluster\Distribution\HashRing::addNodeToRing方法

每一项的hash值是按服务器ip:端口的格式,作crc32计算的

protected function addNodeToRing(&$ring, $node, $totalNodes, $replicas, $weightRatio){ $nodeObject = $node['object']; $nodeHash = $this->getNodeHash($nodeObject); $replicas = (int) round($weightRatio * $totalNodes * $replicas); for ($i = 0; $i < $replicas; $i++) { $key = crc32("$nodeHash:$i"); $ring[$key] = $nodeObject; }}

key的hash值也有了,服务器环也计算好了,剩下的就是查找了,二分法能较快的查找相应的服务器节点

更多关于Laravel相关内容感兴趣的读者可查看本站专题:《Laravel框架入门与进阶教程》、《php优秀开发框架总结》、《php面向对象程序设计入门教程》、《php+mysql数据库操作入门教程》及《php常见数据库操作技巧汇总》

希望本文所述对大家基于Laravel框架的PHP程序设计有所帮助。

本文实例讲述了Laravel框架实现redis集群的方法。分享给大家供大家参考,具体如下:

在app/config/database.php中配置如下:

'redis' => array( 'cluster' => true, 'default' => array( 'host' => '172.21.107.247', 'port' => 6379, ), 'redis1' => array( 'host' => '172.21.107.248', 'port' => 6379, ),

其中cluster选择为true,接下来就可以作集群使用了;

如果把session的driver设置为redis,则可以使用其集群功能了:

我们来看下session的实现,当我们在代码中这样写:

Session::put('test', 124);

实际的执行流程是这样的:

Illuminate\Support\Facades\SessionIlluminate\Support\Facades\FacadeIlluminate\Session\Facade::app['session']->putIlluminate\Session\Facade::app['session']为Illuminate\Session\SessionManagerIlluminate\Support\Manager::__call

Session会根据返回创建driver

$this->app['config']['session.driver']

即配置文件中配置的,这里我们配置为redis

Illuminate\Session\SessionManager::Illuminate\Session\SessionManager

最终由Illuminate\Session\Store来负责put的调用

而Store类负责存储的类是Illuminate\Session\CacheBasedSessionHandler

后者又将请求转发给$this->app['cache']->driver($driver)……经过一系列代码追查,存储类为Predis\Client\Database,看其构造函数:

public function __construct(array $servers = array()){ if (isset($servers['cluster']) && $servers['cluster']) { $this->clients = $this->createAggregateClient($servers); } else { $this->clients = $this->createSingleClients($servers); }}

如果设置为集群,则调用createAggregateClient方法

protected function createAggregateClient(array $servers){ $servers = array_except($servers, array('cluster')); return array('default' => new Client(array_values($servers)));}

这里会把所有服务器放在default组中

实际存数据的类是Predis\Client,这里有根据配置创建服务器的代码,具体可以自己看下;

Predis\Cluster\PredisClusterHashStrategy类负责计算key的hash,关键函数:

getHash

getKeyFromFirstArgument

而Predis\Cluster\Distribution\HashRing负责服务器环的维护,关键函数

addNodeToRing

get

hash

大概原理是这样,如执行以下redis命令

get ok

会将ok作crc32运算得到一个hash值

所有服务器按一定算法放到一个长度默认为128的数组中,每个服务器在其中占几项,由以下决定:

权重/总权重*总的服务器数量*128,可参考Predis\Cluster\Distribution\HashRing::addNodeToRing方法

每一项的hash值是按服务器ip:端口的格式,作crc32计算的

protected function addNodeToRing(&$ring, $node, $totalNodes, $replicas, $weightRatio){ $nodeObject = $node['object']; $nodeHash = $this->getNodeHash($nodeObject); $replicas = (int) round($weightRatio * $totalNodes * $replicas); for ($i = 0; $i < $replicas; $i++) { $key = crc32("$nodeHash:$i"); $ring[$key] = $nodeObject; }}

key的hash值也有了,服务器环也计算好了,剩下的就是查找了,二分法能较快的查找相应的服务器节点

更多关于Laravel相关内容感兴趣的读者可查看本站专题:《Laravel框架入门与进阶教程》、《php优秀开发框架总结》、《php面向对象程序设计入门教程》、《php+mysql数据库操作入门教程》及《php常见数据库操作技巧汇总》

希望本文所述对大家基于Laravel框架的PHP程序设计有所帮助。

本文实例讲述了Laravel框架实现redis集群的方法。分享给大家供大家参考,具体如下:

在app/config/database.php中配置如下:

'redis' => array( 'cluster' => true, 'default' => array( 'host' => '172.21.107.247', 'port' => 6379, ), 'redis1' => array( 'host' => '172.21.107.248', 'port' => 6379, ),

其中cluster选择为true,接下来就可以作集群使用了;

如果把session的driver设置为redis,则可以使用其集群功能了:

我们来看下session的实现,当我们在代码中这样写:

Session::put('test', 124);

实际的执行流程是这样的:

Illuminate\Support\Facades\SessionIlluminate\Support\Facades\FacadeIlluminate\Session\Facade::app['session']->putIlluminate\Session\Facade::app['session']为Illuminate\Session\SessionManagerIlluminate\Support\Manager::__call

Session会根据返回创建driver

$this->app['config']['session.driver']

即配置文件中配置的,这里我们配置为redis

Illuminate\Session\SessionManager::Illuminate\Session\SessionManager

最终由Illuminate\Session\Store来负责put的调用

而Store类负责存储的类是Illuminate\Session\CacheBasedSessionHandler

后者又将请求转发给$this->app['cache']->driver($driver)……经过一系列代码追查,存储类为Predis\Client\Database,看其构造函数:

public function __construct(array $servers = array()){ if (isset($servers['cluster']) && $servers['cluster']) { $this->clients = $this->createAggregateClient($servers); } else { $this->clients = $this->createSingleClients($servers); }}

如果设置为集群,则调用createAggregateClient方法

protected function createAggregateClient(array $servers){ $servers = array_except($servers, array('cluster')); return array('default' => new Client(array_values($servers)));}

这里会把所有服务器放在default组中

实际存数据的类是Predis\Client,这里有根据配置创建服务器的代码,具体可以自己看下;

Predis\Cluster\PredisClusterHashStrategy类负责计算key的hash,关键函数:

getHash

getKeyFromFirstArgument

而Predis\Cluster\Distribution\HashRing负责服务器环的维护,关键函数

addNodeToRing

get

hash

大概原理是这样,如执行以下redis命令

get ok

会将ok作crc32运算得到一个hash值

所有服务器按一定算法放到一个长度默认为128的数组中,每个服务器在其中占几项,由以下决定:

权重/总权重*总的服务器数量*128,可参考Predis\Cluster\Distribution\HashRing::addNodeToRing方法

每一项的hash值是按服务器ip:端口的格式,作crc32计算的

protected function addNodeToRing(&$ring, $node, $totalNodes, $replicas, $weightRatio){ $nodeObject = $node['object']; $nodeHash = $this->getNodeHash($nodeObject); $replicas = (int) round($weightRatio * $totalNodes * $replicas); for ($i = 0; $i < $replicas; $i++) { $key = crc32("$nodeHash:$i"); $ring[$key] = $nodeObject; }}

key的hash值也有了,服务器环也计算好了,剩下的就是查找了,二分法能较快的查找相应的服务器节点

更多关于Laravel相关内容感兴趣的读者可查看本站专题:《Laravel框架入门与进阶教程》、《php优秀开发框架总结》、《php面向对象程序设计入门教程》、《php+mysql数据库操作入门教程》及《php常见数据库操作技巧汇总》

希望本文所述对大家基于Laravel框架的PHP程序设计有所帮助。

本文实例讲述了Laravel框架实现redis集群的方法。分享给大家供大家参考,具体如下:

在app/config/database.php中配置如下:

'redis' => array( 'cluster' => true, 'default' => array( 'host' => '172.21.107.247', 'port' => 6379, ), 'redis1' => array( 'host' => '172.21.107.248', 'port' => 6379, ),

其中cluster选择为true,接下来就可以作集群使用了;

如果把session的driver设置为redis,则可以使用其集群功能了:

我们来看下session的实现,当我们在代码中这样写:

Session::put('test', 124);

实际的执行流程是这样的:

Illuminate\Support\Facades\SessionIlluminate\Support\Facades\FacadeIlluminate\Session\Facade::app['session']->putIlluminate\Session\Facade::app['session']为Illuminate\Session\SessionManagerIlluminate\Support\Manager::__call

Session会根据返回创建driver

$this->app['config']['session.driver']

即配置文件中配置的,这里我们配置为redis

Illuminate\Session\SessionManager::Illuminate\Session\SessionManager

最终由Illuminate\Session\Store来负责put的调用

而Store类负责存储的类是Illuminate\Session\CacheBasedSessionHandler

后者又将请求转发给$this->app['cache']->driver($driver)……经过一系列代码追查,存储类为Predis\Client\Database,看其构造函数:

public function __construct(array $servers = array()){ if (isset($servers['cluster']) && $servers['cluster']) { $this->clients = $this->createAggregateClient($servers); } else { $this->clients = $this->createSingleClients($servers); }}

如果设置为集群,则调用createAggregateClient方法

protected function createAggregateClient(array $servers){ $servers = array_except($servers, array('cluster')); return array('default' => new Client(array_values($servers)));}

这里会把所有服务器放在default组中

实际存数据的类是Predis\Client,这里有根据配置创建服务器的代码,具体可以自己看下;

Predis\Cluster\PredisClusterHashStrategy类负责计算key的hash,关键函数:

getHash

getKeyFromFirstArgument

而Predis\Cluster\Distribution\HashRing负责服务器环的维护,关键函数

addNodeToRing

get

hash

大概原理是这样,如执行以下redis命令

get ok

会将ok作crc32运算得到一个hash值

所有服务器按一定算法放到一个长度默认为128的数组中,每个服务器在其中占几项,由以下决定:

权重/总权重*总的服务器数量*128,可参考Predis\Cluster\Distribution\HashRing::addNodeToRing方法

每一项的hash值是按服务器ip:端口的格式,作crc32计算的

protected function addNodeToRing(&$ring, $node, $totalNodes, $replicas, $weightRatio){ $nodeObject = $node['object']; $nodeHash = $this->getNodeHash($nodeObject); $replicas = (int) round($weightRatio * $totalNodes * $replicas); for ($i = 0; $i < $replicas; $i++) { $key = crc32("$nodeHash:$i"); $ring[$key] = $nodeObject; }}

key的hash值也有了,服务器环也计算好了,剩下的就是查找了,二分法能较快的查找相应的服务器节点

更多关于Laravel相关内容感兴趣的读者可查看本站专题:《Laravel框架入门与进阶教程》、《php优秀开发框架总结》、《php面向对象程序设计入门教程》、《php+mysql数据库操作入门教程》及《php常见数据库操作技巧汇总》

希望本文所述对大家基于Laravel框架的PHP程序设计有所帮助。

本文实例讲述了Laravel框架实现redis集群的方法。分享给大家供大家参考,具体如下:

在app/config/database.php中配置如下:

'redis' => array( 'cluster' => true, 'default' => array( 'host' => '172.21.107.247', 'port' => 6379, ), 'redis1' => array( 'host' => '172.21.107.248', 'port' => 6379, ),

其中cluster选择为true,接下来就可以作集群使用了;

如果把session的driver设置为redis,则可以使用其集群功能了:

我们来看下session的实现,当我们在代码中这样写:

Session::put('test', 124);

实际的执行流程是这样的:

Illuminate\Support\Facades\SessionIlluminate\Support\Facades\FacadeIlluminate\Session\Facade::app['session']->putIlluminate\Session\Facade::app['session']为Illuminate\Session\SessionManagerIlluminate\Support\Manager::__call

Session会根据返回创建driver

$this->app['config']['session.driver']

即配置文件中配置的,这里我们配置为redis

Illuminate\Session\SessionManager::Illuminate\Session\SessionManager

最终由Illuminate\Session\Store来负责put的调用

而Store类负责存储的类是Illuminate\Session\CacheBasedSessionHandler

后者又将请求转发给$this->app['cache']->driver($driver)……经过一系列代码追查,存储类为Predis\Client\Database,看其构造函数:

public function __construct(array $servers = array()){ if (isset($servers['cluster']) && $servers['cluster']) { $this->clients = $this->createAggregateClient($servers); } else { $this->clients = $this->createSingleClients($servers); }}

如果设置为集群,则调用createAggregateClient方法

protected function createAggregateClient(array $servers){ $servers = array_except($servers, array('cluster')); return array('default' => new Client(array_values($servers)));}

这里会把所有服务器放在default组中

实际存数据的类是Predis\Client,这里有根据配置创建服务器的代码,具体可以自己看下;

Predis\Cluster\PredisClusterHashStrategy类负责计算key的hash,关键函数:

getHash

getKeyFromFirstArgument

而Predis\Cluster\Distribution\HashRing负责服务器环的维护,关键函数

addNodeToRing

get

hash

大概原理是这样,如执行以下redis命令

get ok

会将ok作crc32运算得到一个hash值

所有服务器按一定算法放到一个长度默认为128的数组中,每个服务器在其中占几项,由以下决定:

权重/总权重*总的服务器数量*128,可参考Predis\Cluster\Distribution\HashRing::addNodeToRing方法

每一项的hash值是按服务器ip:端口的格式,作crc32计算的

protected function addNodeToRing(&$ring, $node, $totalNodes, $replicas, $weightRatio){ $nodeObject = $node['object']; $nodeHash = $this->getNodeHash($nodeObject); $replicas = (int) round($weightRatio * $totalNodes * $replicas); for ($i = 0; $i < $replicas; $i++) { $key = crc32("$nodeHash:$i"); $ring[$key] = $nodeObject; }}

key的hash值也有了,服务器环也计算好了,剩下的就是查找了,二分法能较快的查找相应的服务器节点

更多关于Laravel相关内容感兴趣的读者可查看本站专题:《Laravel框架入门与进阶教程》、《php优秀开发框架总结》、《php面向对象程序设计入门教程》、《php+mysql数据库操作入门教程》及《php常见数据库操作技巧汇总》

希望本文所述对大家基于Laravel框架的PHP程序设计有所帮助。

Laravel框架实现redis集群的方法分析

本文实例讲述了Laravel框架实现redis集群的方法。分享给大家供大家参考,具体如下:

在app/config/database.php中配置如下:

'redis' => array( 'cluster' => true, 'default' => array( 'host' => '172.21.107.247', 'port' => 6379, ), 'redis1' => array( 'host' => '172.21.107.248', 'port' => 6379, ),

其中cluster选择为true,接下来就可以作集群使用了;

如果把session的driver设置为redis,则可以使用其集群功能了:

我们来看下session的实现,当我们在代码中这样写:

Session::put('test', 124);

实际的执行流程是这样的:

Illuminate\Support\Facades\SessionIlluminate\Support\Facades\FacadeIlluminate\Session\Facade::app['session']->putIlluminate\Session\Facade::app['session']为Illuminate\Session\SessionManagerIlluminate\Support\Manager::__call

Session会根据返回创建driver

$this->app['config']['session.driver']

即配置文件中配置的,这里我们配置为redis

Illuminate\Session\SessionManager::Illuminate\Session\SessionManager

最终由Illuminate\Session\Store来负责put的调用

而Store类负责存储的类是Illuminate\Session\CacheBasedSessionHandler

后者又将请求转发给$this->app['cache']->driver($driver)……经过一系列代码追查,存储类为Predis\Client\Database,看其构造函数:

public function __construct(array $servers = array()){ if (isset($servers['cluster']) && $servers['cluster']) { $this->clients = $this->createAggregateClient($servers); } else { $this->clients = $this->createSingleClients($servers); }}

如果设置为集群,则调用createAggregateClient方法

protected function createAggregateClient(array $servers){ $servers = array_except($servers, array('cluster')); return array('default' => new Client(array_values($servers)));}

这里会把所有服务器放在default组中

实际存数据的类是Predis\Client,这里有根据配置创建服务器的代码,具体可以自己看下;

Predis\Cluster\PredisClusterHashStrategy类负责计算key的hash,关键函数:

getHash

getKeyFromFirstArgument

而Predis\Cluster\Distribution\HashRing负责服务器环的维护,关键函数

addNodeToRing

get

hash

大概原理是这样,如执行以下redis命令

get ok

会将ok作crc32运算得到一个hash值

所有服务器按一定算法放到一个长度默认为128的数组中,每个服务器在其中占几项,由以下决定:

权重/总权重*总的服务器数量*128,可参考Predis\Cluster\Distribution\HashRing::addNodeToRing方法

每一项的hash值是按服务器ip:端口的格式,作crc32计算的

protected function addNodeToRing(&$ring, $node, $totalNodes, $replicas, $weightRatio){ $nodeObject = $node['object']; $nodeHash = $this->getNodeHash($nodeObject); $replicas = (int) round($weightRatio * $totalNodes * $replicas); for ($i = 0; $i < $replicas; $i++) { $key = crc32("$nodeHash:$i"); $ring[$key] = $nodeObject; }}

key的hash值也有了,服务器环也计算好了,剩下的就是查找了,二分法能较快的查找相应的服务器节点

更多关于Laravel相关内容感兴趣的读者可查看本站专题:《Laravel框架入门与进阶教程》、《php优秀开发框架总结》、《php面向对象程序设计入门教程》、《php+mysql数据库操作入门教程》及《php常见数据库操作技巧汇总》

希望本文所述对大家基于Laravel框架的PHP程序设计有所帮助。

Laravel框架实现redis集群的方法分析

本文实例讲述了Laravel框架实现redis集群的方法。分享给大家供大家参考,具体如下:

在app/config/database.php中配置如下:

'redis' => array( 'cluster' => true, 'default' => array( 'host' => '172.21.107.247', 'port' => 6379, ), 'redis1' => array( 'host' => '172.21.107.248', 'port' => 6379, ),

其中cluster选择为true,接下来就可以作集群使用了;

如果把session的driver设置为redis,则可以使用其集群功能了:

我们来看下session的实现,当我们在代码中这样写:

Session::put('test', 124);

实际的执行流程是这样的:

Illuminate\Support\Facades\SessionIlluminate\Support\Facades\FacadeIlluminate\Session\Facade::app['session']->putIlluminate\Session\Facade::app['session']为Illuminate\Session\SessionManagerIlluminate\Support\Manager::__call

Session会根据返回创建driver

$this->app['config']['session.driver']

即配置文件中配置的,这里我们配置为redis

Illuminate\Session\SessionManager::Illuminate\Session\SessionManager

最终由Illuminate\Session\Store来负责put的调用

而Store类负责存储的类是Illuminate\Session\CacheBasedSessionHandler

后者又将请求转发给$this->app['cache']->driver($driver)……经过一系列代码追查,存储类为Predis\Client\Database,看其构造函数:

public function __construct(array $servers = array()){ if (isset($servers['cluster']) && $servers['cluster']) { $this->clients = $this->createAggregateClient($servers); } else { $this->clients = $this->createSingleClients($servers); }}

如果设置为集群,则调用createAggregateClient方法

protected function createAggregateClient(array $servers){ $servers = array_except($servers, array('cluster')); return array('default' => new Client(array_values($servers)));}

这里会把所有服务器放在default组中

实际存数据的类是Predis\Client,这里有根据配置创建服务器的代码,具体可以自己看下;

Predis\Cluster\PredisClusterHashStrategy类负责计算key的hash,关键函数:

getHash

getKeyFromFirstArgument

而Predis\Cluster\Distribution\HashRing负责服务器环的维护,关键函数

addNodeToRing

get

hash

大概原理是这样,如执行以下redis命令

get ok

会将ok作crc32运算得到一个hash值

所有服务器按一定算法放到一个长度默认为128的数组中,每个服务器在其中占几项,由以下决定:

权重/总权重*总的服务器数量*128,可参考Predis\Cluster\Distribution\HashRing::addNodeToRing方法

每一项的hash值是按服务器ip:端口的格式,作crc32计算的

protected function addNodeToRing(&$ring, $node, $totalNodes, $replicas, $weightRatio){ $nodeObject = $node['object']; $nodeHash = $this->getNodeHash($nodeObject); $replicas = (int) round($weightRatio * $totalNodes * $replicas); for ($i = 0; $i < $replicas; $i++) { $key = crc32("$nodeHash:$i"); $ring[$key] = $nodeObject; }}

key的hash值也有了,服务器环也计算好了,剩下的就是查找了,二分法能较快的查找相应的服务器节点

更多关于Laravel相关内容感兴趣的读者可查看本站专题:《Laravel框架入门与进阶教程》、《php优秀开发框架总结》、《php面向对象程序设计入门教程》、《php+mysql数据库操作入门教程》及《php常见数据库操作技巧汇总》

希望本文所述对大家基于Laravel框架的PHP程序设计有所帮助。

本文实例讲述了Laravel框架实现redis集群的方法。分享给大家供大家参考,具体如下:

在app/config/database.php中配置如下:

'redis' => array( 'cluster' => true, 'default' => array( 'host' => '172.21.107.247', 'port' => 6379, ), 'redis1' => array( 'host' => '172.21.107.248', 'port' => 6379, ),

其中cluster选择为true,接下来就可以作集群使用了;

如果把session的driver设置为redis,则可以使用其集群功能了:

我们来看下session的实现,当我们在代码中这样写:

Session::put('test', 124);

实际的执行流程是这样的:

Illuminate\Support\Facades\SessionIlluminate\Support\Facades\FacadeIlluminate\Session\Facade::app['session']->putIlluminate\Session\Facade::app['session']为Illuminate\Session\SessionManagerIlluminate\Support\Manager::__call

Session会根据返回创建driver

$this->app['config']['session.driver']

即配置文件中配置的,这里我们配置为redis

Illuminate\Session\SessionManager::Illuminate\Session\SessionManager

最终由Illuminate\Session\Store来负责put的调用

而Store类负责存储的类是Illuminate\Session\CacheBasedSessionHandler

后者又将请求转发给$this->app['cache']->driver($driver)……经过一系列代码追查,存储类为Predis\Client\Database,看其构造函数:

public function __construct(array $servers = array()){ if (isset($servers['cluster']) && $servers['cluster']) { $this->clients = $this->createAggregateClient($servers); } else { $this->clients = $this->createSingleClients($servers); }}

如果设置为集群,则调用createAggregateClient方法

protected function createAggregateClient(array $servers){ $servers = array_except($servers, array('cluster')); return array('default' => new Client(array_values($servers)));}

这里会把所有服务器放在default组中

实际存数据的类是Predis\Client,这里有根据配置创建服务器的代码,具体可以自己看下;

Predis\Cluster\PredisClusterHashStrategy类负责计算key的hash,关键函数:

getHash

getKeyFromFirstArgument

而Predis\Cluster\Distribution\HashRing负责服务器环的维护,关键函数

addNodeToRing

get

hash

大概原理是这样,如执行以下redis命令

get ok

会将ok作crc32运算得到一个hash值

所有服务器按一定算法放到一个长度默认为128的数组中,每个服务器在其中占几项,由以下决定:

权重/总权重*总的服务器数量*128,可参考Predis\Cluster\Distribution\HashRing::addNodeToRing方法

每一项的hash值是按服务器ip:端口的格式,作crc32计算的

protected function addNodeToRing(&$ring, $node, $totalNodes, $replicas, $weightRatio){ $nodeObject = $node['object']; $nodeHash = $this->getNodeHash($nodeObject); $replicas = (int) round($weightRatio * $totalNodes * $replicas); for ($i = 0; $i < $replicas; $i++) { $key = crc32("$nodeHash:$i"); $ring[$key] = $nodeObject; }}

key的hash值也有了,服务器环也计算好了,剩下的就是查找了,二分法能较快的查找相应的服务器节点

更多关于Laravel相关内容感兴趣的读者可查看本站专题:《Laravel框架入门与进阶教程》、《php优秀开发框架总结》、《php面向对象程序设计入门教程》、《php+mysql数据库操作入门教程》及《php常见数据库操作技巧汇总》

希望本文所述对大家基于Laravel框架的PHP程序设计有所帮助。

Laravel框架实现redis集群的方法分析

本文实例讲述了Laravel框架实现redis集群的方法。分享给大家供大家参考,具体如下:

在app/config/database.php中配置如下:

'redis' => array( 'cluster' => true, 'default' => array( 'host' => '172.21.107.247', 'port' => 6379, ), 'redis1' => array( 'host' => '172.21.107.248', 'port' => 6379, ),

其中cluster选择为true,接下来就可以作集群使用了;

如果把session的driver设置为redis,则可以使用其集群功能了:

我们来看下session的实现,当我们在代码中这样写:

Session::put('test', 124);

实际的执行流程是这样的:

Illuminate\Support\Facades\SessionIlluminate\Support\Facades\FacadeIlluminate\Session\Facade::app['session']->putIlluminate\Session\Facade::app['session']为Illuminate\Session\SessionManagerIlluminate\Support\Manager::__call

Session会根据返回创建driver

$this->app['config']['session.driver']

即配置文件中配置的,这里我们配置为redis

Illuminate\Session\SessionManager::Illuminate\Session\SessionManager

最终由Illuminate\Session\Store来负责put的调用

而Store类负责存储的类是Illuminate\Session\CacheBasedSessionHandler

后者又将请求转发给$this->app['cache']->driver($driver)……经过一系列代码追查,存储类为Predis\Client\Database,看其构造函数:

public function __construct(array $servers = array()){ if (isset($servers['cluster']) && $servers['cluster']) { $this->clients = $this->createAggregateClient($servers); } else { $this->clients = $this->createSingleClients($servers); }}

如果设置为集群,则调用createAggregateClient方法

protected function createAggregateClient(array $servers){ $servers = array_except($servers, array('cluster')); return array('default' => new Client(array_values($servers)));}

这里会把所有服务器放在default组中

实际存数据的类是Predis\Client,这里有根据配置创建服务器的代码,具体可以自己看下;

Predis\Cluster\PredisClusterHashStrategy类负责计算key的hash,关键函数:

getHash

getKeyFromFirstArgument

而Predis\Cluster\Distribution\HashRing负责服务器环的维护,关键函数

addNodeToRing

get

hash

大概原理是这样,如执行以下redis命令

get ok

会将ok作crc32运算得到一个hash值

所有服务器按一定算法放到一个长度默认为128的数组中,每个服务器在其中占几项,由以下决定:

权重/总权重*总的服务器数量*128,可参考Predis\Cluster\Distribution\HashRing::addNodeToRing方法

每一项的hash值是按服务器ip:端口的格式,作crc32计算的

protected function addNodeToRing(&$ring, $node, $totalNodes, $replicas, $weightRatio){ $nodeObject = $node['object']; $nodeHash = $this->getNodeHash($nodeObject); $replicas = (int) round($weightRatio * $totalNodes * $replicas); for ($i = 0; $i < $replicas; $i++) { $key = crc32("$nodeHash:$i"); $ring[$key] = $nodeObject; }}

key的hash值也有了,服务器环也计算好了,剩下的就是查找了,二分法能较快的查找相应的服务器节点

更多关于Laravel相关内容感兴趣的读者可查看本站专题:《Laravel框架入门与进阶教程》、《php优秀开发框架总结》、《php面向对象程序设计入门教程》、《php+mysql数据库操作入门教程》及《php常见数据库操作技巧汇总》

希望本文所述对大家基于Laravel框架的PHP程序设计有所帮助。

Laravel框架实现redis集群的方法分析Laravel框架实现redis集群的方法分析Laravel框架实现redis集群的方法分析

2.Laravel框架实现redis集群的方法分析。

本文实例讲述了Laravel框架实现redis集群的方法。分享给大家供大家参考,具体如下:

在app/config/database.php中配置如下:

'redis' => array( 'cluster' => true, 'default' => array( 'host' => '172.21.107.247', 'port' => 6379, ), 'redis1' => array( 'host' => '172.21.107.248', 'port' => 6379, ),

其中cluster选择为true,接下来就可以作集群使用了;

如果把session的driver设置为redis,则可以使用其集群功能了:

我们来看下session的实现,当我们在代码中这样写:

Session::put('test', 124);

实际的执行流程是这样的:

Illuminate\Support\Facades\SessionIlluminate\Support\Facades\FacadeIlluminate\Session\Facade::app['session']->putIlluminate\Session\Facade::app['session']为Illuminate\Session\SessionManagerIlluminate\Support\Manager::__call

Session会根据返回创建driver

$this->app['config']['session.driver']

即配置文件中配置的,这里我们配置为redis

Illuminate\Session\SessionManager::Illuminate\Session\SessionManager

最终由Illuminate\Session\Store来负责put的调用

而Store类负责存储的类是Illuminate\Session\CacheBasedSessionHandler

后者又将请求转发给$this->app['cache']->driver($driver)……经过一系列代码追查,存储类为Predis\Client\Database,看其构造函数:

public function __construct(array $servers = array()){ if (isset($servers['cluster']) && $servers['cluster']) { $this->clients = $this->createAggregateClient($servers); } else { $this->clients = $this->createSingleClients($servers); }}

如果设置为集群,则调用createAggregateClient方法

protected function createAggregateClient(array $servers){ $servers = array_except($servers, array('cluster')); return array('default' => new Client(array_values($servers)));}

这里会把所有服务器放在default组中

实际存数据的类是Predis\Client,这里有根据配置创建服务器的代码,具体可以自己看下;

Predis\Cluster\PredisClusterHashStrategy类负责计算key的hash,关键函数:

getHash

getKeyFromFirstArgument

而Predis\Cluster\Distribution\HashRing负责服务器环的维护,关键函数

addNodeToRing

get

hash

大概原理是这样,如执行以下redis命令

get ok

会将ok作crc32运算得到一个hash值

所有服务器按一定算法放到一个长度默认为128的数组中,每个服务器在其中占几项,由以下决定:

权重/总权重*总的服务器数量*128,可参考Predis\Cluster\Distribution\HashRing::addNodeToRing方法

每一项的hash值是按服务器ip:端口的格式,作crc32计算的

protected function addNodeToRing(&$ring, $node, $totalNodes, $replicas, $weightRatio){ $nodeObject = $node['object']; $nodeHash = $this->getNodeHash($nodeObject); $replicas = (int) round($weightRatio * $totalNodes * $replicas); for ($i = 0; $i < $replicas; $i++) { $key = crc32("$nodeHash:$i"); $ring[$key] = $nodeObject; }}

key的hash值也有了,服务器环也计算好了,剩下的就是查找了,二分法能较快的查找相应的服务器节点

更多关于Laravel相关内容感兴趣的读者可查看本站专题:《Laravel框架入门与进阶教程》、《php优秀开发框架总结》、《php面向对象程序设计入门教程》、《php+mysql数据库操作入门教程》及《php常见数据库操作技巧汇总》

希望本文所述对大家基于Laravel框架的PHP程序设计有所帮助。

Laravel框架实现redis集群的方法分析

本文实例讲述了Laravel框架实现redis集群的方法。分享给大家供大家参考,具体如下:

在app/config/database.php中配置如下:

'redis' => array( 'cluster' => true, 'default' => array( 'host' => '172.21.107.247', 'port' => 6379, ), 'redis1' => array( 'host' => '172.21.107.248', 'port' => 6379, ),

其中cluster选择为true,接下来就可以作集群使用了;

如果把session的driver设置为redis,则可以使用其集群功能了:

我们来看下session的实现,当我们在代码中这样写:

Session::put('test', 124);

实际的执行流程是这样的:

Illuminate\Support\Facades\SessionIlluminate\Support\Facades\FacadeIlluminate\Session\Facade::app['session']->putIlluminate\Session\Facade::app['session']为Illuminate\Session\SessionManagerIlluminate\Support\Manager::__call

Session会根据返回创建driver

$this->app['config']['session.driver']

即配置文件中配置的,这里我们配置为redis

Illuminate\Session\SessionManager::Illuminate\Session\SessionManager

最终由Illuminate\Session\Store来负责put的调用

而Store类负责存储的类是Illuminate\Session\CacheBasedSessionHandler

后者又将请求转发给$this->app['cache']->driver($driver)……经过一系列代码追查,存储类为Predis\Client\Database,看其构造函数:

public function __construct(array $servers = array()){ if (isset($servers['cluster']) && $servers['cluster']) { $this->clients = $this->createAggregateClient($servers); } else { $this->clients = $this->createSingleClients($servers); }}

如果设置为集群,则调用createAggregateClient方法

protected function createAggregateClient(array $servers){ $servers = array_except($servers, array('cluster')); return array('default' => new Client(array_values($servers)));}

这里会把所有服务器放在default组中

实际存数据的类是Predis\Client,这里有根据配置创建服务器的代码,具体可以自己看下;

Predis\Cluster\PredisClusterHashStrategy类负责计算key的hash,关键函数:

getHash

getKeyFromFirstArgument

而Predis\Cluster\Distribution\HashRing负责服务器环的维护,关键函数

addNodeToRing

get

hash

大概原理是这样,如执行以下redis命令

get ok

会将ok作crc32运算得到一个hash值

所有服务器按一定算法放到一个长度默认为128的数组中,每个服务器在其中占几项,由以下决定:

权重/总权重*总的服务器数量*128,可参考Predis\Cluster\Distribution\HashRing::addNodeToRing方法

每一项的hash值是按服务器ip:端口的格式,作crc32计算的

protected function addNodeToRing(&$ring, $node, $totalNodes, $replicas, $weightRatio){ $nodeObject = $node['object']; $nodeHash = $this->getNodeHash($nodeObject); $replicas = (int) round($weightRatio * $totalNodes * $replicas); for ($i = 0; $i < $replicas; $i++) { $key = crc32("$nodeHash:$i"); $ring[$key] = $nodeObject; }}

key的hash值也有了,服务器环也计算好了,剩下的就是查找了,二分法能较快的查找相应的服务器节点

更多关于Laravel相关内容感兴趣的读者可查看本站专题:《Laravel框架入门与进阶教程》、《php优秀开发框架总结》、《php面向对象程序设计入门教程》、《php+mysql数据库操作入门教程》及《php常见数据库操作技巧汇总》

希望本文所述对大家基于Laravel框架的PHP程序设计有所帮助。

Laravel框架实现redis集群的方法分析

3.

本文实例讲述了Laravel框架实现redis集群的方法。分享给大家供大家参考,具体如下:

在app/config/database.php中配置如下:

'redis' => array( 'cluster' => true, 'default' => array( 'host' => '172.21.107.247', 'port' => 6379, ), 'redis1' => array( 'host' => '172.21.107.248', 'port' => 6379, ),

其中cluster选择为true,接下来就可以作集群使用了;

如果把session的driver设置为redis,则可以使用其集群功能了:

我们来看下session的实现,当我们在代码中这样写:

Session::put('test', 124);

实际的执行流程是这样的:

Illuminate\Support\Facades\SessionIlluminate\Support\Facades\FacadeIlluminate\Session\Facade::app['session']->putIlluminate\Session\Facade::app['session']为Illuminate\Session\SessionManagerIlluminate\Support\Manager::__call

Session会根据返回创建driver

$this->app['config']['session.driver']

即配置文件中配置的,这里我们配置为redis

Illuminate\Session\SessionManager::Illuminate\Session\SessionManager

最终由Illuminate\Session\Store来负责put的调用

而Store类负责存储的类是Illuminate\Session\CacheBasedSessionHandler

后者又将请求转发给$this->app['cache']->driver($driver)……经过一系列代码追查,存储类为Predis\Client\Database,看其构造函数:

public function __construct(array $servers = array()){ if (isset($servers['cluster']) && $servers['cluster']) { $this->clients = $this->createAggregateClient($servers); } else { $this->clients = $this->createSingleClients($servers); }}

如果设置为集群,则调用createAggregateClient方法

protected function createAggregateClient(array $servers){ $servers = array_except($servers, array('cluster')); return array('default' => new Client(array_values($servers)));}

这里会把所有服务器放在default组中

实际存数据的类是Predis\Client,这里有根据配置创建服务器的代码,具体可以自己看下;

Predis\Cluster\PredisClusterHashStrategy类负责计算key的hash,关键函数:

getHash

getKeyFromFirstArgument

而Predis\Cluster\Distribution\HashRing负责服务器环的维护,关键函数

addNodeToRing

get

hash

大概原理是这样,如执行以下redis命令

get ok

会将ok作crc32运算得到一个hash值

所有服务器按一定算法放到一个长度默认为128的数组中,每个服务器在其中占几项,由以下决定:

权重/总权重*总的服务器数量*128,可参考Predis\Cluster\Distribution\HashRing::addNodeToRing方法

每一项的hash值是按服务器ip:端口的格式,作crc32计算的

protected function addNodeToRing(&$ring, $node, $totalNodes, $replicas, $weightRatio){ $nodeObject = $node['object']; $nodeHash = $this->getNodeHash($nodeObject); $replicas = (int) round($weightRatio * $totalNodes * $replicas); for ($i = 0; $i < $replicas; $i++) { $key = crc32("$nodeHash:$i"); $ring[$key] = $nodeObject; }}

key的hash值也有了,服务器环也计算好了,剩下的就是查找了,二分法能较快的查找相应的服务器节点

更多关于Laravel相关内容感兴趣的读者可查看本站专题:《Laravel框架入门与进阶教程》、《php优秀开发框架总结》、《php面向对象程序设计入门教程》、《php+mysql数据库操作入门教程》及《php常见数据库操作技巧汇总》

希望本文所述对大家基于Laravel框架的PHP程序设计有所帮助。

Laravel框架实现redis集群的方法分析

本文实例讲述了Laravel框架实现redis集群的方法。分享给大家供大家参考,具体如下:

在app/config/database.php中配置如下:

'redis' => array( 'cluster' => true, 'default' => array( 'host' => '172.21.107.247', 'port' => 6379, ), 'redis1' => array( 'host' => '172.21.107.248', 'port' => 6379, ),

其中cluster选择为true,接下来就可以作集群使用了;

如果把session的driver设置为redis,则可以使用其集群功能了:

我们来看下session的实现,当我们在代码中这样写:

Session::put('test', 124);

实际的执行流程是这样的:

Illuminate\Support\Facades\SessionIlluminate\Support\Facades\FacadeIlluminate\Session\Facade::app['session']->putIlluminate\Session\Facade::app['session']为Illuminate\Session\SessionManagerIlluminate\Support\Manager::__call

Session会根据返回创建driver

$this->app['config']['session.driver']

即配置文件中配置的,这里我们配置为redis

Illuminate\Session\SessionManager::Illuminate\Session\SessionManager

最终由Illuminate\Session\Store来负责put的调用

而Store类负责存储的类是Illuminate\Session\CacheBasedSessionHandler

后者又将请求转发给$this->app['cache']->driver($driver)……经过一系列代码追查,存储类为Predis\Client\Database,看其构造函数:

public function __construct(array $servers = array()){ if (isset($servers['cluster']) && $servers['cluster']) { $this->clients = $this->createAggregateClient($servers); } else { $this->clients = $this->createSingleClients($servers); }}

如果设置为集群,则调用createAggregateClient方法

protected function createAggregateClient(array $servers){ $servers = array_except($servers, array('cluster')); return array('default' => new Client(array_values($servers)));}

这里会把所有服务器放在default组中

实际存数据的类是Predis\Client,这里有根据配置创建服务器的代码,具体可以自己看下;

Predis\Cluster\PredisClusterHashStrategy类负责计算key的hash,关键函数:

getHash

getKeyFromFirstArgument

而Predis\Cluster\Distribution\HashRing负责服务器环的维护,关键函数

addNodeToRing

get

hash

大概原理是这样,如执行以下redis命令

get ok

会将ok作crc32运算得到一个hash值

所有服务器按一定算法放到一个长度默认为128的数组中,每个服务器在其中占几项,由以下决定:

权重/总权重*总的服务器数量*128,可参考Predis\Cluster\Distribution\HashRing::addNodeToRing方法

每一项的hash值是按服务器ip:端口的格式,作crc32计算的

protected function addNodeToRing(&$ring, $node, $totalNodes, $replicas, $weightRatio){ $nodeObject = $node['object']; $nodeHash = $this->getNodeHash($nodeObject); $replicas = (int) round($weightRatio * $totalNodes * $replicas); for ($i = 0; $i < $replicas; $i++) { $key = crc32("$nodeHash:$i"); $ring[$key] = $nodeObject; }}

key的hash值也有了,服务器环也计算好了,剩下的就是查找了,二分法能较快的查找相应的服务器节点

更多关于Laravel相关内容感兴趣的读者可查看本站专题:《Laravel框架入门与进阶教程》、《php优秀开发框架总结》、《php面向对象程序设计入门教程》、《php+mysql数据库操作入门教程》及《php常见数据库操作技巧汇总》

希望本文所述对大家基于Laravel框架的PHP程序设计有所帮助。

本文实例讲述了Laravel框架实现redis集群的方法。分享给大家供大家参考,具体如下:

在app/config/database.php中配置如下:

'redis' => array( 'cluster' => true, 'default' => array( 'host' => '172.21.107.247', 'port' => 6379, ), 'redis1' => array( 'host' => '172.21.107.248', 'port' => 6379, ),

其中cluster选择为true,接下来就可以作集群使用了;

如果把session的driver设置为redis,则可以使用其集群功能了:

我们来看下session的实现,当我们在代码中这样写:

Session::put('test', 124);

实际的执行流程是这样的:

Illuminate\Support\Facades\SessionIlluminate\Support\Facades\FacadeIlluminate\Session\Facade::app['session']->putIlluminate\Session\Facade::app['session']为Illuminate\Session\SessionManagerIlluminate\Support\Manager::__call

Session会根据返回创建driver

$this->app['config']['session.driver']

即配置文件中配置的,这里我们配置为redis

Illuminate\Session\SessionManager::Illuminate\Session\SessionManager

最终由Illuminate\Session\Store来负责put的调用

而Store类负责存储的类是Illuminate\Session\CacheBasedSessionHandler

后者又将请求转发给$this->app['cache']->driver($driver)……经过一系列代码追查,存储类为Predis\Client\Database,看其构造函数:

public function __construct(array $servers = array()){ if (isset($servers['cluster']) && $servers['cluster']) { $this->clients = $this->createAggregateClient($servers); } else { $this->clients = $this->createSingleClients($servers); }}

如果设置为集群,则调用createAggregateClient方法

protected function createAggregateClient(array $servers){ $servers = array_except($servers, array('cluster')); return array('default' => new Client(array_values($servers)));}

这里会把所有服务器放在default组中

实际存数据的类是Predis\Client,这里有根据配置创建服务器的代码,具体可以自己看下;

Predis\Cluster\PredisClusterHashStrategy类负责计算key的hash,关键函数:

getHash

getKeyFromFirstArgument

而Predis\Cluster\Distribution\HashRing负责服务器环的维护,关键函数

addNodeToRing

get

hash

大概原理是这样,如执行以下redis命令

get ok

会将ok作crc32运算得到一个hash值

所有服务器按一定算法放到一个长度默认为128的数组中,每个服务器在其中占几项,由以下决定:

权重/总权重*总的服务器数量*128,可参考Predis\Cluster\Distribution\HashRing::addNodeToRing方法

每一项的hash值是按服务器ip:端口的格式,作crc32计算的

protected function addNodeToRing(&$ring, $node, $totalNodes, $replicas, $weightRatio){ $nodeObject = $node['object']; $nodeHash = $this->getNodeHash($nodeObject); $replicas = (int) round($weightRatio * $totalNodes * $replicas); for ($i = 0; $i < $replicas; $i++) { $key = crc32("$nodeHash:$i"); $ring[$key] = $nodeObject; }}

key的hash值也有了,服务器环也计算好了,剩下的就是查找了,二分法能较快的查找相应的服务器节点

更多关于Laravel相关内容感兴趣的读者可查看本站专题:《Laravel框架入门与进阶教程》、《php优秀开发框架总结》、《php面向对象程序设计入门教程》、《php+mysql数据库操作入门教程》及《php常见数据库操作技巧汇总》

希望本文所述对大家基于Laravel框架的PHP程序设计有所帮助。

Laravel框架实现redis集群的方法分析

本文实例讲述了Laravel框架实现redis集群的方法。分享给大家供大家参考,具体如下:

在app/config/database.php中配置如下:

'redis' => array( 'cluster' => true, 'default' => array( 'host' => '172.21.107.247', 'port' => 6379, ), 'redis1' => array( 'host' => '172.21.107.248', 'port' => 6379, ),

其中cluster选择为true,接下来就可以作集群使用了;

如果把session的driver设置为redis,则可以使用其集群功能了:

我们来看下session的实现,当我们在代码中这样写:

Session::put('test', 124);

实际的执行流程是这样的:

Illuminate\Support\Facades\SessionIlluminate\Support\Facades\FacadeIlluminate\Session\Facade::app['session']->putIlluminate\Session\Facade::app['session']为Illuminate\Session\SessionManagerIlluminate\Support\Manager::__call

Session会根据返回创建driver

$this->app['config']['session.driver']

即配置文件中配置的,这里我们配置为redis

Illuminate\Session\SessionManager::Illuminate\Session\SessionManager

最终由Illuminate\Session\Store来负责put的调用

而Store类负责存储的类是Illuminate\Session\CacheBasedSessionHandler

后者又将请求转发给$this->app['cache']->driver($driver)……经过一系列代码追查,存储类为Predis\Client\Database,看其构造函数:

public function __construct(array $servers = array()){ if (isset($servers['cluster']) && $servers['cluster']) { $this->clients = $this->createAggregateClient($servers); } else { $this->clients = $this->createSingleClients($servers); }}

如果设置为集群,则调用createAggregateClient方法

protected function createAggregateClient(array $servers){ $servers = array_except($servers, array('cluster')); return array('default' => new Client(array_values($servers)));}

这里会把所有服务器放在default组中

实际存数据的类是Predis\Client,这里有根据配置创建服务器的代码,具体可以自己看下;

Predis\Cluster\PredisClusterHashStrategy类负责计算key的hash,关键函数:

getHash

getKeyFromFirstArgument

而Predis\Cluster\Distribution\HashRing负责服务器环的维护,关键函数

addNodeToRing

get

hash

大概原理是这样,如执行以下redis命令

get ok

会将ok作crc32运算得到一个hash值

所有服务器按一定算法放到一个长度默认为128的数组中,每个服务器在其中占几项,由以下决定:

权重/总权重*总的服务器数量*128,可参考Predis\Cluster\Distribution\HashRing::addNodeToRing方法

每一项的hash值是按服务器ip:端口的格式,作crc32计算的

protected function addNodeToRing(&$ring, $node, $totalNodes, $replicas, $weightRatio){ $nodeObject = $node['object']; $nodeHash = $this->getNodeHash($nodeObject); $replicas = (int) round($weightRatio * $totalNodes * $replicas); for ($i = 0; $i < $replicas; $i++) { $key = crc32("$nodeHash:$i"); $ring[$key] = $nodeObject; }}

key的hash值也有了,服务器环也计算好了,剩下的就是查找了,二分法能较快的查找相应的服务器节点

更多关于Laravel相关内容感兴趣的读者可查看本站专题:《Laravel框架入门与进阶教程》、《php优秀开发框架总结》、《php面向对象程序设计入门教程》、《php+mysql数据库操作入门教程》及《php常见数据库操作技巧汇总》

希望本文所述对大家基于Laravel框架的PHP程序设计有所帮助。

本文实例讲述了Laravel框架实现redis集群的方法。分享给大家供大家参考,具体如下:

在app/config/database.php中配置如下:

'redis' => array( 'cluster' => true, 'default' => array( 'host' => '172.21.107.247', 'port' => 6379, ), 'redis1' => array( 'host' => '172.21.107.248', 'port' => 6379, ),

其中cluster选择为true,接下来就可以作集群使用了;

如果把session的driver设置为redis,则可以使用其集群功能了:

我们来看下session的实现,当我们在代码中这样写:

Session::put('test', 124);

实际的执行流程是这样的:

Illuminate\Support\Facades\SessionIlluminate\Support\Facades\FacadeIlluminate\Session\Facade::app['session']->putIlluminate\Session\Facade::app['session']为Illuminate\Session\SessionManagerIlluminate\Support\Manager::__call

Session会根据返回创建driver

$this->app['config']['session.driver']

即配置文件中配置的,这里我们配置为redis

Illuminate\Session\SessionManager::Illuminate\Session\SessionManager

最终由Illuminate\Session\Store来负责put的调用

而Store类负责存储的类是Illuminate\Session\CacheBasedSessionHandler

后者又将请求转发给$this->app['cache']->driver($driver)……经过一系列代码追查,存储类为Predis\Client\Database,看其构造函数:

public function __construct(array $servers = array()){ if (isset($servers['cluster']) && $servers['cluster']) { $this->clients = $this->createAggregateClient($servers); } else { $this->clients = $this->createSingleClients($servers); }}

如果设置为集群,则调用createAggregateClient方法

protected function createAggregateClient(array $servers){ $servers = array_except($servers, array('cluster')); return array('default' => new Client(array_values($servers)));}

这里会把所有服务器放在default组中

实际存数据的类是Predis\Client,这里有根据配置创建服务器的代码,具体可以自己看下;

Predis\Cluster\PredisClusterHashStrategy类负责计算key的hash,关键函数:

getHash

getKeyFromFirstArgument

而Predis\Cluster\Distribution\HashRing负责服务器环的维护,关键函数

addNodeToRing

get

hash

大概原理是这样,如执行以下redis命令

get ok

会将ok作crc32运算得到一个hash值

所有服务器按一定算法放到一个长度默认为128的数组中,每个服务器在其中占几项,由以下决定:

权重/总权重*总的服务器数量*128,可参考Predis\Cluster\Distribution\HashRing::addNodeToRing方法

每一项的hash值是按服务器ip:端口的格式,作crc32计算的

protected function addNodeToRing(&$ring, $node, $totalNodes, $replicas, $weightRatio){ $nodeObject = $node['object']; $nodeHash = $this->getNodeHash($nodeObject); $replicas = (int) round($weightRatio * $totalNodes * $replicas); for ($i = 0; $i < $replicas; $i++) { $key = crc32("$nodeHash:$i"); $ring[$key] = $nodeObject; }}

key的hash值也有了,服务器环也计算好了,剩下的就是查找了,二分法能较快的查找相应的服务器节点

更多关于Laravel相关内容感兴趣的读者可查看本站专题:《Laravel框架入门与进阶教程》、《php优秀开发框架总结》、《php面向对象程序设计入门教程》、《php+mysql数据库操作入门教程》及《php常见数据库操作技巧汇总》

希望本文所述对大家基于Laravel框架的PHP程序设计有所帮助。

本文实例讲述了Laravel框架实现redis集群的方法。分享给大家供大家参考,具体如下:

在app/config/database.php中配置如下:

'redis' => array( 'cluster' => true, 'default' => array( 'host' => '172.21.107.247', 'port' => 6379, ), 'redis1' => array( 'host' => '172.21.107.248', 'port' => 6379, ),

其中cluster选择为true,接下来就可以作集群使用了;

如果把session的driver设置为redis,则可以使用其集群功能了:

我们来看下session的实现,当我们在代码中这样写:

Session::put('test', 124);

实际的执行流程是这样的:

Illuminate\Support\Facades\SessionIlluminate\Support\Facades\FacadeIlluminate\Session\Facade::app['session']->putIlluminate\Session\Facade::app['session']为Illuminate\Session\SessionManagerIlluminate\Support\Manager::__call

Session会根据返回创建driver

$this->app['config']['session.driver']

即配置文件中配置的,这里我们配置为redis

Illuminate\Session\SessionManager::Illuminate\Session\SessionManager

最终由Illuminate\Session\Store来负责put的调用

而Store类负责存储的类是Illuminate\Session\CacheBasedSessionHandler

后者又将请求转发给$this->app['cache']->driver($driver)……经过一系列代码追查,存储类为Predis\Client\Database,看其构造函数:

public function __construct(array $servers = array()){ if (isset($servers['cluster']) && $servers['cluster']) { $this->clients = $this->createAggregateClient($servers); } else { $this->clients = $this->createSingleClients($servers); }}

如果设置为集群,则调用createAggregateClient方法

protected function createAggregateClient(array $servers){ $servers = array_except($servers, array('cluster')); return array('default' => new Client(array_values($servers)));}

这里会把所有服务器放在default组中

实际存数据的类是Predis\Client,这里有根据配置创建服务器的代码,具体可以自己看下;

Predis\Cluster\PredisClusterHashStrategy类负责计算key的hash,关键函数:

getHash

getKeyFromFirstArgument

而Predis\Cluster\Distribution\HashRing负责服务器环的维护,关键函数

addNodeToRing

get

hash

大概原理是这样,如执行以下redis命令

get ok

会将ok作crc32运算得到一个hash值

所有服务器按一定算法放到一个长度默认为128的数组中,每个服务器在其中占几项,由以下决定:

权重/总权重*总的服务器数量*128,可参考Predis\Cluster\Distribution\HashRing::addNodeToRing方法

每一项的hash值是按服务器ip:端口的格式,作crc32计算的

protected function addNodeToRing(&$ring, $node, $totalNodes, $replicas, $weightRatio){ $nodeObject = $node['object']; $nodeHash = $this->getNodeHash($nodeObject); $replicas = (int) round($weightRatio * $totalNodes * $replicas); for ($i = 0; $i < $replicas; $i++) { $key = crc32("$nodeHash:$i"); $ring[$key] = $nodeObject; }}

key的hash值也有了,服务器环也计算好了,剩下的就是查找了,二分法能较快的查找相应的服务器节点

更多关于Laravel相关内容感兴趣的读者可查看本站专题:《Laravel框架入门与进阶教程》、《php优秀开发框架总结》、《php面向对象程序设计入门教程》、《php+mysql数据库操作入门教程》及《php常见数据库操作技巧汇总》

希望本文所述对大家基于Laravel框架的PHP程序设计有所帮助。

4.

本文实例讲述了Laravel框架实现redis集群的方法。分享给大家供大家参考,具体如下:

在app/config/database.php中配置如下:

'redis' => array( 'cluster' => true, 'default' => array( 'host' => '172.21.107.247', 'port' => 6379, ), 'redis1' => array( 'host' => '172.21.107.248', 'port' => 6379, ),

其中cluster选择为true,接下来就可以作集群使用了;

如果把session的driver设置为redis,则可以使用其集群功能了:

我们来看下session的实现,当我们在代码中这样写:

Session::put('test', 124);

实际的执行流程是这样的:

Illuminate\Support\Facades\SessionIlluminate\Support\Facades\FacadeIlluminate\Session\Facade::app['session']->putIlluminate\Session\Facade::app['session']为Illuminate\Session\SessionManagerIlluminate\Support\Manager::__call

Session会根据返回创建driver

$this->app['config']['session.driver']

即配置文件中配置的,这里我们配置为redis

Illuminate\Session\SessionManager::Illuminate\Session\SessionManager

最终由Illuminate\Session\Store来负责put的调用

而Store类负责存储的类是Illuminate\Session\CacheBasedSessionHandler

后者又将请求转发给$this->app['cache']->driver($driver)……经过一系列代码追查,存储类为Predis\Client\Database,看其构造函数:

public function __construct(array $servers = array()){ if (isset($servers['cluster']) && $servers['cluster']) { $this->clients = $this->createAggregateClient($servers); } else { $this->clients = $this->createSingleClients($servers); }}

如果设置为集群,则调用createAggregateClient方法

protected function createAggregateClient(array $servers){ $servers = array_except($servers, array('cluster')); return array('default' => new Client(array_values($servers)));}

这里会把所有服务器放在default组中

实际存数据的类是Predis\Client,这里有根据配置创建服务器的代码,具体可以自己看下;

Predis\Cluster\PredisClusterHashStrategy类负责计算key的hash,关键函数:

getHash

getKeyFromFirstArgument

而Predis\Cluster\Distribution\HashRing负责服务器环的维护,关键函数

addNodeToRing

get

hash

大概原理是这样,如执行以下redis命令

get ok

会将ok作crc32运算得到一个hash值

所有服务器按一定算法放到一个长度默认为128的数组中,每个服务器在其中占几项,由以下决定:

权重/总权重*总的服务器数量*128,可参考Predis\Cluster\Distribution\HashRing::addNodeToRing方法

每一项的hash值是按服务器ip:端口的格式,作crc32计算的

protected function addNodeToRing(&$ring, $node, $totalNodes, $replicas, $weightRatio){ $nodeObject = $node['object']; $nodeHash = $this->getNodeHash($nodeObject); $replicas = (int) round($weightRatio * $totalNodes * $replicas); for ($i = 0; $i < $replicas; $i++) { $key = crc32("$nodeHash:$i"); $ring[$key] = $nodeObject; }}

key的hash值也有了,服务器环也计算好了,剩下的就是查找了,二分法能较快的查找相应的服务器节点

更多关于Laravel相关内容感兴趣的读者可查看本站专题:《Laravel框架入门与进阶教程》、《php优秀开发框架总结》、《php面向对象程序设计入门教程》、《php+mysql数据库操作入门教程》及《php常见数据库操作技巧汇总》

希望本文所述对大家基于Laravel框架的PHP程序设计有所帮助。

本文实例讲述了Laravel框架实现redis集群的方法。分享给大家供大家参考,具体如下:

在app/config/database.php中配置如下:

'redis' => array( 'cluster' => true, 'default' => array( 'host' => '172.21.107.247', 'port' => 6379, ), 'redis1' => array( 'host' => '172.21.107.248', 'port' => 6379, ),

其中cluster选择为true,接下来就可以作集群使用了;

如果把session的driver设置为redis,则可以使用其集群功能了:

我们来看下session的实现,当我们在代码中这样写:

Session::put('test', 124);

实际的执行流程是这样的:

Illuminate\Support\Facades\SessionIlluminate\Support\Facades\FacadeIlluminate\Session\Facade::app['session']->putIlluminate\Session\Facade::app['session']为Illuminate\Session\SessionManagerIlluminate\Support\Manager::__call

Session会根据返回创建driver

$this->app['config']['session.driver']

即配置文件中配置的,这里我们配置为redis

Illuminate\Session\SessionManager::Illuminate\Session\SessionManager

最终由Illuminate\Session\Store来负责put的调用

而Store类负责存储的类是Illuminate\Session\CacheBasedSessionHandler

后者又将请求转发给$this->app['cache']->driver($driver)……经过一系列代码追查,存储类为Predis\Client\Database,看其构造函数:

public function __construct(array $servers = array()){ if (isset($servers['cluster']) && $servers['cluster']) { $this->clients = $this->createAggregateClient($servers); } else { $this->clients = $this->createSingleClients($servers); }}

如果设置为集群,则调用createAggregateClient方法

protected function createAggregateClient(array $servers){ $servers = array_except($servers, array('cluster')); return array('default' => new Client(array_values($servers)));}

这里会把所有服务器放在default组中

实际存数据的类是Predis\Client,这里有根据配置创建服务器的代码,具体可以自己看下;

Predis\Cluster\PredisClusterHashStrategy类负责计算key的hash,关键函数:

getHash

getKeyFromFirstArgument

而Predis\Cluster\Distribution\HashRing负责服务器环的维护,关键函数

addNodeToRing

get

hash

大概原理是这样,如执行以下redis命令

get ok

会将ok作crc32运算得到一个hash值

所有服务器按一定算法放到一个长度默认为128的数组中,每个服务器在其中占几项,由以下决定:

权重/总权重*总的服务器数量*128,可参考Predis\Cluster\Distribution\HashRing::addNodeToRing方法

每一项的hash值是按服务器ip:端口的格式,作crc32计算的

protected function addNodeToRing(&$ring, $node, $totalNodes, $replicas, $weightRatio){ $nodeObject = $node['object']; $nodeHash = $this->getNodeHash($nodeObject); $replicas = (int) round($weightRatio * $totalNodes * $replicas); for ($i = 0; $i < $replicas; $i++) { $key = crc32("$nodeHash:$i"); $ring[$key] = $nodeObject; }}

key的hash值也有了,服务器环也计算好了,剩下的就是查找了,二分法能较快的查找相应的服务器节点

更多关于Laravel相关内容感兴趣的读者可查看本站专题:《Laravel框架入门与进阶教程》、《php优秀开发框架总结》、《php面向对象程序设计入门教程》、《php+mysql数据库操作入门教程》及《php常见数据库操作技巧汇总》

希望本文所述对大家基于Laravel框架的PHP程序设计有所帮助。

Laravel框架实现redis集群的方法分析Laravel框架实现redis集群的方法分析

本文实例讲述了Laravel框架实现redis集群的方法。分享给大家供大家参考,具体如下:

在app/config/database.php中配置如下:

'redis' => array( 'cluster' => true, 'default' => array( 'host' => '172.21.107.247', 'port' => 6379, ), 'redis1' => array( 'host' => '172.21.107.248', 'port' => 6379, ),

其中cluster选择为true,接下来就可以作集群使用了;

如果把session的driver设置为redis,则可以使用其集群功能了:

我们来看下session的实现,当我们在代码中这样写:

Session::put('test', 124);

实际的执行流程是这样的:

Illuminate\Support\Facades\SessionIlluminate\Support\Facades\FacadeIlluminate\Session\Facade::app['session']->putIlluminate\Session\Facade::app['session']为Illuminate\Session\SessionManagerIlluminate\Support\Manager::__call

Session会根据返回创建driver

$this->app['config']['session.driver']

即配置文件中配置的,这里我们配置为redis

Illuminate\Session\SessionManager::Illuminate\Session\SessionManager

最终由Illuminate\Session\Store来负责put的调用

而Store类负责存储的类是Illuminate\Session\CacheBasedSessionHandler

后者又将请求转发给$this->app['cache']->driver($driver)……经过一系列代码追查,存储类为Predis\Client\Database,看其构造函数:

public function __construct(array $servers = array()){ if (isset($servers['cluster']) && $servers['cluster']) { $this->clients = $this->createAggregateClient($servers); } else { $this->clients = $this->createSingleClients($servers); }}

如果设置为集群,则调用createAggregateClient方法

protected function createAggregateClient(array $servers){ $servers = array_except($servers, array('cluster')); return array('default' => new Client(array_values($servers)));}

这里会把所有服务器放在default组中

实际存数据的类是Predis\Client,这里有根据配置创建服务器的代码,具体可以自己看下;

Predis\Cluster\PredisClusterHashStrategy类负责计算key的hash,关键函数:

getHash

getKeyFromFirstArgument

而Predis\Cluster\Distribution\HashRing负责服务器环的维护,关键函数

addNodeToRing

get

hash

大概原理是这样,如执行以下redis命令

get ok

会将ok作crc32运算得到一个hash值

所有服务器按一定算法放到一个长度默认为128的数组中,每个服务器在其中占几项,由以下决定:

权重/总权重*总的服务器数量*128,可参考Predis\Cluster\Distribution\HashRing::addNodeToRing方法

每一项的hash值是按服务器ip:端口的格式,作crc32计算的

protected function addNodeToRing(&$ring, $node, $totalNodes, $replicas, $weightRatio){ $nodeObject = $node['object']; $nodeHash = $this->getNodeHash($nodeObject); $replicas = (int) round($weightRatio * $totalNodes * $replicas); for ($i = 0; $i < $replicas; $i++) { $key = crc32("$nodeHash:$i"); $ring[$key] = $nodeObject; }}

key的hash值也有了,服务器环也计算好了,剩下的就是查找了,二分法能较快的查找相应的服务器节点

更多关于Laravel相关内容感兴趣的读者可查看本站专题:《Laravel框架入门与进阶教程》、《php优秀开发框架总结》、《php面向对象程序设计入门教程》、《php+mysql数据库操作入门教程》及《php常见数据库操作技巧汇总》

希望本文所述对大家基于Laravel框架的PHP程序设计有所帮助。

Laravel框架实现redis集群的方法分析

本文实例讲述了Laravel框架实现redis集群的方法。分享给大家供大家参考,具体如下:

在app/config/database.php中配置如下:

'redis' => array( 'cluster' => true, 'default' => array( 'host' => '172.21.107.247', 'port' => 6379, ), 'redis1' => array( 'host' => '172.21.107.248', 'port' => 6379, ),

其中cluster选择为true,接下来就可以作集群使用了;

如果把session的driver设置为redis,则可以使用其集群功能了:

我们来看下session的实现,当我们在代码中这样写:

Session::put('test', 124);

实际的执行流程是这样的:

Illuminate\Support\Facades\SessionIlluminate\Support\Facades\FacadeIlluminate\Session\Facade::app['session']->putIlluminate\Session\Facade::app['session']为Illuminate\Session\SessionManagerIlluminate\Support\Manager::__call

Session会根据返回创建driver

$this->app['config']['session.driver']

即配置文件中配置的,这里我们配置为redis

Illuminate\Session\SessionManager::Illuminate\Session\SessionManager

最终由Illuminate\Session\Store来负责put的调用

而Store类负责存储的类是Illuminate\Session\CacheBasedSessionHandler

后者又将请求转发给$this->app['cache']->driver($driver)……经过一系列代码追查,存储类为Predis\Client\Database,看其构造函数:

public function __construct(array $servers = array()){ if (isset($servers['cluster']) && $servers['cluster']) { $this->clients = $this->createAggregateClient($servers); } else { $this->clients = $this->createSingleClients($servers); }}

如果设置为集群,则调用createAggregateClient方法

protected function createAggregateClient(array $servers){ $servers = array_except($servers, array('cluster')); return array('default' => new Client(array_values($servers)));}

这里会把所有服务器放在default组中

实际存数据的类是Predis\Client,这里有根据配置创建服务器的代码,具体可以自己看下;

Predis\Cluster\PredisClusterHashStrategy类负责计算key的hash,关键函数:

getHash

getKeyFromFirstArgument

而Predis\Cluster\Distribution\HashRing负责服务器环的维护,关键函数

addNodeToRing

get

hash

大概原理是这样,如执行以下redis命令

get ok

会将ok作crc32运算得到一个hash值

所有服务器按一定算法放到一个长度默认为128的数组中,每个服务器在其中占几项,由以下决定:

权重/总权重*总的服务器数量*128,可参考Predis\Cluster\Distribution\HashRing::addNodeToRing方法

每一项的hash值是按服务器ip:端口的格式,作crc32计算的

protected function addNodeToRing(&$ring, $node, $totalNodes, $replicas, $weightRatio){ $nodeObject = $node['object']; $nodeHash = $this->getNodeHash($nodeObject); $replicas = (int) round($weightRatio * $totalNodes * $replicas); for ($i = 0; $i < $replicas; $i++) { $key = crc32("$nodeHash:$i"); $ring[$key] = $nodeObject; }}

key的hash值也有了,服务器环也计算好了,剩下的就是查找了,二分法能较快的查找相应的服务器节点

更多关于Laravel相关内容感兴趣的读者可查看本站专题:《Laravel框架入门与进阶教程》、《php优秀开发框架总结》、《php面向对象程序设计入门教程》、《php+mysql数据库操作入门教程》及《php常见数据库操作技巧汇总》

希望本文所述对大家基于Laravel框架的PHP程序设计有所帮助。

本文实例讲述了Laravel框架实现redis集群的方法。分享给大家供大家参考,具体如下:

在app/config/database.php中配置如下:

'redis' => array( 'cluster' => true, 'default' => array( 'host' => '172.21.107.247', 'port' => 6379, ), 'redis1' => array( 'host' => '172.21.107.248', 'port' => 6379, ),

其中cluster选择为true,接下来就可以作集群使用了;

如果把session的driver设置为redis,则可以使用其集群功能了:

我们来看下session的实现,当我们在代码中这样写:

Session::put('test', 124);

实际的执行流程是这样的:

Illuminate\Support\Facades\SessionIlluminate\Support\Facades\FacadeIlluminate\Session\Facade::app['session']->putIlluminate\Session\Facade::app['session']为Illuminate\Session\SessionManagerIlluminate\Support\Manager::__call

Session会根据返回创建driver

$this->app['config']['session.driver']

即配置文件中配置的,这里我们配置为redis

Illuminate\Session\SessionManager::Illuminate\Session\SessionManager

最终由Illuminate\Session\Store来负责put的调用

而Store类负责存储的类是Illuminate\Session\CacheBasedSessionHandler

后者又将请求转发给$this->app['cache']->driver($driver)……经过一系列代码追查,存储类为Predis\Client\Database,看其构造函数:

public function __construct(array $servers = array()){ if (isset($servers['cluster']) && $servers['cluster']) { $this->clients = $this->createAggregateClient($servers); } else { $this->clients = $this->createSingleClients($servers); }}

如果设置为集群,则调用createAggregateClient方法

protected function createAggregateClient(array $servers){ $servers = array_except($servers, array('cluster')); return array('default' => new Client(array_values($servers)));}

这里会把所有服务器放在default组中

实际存数据的类是Predis\Client,这里有根据配置创建服务器的代码,具体可以自己看下;

Predis\Cluster\PredisClusterHashStrategy类负责计算key的hash,关键函数:

getHash

getKeyFromFirstArgument

而Predis\Cluster\Distribution\HashRing负责服务器环的维护,关键函数

addNodeToRing

get

hash

大概原理是这样,如执行以下redis命令

get ok

会将ok作crc32运算得到一个hash值

所有服务器按一定算法放到一个长度默认为128的数组中,每个服务器在其中占几项,由以下决定:

权重/总权重*总的服务器数量*128,可参考Predis\Cluster\Distribution\HashRing::addNodeToRing方法

每一项的hash值是按服务器ip:端口的格式,作crc32计算的

protected function addNodeToRing(&$ring, $node, $totalNodes, $replicas, $weightRatio){ $nodeObject = $node['object']; $nodeHash = $this->getNodeHash($nodeObject); $replicas = (int) round($weightRatio * $totalNodes * $replicas); for ($i = 0; $i < $replicas; $i++) { $key = crc32("$nodeHash:$i"); $ring[$key] = $nodeObject; }}

key的hash值也有了,服务器环也计算好了,剩下的就是查找了,二分法能较快的查找相应的服务器节点

更多关于Laravel相关内容感兴趣的读者可查看本站专题:《Laravel框架入门与进阶教程》、《php优秀开发框架总结》、《php面向对象程序设计入门教程》、《php+mysql数据库操作入门教程》及《php常见数据库操作技巧汇总》

希望本文所述对大家基于Laravel框架的PHP程序设计有所帮助。

本文实例讲述了Laravel框架实现redis集群的方法。分享给大家供大家参考,具体如下:

在app/config/database.php中配置如下:

'redis' => array( 'cluster' => true, 'default' => array( 'host' => '172.21.107.247', 'port' => 6379, ), 'redis1' => array( 'host' => '172.21.107.248', 'port' => 6379, ),

其中cluster选择为true,接下来就可以作集群使用了;

如果把session的driver设置为redis,则可以使用其集群功能了:

我们来看下session的实现,当我们在代码中这样写:

Session::put('test', 124);

实际的执行流程是这样的:

Illuminate\Support\Facades\SessionIlluminate\Support\Facades\FacadeIlluminate\Session\Facade::app['session']->putIlluminate\Session\Facade::app['session']为Illuminate\Session\SessionManagerIlluminate\Support\Manager::__call

Session会根据返回创建driver

$this->app['config']['session.driver']

即配置文件中配置的,这里我们配置为redis

Illuminate\Session\SessionManager::Illuminate\Session\SessionManager

最终由Illuminate\Session\Store来负责put的调用

而Store类负责存储的类是Illuminate\Session\CacheBasedSessionHandler

后者又将请求转发给$this->app['cache']->driver($driver)……经过一系列代码追查,存储类为Predis\Client\Database,看其构造函数:

public function __construct(array $servers = array()){ if (isset($servers['cluster']) && $servers['cluster']) { $this->clients = $this->createAggregateClient($servers); } else { $this->clients = $this->createSingleClients($servers); }}

如果设置为集群,则调用createAggregateClient方法

protected function createAggregateClient(array $servers){ $servers = array_except($servers, array('cluster')); return array('default' => new Client(array_values($servers)));}

这里会把所有服务器放在default组中

实际存数据的类是Predis\Client,这里有根据配置创建服务器的代码,具体可以自己看下;

Predis\Cluster\PredisClusterHashStrategy类负责计算key的hash,关键函数:

getHash

getKeyFromFirstArgument

而Predis\Cluster\Distribution\HashRing负责服务器环的维护,关键函数

addNodeToRing

get

hash

大概原理是这样,如执行以下redis命令

get ok

会将ok作crc32运算得到一个hash值

所有服务器按一定算法放到一个长度默认为128的数组中,每个服务器在其中占几项,由以下决定:

权重/总权重*总的服务器数量*128,可参考Predis\Cluster\Distribution\HashRing::addNodeToRing方法

每一项的hash值是按服务器ip:端口的格式,作crc32计算的

protected function addNodeToRing(&$ring, $node, $totalNodes, $replicas, $weightRatio){ $nodeObject = $node['object']; $nodeHash = $this->getNodeHash($nodeObject); $replicas = (int) round($weightRatio * $totalNodes * $replicas); for ($i = 0; $i < $replicas; $i++) { $key = crc32("$nodeHash:$i"); $ring[$key] = $nodeObject; }}

key的hash值也有了,服务器环也计算好了,剩下的就是查找了,二分法能较快的查找相应的服务器节点

更多关于Laravel相关内容感兴趣的读者可查看本站专题:《Laravel框架入门与进阶教程》、《php优秀开发框架总结》、《php面向对象程序设计入门教程》、《php+mysql数据库操作入门教程》及《php常见数据库操作技巧汇总》

希望本文所述对大家基于Laravel框架的PHP程序设计有所帮助。

Laravel框架实现redis集群的方法分析

本文实例讲述了Laravel框架实现redis集群的方法。分享给大家供大家参考,具体如下:

在app/config/database.php中配置如下:

'redis' => array( 'cluster' => true, 'default' => array( 'host' => '172.21.107.247', 'port' => 6379, ), 'redis1' => array( 'host' => '172.21.107.248', 'port' => 6379, ),

其中cluster选择为true,接下来就可以作集群使用了;

如果把session的driver设置为redis,则可以使用其集群功能了:

我们来看下session的实现,当我们在代码中这样写:

Session::put('test', 124);

实际的执行流程是这样的:

Illuminate\Support\Facades\SessionIlluminate\Support\Facades\FacadeIlluminate\Session\Facade::app['session']->putIlluminate\Session\Facade::app['session']为Illuminate\Session\SessionManagerIlluminate\Support\Manager::__call

Session会根据返回创建driver

$this->app['config']['session.driver']

即配置文件中配置的,这里我们配置为redis

Illuminate\Session\SessionManager::Illuminate\Session\SessionManager

最终由Illuminate\Session\Store来负责put的调用

而Store类负责存储的类是Illuminate\Session\CacheBasedSessionHandler

后者又将请求转发给$this->app['cache']->driver($driver)……经过一系列代码追查,存储类为Predis\Client\Database,看其构造函数:

public function __construct(array $servers = array()){ if (isset($servers['cluster']) && $servers['cluster']) { $this->clients = $this->createAggregateClient($servers); } else { $this->clients = $this->createSingleClients($servers); }}

如果设置为集群,则调用createAggregateClient方法

protected function createAggregateClient(array $servers){ $servers = array_except($servers, array('cluster')); return array('default' => new Client(array_values($servers)));}

这里会把所有服务器放在default组中

实际存数据的类是Predis\Client,这里有根据配置创建服务器的代码,具体可以自己看下;

Predis\Cluster\PredisClusterHashStrategy类负责计算key的hash,关键函数:

getHash

getKeyFromFirstArgument

而Predis\Cluster\Distribution\HashRing负责服务器环的维护,关键函数

addNodeToRing

get

hash

大概原理是这样,如执行以下redis命令

get ok

会将ok作crc32运算得到一个hash值

所有服务器按一定算法放到一个长度默认为128的数组中,每个服务器在其中占几项,由以下决定:

权重/总权重*总的服务器数量*128,可参考Predis\Cluster\Distribution\HashRing::addNodeToRing方法

每一项的hash值是按服务器ip:端口的格式,作crc32计算的

protected function addNodeToRing(&$ring, $node, $totalNodes, $replicas, $weightRatio){ $nodeObject = $node['object']; $nodeHash = $this->getNodeHash($nodeObject); $replicas = (int) round($weightRatio * $totalNodes * $replicas); for ($i = 0; $i < $replicas; $i++) { $key = crc32("$nodeHash:$i"); $ring[$key] = $nodeObject; }}

key的hash值也有了,服务器环也计算好了,剩下的就是查找了,二分法能较快的查找相应的服务器节点

更多关于Laravel相关内容感兴趣的读者可查看本站专题:《Laravel框架入门与进阶教程》、《php优秀开发框架总结》、《php面向对象程序设计入门教程》、《php+mysql数据库操作入门教程》及《php常见数据库操作技巧汇总》

希望本文所述对大家基于Laravel框架的PHP程序设计有所帮助。

本文实例讲述了Laravel框架实现redis集群的方法。分享给大家供大家参考,具体如下:

在app/config/database.php中配置如下:

'redis' => array( 'cluster' => true, 'default' => array( 'host' => '172.21.107.247', 'port' => 6379, ), 'redis1' => array( 'host' => '172.21.107.248', 'port' => 6379, ),

其中cluster选择为true,接下来就可以作集群使用了;

如果把session的driver设置为redis,则可以使用其集群功能了:

我们来看下session的实现,当我们在代码中这样写:

Session::put('test', 124);

实际的执行流程是这样的:

Illuminate\Support\Facades\SessionIlluminate\Support\Facades\FacadeIlluminate\Session\Facade::app['session']->putIlluminate\Session\Facade::app['session']为Illuminate\Session\SessionManagerIlluminate\Support\Manager::__call

Session会根据返回创建driver

$this->app['config']['session.driver']

即配置文件中配置的,这里我们配置为redis

Illuminate\Session\SessionManager::Illuminate\Session\SessionManager

最终由Illuminate\Session\Store来负责put的调用

而Store类负责存储的类是Illuminate\Session\CacheBasedSessionHandler

后者又将请求转发给$this->app['cache']->driver($driver)……经过一系列代码追查,存储类为Predis\Client\Database,看其构造函数:

public function __construct(array $servers = array()){ if (isset($servers['cluster']) && $servers['cluster']) { $this->clients = $this->createAggregateClient($servers); } else { $this->clients = $this->createSingleClients($servers); }}

如果设置为集群,则调用createAggregateClient方法

protected function createAggregateClient(array $servers){ $servers = array_except($servers, array('cluster')); return array('default' => new Client(array_values($servers)));}

这里会把所有服务器放在default组中

实际存数据的类是Predis\Client,这里有根据配置创建服务器的代码,具体可以自己看下;

Predis\Cluster\PredisClusterHashStrategy类负责计算key的hash,关键函数:

getHash

getKeyFromFirstArgument

而Predis\Cluster\Distribution\HashRing负责服务器环的维护,关键函数

addNodeToRing

get

hash

大概原理是这样,如执行以下redis命令

get ok

会将ok作crc32运算得到一个hash值

所有服务器按一定算法放到一个长度默认为128的数组中,每个服务器在其中占几项,由以下决定:

权重/总权重*总的服务器数量*128,可参考Predis\Cluster\Distribution\HashRing::addNodeToRing方法

每一项的hash值是按服务器ip:端口的格式,作crc32计算的

protected function addNodeToRing(&$ring, $node, $totalNodes, $replicas, $weightRatio){ $nodeObject = $node['object']; $nodeHash = $this->getNodeHash($nodeObject); $replicas = (int) round($weightRatio * $totalNodes * $replicas); for ($i = 0; $i < $replicas; $i++) { $key = crc32("$nodeHash:$i"); $ring[$key] = $nodeObject; }}

key的hash值也有了,服务器环也计算好了,剩下的就是查找了,二分法能较快的查找相应的服务器节点

更多关于Laravel相关内容感兴趣的读者可查看本站专题:《Laravel框架入门与进阶教程》、《php优秀开发框架总结》、《php面向对象程序设计入门教程》、《php+mysql数据库操作入门教程》及《php常见数据库操作技巧汇总》

希望本文所述对大家基于Laravel框架的PHP程序设计有所帮助。

。澳门汽车玻璃厂家价格

展开全文
相关文章
澳门生产压焊钢格板报价

本文实例讲述了Laravel框架实现redis集群的方法。分享给大家供大家参考,具体如下:

在app/config/database.php中配置如下:

'redis' => array( 'cluster' => true, 'default' => array( 'host' => '172.21.107.247', 'port' => 6379, ), 'redis1' => array( 'host' => '172.21.107.248', 'port' => 6379, ),

其中cluster选择为true,接下来就可以作集群使用了;

如果把session的driver设置为redis,则可以使用其集群功能了:

我们来看下session的实现,当我们在代码中这样写:

Session::put('test', 124);

实际的执行流程是这样的:

Illuminate\Support\Facades\SessionIlluminate\Support\Facades\FacadeIlluminate\Session\Facade::app['session']->putIlluminate\Session\Facade::app['session']为Illuminate\Session\SessionManagerIlluminate\Support\Manager::__call

Session会根据返回创建driver

$this->app['config']['session.driver']

即配置文件中配置的,这里我们配置为redis

Illuminate\Session\SessionManager::Illuminate\Session\SessionManager

最终由Illuminate\Session\Store来负责put的调用

而Store类负责存储的类是Illuminate\Session\CacheBasedSessionHandler

后者又将请求转发给$this->app['cache']->driver($driver)……经过一系列代码追查,存储类为Predis\Client\Database,看其构造函数:

public function __construct(array $servers = array()){ if (isset($servers['cluster']) && $servers['cluster']) { $this->clients = $this->createAggregateClient($servers); } else { $this->clients = $this->createSingleClients($servers); }}

如果设置为集群,则调用createAggregateClient方法

protected function createAggregateClient(array $servers){ $servers = array_except($servers, array('cluster')); return array('default' => new Client(array_values($servers)));}

这里会把所有服务器放在default组中

实际存数据的类是Predis\Client,这里有根据配置创建服务器的代码,具体可以自己看下;

Predis\Cluster\PredisClusterHashStrategy类负责计算key的hash,关键函数:

getHash

getKeyFromFirstArgument

而Predis\Cluster\Distribution\HashRing负责服务器环的维护,关键函数

addNodeToRing

get

hash

大概原理是这样,如执行以下redis命令

get ok

会将ok作crc32运算得到一个hash值

所有服务器按一定算法放到一个长度默认为128的数组中,每个服务器在其中占几项,由以下决定:

权重/总权重*总的服务器数量*128,可参考Predis\Cluster\Distribution\HashRing::addNodeToRing方法

每一项的hash值是按服务器ip:端口的格式,作crc32计算的

protected function addNodeToRing(&$ring, $node, $totalNodes, $replicas, $weightRatio){ $nodeObject = $node['object']; $nodeHash = $this->getNodeHash($nodeObject); $replicas = (int) round($weightRatio * $totalNodes * $replicas); for ($i = 0; $i < $replicas; $i++) { $key = crc32("$nodeHash:$i"); $ring[$key] = $nodeObject; }}

key的hash值也有了,服务器环也计算好了,剩下的就是查找了,二分法能较快的查找相应的服务器节点

更多关于Laravel相关内容感兴趣的读者可查看本站专题:《Laravel框架入门与进阶教程》、《php优秀开发框架总结》、《php面向对象程序设计入门教程》、《php+mysql数据库操作入门教程》及《php常见数据库操作技巧汇总》

希望本文所述对大家基于Laravel框架的PHP程序设计有所帮助。

千百万时时彩靠谱吗

本文实例讲述了Laravel框架实现redis集群的方法。分享给大家供大家参考,具体如下:

在app/config/database.php中配置如下:

'redis' => array( 'cluster' => true, 'default' => array( 'host' => '172.21.107.247', 'port' => 6379, ), 'redis1' => array( 'host' => '172.21.107.248', 'port' => 6379, ),

其中cluster选择为true,接下来就可以作集群使用了;

如果把session的driver设置为redis,则可以使用其集群功能了:

我们来看下session的实现,当我们在代码中这样写:

Session::put('test', 124);

实际的执行流程是这样的:

Illuminate\Support\Facades\SessionIlluminate\Support\Facades\FacadeIlluminate\Session\Facade::app['session']->putIlluminate\Session\Facade::app['session']为Illuminate\Session\SessionManagerIlluminate\Support\Manager::__call

Session会根据返回创建driver

$this->app['config']['session.driver']

即配置文件中配置的,这里我们配置为redis

Illuminate\Session\SessionManager::Illuminate\Session\SessionManager

最终由Illuminate\Session\Store来负责put的调用

而Store类负责存储的类是Illuminate\Session\CacheBasedSessionHandler

后者又将请求转发给$this->app['cache']->driver($driver)……经过一系列代码追查,存储类为Predis\Client\Database,看其构造函数:

public function __construct(array $servers = array()){ if (isset($servers['cluster']) && $servers['cluster']) { $this->clients = $this->createAggregateClient($servers); } else { $this->clients = $this->createSingleClients($servers); }}

如果设置为集群,则调用createAggregateClient方法

protected function createAggregateClient(array $servers){ $servers = array_except($servers, array('cluster')); return array('default' => new Client(array_values($servers)));}

这里会把所有服务器放在default组中

实际存数据的类是Predis\Client,这里有根据配置创建服务器的代码,具体可以自己看下;

Predis\Cluster\PredisClusterHashStrategy类负责计算key的hash,关键函数:

getHash

getKeyFromFirstArgument

而Predis\Cluster\Distribution\HashRing负责服务器环的维护,关键函数

addNodeToRing

get

hash

大概原理是这样,如执行以下redis命令

get ok

会将ok作crc32运算得到一个hash值

所有服务器按一定算法放到一个长度默认为128的数组中,每个服务器在其中占几项,由以下决定:

权重/总权重*总的服务器数量*128,可参考Predis\Cluster\Distribution\HashRing::addNodeToRing方法

每一项的hash值是按服务器ip:端口的格式,作crc32计算的

protected function addNodeToRing(&$ring, $node, $totalNodes, $replicas, $weightRatio){ $nodeObject = $node['object']; $nodeHash = $this->getNodeHash($nodeObject); $replicas = (int) round($weightRatio * $totalNodes * $replicas); for ($i = 0; $i < $replicas; $i++) { $key = crc32("$nodeHash:$i"); $ring[$key] = $nodeObject; }}

key的hash值也有了,服务器环也计算好了,剩下的就是查找了,二分法能较快的查找相应的服务器节点

更多关于Laravel相关内容感兴趣的读者可查看本站专题:《Laravel框架入门与进阶教程》、《php优秀开发框架总结》、《php面向对象程序设计入门教程》、《php+mysql数据库操作入门教程》及《php常见数据库操作技巧汇总》

希望本文所述对大家基于Laravel框架的PHP程序设计有所帮助。

....

免费送彩金的博彩娱乐网站

本文实例讲述了Laravel框架实现redis集群的方法。分享给大家供大家参考,具体如下:

在app/config/database.php中配置如下:

'redis' => array( 'cluster' => true, 'default' => array( 'host' => '172.21.107.247', 'port' => 6379, ), 'redis1' => array( 'host' => '172.21.107.248', 'port' => 6379, ),

其中cluster选择为true,接下来就可以作集群使用了;

如果把session的driver设置为redis,则可以使用其集群功能了:

我们来看下session的实现,当我们在代码中这样写:

Session::put('test', 124);

实际的执行流程是这样的:

Illuminate\Support\Facades\SessionIlluminate\Support\Facades\FacadeIlluminate\Session\Facade::app['session']->putIlluminate\Session\Facade::app['session']为Illuminate\Session\SessionManagerIlluminate\Support\Manager::__call

Session会根据返回创建driver

$this->app['config']['session.driver']

即配置文件中配置的,这里我们配置为redis

Illuminate\Session\SessionManager::Illuminate\Session\SessionManager

最终由Illuminate\Session\Store来负责put的调用

而Store类负责存储的类是Illuminate\Session\CacheBasedSessionHandler

后者又将请求转发给$this->app['cache']->driver($driver)……经过一系列代码追查,存储类为Predis\Client\Database,看其构造函数:

public function __construct(array $servers = array()){ if (isset($servers['cluster']) && $servers['cluster']) { $this->clients = $this->createAggregateClient($servers); } else { $this->clients = $this->createSingleClients($servers); }}

如果设置为集群,则调用createAggregateClient方法

protected function createAggregateClient(array $servers){ $servers = array_except($servers, array('cluster')); return array('default' => new Client(array_values($servers)));}

这里会把所有服务器放在default组中

实际存数据的类是Predis\Client,这里有根据配置创建服务器的代码,具体可以自己看下;

Predis\Cluster\PredisClusterHashStrategy类负责计算key的hash,关键函数:

getHash

getKeyFromFirstArgument

而Predis\Cluster\Distribution\HashRing负责服务器环的维护,关键函数

addNodeToRing

get

hash

大概原理是这样,如执行以下redis命令

get ok

会将ok作crc32运算得到一个hash值

所有服务器按一定算法放到一个长度默认为128的数组中,每个服务器在其中占几项,由以下决定:

权重/总权重*总的服务器数量*128,可参考Predis\Cluster\Distribution\HashRing::addNodeToRing方法

每一项的hash值是按服务器ip:端口的格式,作crc32计算的

protected function addNodeToRing(&$ring, $node, $totalNodes, $replicas, $weightRatio){ $nodeObject = $node['object']; $nodeHash = $this->getNodeHash($nodeObject); $replicas = (int) round($weightRatio * $totalNodes * $replicas); for ($i = 0; $i < $replicas; $i++) { $key = crc32("$nodeHash:$i"); $ring[$key] = $nodeObject; }}

key的hash值也有了,服务器环也计算好了,剩下的就是查找了,二分法能较快的查找相应的服务器节点

更多关于Laravel相关内容感兴趣的读者可查看本站专题:《Laravel框架入门与进阶教程》、《php优秀开发框架总结》、《php面向对象程序设计入门教程》、《php+mysql数据库操作入门教程》及《php常见数据库操作技巧汇总》

希望本文所述对大家基于Laravel框架的PHP程序设计有所帮助。

....

巴彦淖尔天猫入驻平台

本文实例讲述了Laravel框架实现redis集群的方法。分享给大家供大家参考,具体如下:

在app/config/database.php中配置如下:

'redis' => array( 'cluster' => true, 'default' => array( 'host' => '172.21.107.247', 'port' => 6379, ), 'redis1' => array( 'host' => '172.21.107.248', 'port' => 6379, ),

其中cluster选择为true,接下来就可以作集群使用了;

如果把session的driver设置为redis,则可以使用其集群功能了:

我们来看下session的实现,当我们在代码中这样写:

Session::put('test', 124);

实际的执行流程是这样的:

Illuminate\Support\Facades\SessionIlluminate\Support\Facades\FacadeIlluminate\Session\Facade::app['session']->putIlluminate\Session\Facade::app['session']为Illuminate\Session\SessionManagerIlluminate\Support\Manager::__call

Session会根据返回创建driver

$this->app['config']['session.driver']

即配置文件中配置的,这里我们配置为redis

Illuminate\Session\SessionManager::Illuminate\Session\SessionManager

最终由Illuminate\Session\Store来负责put的调用

而Store类负责存储的类是Illuminate\Session\CacheBasedSessionHandler

后者又将请求转发给$this->app['cache']->driver($driver)……经过一系列代码追查,存储类为Predis\Client\Database,看其构造函数:

public function __construct(array $servers = array()){ if (isset($servers['cluster']) && $servers['cluster']) { $this->clients = $this->createAggregateClient($servers); } else { $this->clients = $this->createSingleClients($servers); }}

如果设置为集群,则调用createAggregateClient方法

protected function createAggregateClient(array $servers){ $servers = array_except($servers, array('cluster')); return array('default' => new Client(array_values($servers)));}

这里会把所有服务器放在default组中

实际存数据的类是Predis\Client,这里有根据配置创建服务器的代码,具体可以自己看下;

Predis\Cluster\PredisClusterHashStrategy类负责计算key的hash,关键函数:

getHash

getKeyFromFirstArgument

而Predis\Cluster\Distribution\HashRing负责服务器环的维护,关键函数

addNodeToRing

get

hash

大概原理是这样,如执行以下redis命令

get ok

会将ok作crc32运算得到一个hash值

所有服务器按一定算法放到一个长度默认为128的数组中,每个服务器在其中占几项,由以下决定:

权重/总权重*总的服务器数量*128,可参考Predis\Cluster\Distribution\HashRing::addNodeToRing方法

每一项的hash值是按服务器ip:端口的格式,作crc32计算的

protected function addNodeToRing(&$ring, $node, $totalNodes, $replicas, $weightRatio){ $nodeObject = $node['object']; $nodeHash = $this->getNodeHash($nodeObject); $replicas = (int) round($weightRatio * $totalNodes * $replicas); for ($i = 0; $i < $replicas; $i++) { $key = crc32("$nodeHash:$i"); $ring[$key] = $nodeObject; }}

key的hash值也有了,服务器环也计算好了,剩下的就是查找了,二分法能较快的查找相应的服务器节点

更多关于Laravel相关内容感兴趣的读者可查看本站专题:《Laravel框架入门与进阶教程》、《php优秀开发框架总结》、《php面向对象程序设计入门教程》、《php+mysql数据库操作入门教程》及《php常见数据库操作技巧汇总》

希望本文所述对大家基于Laravel框架的PHP程序设计有所帮助。

....

缅甸赌场有假吗视频

Laravel框架实现redis集群的方法分析....

相关资讯
尊龙现金娱乐一下下载网站

本文实例讲述了Laravel框架实现redis集群的方法。分享给大家供大家参考,具体如下:

在app/config/database.php中配置如下:

'redis' => array( 'cluster' => true, 'default' => array( 'host' => '172.21.107.247', 'port' => 6379, ), 'redis1' => array( 'host' => '172.21.107.248', 'port' => 6379, ),

其中cluster选择为true,接下来就可以作集群使用了;

如果把session的driver设置为redis,则可以使用其集群功能了:

我们来看下session的实现,当我们在代码中这样写:

Session::put('test', 124);

实际的执行流程是这样的:

Illuminate\Support\Facades\SessionIlluminate\Support\Facades\FacadeIlluminate\Session\Facade::app['session']->putIlluminate\Session\Facade::app['session']为Illuminate\Session\SessionManagerIlluminate\Support\Manager::__call

Session会根据返回创建driver

$this->app['config']['session.driver']

即配置文件中配置的,这里我们配置为redis

Illuminate\Session\SessionManager::Illuminate\Session\SessionManager

最终由Illuminate\Session\Store来负责put的调用

而Store类负责存储的类是Illuminate\Session\CacheBasedSessionHandler

后者又将请求转发给$this->app['cache']->driver($driver)……经过一系列代码追查,存储类为Predis\Client\Database,看其构造函数:

public function __construct(array $servers = array()){ if (isset($servers['cluster']) && $servers['cluster']) { $this->clients = $this->createAggregateClient($servers); } else { $this->clients = $this->createSingleClients($servers); }}

如果设置为集群,则调用createAggregateClient方法

protected function createAggregateClient(array $servers){ $servers = array_except($servers, array('cluster')); return array('default' => new Client(array_values($servers)));}

这里会把所有服务器放在default组中

实际存数据的类是Predis\Client,这里有根据配置创建服务器的代码,具体可以自己看下;

Predis\Cluster\PredisClusterHashStrategy类负责计算key的hash,关键函数:

getHash

getKeyFromFirstArgument

而Predis\Cluster\Distribution\HashRing负责服务器环的维护,关键函数

addNodeToRing

get

hash

大概原理是这样,如执行以下redis命令

get ok

会将ok作crc32运算得到一个hash值

所有服务器按一定算法放到一个长度默认为128的数组中,每个服务器在其中占几项,由以下决定:

权重/总权重*总的服务器数量*128,可参考Predis\Cluster\Distribution\HashRing::addNodeToRing方法

每一项的hash值是按服务器ip:端口的格式,作crc32计算的

protected function addNodeToRing(&$ring, $node, $totalNodes, $replicas, $weightRatio){ $nodeObject = $node['object']; $nodeHash = $this->getNodeHash($nodeObject); $replicas = (int) round($weightRatio * $totalNodes * $replicas); for ($i = 0; $i < $replicas; $i++) { $key = crc32("$nodeHash:$i"); $ring[$key] = $nodeObject; }}

key的hash值也有了,服务器环也计算好了,剩下的就是查找了,二分法能较快的查找相应的服务器节点

更多关于Laravel相关内容感兴趣的读者可查看本站专题:《Laravel框架入门与进阶教程》、《php优秀开发框架总结》、《php面向对象程序设计入门教程》、《php+mysql数据库操作入门教程》及《php常见数据库操作技巧汇总》

希望本文所述对大家基于Laravel框架的PHP程序设计有所帮助。

....

大赢足球即时比分网90

本文实例讲述了Laravel框架实现redis集群的方法。分享给大家供大家参考,具体如下:

在app/config/database.php中配置如下:

'redis' => array( 'cluster' => true, 'default' => array( 'host' => '172.21.107.247', 'port' => 6379, ), 'redis1' => array( 'host' => '172.21.107.248', 'port' => 6379, ),

其中cluster选择为true,接下来就可以作集群使用了;

如果把session的driver设置为redis,则可以使用其集群功能了:

我们来看下session的实现,当我们在代码中这样写:

Session::put('test', 124);

实际的执行流程是这样的:

Illuminate\Support\Facades\SessionIlluminate\Support\Facades\FacadeIlluminate\Session\Facade::app['session']->putIlluminate\Session\Facade::app['session']为Illuminate\Session\SessionManagerIlluminate\Support\Manager::__call

Session会根据返回创建driver

$this->app['config']['session.driver']

即配置文件中配置的,这里我们配置为redis

Illuminate\Session\SessionManager::Illuminate\Session\SessionManager

最终由Illuminate\Session\Store来负责put的调用

而Store类负责存储的类是Illuminate\Session\CacheBasedSessionHandler

后者又将请求转发给$this->app['cache']->driver($driver)……经过一系列代码追查,存储类为Predis\Client\Database,看其构造函数:

public function __construct(array $servers = array()){ if (isset($servers['cluster']) && $servers['cluster']) { $this->clients = $this->createAggregateClient($servers); } else { $this->clients = $this->createSingleClients($servers); }}

如果设置为集群,则调用createAggregateClient方法

protected function createAggregateClient(array $servers){ $servers = array_except($servers, array('cluster')); return array('default' => new Client(array_values($servers)));}

这里会把所有服务器放在default组中

实际存数据的类是Predis\Client,这里有根据配置创建服务器的代码,具体可以自己看下;

Predis\Cluster\PredisClusterHashStrategy类负责计算key的hash,关键函数:

getHash

getKeyFromFirstArgument

而Predis\Cluster\Distribution\HashRing负责服务器环的维护,关键函数

addNodeToRing

get

hash

大概原理是这样,如执行以下redis命令

get ok

会将ok作crc32运算得到一个hash值

所有服务器按一定算法放到一个长度默认为128的数组中,每个服务器在其中占几项,由以下决定:

权重/总权重*总的服务器数量*128,可参考Predis\Cluster\Distribution\HashRing::addNodeToRing方法

每一项的hash值是按服务器ip:端口的格式,作crc32计算的

protected function addNodeToRing(&$ring, $node, $totalNodes, $replicas, $weightRatio){ $nodeObject = $node['object']; $nodeHash = $this->getNodeHash($nodeObject); $replicas = (int) round($weightRatio * $totalNodes * $replicas); for ($i = 0; $i < $replicas; $i++) { $key = crc32("$nodeHash:$i"); $ring[$key] = $nodeObject; }}

key的hash值也有了,服务器环也计算好了,剩下的就是查找了,二分法能较快的查找相应的服务器节点

更多关于Laravel相关内容感兴趣的读者可查看本站专题:《Laravel框架入门与进阶教程》、《php优秀开发框架总结》、《php面向对象程序设计入门教程》、《php+mysql数据库操作入门教程》及《php常见数据库操作技巧汇总》

希望本文所述对大家基于Laravel框架的PHP程序设计有所帮助。

....

热门资讯