libmemcached初探

     最近要使用memcacheq作为消息队列，想找下memcacheq的c的客户端库，后来一想，既然memcacheq本身是支持memcache协议的，使用memcached的客户端的库应该就可以了。

     惭愧的是，真没用编写过c对memcached的操作，以前只是简简单单的使用下ruby程序对客户端操作而已，不过ruby下的memcache客户端实在是简介，昨天很快就用ruby实现了我的应用的初级模型，可惜后台开发，效率还是很重要的。接下来昨天到今天上午一直再看libmemcached的库写了几个小程序。话说ruby，python和perl，php也是使用该库编写的memcached客户端程序的。

     发现libmemcached本身支持 memcached的分布式应用。

   

[cpp]  view plain copy

1. #include <stdio.h>  
2. #include <stdlib.h>  
3. #include <string.h>  
4. #include <libmemcached/memcached.h>  
5. int fun(memcached_server_st *servers)  
6. {  
7.     //return servers[0].count;  
8. }  
9. int main(int argc, char *argv[])  
10. {  
11.     memcached_st *memc;  
12.     memcached_return rc;  
13.     memcached_server_st *servers;  
14.     char value[8191];  
15.     //connect multi server  
16.     memc = memcached_create(NULL);  
17.     // memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SORT_HOSTS, 1);  
18.    memcached_behavior_set(memc,MEMCACHED_BEHAVIOR_DISTRIBUTION,MEMCACHED_DISTRIBUTION_CONSISTENT);  
19.     servers = memcached_server_list_append(NULL, "localhost", 21202, &rc);  
20.   //  servers = memcached_server_list_append(servers, "localhost", 21201, &rc);  
21.     servers = memcached_server_list_append(servers, "localhost", 11217, &rc);  
22.  //   servers = memcached_server_list_append(servers, "localhost",11216,&rc);  
23.     rc = memcached_server_push(memc, servers);  
24. //    int count = memcached_server_list_count(servers);  
25.     int  count2 = memcached_server_count(memc);  
26.       
27.       
28.     fprintf(stdout, "server count is%d/n",memc->number_of_hosts);      
29.     memcached_server_free(servers);  
30.     //Save multi data  
31.     size_t i;  
32.     const char const *keys[]= {"key1", "key2", "key3","key4"};  
33.    const  size_t key_length[]= {4, 4, 4, 4};  
34.     char *values[] = {"This is c first value", "This is c second value", "This is c third value"," this is c forth value"};  
35.     size_t val_length[]= {21, 22, 21, 21};  
36.     for (i=0; i < 4; i++) {  
37.     rc = memcached_set(memc, keys[i], key_length[i], values[i], val_length[i], (time_t)180,(uint32_t)0);  
38.     if (rc == MEMCACHED_SUCCESS) {  
39.         printf("Save key:%s data:/"%s/" success./n", keys[i], values[i]);  
40.     }  
41.     }  
42.     //Fetch multi data  
43.     char return_key[MEMCACHED_MAX_KEY];  
44.     size_t return_key_length;  
45.     char *return_value;  
46.     size_t return_value_length;  
47.     uint32_t flags;  
48.     rc = memcached_mget(memc, keys, key_length, 4);  
49.     while ((return_value = memcached_fetch(memc, return_key, &return_key_length, &return_value_length, &flags, &rc))) {  
50.     if (rc == MEMCACHED_SUCCESS) {  
51.         printf("Fetch key:%s data:%s/n", return_key, return_value);  
52.     }  
53.     }  
54.      
55.     //Delete multi data  
56.     for (i=0; i <4; i++) {  
57.     rc = memcached_set(memc, keys[i], key_length[i], values[i], val_length[i], (time_t)180, (uint32_t)0);  
58.     rc = memcached_delete(memc, keys[i], key_length[i], (time_t)0);  
59.     if (rc == MEMCACHED_SUCCESS) {  
60.         printf("Delete %s success/n", keys[i], values[i]);  
61.     }  
62.     }  
63.     //free  
64.     memcached_free(memc);  
65.     return 0;  
66. }   

 

另外还支持连接池的管理：

 

 

[c-sharp]  view plain copy

1. #include <assert.h>  
2. #include <stdio.h>  
3. #include <stdint.h>  
4. #include <stdlib.h>  
5. #include <string.h>  
6. #include <sys/time.h>  
7. #include <sys/types.h>  
8. #include <sys/stat.h>  
9. #include <signal.h>  
10. #include <unistd.h>  
11. #include <time.h>  
12. #include <libmemcached/memcached.h>  
13. #include <libmemcached/memcached_util.h>  
14. int main(void)  
15. {  
16.     memcached_return_t rc;  
17.     memcached_st *memc;  
18.     memc = memcached_create(NULL);  
19.     const char *keys[] = {"foo", "foo2"};  
20.     size_t lengths[] = {3,4};  
21.     const char *values[]= { "fjord", "41" };  
22.     memcached_server_st *servers;  
23.     //servers= memcached_server_list_append(NULL, "localhost", 21201, &rc);  
24.     servers = memcached_server_list_append_with_weight(NULL,"localhost",21201,0,&rc);  
25.     assert (servers != NULL);  
26.     memcached_server_push(memc,servers);  
27.     memcached_pool_st *pool = memcached_pool_create(memc,5,10);  
28.       
29.       
30.   // Set foo and foo2  
31.     int i;  
32.   for ( i= 0; i < 2; i++)  
33.   {  
34.     rc= memcached_set(memc, keys[i], lengths[i], values[i], strlen(values[i]),  
35.               (time_t)0, (uint32_t)0);  
36.     assert(rc == MEMCACHED_SUCCESS);  
37.   }  
38.   char *string;  
39.   size_t string_length;  
40.   uint32_t flags;  
41.   // retrieve both via mget  
42.   rc= memcached_mget(memc, keys, lengths, 2);  
43.   assert(rc == MEMCACHED_SUCCESS);  
44.   char key[MEMCACHED_MAX_KEY];  
45.   size_t key_length;  
46.   // this should get both  
47.   for ( i = 0; i < 2; i++)  
48.   {  
49.     string= memcached_fetch(memc, key, &key_length, &string_length,  
50.                             &flags, &rc);  
51.     assert(rc == MEMCACHED_SUCCESS);  
52.     int val = 0;  
53.     if (key_length == 4)  
54.       val= 1;  
55.     assert(string_length == strlen(values[val]));  
56.     assert(strncmp(values[val], string, string_length) == 0);  
57.     free(string);  
58.   }  
59.   // this should indicate end  
60.   string= memcached_fetch(memc, key, &key_length, &string_length, &flags, &rc);  
61.   assert(rc == MEMCACHED_END);  
62.   // now get just one  
63.   rc= memcached_mget(memc, keys, lengths, 1);  
64.   assert(rc == MEMCACHED_SUCCESS);  
65.   string= memcached_fetch(memc, key, &key_length, &string_length, &flags, &rc);  
66.   assert(key_length == lengths[0]);  
67.   assert(strncmp(keys[0], key, key_length) == 0);  
68.   assert(string_length == strlen(values[0]));  
69.   assert(strncmp(values[0], string, string_length) == 0);  
70.   assert(rc == MEMCACHED_SUCCESS);  
71.   free(string);  
72.   // this should indicate end  
73.   string= memcached_fetch(memc, key, &key_length, &string_length, &flags, &rc);  
74.   assert(rc == MEMCACHED_END);  
75.     
76.   memcached_free(memc);  
77.   return 1;  
78. }  

 

    基本的api，libmemcached给出的examples比较少，建议看下他自带的tests目录下的测试函数，比较有帮助，libmemcached-api基本操作差不多了，下面估计要研究的是如何将memcacheq实现分布。初步是简单的通过一致性hash算法，将消息分布到不同的memcacheq中去。

  接着需要研究下redis，等下周就开始动手上路了。

原文地址：http://blog.csdn.net/saint1126/article/details/6080146