Memcached学习笔记 — 第四部分:Memcached Java 客户端-gwhalin(1)-介绍及使用
Memcached java client是官方推荐的最早的memcached java客户端。最新版本：java_memcached-release_2.6.1。
官方下载地址：https://github.com/gwhalin/Memcached-Java-Client采用阻塞式SOCKET通讯，据说目前版本进行了很多优化，性能有所提高（只看过1.5的源代码，还没来及看最新的）提供key方式的连接池，默认连接池key为default。（老版本了）。2.6.1版本支持apache-commoms-pool作为连接池。支持权重配置。后期的版本提增加了cas支持和getMutl功能
Java代码
1. import com.danga.MemCached.MemCachedClient;
2. import com.danga.MemCached.SockIOPool;
3. import com.schooner.MemCached.MemcachedItem;
4.
5. public class MemcachedForJavaExample {
6.
7. // create a static client as most installs only need
8. // a single instance
9. protected static MemCachedClient mcc = new MemCachedClient();
10.
11. // set up connection pool once at class load
12. static {
13.
14. // server list and weights
15. String[] servers = { "localhost:11211", "localhost:11212", "localhost:11213" };
16.
17. Integer[] weights = { 3, 3, 2 };
18.
19. // grab an instance of our connection pool
20. SockIOPool pool = SockIOPool.getInstance();
21.
22. // set the servers and the weights
23. pool.setServers(servers);
24. pool.setWeights(weights);
25. pool.setHashingAlg(SockIOPool.CONSISTENT_HASH);
26.
27. // set some basic pool settings
28. // 5 initial, 5 min, and 250 max conns
29. // and set the max idle time for a conn
30. // to 6 hours
31. pool.setInitConn(5);
32. pool.setMinConn(5);
33. pool.setMaxConn(250);
34. pool.setMaxIdle(1000 * 60 * 60 * 6);
35.
36. // set the sleep for the maint thread
37. // it will wake up every x seconds and
38. // maintain the pool size
39. pool.setMaintSleep(30);
40.
41. // set some TCP settings
42. // disable nagle
43. // set the read timeout to 3 secs
44. // and don't set a connect timeout
45. pool.setNagle(false);
46. pool.setSocketTO(3000);
47. pool.setSocketConnectTO(0);
48.
49. // initialize the connection pool
50. pool.initialize();
51. }
52.
53. public static void main(String[] args) {
54. System.out.println("SET: " + mcc.set("key1", "value1"));
55. System.out.println("SET: " + mcc.set("key2", "value2"));
56. System.out.println("SET: " + mcc.set("key3", "value3"));
57. System.out.println("GET: " + mcc.get("key1"));
58. MemcachedItem item = mcc.gets("key1");
59. System.out.println("GETS: value=" + item.getValue() + ",CasUnique:"+item.getCasUnique());
60. System.out.println("SET: " + mcc.set("key1", "value1_1"));
61. System.out.println("CAS: " + mcc.cas("key1", "value1_2", item.getCasUnique())); //必须FALSE
62. System.out.println("getMulti:" + mcc.getMulti(new String[]{"key1","key2","key3"}));
63. }
64.
65. }
这个标题不好取，因为是我自己的想法，还需要大家多提意见，一起讨论。想叫“建议代码”或者“推荐代码”，觉得不合适，还是先叫“我的代码”吧，呵呵。
1. 在原始客户端上层，根据业务需求封装MemcachedService(或叫MemcachedClient)，负责缓存功能的包装。如：你的业务只需要add,set,get,gets,cas,delete业务，那就只封装这几个功能。这样做的好处是，屏蔽了各种客户端的API差异，让你的业务系统与客户端实现解耦合，如果你以后需要换客户端实现，对你的业务系统不会照成影响。2. 一般不要直接采用new的方式在你的代码中显示使用memcached客户端实现，应该采用单例的方式使用memcached客户端实现，或者使用Spring的singleton方式配置。Memcached客户端实现是线程安全的。3. memcached客户端一般都需要大量的配置，考虑扩展和配置修改，应该把参数设置设计为可配置的，可以写到propertis配置文件中或是使用Spring进行配置。
Java代码
1. /**
2. * Memcached 常用功能接口定义,用于业务层直接使用，屏蔽各种客户端实现的API差异，实现解耦客户端与业务系统的目的
3. * 无过期时间和flags支持，无append,prepend,replace,incr,decr等操作
4. *
5. * @author zhangpu
6. *
7. */
8. public interface MemcachedClientService {
9.
10. String get(String key);
11.
12. CacheItem gets(String key);
13.
14. boolean add(String key, String value);
15.
16. boolean set(String key, String value);
17.
18. boolean cas(String key, String value, long unique);
19.
20. boolean delete(String key)
21.
22. boolean flushAll();
23.
24. }
Java代码
1. public class CacheItem {
2.
3. private String key;
4. private String value;
5. private long unique;
6.
7. public CacheItem() {
8. super();
9. }
10.
11. public CacheItem(String key, String value, long unique) {
12. super();
13. this.key = key;
14. this.value = value;
15. this.unique = unique;
16. }
17.
18. public String getKey() {
19. return key;
20. }
21.
22. public void setKey(String key) {
23. this.key = key;
24. }
25.
26. public String getValue() {
27. return value;
28. }
29.
30. public void setValue(String value) {
31. this.value = value;
32. }
33.
34. public long getUnique() {
35. return unique;
36. }
37.
38. public void setUnique(long unique) {
39. this.unique = unique;
40. }
41.
42. }
Java代码
1. /**
2. * Memcached for java客户端缓存服务实现
3. * @author zhangpu
4. *
5. */
6. public class MemcachedClientJava implements MemcachedClientService {
7.
8. MemCachedClient mmc = MemcachedClientFactory.getInstance();
9. public boolean add(String key, String value) {
10. return mmc.add(key, value);
11. }
12.
13. public boolean cas(String key, String value, long unique) {
14. return mmc.cas(key, value, unique);
15. }
16.
17. public String get(String key) {
18. return (String) mmc.get(key);
19. }
20.
21. public CacheItem gets(String key) {
22. MemcachedItem item = mmc.gets(key);
23. return new CacheItem(key, (String) item.getValue(), item.getCasUnique());
24. }
25.
26. public boolean set(String key, String value) {
27. return mmc.set(key, value);
28. }
29.
30. public boolean delete(String key) {
31. return mmc.delete(key);
32. }
33.
34.
35. public boolean flushAll() {
36. return mmc.flushAll();
37. }
38.
39. }
Java代码
1. /**
2. * MemcachedClient 单例(JDK1.5以上)
3. * @author zhangpu
4. *
5. */
6. public class MemcachedClientFactory extends ConfigurableConstants{
7.
8. private static volatile MemCachedClient mmc;
9.
10. static {
11. init("memcached-client.properties");
12.
13. //{ "localhost:11211", "localhost:11212", "localhost:11213" };
14. String[] servers = getProperty("memcached-servers","").split(",");
15.
16. Integer[] weights = null;
17. String weightsCfg = getProperty("memcached-weights","");
18. if(weightsCfg != null){
19. String[] wcfg = weightsCfg.split(",");
20. weights = new Integer[wcfg.length];
21. for (int i = 0; i < weights.length; i++) {
22. weights[i] = Integer.valueOf(wcfg[i]);
23. }
24. }else{
25. weights = new Integer[servers.length];
26. for (int i = 0; i < weights.length; i++) {
27. weights[i] = 1;
28. }
29. }
30.
31. SockIOPool pool = SockIOPool.getInstance();
32.
33. pool.setServers(servers);
34. pool.setWeights(weights);
35. pool.setHashingAlg(SockIOPool.CONSISTENT_HASH);
36.
37. pool.setInitConn(getProperty("memcached-initConn",5));
38. pool.setMinConn(getProperty("memcached-minConn",5));
39. pool.setMaxConn(getProperty("memcached-maxConn",250));
40. pool.setMaxIdle(1000 * 60 * 60 * 6);
41.
42. pool.setMaintSleep(30);
43.
44. pool.setNagle(false);
45. pool.setSocketTO(3000);
46. pool.setSocketConnectTO(0);
47.
48. pool.initialize();
49. }
50.
51. private MemcachedClientFactory() {
52.
53. }
54.
55. public static MemCachedClient getInstance() {
56. if (mmc == null) {
57. synchronized (MemCachedClient.class) {
58. if (mmc == null) {
59. mmc = new MemCachedClient();
60. }
61. }
62. }
63. return mmc;
64. }
65.
66. }
Java代码
1. /**
2.
3. * 通过 properties 文件配置设置常量基类 负责加载和读取 properties 属性文件并提供访问的静态工具方法
4.
5. *
6.
7. * @author zhangpu
8.
9. *
10.
11. */
12.
13. public class ConfigurableConstants {
14.
15. protected static Log logger = LogFactory.getLog(ConfigurableConstants.class);
16.
17. protected static Properties p = new Properties();
18.
19.
20.
21. protected static void init(String propertyFileName) {
22.
23. InputStream in = null;
24.
25. try {
26.
27. in = ConfigurableConstants.class.getClassLoader().getResourceAsStream(propertyFileName);
28.
29. if (in != null)
30.
31. p.load(in);
32.
33. } catch (IOException e) {
34.
35. logger.error("load " + propertyFileName + " into Constants error!");
36.
37. } finally {
38.
39. if (in != null) {
40.
41. try {
42.
43. in.close();
44.
45. } catch (IOException e) {
46.
47. logger.error("close " + propertyFileName + " error!");
48.
49. }
50.
51. }
52.
53. }
54.
55. }
56.
57.
58.
59. protected static String getProperty(String key, String defaultValue) {
60.
61. return p.getProperty(key, defaultValue);
62.
63. }
64.
65.
66.
67. protected static int getProperty(String key, int defaultValue) {
68.
69. try {
70.
71. return Integer.parseInt(getProperty(key, ""));
72.
73. } catch (Exception e) {
74.
75. return defaultValue;
76.
77. }
78.
79.
80.
81. }
82.
83. }
memcached-client.properties
Properties代码
1. memcached-client.properties
2. memcached-servers=localhost:11211,localhost:11212,localhost:11213
3. memcached-weights=3,3,2
4. memcached-initConn=5
5. memcached-minConn=5
6. memcached-maxConn=250
后续提供性能测试，spring整合，版本差异测试，及其它客户端对比。
本文来源：https://www.2haoxitong.net/k/doc/b8cbc0d450e2524de5187ee6.html
文档为doc格式