多台memcache 研究-php-it论坛-计算机论坛

安哥网络

多台memcache 研究-php-it论坛-计算机论坛
第一种方法是通过设置特殊key前缀实现分布，基本可以实现memcache和key的一对多关系，好处在于不会混淆，代码如下：

1. <?php
   
2. $key='en_key2';
   
3. //print_r(mem_arr($key));
   
4. $mem_arr=mem_arr($key);
   
5. $mem = new Memcache;
   
6. $mem->connect($mem_arr['host'],$mem_arr['port']);
   
7. if(!$result=$mem->get('$key')){
   
8.         $mem->set($key, 'This is a memcached test!', 0, 60);
   
9.         $result=$mem->get($key);
   
10.   }
    
11. echo $result."---------".$mem_arr['host'].'--'.$mem_arr['port'];
    
12. 
    
13. function mem_arr($key)
    
14. {
    
15.         $memcached = array(  
    
16. 
    
17.         'cn'=>array('192.168.1.101',11212),
    
18. 
    
19.         'en'=>array('192.168.1.102',11212)
    
20. 
    
21.         );
    
22. 
    
23.         if(substr($key,0,2)=='cn')
    
24.         {
    
25.                 $mem['host']=$memcached['cn'][0];
    
26.                 $mem['port']=$memcached['cn'][1];
    
27.         }else
    
28.         {
    
29.                 $mem['host']=$memcached['en'][0];
    
30.                 $mem['port']=$memcached['en'][1];
    
31.         }
    
32.         return $mem;       
    
33. }
    
34. 
    
35. 
    
36. ------------在102上查看
    
37. <?php
    
38. $mem = new Memcache;
    
39. $mem->connect("92.168.1.102", 11212);
    
40. $val = $mem->get('en_key2');
    
41. echo $val;
    
42. 
    
43. ?>

复制代码

第二种方法是用的网上的一个方法，重写了memcache类，实现数组操作，这种方法对memcache服务器的扩展性不好

1. MemcacheOpt.class.php
   
2. 
   
3. <?php
   
4. /**
   
5. * Memcache 操作类 (支持同步和分组访问)
   
6. * author     : heiyeluren <http://blog.csdn.net/heiyeshuwu>
   
7. * created    : 2007-06-21
   
8. * lastModifed: 2007-06-21
   
9. */
   
10. 
    
11. /** * Memcache操作类 */
    
12. class MemcacheOpt
    
13. {
    
14.     //---------------------
    
15.     //  属性定义
    
16.     //---------------------
    
17.     /**     * 是否进行多组同步      */
    
18.     var $isGroup    = true;
    
19.     /**
    
20.      * 多组同步情况下是否使用减轻负载的随机存取
    
21.      */
    
22.     var $isRandom   = true;
    
23. 
    
24.     /** 默认的Memcache服务器端口  */
    
25.     var $mmcPort    = 11211;
    
26. 
    
27.     /** 保存原始组信息*/
    
28.     var $groups     = array();
    
29. 
    
30.     /** 保存第一、二组Memcache服务器信息*/
    
31.     var $group1     = array();
    
32.     var $group2     = array();
    
33.     /** * 保存第一、二组连接对象  */
    
34.     var $mmc1       = '';
    
35.     var $mmc2       = '';
    
36.    
    
37. 
    
38.     //---------------------
    
39.     //   内部操作方法
    
40.     //---------------------
    
41. 
    
42.     /** 显示错误信息     *
    
43.      * @param string $msg 需要显示消息的内容
    
44.      * @param string $type 消息类型，error是普通错误消息，fatal 是致命错误，将终止程序执行, message 是普通消息，缺省状
    
45. 
    
46. 态
    
47.      * @return bool true
    
48.      */
    
49.     function showMessage($msg, $type){
    
50.         $msg .= " ";
    
51.         switch($type){
    
52.             case 'error':
    
53.                 echo("Memcache Error: ". $msg);
    
54.                 break;
    
55.             case 'fatal':
    
56.                 die("Memcache Fatal: ". $msg);
    
57.                 break;
    
58.             case 'message':
    
59.                 echo("Memcache Message: ". $msg);
    
60.                 break;
    
61.             default:
    
62.                 echo("Memcache Error: ". $msg);
    
63.         }
    
64.         return true;
    
65.     }
    
66. 
    
67. 
    
68.     /**
    
69.      * 构造函数 (初始化分组和连接到服务器)
    
70.      */
    
71.     function MemcacheOpt($hostArray, $hostArray2=array()){
    
72.         if (!is_array($hostArray) || empty($hostArray)){
    
73.             $this->showMessage('Memcache host list invalid', 'fatal');
    
74.         }
    
75.         $this->groups = array_merge($hostArray, $hostArray2);
    
76.         $this->splitGroup($hostArray, $hostArray2);
    
77.         $this->connect();
    
78.     }
    
79. 
    
80.     /**
    
81.      * 对组进行切分 (按照是否需要分组进行相应的切分)
    
82.      *
    
83.      * @param array $hostArray 主机数组列表1
    
84.      * @param array $hostArray2 主机数组列表2
    
85.      * @return void
    
86.      */
    
87.     function splitGroup($hostArray, $hostArray2=array()){
    
88.         //如果只有一台机器则不使用分组
    
89.         if (count($hostArray) < 2 && empty($hostArray2)){  $this->isGroup = false;  }
    
90. 
    
91.         //使用分组
    
92.         if ($this->isGroup){
    
93.             if (is_array($hostArray2) && !empty($hostArray2)){
    
94.                 $this->group1 = $hostArray;
    
95.                 $this->group2 = $hostArray2;
    
96.             }else{
    
97.                 $count = ceil(count($hostArray) / 2);
    
98.                 $this->group1 = array_splice($hostArray, 0, $count);
    
99.                 $this->group2 = array_splice($hostArray, 0);
    
100.             }
     
101.         }else{  $this->group1 = $hostArray;         }
     
102.     }
     
103. 
     
104.     /**     * 连接到Memcache服务器     */
     
105.     function connect(){
     
106.         if (!is_array($this->group1) || empty($this->group1)){
     
107.             $this->showMessage("Memcache host1 array invalid", 'error');
     
108.             return false;
     
109.         }
     
110. 
     
111.         //连接第一组Memcache服务器
     
112.         $this->mmc1 = new Memcache;
     
113.         foreach($this->group1 as $hosts){
     
114.             $tmp = explode(":", $hosts);
     
115.             $host = $tmp[0];
     
116.             $port = (!isset($tmp[1]) || $tmp[1]=='') ? $this->mmcPort : $tmp[1];
     
117.             $this->mmc1->addServer($host, $port);
     
118.         }
     
119. 
     
120.         //如果需要分组则连接第二组Memcache服务器
     
121.         if ($this->isGroup){
     
122.             if ( !is_array($this->group2) || empty($this->group2) ){
     
123.                 $this->showMessage("Memcache host2 array invalid", 'error');
     
124.                 return false;
     
125.             }
     
126.             $this->mmc2 = new Memcache;
     
127.             foreach($this->group2 as $hosts){
     
128.                 $tmp = explode(":", $hosts);
     
129.                 $host = $tmp[0];
     
130.                 $port = (!isset($tmp[1]) || $tmp[1]=='') ? $this->mmcPort : $tmp[1];
     
131.                 $this->mmc2->addServer($host, $port);
     
132.             }
     
133.         }
     
134.     }
     
135. 
     
136.     /**     * 关闭Memcache服务器连接     */
     
137.     function close(){
     
138.         if (is_object($this->mmc1)){            $this->mmc1->close();        }
     
139.         if (is_object($this->mmc1)){            $this->mmc1->close();        }        
     
140.         return true;
     
141.     }
     
142. 
     
143.     /**
     
144.      * 数据操作核心函数
     
145.      *
     
146.      * @param string $optType 操作类型，主要有 add, set, replace, delete, flush
     
147.      * @param string $key 关键字，如果是 add,set,replace,delete 需要提交key参数
     
148.      * @param string $val 关键字对应的值，如果是 add, set,replace 需要提交value参数
     
149.      * @param int $expire 数据有效期，如果是 add,set,replace需要提交expire参数
     
150.      * @return mixed 不同的需要产生不同的返回
     
151.      */
     
152.     function opt($optType, $key='', $val='', $expire=''){
     
153.         if (!is_object($this->mmc1)){
     
154.             $this->showMessage("Not availability memcache connection object", 'fatal');
     
155.         }
     
156.         if ($this->isGroup && !is_object($this->mmc2)){
     
157.             $this->showMessage("Group 2 memcache host connection object not availability", 'error');
     
158.         }
     
159. 
     
160.         //加入数据操作
     
161.         if ($optType=='add' || $optType=='set' || $optType=='replace'){
     
162.             $this->mmc1->set($key, $val, false, $expire);
     
163.             if ($this->isGroup && is_object($this->mmc2)){
     
164.                 $this->mmc2->set($key, $val, false, $expire);
     
165.             }
     
166.             return true;
     
167.         }
     
168. 
     
169.         //获取数据操作
     
170.         if ($optType == 'get'){
     
171. 
     
172.             //缺省获取第一组数据
     
173.             if (!$this->isGroup || !is_object($this->mmc2)){
     
174.                 return $this->mmc1->get($key);        
     
175.             }
     
176. 
     
177.             //分组情况下逐组访问
     
178.             $num = ( $this->isRandom ? rand(1, 2) : 1 );
     
179.             $obj = "mmc". $num;
     
180.             $val = $this->$obj->get($key);
     
181. 
     
182.             //如果没有提取到数据，则访问另外一组
     
183.             if ($val == ""){
     
184.                 switch($num){
     
185.                     case 1: $val = $this->mmc2->get($key); break;
     
186.                     case 2: $val = $this->mmc1->get($key); break;
     
187.                     default: $val = $this->mmc1->get($key);
     
188.                 }
     
189.             }
     
190.             return $val;
     
191.         }
     
192. 
     
193.         //删除数据操作
     
194.         if ($optType == 'delete'){
     
195.             $this->mmc1->delete($key, $expire);
     
196.             if ($this->isGroup && is_object($this->mmc2)){
     
197.                 $this->mmc2->delete($key);        
     
198.             }
     
199.             return true;
     
200.         }
     
201. 
     
202.         //清空数据操作     
     
203.         if($optType == 'flush'){
     
204.             $this->mmc1->flush();
     
205.             if ($this->isGroup && is_object($this->mmc2)){
     
206.                 $this->mmc2->flush();        
     
207.             }
     
208.             return true;
     
209.         }
     
210.         
     
211.     }
     
212.     //---------------------
     
213.     //   外部操作方法
     
214.     //---------------------
     
215. 
     
216.     //增加一个元素
     
217.     function add($key, $val, $expire=''){   return $this->opt('add', $key, $val, $expire);     }
     
218. 
     
219.     //增加一个元素
     
220.     function set($key, $val, $expire=''){        return $this->opt('set', $key, $val, $expire);    }
     
221. 
     
222.     //替换一个元素
     
223.     function replace($key, $val, $expire=''){        return $this->opt('replace', $val, $expire);    }
     
224. 
     
225.     //获取一个元素
     
226.     function get($key){        return $this->opt('get', $key);    }
     
227. 
     
228.     //删除一个元素
     
229.     function delete($key, $timeout=''){      return $this->opt('delete', $key, '', $timeout);    }
     
230. 
     
231.     //让所有的元素过期 (本接口不要轻易使用)
     
232.     function flush(){       return $this->opt('flush');     }
     
233. 
     
234. 
     
235.     /**     * 获取所有Memcache服务器状态     */
     
236.     function getStats(){
     
237.         $status = array();
     
238. 
     
239.         //单独连接到每台Memcache
     
240.         foreach($this->groups as $key=>$hosts){
     
241.             $tmp = explode(":", $hosts);
     
242.             $host = $tmp[0];
     
243.             $port = (!isset($tmp[1]) || $tmp[1]=='') ? $this->mmcPort : $tmp[1];
     
244. 
     
245.             $conn = new Memcache;
     
246.             $conn->connect($host, $port);
     
247.             $s = $conn->getStats();
     
248.             $s['host'] = $host;
     
249.             $s['port'] = $port;
     
250.             $status[$key] = $s;
     
251.         }
     
252.         return $status;
     
253.     }
     
254. 
     
255.     /**
     
256.      * 获取所有Memcache服务器版本号
     
257.      */
     
258.     function getVersion(){
     
259.         $version = array();
     
260.         $stats = $this->getStats();
     
261.         foreach($stats as $key=>$s){
     
262.             $v['host'] = $s['host'];
     
263.             $v['port'] = $s['port'];
     
264.             $v['version'] = $s['version'];
     
265.             $version[$key] = $v;
     
266.         }
     
267.         return $version;
     
268.     }
     
269. 
     
270. }
     
271. ?>
     
272. 
     
273. 101:
     
274. memcached -d -m 50 -p 11212 -u root
     
275. memcached -d -m 50 -p 11213 -u root
     
276. 
     
277. 
     
278. 102:
     
279. memcached -d -m 50 -p 11212 -u root
     
280. memcached -d -m 50 -p 11213 -u root
     
281. 
     
282. <?php
     
283. require_once("MemcacheOpt.class.php");
     
284. 
     
285. //操作代码
     
286. $hostArray = array("192.168.1.101:11212", "192.168.1.101:11213","192.168.1.102:11212","192.168.1.102:11213");
     
287. $m = new MemcacheOpt($hostArray);
     
288. 
     
289. $m->add("key1", "key1_value", 30);
     
290. $m->add("key2", "key2_value", 30);
     
291. $m->add("key3", "key3_value", 30);
     
292. $m->add("key4", "key4_value", 30);
     
293. echo $m->get("key1"). " ";
     
294. echo $m->get("key2"). " ";
     
295. echo $m->get("key3"). " ";
     
296. echo $m->get("key4"). " ";
     
297. print_r($m->getStats());
     
298. print_r($m->getVersion());
     
299. 
     
300. ?>

复制代码

今天测试还碰到一个奇怪的问题，下面三段代码都应该是可以执行的，最后一段却报错不能连接，不解。

1. -----------ok
   
2. <?php
   
3. $mem = new Memcache;
   
4. $mem->connect("127.0.0.1", 11211);
   
5. $mem->set('key', 'This is a memcached test!', 0, 60);
   
6. $val = $mem->get('key');
   
7. echo $val;
   
8. 
   
9. ?>
   
10. 
    
11. 
    
12. --------ok
    
13. 101:
    
14. memcached -d -m 50 -p 11212 -u root
    
15. memcached -d -m 50 -p 11213 -u root
    
16. <?php
    
17. $mem = new Memcache;
    
18. $mem->connect("192.168.1.101",11212);
    
19. $mem->set('keysss', 'This is a memcached test!', 0, 60);
    
20. $val = $mem->get('keysss');
    
21. echo $val;
    
22. 
    
23. ?>
    
24. 
    
25. ------------------------Warning: Memcache::connect() [memcache.connect]: Can't connect to 192.168.1.101:11211, Connection refused (111) in /var/www/mem3.php on line 3
    
26. 
    
27. memcached启动的时候有一项是指定ip的,如果已经指定了IP.那么可能就无法再使用localhost或127.0.0.1(猜的,不知道是不是这样,俺一般是不指定的,所以默认localhost或127.0.0.1都是可以的)
    
28. 
    
29. 
    
30. 
    
31. <?php
    
32. $mem = new Memcache;
    
33. $mem->connect("<strong><span style="color: #ff0000;">192.168.1.101",11211</span>);</strong>
    
34. $mem->set('keysdf', 'This is a memcached test!', 0, 60);
    
35. $val = $mem->get('keysdf');
    
36. echo $val;
    
37. 
    
38. ?>

复制代码

本文摘自：http://zhengdl126.iteye.com/blog/423779