java客户端调用Memcached的三种方及mc的原理

叁歲伎倆 2022-06-05 23:24 161阅读 0赞

# Memcached简介 #

Memcache是一个高性能的 [分布式][Link 1]的内存对象缓存系统，通过在 [内存][Link 2]里维护一个统一的巨大的 [hash表][hash]，它能够用来存储各种 [格式][Link 3]的数据，包括 [图像][Link 4]、 [视频][Link 5]、 [文件][Link 6]以及 [数据库][Link 7]检索的结果等。简单的说就是将数据调用到内存中，然后从内存中读取，从而大大提高读取速度。

Memcache是danga的一个项目，最早是LiveJournal 服务的，最初为了加速 LiveJournal 访问速度而开发的，后来被很多大型的网站采用。

Memcached是以守护程序方式运行于一个或多个 [服务器][Link 8]中，随时会接收 [客户端][Link 9]的 [连接][Link 10]和操作。

#  #

# Memcached工作原理 #

客户端可以由各种语言编写，目前已知的客户端 API 包括 Perl/PHP/Python/Ruby/Java/C\#/C 等等。客户端在与 memcached 服务建立连接之后，接下来的事情就是存取对象了，每个被存取的对象都有一个唯一的标识符 key，存取操作均通过这个 key 进行，保存到 memcached 中的对象实际上是放置内存中的，并不是保存在 cache 文件中的，这也是为什么 memcached 能够如此高效快速的原因。注意，这些对象并不是持久的，服务停止之后，里边的数据就会丢失。   
与许多 cache 工具类似，Memcached 的原理并不复杂。它采用了C/S的模式，在 server 端启动服务进程，在启动时可以指定监听的 ip，自己的端口号，所使用的内存大小等几个关键参数。一旦启动，服务就一直处于可用状态。Memcached 的目前版本是通过C实现，采用了单进程，单线程，异步I/O，基于事件 (event\_based) 的服务方式.使用 libevent 作为事件通知实现。多个 Server 可以协同工作，但这些 Server 之间是没有任何通讯联系的，每个 Server 只是对自己的数据进行管理。Client 端通过指定 Server 端的 ip 地址(通过域名应该也可以)。需要缓存的对象或数据是以 key->value 对的形式保存在Server端。key 的值通过 hash 进行转换，根据 hash 值把 value 传递到对应的具体的某个 Server 上。当需要获取对象数据时，也根据 key 进行。首先对 key 进行 hash，通过获得的值可以确定它被保存在了哪台 Server 上，然后再向该 Server 发出请求。Client 端只需要知道保存 hash(key) 的值在哪台服务器上就可以了。

其实说到底，memcache 的工作就是在专门的机器的内存里维护一张巨大的 hash 表，来存储经常被读写的一些数组与文件，从而极大的提高网站的运行效率。

# 1、三种API的比较 #

（1）较早推出的memcached JAVA客户端API，应用广泛，运行比较稳定。

（2）A simple, asynchronous, single-threaded memcached client written in java. 支持异步，单线程的memcached客户端，用到了java1.5版本的concurrent和nio，存取速度会高于前者，但是稳定性不好，测试中常 报timeOut等相关异常。

（3）XMemcached同样是基于java nio的客户端，java nio相比于传统阻塞io模型来说，有效率高（特别在高并发下）和资源耗费相对较少的优点。传统阻塞IO为了提高效率，需要创建一定数量的连接形成连接 池，而nio仅需要一个连接即可（当然,nio也是可以做池化处理），相对来说减少了线程创建和切换的开销，这一点在高并发下特别明显。因此 XMemcached与Spymemcached在性能都非常优秀，在某些方面（存储的数据比较小的情况下）Xmemcached比 Spymemcached的表现更为优秀，具体可以看这个Java Memcached Clients Benchmark。

## 2、建议 ##

由于memcached client for java发布了新版本，性能上有所提高，并且运行稳定，所以建议使用memcached client for java。

XMemcached也使用得比较广泛，而且有较详细的中文API文档，具有如下特点：高性 能、支持完整的协议、支持客户端分布、允许设置节点权重、动态增删节点、支持JMX、与Spring框架和Hibernate-memcached的集 成、客户端连接池、可扩展性好等。

# 3、示例代码 #

#  #

##  ##

## （1）memcached client for java ##

## https://cloud.github.com/downloads/gwhalin/Memcached-Java-Client/java\_memcached-release\_2.6.6.zip下载解压后，将里面所有的jar包添加到项目的构建路径里。 ##

**\[java\]**  [view plain][]   [copy][view plain]

[print][view plain] [?][view plain]

1.  **import** java.util.Date;  
2.    
3.  **import** com.danga.MemCached.\*;  
4.    
5.  **public** **class** MemcacheManagerForGwhalin \{  
6.    
7.      // 构建缓存客户端  
8.      **private** **static** MemCachedClient cachedClient;  
9.      // 单例模式实现客户端管理类  
10.     **private** **static** MemcacheManagerForGwhalin INSTANCE = **new** MemcacheManagerForGwhalin();  
11.   
12.     **private** MemcacheManagerForGwhalin() \{  
13.         cachedClient = **new** MemCachedClient();  
14.           
15.         // 初始化SockIOPool，管理memcached的连接池  
16.         SockIOPool pool = SockIOPool.getInstance();  
17.   
18.         // 设置缓存服务器列表，当使用分布式缓存的时，可以指定多个缓存服务器。（这里应该设置为多个不同的服务器）  
19.         String\[\] servers = \{ "192.168.163.10:11211", "192.168.163.11:11211"  
20.         // 也可以使用域名 "server3.mydomain.com:1624"  
21.         \};  
22.   
23.         pool.setServers(servers);  
24.         pool.setFailover(**true**);  
25.         pool.setInitConn(10); // 设置初始连接  
26.         pool.setMinConn(5);// 设置最小连接  
27.         pool.setMaxConn(250); // 设置最大连接  
28.         pool.setMaxIdle(1000 \* 60 \* 60 \* 3); // 设置每个连接最大空闲时间3个小时  
29.         pool.setMaintSleep(30);  
30.         pool.setNagle(**false**);  
31.         pool.setSocketTO(3000);  
32.         pool.setAliveCheck(**true**);  
33.         pool.initialize();  
34.     \}  
35.   
36.     /\*\* 
37.      \* 获取缓存管理器唯一实例 
38.      \*  
39.      \* @return 
40.      \*/  
41.     **public** **static** MemcacheManagerForGwhalin getInstance() \{  
42.         **return** INSTANCE;  
43.     \}  
44.   
45.     **public** **void** add(String key, Object value) \{  
46.         cachedClient.set(key, value);  
47.     \}  
48.   
49.     **public** **void** add(String key, Object value, **int** milliseconds) \{  
50.         cachedClient.set(key, value, milliseconds);  
51.     \}  
52.   
53.     **public** **void** remove(String key) \{  
54.         cachedClient.delete(key);  
55.     \}  
56.   
57.     **public** **void** remove(String key, **int** milliseconds) \{  
58.         cachedClient.delete(key, milliseconds, **new** Date());  
59.     \}  
60.   
61.     **public** **void** update(String key, Object value, **int** milliseconds) \{  
62.         cachedClient.replace(key, value, milliseconds);  
63.     \}  
64.   
65.     **public** **void** update(String key, Object value) \{  
66.         cachedClient.replace(key, value);  
67.     \}  
68.   
69.     **public** Object get(String key) \{  
70.         **return** cachedClient.get(key);  
71.     \}  
72.   
73.     **public** **static** **void** main(String\[\] args) \{  
74.         //将对象加入到memcached缓存  
75.         cachedClient.add("keke", "This is a test String");  
76.         //从memcached缓存中按key值取对象  
77.         String result  = (String) cachedClient.get("keke");  
78.         System.out.println(result);  
79.     \}  
80.       
81. \}

## （2） spymemcached ##

官方下载网址：http://code.google.com/p/spymemcached/

**\[java\]**  [view plain][]   [copy][view plain]

[print][view plain] [?][view plain]

1.  **public** **class** MemcacheManagerForSpy **implements** IMemcacheManager \{  
2.      // 缓存客户端  
3.      **private** MemcachedClient memcacheCient;  
4.      // Manager管理对象，单例模式  
5.      **private** **static** MemcacheManagerForSpy INSTANCE = **new** MemcacheManagerForSpy();  
6.    
7.      **private** MemcacheManagerForSpy() \{  
8.          **try** \{  
9.              memcacheCient = **new** MemcachedClient(**new** InetSocketAddress(  
10.                     "127.0.0.1", 11211));  
11.         \} **catch** (IOException e) \{  
12.             e.printStackTrace();  
13.         \}  
14.     \}  
15.   
16.     **public** **static** MemcacheManagerForSpy getInstance() \{  
17.         **return** INSTANCE;  
18.     \}  
19.   
20.     @Override  
21.     **public** **void** add(String key, Object value, **int** milliseconds) \{  
22.         memcacheCient.add(key, milliseconds, value);  
23.     \}  
24.   
25.     @Override  
26.     **public** **void** add(String key, Object value) \{  
27.         memcacheCient.add(key, 3600, value);  
28.   
29.     \}  
30.   
31.     @Override  
32.     **public** **void** remove(String key, **int** milliseconds) \{  
33.         memcacheCient.delete(key);  
34.     \}  
35.   
36.     @Override  
37.     **public** **void** remove(String key) \{  
38.         memcacheCient.delete(key);  
39.     \}  
40.   
41.     @Override  
42.     **public** **void** update(String key, Object value, **int** milliseconds) \{  
43.         memcacheCient.replace(key, milliseconds, value);  
44.     \}  
45.   
46.     @Override  
47.     **public** **void** update(String key, Object value) \{  
48.         memcacheCient.replace(key, 3600, value);  
49.     \}  
50.   
51.     @Override  
52.     **public** Object get(String key) \{  
53.         **return** memcacheCient.get(key);  
54.     \}  
55. \}

## （3）xmemcached ##

Xmemcached的官方网址是：[http://code.google.com/p/xmemcached/][http_code.google.com_p_xmemcached]

**\[java\]**  [view plain][]   [copy][view plain]

[print][view plain] [?][view plain]

1.  **import** java.io.IOException;  
2.  **import** java.util.concurrent.TimeoutException;  
3.  **import** net.rubyeye.xmemcached.utils.AddrUtil;  
4.  **import** net.rubyeye.xmemcached.MemcachedClient;  
5.  **import** net.rubyeye.xmemcached.MemcachedClientBuilder;  
6.  **import** net.rubyeye.xmemcached.XMemcachedClientBuilder;  
7.  **import** net.rubyeye.xmemcached.exception.MemcachedException;  
8.  **public** **class** TestXMemcache \{  
9.        
10.     **public** **static** **void** main(String\[\] args) \{  
11.         MemcachedClientBuilder builder = **new** XMemcachedClientBuilder(AddrUtil.getAddresses("10.11.15.222:10000"));  
12.         MemcachedClient memcachedClient;  
13.         **try** \{  
14.             memcachedClient = builder.build();  
15.             memcachedClient.set("hello", 0, "Hello,xmemcached");  
16.             String value = memcachedClient.get("hello");  
17.             System.out.println("hello=" + value);  
18.             memcachedClient.delete("hello");  
19.             value = memcachedClient.get("hello");  
20.             System.out.println("hello=" + value);  
21.             // close memcached client  
22.             memcachedClient.shutdown();  
23.         \} **catch** (MemcachedException e) \{  
24.             System.err.println("MemcachedClient operation fail");  
25.             e.printStackTrace();  
26.         \} **catch** (TimeoutException e) \{  
27.             System.err.println("MemcachedClient operation timeout");  
28.             e.printStackTrace();  
29.         \} **catch** (InterruptedException e) \{  
30.             // ignore  
31.         \} **catch** (IOException e) \{  
32.             System.err.println("Shutdown MemcachedClient fail");  
33.             e.printStackTrace();  
34.   
35.         \}  
36.   
37.     \}  
38.

[Link 1]: http://baike.baidu.com/view/402382.htm
[Link 2]: http://baike.baidu.com/view/1082.htm
[hash]: http://baike.baidu.com/view/1207363.htm
[Link 3]: http://baike.baidu.com/view/33401.htm
[Link 4]: http://baike.baidu.com/view/42116.htm
[Link 5]: http://baike.baidu.com/view/16215.htm
[Link 6]: http://baike.baidu.com/view/345685.htm
[Link 7]: http://baike.baidu.com/view/1088.htm
[Link 8]: http://baike.baidu.com/view/899.htm
[Link 9]: http://baike.baidu.com/view/930.htm
[Link 10]: http://baike.baidu.com/view/543312.htm
[view plain]: http://blog.csdn.net/xuke6677/article/details/38706501#
[http_code.google.com_p_xmemcached]: http://code.google.com/p/xmemcached/%EF%BC%8C%E5%8F%AF%E4%BB%A5%E4%BB%8E%E5%85%B6%E5%AE%98%E7%BD%91%E4%B8%8A%E4%B8%8B%E8%BD%BD%E6%9C%80%E6%96%B0%E7%89%88%E6%9C%AC%E7%9A%841.2.4