`
Donald_Draper
  • 浏览: 985586 次
社区版块
存档分类
最新评论

Memcached分布式客户端（Xmemcached）

memcached 
阅读更多
memcached 安装配置：http://donald-draper.iteye.com/blog/2395580
memcached 命令：http://donald-draper.iteye.com/blog/2395628
Memcached Standby客户端：http://donald-draper.iteye.com/blog/2396260
上一篇MemcachedStandbyClient文章，我们测试了XMemcached的Standby模式客户端，
今天来看一下XMemcached分布式客户端：
Memcached的分布是通过客户端实现的，客户端根据key的哈希值得到将要存储的memcached节点，并将对应的value存储到相应的节点。XMemcached同样支持客户端的分布策略，
默认分布的策略是按照key的哈希值模以连接数得到的余数，对应的连接就是将要存储的节点。如果使用默认的分布策略，你不需要做任何配置或者编程。
XMemcached同样支持一致性哈希（consistent hash)，通过编程设置： 
MemcachedClientBuilder builder = new XMemcachedClientBuilder(AddrUtil
		.getAddresses(properties.getProperty("test.memcached.servers"))
builder.setSessionLocator(new KetamaMemcachedSessionLocator());
MemcachedClient client=builder.build();

一致性hash可以参见这篇文章：
MemCache超详细解读：http://www.csdn.net/article/2016-03-16/2826609
XMemcached还提供了额外的一种哈希算法——选举散列,在某些场景下可以替代一致性哈希 
MemcachedClientBuilder builder = new XMemcachedClientBuilder(
                                        AddrUtil.getAddresses("server1:11211 server2:11211 server3:11211"));
builder.setSessionLocator(new ElectionMemcachedSessionLocator());
MemcachedClient mc = builder.build();

我们选用用一致性hash算法：
本文的源代码可以从以下地址load:
https://github.com/Donaldhan/memcached-demo
启动3个memcached实例： 
[memcached@donald ~]$ memcached -p 11211 -d -u memcached -l 192.168.126.128 -c 1024 
[memcached@donald ~]$ memcached -p 11212 -d -u memcached -l 192.168.126.128 -c 1024 
[memcached@donald ~]$ memcached -p 11213 -d -u memcached -l 192.168.126.128 -c 1024 
[memcached@donald ~]$ ps -ef | grep memcached
root       4514   1248  0 22:01 ?        00:00:00 sshd: memcached [priv]
memcach+   4517   4514  0 22:01 ?        00:00:00 sshd: memcached@pts/1
memcach+   5172      1  0 22:04 ?        00:00:00 memcached -p 11211 -d -u memcached -l 192.168.126.128 -c 1024
memcach+   5208      1  0 22:07 ?        00:00:00 memcached -p 11212 -d -u memcached -l 192.168.126.128 -c 1024
memcach+   5219      1  0 22:07 ?        00:00:00 memcached -p 11213 -d -u memcached -l 192.168.126.128 -c 1024
memcach+   5238   4522  0 22:07 pts/1    00:00:00 grep --color=auto memcached
[memcached@donald ~]$


创建memcache属性文件memcached.properties： 

############################
##memcached server ip address list
############standby############## 
standbyServerList=192.168.126.128:11211
############Distribute############## 
distributeServerList=192.168.126.128:11211 192.168.126.128:11212 192.168.126.128:11213
poolName=sidsock
poolSize=16


创建属性文件工具类： 

package util;


import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;


/**
 * 
 * @author donald
 * 2017年9月29日
 * 下午10:21:34
 */
public class PropertiesUtil {
	private static final Logger log  = LoggerFactory.getLogger(PropertiesUtil.class);
	private static final String MEMCACHED_CONFIG_FILE = "memcached.properties";
    private static volatile PropertiesUtil instance = null;
    private static Properties properties = null;
    static{
    	 if (properties == null) {
    		 properties = new Properties();
         }
         try {
        	 InputStream inputStream = Thread.currentThread().getContextClassLoader()
        	            .getResourceAsStream(MEMCACHED_CONFIG_FILE);
        	 properties.load(inputStream);
         } catch (IOException e1) {
             e1.printStackTrace();
         }
    }
    
    /**
     * 
     * @return
     */
    public static synchronized PropertiesUtil getInstance() {
        if (instance == null) {
        	instance = new PropertiesUtil();
        }
        return instance;
    }
    /**
     * 
     * @param key
     * @return
     */
    public String getProperty(String key) {
        return properties.getProperty(key);
    }
    
    /**
     * 获取属性int值
     * @param key
     * @return
     */
    public Integer getInteger(String key) {
    	String value = properties.getProperty(key);
        return Integer.valueOf(value);
    }
    
    
    public static void main(String[] args) {
		log.info("serverList:"+PropertiesUtil.getInstance().getProperty("standbyServerList"));
	}
}

创建memcache分布式客户端： 

package bootstrap;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.util.List;
import java.util.concurrent.TimeoutException;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import net.rubyeye.xmemcached.Counter;
import net.rubyeye.xmemcached.GetsResponse;
import net.rubyeye.xmemcached.MemcachedClient;
import net.rubyeye.xmemcached.MemcachedClientBuilder;
import net.rubyeye.xmemcached.XMemcachedClientBuilder;
import net.rubyeye.xmemcached.exception.MemcachedException;
import net.rubyeye.xmemcached.impl.KetamaMemcachedSessionLocator;
import net.rubyeye.xmemcached.utils.AddrUtil;
import util.PropertiesUtil;

/**
 * Memcached distribution 客户端
 * Memcached的分布是通过客户端实现的，客户端根据key的哈希值得到将要存储的memcached节点，
 * 并将对应的value存储到相应的节点。
 * XMemcached同样支持客户端的分布策略，默认分布的策略是按照key的哈希值模以连接数得到的余数，
 * 对应的连接就是将要存储的节点。如果使用默认的分布策略，你不需要做任何配置或者编程。
 * XMemcached同样支持一致性哈希（consistent hash)，通过编程设置：
 * MemcachedClientBuilder builder = new XMemcachedClientBuilder(AddrUtil
 *				.getAddresses(properties.getProperty("test.memcached.servers"))
 * builder.setSessionLocator(new KetamaMemcachedSessionLocator());
 * MemcachedClient client=builder.build();
 * 具体一致性哈希算法原理见：http://www.csdn.net/article/2016-03-16/2826609
 * XMemcached还提供了额外的一种哈希算法——选举散列,在某些场景下可以替代一致性哈希
 * MemcachedClientBuilder builder = new XMemcachedClientBuilder(
 *                AddrUtil.getAddresses("server1:11211 server2:11211 server3:11211"));
 * builder.setSessionLocator(new ElectionMemcachedSessionLocator());
 * MemcachedClient mc = builder.build();
 * @author donald
 * 2017年10月10日
 * 下午12:49:45
 */
public class MemcachedDistributeClient {
	private static final Logger log = LoggerFactory.getLogger(MemcachedDistributeClient.class);
	private static final String MEMCACHED_SERVER_LIST = "distributeServerList";
	private static PropertiesUtil  propertiesUtil = PropertiesUtil.getInstance();
	private static volatile MemcachedDistributeClient instance;
	private static MemcachedClientBuilder builder;
	private static MemcachedClient memcachedClient;
	static{
		String distributeServerList = propertiesUtil.getProperty(MEMCACHED_SERVER_LIST);
		List<InetSocketAddress> serverAddresses = AddrUtil.getAddresses(distributeServerList);
		builder = new XMemcachedClientBuilder(serverAddresses);
		builder.setSessionLocator(new KetamaMemcachedSessionLocator());
		try {
			memcachedClient = builder.build();
		} catch (IOException e) {
			log.error("连接异常");
			e.printStackTrace();
		}
	}
	public static synchronized MemcachedDistributeClient getInstance() {
		if (instance == null) {
			instance = new MemcachedDistributeClient();
		}
		return instance;
	}

	/**
	 * 
	 * @param key
	 * @param value
	 * @return
	 */
	public boolean set(String key,Object value){
		return set(key, 0, value);
	}
	/**
	 * 
	 * @param key
	 * @param expire 过期时间秒
	 * @param value
	 * @return
	 */
	public boolean set(String key,int expire,Object value){
		boolean finish = false;
		try {
			finish = memcachedClient.set(key, expire, value);
		} catch (TimeoutException e) {
			log.error("set超时");
			e.printStackTrace();
		} catch (InterruptedException e) {
			log.error("set中断异常");
			e.printStackTrace();
		} catch (MemcachedException e) {
			log.error("set错误");
			e.printStackTrace();
		}
		return finish;
	}
	/**
	 * 
	 * @param key
	 * @param value
	 * @return
	 */
	public boolean add(String key,Object value){
		return add(key, 0, value);
	}
	/**
	 * 
	 * @param key
	 * @param expire 过期时间秒
	 * @param value
	 * @return
	 */
	public boolean add(String key,int expire,Object value){
		boolean finish = false;
		try {
			finish = memcachedClient.add(key, expire, value);
		} catch (TimeoutException e) {
			log.error("add超时");
			e.printStackTrace();
		} catch (InterruptedException e) {
			log.error("add中断异常");
			e.printStackTrace();
		} catch (MemcachedException e) {
			log.error("add错误");
			e.printStackTrace();
		}
		return finish;
	}
	/**
	 * 
	 * @param key
	 * @return
	 */
	public Object get(String key){
		Object value = null;
		try {
			value = memcachedClient.get(key);
		} catch (TimeoutException e) {
			log.error("get超时");
			e.printStackTrace();
		} catch (InterruptedException e) {
			log.error("get中断异常");
			e.printStackTrace();
		} catch (MemcachedException e) {
			log.error("get操作错误");
			e.printStackTrace();
		}
		return value;
	}
	/**
	 * 
	 * @param key
	 * @param appendValue
	 * @return
	 */
	public boolean append(String key,Object appendValue){
		boolean finish = false;
		try {
			finish = memcachedClient.append(key, appendValue);
		} catch (TimeoutException e) {
			log.error("append超时");
			e.printStackTrace();
		} catch (InterruptedException e) {
			log.error("append中断异常");
			e.printStackTrace();
		} catch (MemcachedException e) {
			log.error("append操作错误");
			e.printStackTrace();
		}
		return finish;
	}
	/**
	 * 
	 * @param key
	 * @param prependValue
	 * @return
	 */
	public boolean prepend(String key,Object prependValue){
		boolean finish = false;
		try {
			finish = memcachedClient.prepend(key, prependValue);
		} catch (TimeoutException e) {
			log.error("prepend超时");
			e.printStackTrace();
		} catch (InterruptedException e) {
			log.error("prepend中断异常");
			e.printStackTrace();
		} catch (MemcachedException e) {
			log.error("prepend操作错误");
			e.printStackTrace();
		}
		return finish;
	}
	/**
	 * 
	 * @param key
	 * @param value
	 * @return
	 */
	public boolean replace(String key,Object value){
		return replace(key, 0, value);
	}
	/**
	 * 
	 * @param key
	 * @param expire 过期时间秒
	 * @param value
	 * @return
	 */
	public boolean replace(String key,int expire,Object value){
		boolean finish = false;
		try {
			finish = memcachedClient.replace(key, expire, value);
		} catch (TimeoutException e) {
			log.error("replace超时");
			e.printStackTrace();
		} catch (InterruptedException e) {
			log.error("replace中断异常");
			e.printStackTrace();
		} catch (MemcachedException e) {
			log.error("replace错误");
			e.printStackTrace();
		}
		return finish;
	}
	/**
	 * 
	 * @param key
	 * @param expire
	 * @return
	 */
	public boolean touch(String key,int expire){
		boolean finish = false;
		try {
			finish = memcachedClient.touch(key, expire);
		} catch (TimeoutException e) {
			log.error("touch超时");
			e.printStackTrace();
		} catch (InterruptedException e) {
			log.error("touch中断异常");
			e.printStackTrace();
		} catch (MemcachedException e) {
			log.error("touch操作错误");
			e.printStackTrace();
		}
		return finish;
	}
	/**
	 * @param key
	 * @param step
	 * @param defalut
	 * @return
	 */
	public long incr(String key,long step,long defalut){
		long value = 0;
		try {
			value = memcachedClient.incr(key, step, defalut);
		} catch (TimeoutException e) {
			log.error("incr超时");
			e.printStackTrace();
		} catch (InterruptedException e) {
			log.error("incr中断异常");
			e.printStackTrace();
		} catch (MemcachedException e) {
			log.error("incr操作错误");
			e.printStackTrace();
		}
		return value;
	}
	/**
	 * 
	 * @param key
	 * @param step
	 * @return
	 */
	public long incr(String key,long step){
		long value = 0;
		try {
			value = memcachedClient.incr(key, step);
		} catch (TimeoutException e) {
			log.error("incr超时");
			e.printStackTrace();
		} catch (InterruptedException e) {
			log.error("incr中断异常");
			e.printStackTrace();
		} catch (MemcachedException e) {
			log.error("incr操作错误");
			e.printStackTrace();
		}
		return value;
	}
	/**
	 * 
	 * @param key
	 * @param step
	 * @return
	 */
	public long decr(String key,long step){
		long value = 0;
		try {
			value = memcachedClient.decr(key, step);
		} catch (TimeoutException e) {
			log.error("decr超时");
			e.printStackTrace();
		} catch (InterruptedException e) {
			log.error("decr中断异常");
			e.printStackTrace();
		} catch (MemcachedException e) {
			log.error("decr操作错误");
			e.printStackTrace();
		}
		return value;
	}
	/**
	 * 
	 * @param key
	 * @return
	 */
	public long gets(String key){
		long sid = 0;
		try {
			GetsResponse<Integer> result = memcachedClient.gets(key);
			sid = result.getCas(); 
		} catch (TimeoutException e) {
			log.error("gets超时");
			e.printStackTrace();
		} catch (InterruptedException e) {
			log.error("gets中断异常");
			e.printStackTrace();
		} catch (MemcachedException e) {
			log.error("gets操作错误");
			e.printStackTrace();
		}
		return sid;
	}
	/**
	 * 
	 * @param key
	 * @param obj
	 * @return
	 */
	public boolean cas(String key,Object obj){
		boolean finish = false;
		long sid = gets(key);
		finish = cas(key, 0, obj, sid);
		return finish;
	}
	/**
	 * 
	 * @param key
	 * @param expire
	 * @param obj
	 * @param sid key当前版本id
	 * @return
	 */
	public boolean cas(String key, int expire, Object obj, long sid){
		boolean finish = false;
		try {
			finish = memcachedClient.cas(key, expire, obj, sid);
		} catch (TimeoutException e) {
			log.error("cas超时");
			e.printStackTrace();
		} catch (InterruptedException e) {
			log.error("cas中断异常");
			e.printStackTrace();
		} catch (MemcachedException e) {
			log.error("cas操作错误");
			e.printStackTrace();
		}
		return finish;
	}
	/**
	 * @param key
	 * @return
	 */
	public boolean delete(String key){
		boolean finish = false;
		try {
			finish = memcachedClient.delete(key);
		} catch (TimeoutException e) {
			log.error("delete超时");
			e.printStackTrace();
		} catch (InterruptedException e) {
			log.error("delete中断异常");
			e.printStackTrace();
		} catch (MemcachedException e) {
			log.error("delete操作错误");
			e.printStackTrace();
		}
		return finish;
	}
	/**
	 * 
	 * @param key
	 * @return
	 */
	public void deleteWithNoReply(String key){
		try {
			memcachedClient.deleteWithNoReply(key);
		} catch (InterruptedException e) {
			log.error("deleteWithNoReply中断异常");
			e.printStackTrace();
		} catch (MemcachedException e) {
			log.error("deleteWithNoReply操作错误");
			e.printStackTrace();
		}
	}
	/**
	 * @param key
	 * @return
	 */
	public Counter getCounter(String key) {
		return getCounter(key,0);
	}
	/**
	 * @param key
	 * @param init
	 * @return
	 */
	public Counter getCounter(String key,int init) {
		Counter counter = memcachedClient.getCounter(key,init);
		return counter;
	}
	/**
	 * 
	 */
	public void flushAll(){
		try {
			memcachedClient.flushAll();
		} catch (TimeoutException e) {
			log.error("flushAll超时");
			e.printStackTrace();
		} catch (InterruptedException e) {
			log.error("flushAll中断异常");
			e.printStackTrace();
		} catch (MemcachedException e) {
			log.error("flushAll操作错误");
			e.printStackTrace();
		}
	}
	public void shutdown(){
		try {
			memcachedClient.shutdown();
		} catch (IOException e) {
			log.error("客户端关闭异常");
			e.printStackTrace();
		}
	}
	/* (non-Javadoc)
	 * @see java.lang.Object#finalize()
	 */
	@Override
	protected void finalize() {
		try {
			
			memcachedClient.shutdown();
		} catch (IOException e) {
			log.error("memcached 关闭客户端连接失败！");
			e.printStackTrace();
		}
	}
}


创建测试类： 

package bootstrap;

import java.util.concurrent.TimeoutException;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import net.rubyeye.xmemcached.Counter;
import net.rubyeye.xmemcached.exception.MemcachedException;

/**
 * Memcached 分布式客户端测试类
 * @author 
 * donald 
 * 2017年10月10日 
 * 下午12:49:45
 */
public class MemcachedDistributeClientTest {
	private static final Logger log = LoggerFactory.getLogger(MemcachedDistributeClientTest.class);
	public static void main(String[] args) {
		MemcachedDistributeClient memcachedClient = MemcachedDistributeClient.getInstance();
		memcachedClient.set("name", 0, "donald");
		String value = (String) memcachedClient.get("name");
		log.info("set name={}", value);
		memcachedClient.delete("name");
		value = (String) memcachedClient.get("name");
		log.info("delete name={}", value);
		if (!memcachedClient.set("name", 0, "jamel")) {
			log.error("set error");
		}
		value = (String) memcachedClient.get("name");
		log.info("set name={}", value);
		if (memcachedClient.add("name", 0, "donald")) {
			log.error("Add error,key is existed");
		}
		value = (String) memcachedClient.get("name");
		log.info("name={}", value);
		if (!memcachedClient.replace("name", 0, "rain")) {
			log.error("replace error");
		}
		value = (String) memcachedClient.get("name");
		log.info("repalce name={}", value);
		memcachedClient.append("name", "-han");
		value = (String) memcachedClient.get("name");
		log.info("append name={}", value);
		memcachedClient.prepend("name", "0-");
		value = (String) memcachedClient.get("name");
		log.info("prepend name={}", value);
		memcachedClient.touch("name", 3);
		try {
			Thread.sleep(3000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		value = (String) memcachedClient.get("name");
		log.info("after touch name={}", value);
		memcachedClient.deleteWithNoReply("name");
		memcachedClient.set("age", 0, "27");
		log.info("age={}", memcachedClient.get("age"));
		memcachedClient.incr("age", 2, 1);// age 增加2，age不存在，则为1
		memcachedClient.incr("age", 1);
		log.info("incr age={}", memcachedClient.get("age"));
		memcachedClient.decr("age", 2);
		log.info("decr age={}", memcachedClient.get("age"));
		if (!memcachedClient.cas("age", 27)) {
			log.error("cas error");
		}
		log.info("cas age={}", memcachedClient.get("age"));
		Counter counter = memcachedClient.getCounter("counter", 0);
		try {
			log.info("incrementAndGet counter,{}", counter.incrementAndGet());
			log.info("decrementAndGet counter,{}", counter.decrementAndGet());
			log.info("addAndGet counter,{}", counter.addAndGet(3));
		} catch (MemcachedException e) {
			e.printStackTrace();
		} catch (InterruptedException e) {
			e.printStackTrace();
		} catch (TimeoutException e) {
			e.printStackTrace();
		}
		memcachedClient.shutdown();
	}
}

运行测试类，控制台输出如下： 

22:32:41.794 [main] INFO  net.rubyeye.xmemcached.XMemcachedClient 729- XMemcachedClient is using Text protocol
22:32:41.841 [main] INFO  com.google.code.yanf4j.nio.impl.SelectorManager 37- Creating 4 reactors...
22:32:41.859 [main] INFO  com.google.code.yanf4j.core.impl.AbstractController 377- The Controller started at localhost/127.0.0.1:0 ...
22:32:50.918 [Xmemcached-Reactor-0] INFO  com.google.code.yanf4j.core.impl.AbstractController 253- Add a session: 192.168.126.128:11211
22:33:00.033 [Xmemcached-Reactor-0] INFO  com.google.code.yanf4j.core.impl.AbstractController 253- Add a session: 192.168.126.128:11212
22:33:09.118 [Xmemcached-Reactor-0] INFO  com.google.code.yanf4j.core.impl.AbstractController 253- Add a session: 192.168.126.128:11213
22:33:09.185 [main] INFO  bootstrap.MemcachedDistributeClientTest 24- set name=donald
22:33:09.196 [main] INFO  bootstrap.MemcachedDistributeClientTest 27- delete name=null
22:33:09.202 [main] INFO  bootstrap.MemcachedDistributeClientTest 32- set name=jamel
22:33:09.210 [main] INFO  bootstrap.MemcachedDistributeClientTest 37- name=jamel
22:33:09.216 [main] INFO  bootstrap.MemcachedDistributeClientTest 42- repalce name=rain
22:33:09.221 [main] INFO  bootstrap.MemcachedDistributeClientTest 45- append name=rain-han
22:33:09.227 [main] INFO  bootstrap.MemcachedDistributeClientTest 48- prepend name=0-rain-han
22:33:12.234 [main] INFO  bootstrap.MemcachedDistributeClientTest 56- after touch name=null
22:33:12.240 [main] INFO  bootstrap.MemcachedDistributeClientTest 59- age=27
22:33:12.250 [main] INFO  bootstrap.MemcachedDistributeClientTest 62- incr age=30
22:33:12.255 [main] INFO  bootstrap.MemcachedDistributeClientTest 64- decr age=28
22:33:12.267 [main] INFO  bootstrap.MemcachedDistributeClientTest 68- cas age=27
22:33:12.275 [main] INFO  bootstrap.MemcachedDistributeClientTest 71- incrementAndGet counter,1
22:33:12.278 [main] INFO  bootstrap.MemcachedDistributeClientTest 72- decrementAndGet counter,0
22:33:12.281 [main] INFO  bootstrap.MemcachedDistributeClientTest 73- addAndGet counter,3
22:33:12.320 [Xmemcached-Reactor-3] INFO  com.google.code.yanf4j.core.impl.AbstractController 368- Remove a session: 192.168.126.128:11212
22:33:12.326 [Xmemcached-Reactor-1] INFO  com.google.code.yanf4j.core.impl.AbstractController 368- Remove a session: 192.168.126.128:11213
22:33:12.328 [Xmemcached-Reactor-2] INFO  com.google.code.yanf4j.core.impl.AbstractController 368- Remove a session: 192.168.126.128:11211
22:33:12.330 [main] INFO  com.google.code.yanf4j.core.impl.AbstractController 486- Controller has been stopped.

从控制台输出来看，与Standby客户端的测试类控制台输出基本没有区别，唯一不同的是，创建了三个会话，三个会话的Memcached实例为： 
192.168.126.128:11211
192.168.126.128:11212
192.168.126.128:11213

关闭客户端时，同时关闭了三个会话：
分别连接3个Memcached实例,分别获取name，age，counter属性： 
[memcached@donald ~]$ telnet 192.168.126.128 11211
Trying 192.168.126.128...
Connected to 192.168.126.128.
Escape character is '^]'.
get name
END
get age
END
get counter
VALUE counter 0 1
3
END



Last login: Wed Oct 11 22:22:25 2017 from 192.168.126.1
[memcached@donald ~]$ telnet 192.168.126.128 11212
Trying 192.168.126.128...
Connected to 192.168.126.128.
Escape character is '^]'.
get name
END
get age
END
get counter
END




[memcached@donald ~]$ telnet 192.168.126.128 11213
Trying 192.168.126.128...
Connected to 192.168.126.128.
Escape character is '^]'.
get name
END
get age
VALUE age 512 1

END
get counter
END


从上面可以看出，由于我们name属性已经删除，所有name为空，counter在11211上，
age在11213上。

创建测试实例2： 

package bootstrap;

import java.util.concurrent.TimeoutException;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import net.rubyeye.xmemcached.Counter;
import net.rubyeye.xmemcached.exception.MemcachedException;

/**
 * Memcached 分布式客户端测试类
 * @author 
 * donald 
 * 2017年10月10日 
 * 下午12:49:45
 */
public class MemcachedDistributeClientTest2 {
	private static final Logger log = LoggerFactory.getLogger(MemcachedDistributeClientTest2.class);
	public static void main(String[] args) {
		MemcachedDistributeClient memcachedClient = MemcachedDistributeClient.getInstance();
		memcachedClient.flushAll();
		memcachedClient.set("name", 0, "donald");
		String value = (String) memcachedClient.get("name");
		log.info("set name={}", value);
		memcachedClient.set("age", 0, "27");
		log.info("age={}", memcachedClient.get("age"));
		memcachedClient.incr("age", 1);
		log.info("incr age={}", memcachedClient.get("age"));
		Counter counter = memcachedClient.getCounter("counter", 0);
		try {
			log.info("incrementAndGet counter,{}", counter.incrementAndGet());
			log.info("decrementAndGet counter,{}", counter.decrementAndGet());
			log.info("addAndGet counter,{}", counter.addAndGet(3));
		} catch (MemcachedException e) {
			e.printStackTrace();
		} catch (InterruptedException e) {
			e.printStackTrace();
		} catch (TimeoutException e) {
			e.printStackTrace();
		}
		memcachedClient.shutdown();
	}
}


运行测试类控制台输出： 
22:53:04.215 [main] INFO  net.rubyeye.xmemcached.XMemcachedClient 729- XMemcachedClient is using Text protocol
22:53:04.257 [main] INFO  com.google.code.yanf4j.nio.impl.SelectorManager 37- Creating 4 reactors...
22:53:04.275 [main] INFO  com.google.code.yanf4j.core.impl.AbstractController 377- The Controller started at localhost/127.0.0.1:0 ...
22:53:13.334 [Xmemcached-Reactor-0] INFO  com.google.code.yanf4j.core.impl.AbstractController 253- Add a session: 192.168.126.128:11211
22:53:22.375 [Xmemcached-Reactor-0] INFO  com.google.code.yanf4j.core.impl.AbstractController 253- Add a session: 192.168.126.128:11212
22:53:31.397 [Xmemcached-Reactor-0] INFO  com.google.code.yanf4j.core.impl.AbstractController 253- Add a session: 192.168.126.128:11213
22:53:31.544 [main] INFO  bootstrap.MemcachedDistributeClientTest2 25- set name=donald
22:53:31.553 [main] INFO  bootstrap.MemcachedDistributeClientTest2 27- age=27
22:53:31.562 [main] INFO  bootstrap.MemcachedDistributeClientTest2 29- incr age=28
22:53:31.570 [main] INFO  bootstrap.MemcachedDistributeClientTest2 32- incrementAndGet counter,1
22:53:31.573 [main] INFO  bootstrap.MemcachedDistributeClientTest2 33- decrementAndGet counter,0
22:53:31.578 [main] INFO  bootstrap.MemcachedDistributeClientTest2 34- addAndGet counter,3
22:53:31.625 [Xmemcached-Reactor-1] INFO  com.google.code.yanf4j.core.impl.AbstractController 368- Remove a session: 192.168.126.128:11213
22:53:31.629 [Xmemcached-Reactor-2] INFO  com.google.code.yanf4j.core.impl.AbstractController 368- Remove a session: 192.168.126.128:11211
22:53:31.631 [Xmemcached-Reactor-3] INFO  com.google.code.yanf4j.core.impl.AbstractController 368- Remove a session: 192.168.126.128:11212
22:53:31.632 [main] INFO  com.google.code.yanf4j.core.impl.AbstractController 486- Controller has been stopped.


分别连接3个Memcached实例,分别获取name，age，counter属性： 


[memcached@donald ~]$ telnet 192.168.126.128 11211
Trying 192.168.126.128...
Connected to 192.168.126.128.
Escape character is '^]'.
get name
END
get age
END
get counter
VALUE counter 0 1
3
END


[memcached@donald ~]$ telnet 192.168.126.128 11212
Trying 192.168.126.128...
Connected to 192.168.126.128.
Escape character is '^]'.
get name
END
get age
END
get counter
END
quit

[memcached@donald ~]$ telnet 192.168.126.128 11212
Trying 192.168.126.128...
Connected to 192.168.126.128.
Escape character is '^]'.
get name
END
get age
END
get counter
END

[memcached@donald ~]$ telnet 192.168.126.128 11213
Trying 192.168.126.128...
Connected to 192.168.126.128.
Escape character is '^]'.
get name
VALUE name 0 6
donald
END
get age
VALUE age 0 2
28
END
get counter
END

从上面可以看出，name，age，counter分布在11211，11212，11213上。
0
顶
0
踩
分享到：
| Memcache客户端（Xmemcached）
评论
1 楼 flyfeifei66 2018-07-09  
打算使用xmemcache作为memcache的客户端，由于xmemcache是基于NIO的异步多路复用IO技术，网上的资料都说只需要一个客户端连接即可（线程安全？）。做法基本就是实例化出来XMemcachedClientBuilder，然后利用这个builder创建一个memcachedClient就可以操作缓存了。
       在其他资料上看到并发量大时一个连接性能也是有问题的，容易timeout，其实也可以用多个client。且XMemcachedClientBuilder确实有个setConnectionPoolSize方法。但是我看了下XMemcachedClientBuilder确没有其他的设置参数的方法，一个真正意义上的池化技术，至少得有连接最大数，默认初始数量，最大空闲等配置，还得有资源的回收/释放方法，我找了下这些XMemcachedClientBuilder统统没有。并且memcachedClient也没有close 、disconnect类似的方法？难道XMemcachedClientBuilder只是个伪池子？设置PoolSize仅仅是设置它能生产client的最大数量，然后自己没有管理这些client的功能？
           我尝试读了下源码，看的非常晕，没找到头绪

另外就是服务器的参数顺序不同,一个度一个写是否会有问题？
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    Java毕设项目：基于spring+mybatis+maven+mysql实现的优选生鲜电商系统【含源码+数据库+毕业论文】

    一、项目简介 本项目是一套基于SSM框架实现的菜匣子优选生鲜电商系统蔬菜水果商城 包含：项目源码、数据库脚本等，该项目附带全部源码可作为毕设使用。 项目都经过严格调试，eclipse或者idea 确保可以运行！ 该系统功能完善、界面美观、操作简单、功能齐全、管理便捷，具有很高的实际应用价值 二、技术实现 jdk版本：1.8 及以上 ide工具：IDEA或者eclipse 数据库: mysql5.7 后端：spring+springmvc+mybatis+maven+mysql 前端：jsp，css，jquery 三、系统功能 系统用户包括有管理员、用户 主要功能如下： 用户登录 用户注册 首页 个人中心 修改密码 个人信息 用户管理 商品分类管理 商品信息管理 商品上架 商品下架 添加库存、减少库存 系统管理 订单管理 商品信息展示 点我收藏 添加到购物车 立即购买 确认下单 支付 余额充值 退款 新闻资讯 我的订单 我的地址 我的收藏等功能 详见 https://flypeppa.blog.csdn.net/article/details/139756831

    数字图像取证.pptx

    数字图像取证.pptx

    Java源码springboot的房屋交易平台的设计与实现-毕业设计论文-期末大作业.zip

    本项目是基于Java语言和Spring Boot框架构建的房屋交易平台的设计与实现，可作为毕业设计论文及期末大作业的素材。项目主要功能涵盖用户注册登录、房源信息发布与浏览、租赁交易管理等。通过该平台，房东能轻松发布房屋信息并随时管理房源状态，用户可以便捷地查找浏览房源并预约看房。平台采用前后端分离架构，后端Spring Boot负责业务逻辑处理与数据管理，其自动配置等特性有助于简化开发流程，前端利用Vue.js构建用户界面，组件的灵活使用使页面交互体验较好。本项目旨在将计算机相关知识应用于实际场景，让学习者通过项目实战深入理解知识，锻炼解决问题的能力。项目为完整毕设源码，先看项目演示，希望对需要的同学有帮助。

    2-万能拍照识别2.0 一款多功能拍照识别应用

    万能拍照识物是一款多功能拍照识别应用，可以拍照识别动物、植物、菜肴、车型、二维码和条形码、物品等。支持从手机内存选取图片识别，识别文字后可一键复制，显示识别结果后可一键搜索更多资料。操作方便，识别准确。 【使用方法】：安装软件后，打开相机对准想要识别的对象进行拍照，或者从相册中选择图片进行识别。识别完成后，可以选择复制文字或搜索更多信息。

    基于神经音频编解码器的高效语音分离技术研究-Codecformer模型

    内容概要：本文探讨了将语音分离任务嵌入到神经音频编解码器（NAC）的特征空间内的新方法，提出了一种新型模型——Codecformer。该模型在推理时减少了52倍MAC操作次数，同时分离性能与云部署的Sepformer相当。此外，还引入了新的损失函数——Codec SI-SDR，用于指导训练过程。 适合人群：从事音频信号处理和机器学习的研究人员和工程师。 使用场景及目标：①需要高效执行语音分离的边缘计算应用；②降低云计算对音频传输和处理的成本。 其他说明：通过对比不同训练目标的影响以及RVQ层的效果，证明了在压缩编码特征空间内进行语音分离的可行性及其优势。文章还指出了未来可以改进的方向，包括对混合数据预训练NAC和探索Codecformer作为下游任务的第一阶段模型。

    基于Spark的电影推荐系统资源

    基于Spark的电影推荐系统资源

    全自动裁断机（sw18可编辑+工程图+BOM）全套设计资料100%好用.zip

    全自动裁断机（sw18可编辑+工程图+BOM）全套设计资料100%好用.zip

    OpenGL使用glsl实现smallpt

    [OpenGL]使用glsl实现smallpt

    Java源码springboot线上医院挂号系统-毕业设计论文-期末大作业.zip

    本项目是一个基于Spring Boot框架的线上医院挂号系统，旨在利用现代信息技术优化医院挂号流程，提升患者就医体验和医院运营效率。系统主要功能包括用户注册与登录、医院及科室信息查询、医生排班查看、在线预约挂号、挂号记录管理与提醒等。通过该系统，患者可以方便地查询医院和医生的相关信息，并根据自己的需求预约挂号，避免了长时间排队等候的烦恼。 在技术实现上，系统采用了Spring Boot框架，结合了Spring MVC、MyBatis等主流技术栈，实现了前后端分离的架构设计。数据库方面选用了MySQL，并通过Flyway进行版本控制，确保数据库结构的一致性和可维护性。此外，系统还集成了Redis缓存技术，提高了数据访问速度和系统性能。 项目为完整毕设源码，先看项目演示，希望对需要的同学有帮助。

    无人机频射信号检测数据集，平均正确识别率在94.3％，支持pasical voc xml格式的标注，364张原始图片

    无人机频射信号检测数据集，平均正确识别率在94.3％，支持pasical voc xml格式的标注，364张原始图片

    基于ssm的五台山景点购票系统源码（java毕业设计完整源码+LW）.zip

    功能说明： 五台山景点购票系统的主要使用者分为管理员和用户，实现功能包括管理员：首页、个人中心、用户管理、景点信息管理、购票信息管理、酒店信息管理、客房类型管理、客房信息管理、客房预订管理、交流论坛、系统管理，用户：首页、个人中心、购票信息管理、客房预订管理、我的收藏管理，前台首页；首页、景点信息、酒店信息、客房信息、交流论坛、红色文化、个人中心、后台管理、客服等功能。环境说明： 开发语言：Java 框架：ssm，mybatis JDK版本：JDK1.8 数据库：mysql 5.7及以上 数据库工具：Navicat11及以上 开发软件：eclipse/idea Maven包：Maven3.3及以上 服务器：tomcat7及以上。。。

    伺服机械臂sw21可编辑全套设计资料100%好用.zip

    伺服机械臂sw21可编辑全套设计资料100%好用.zip

    生产线双牵引机（sw18可编辑+cad+bom）全套设计资料100%好用.zip

    生产线双牵引机（sw18可编辑+cad+bom）全套设计资料100%好用.zip

    Java源码springboot基于JAVA语言的在线考试与学习交流网页平台-毕业设计论文-期末大作业.zip

    本项目是一个基于Java语言的在线考试与学习交流网页平台，采用Spring Boot框架进行开发。该项目旨在利用现代信息技术，为学生提供一个便捷、高效的学习与考试环境，同时也为教师提供一个方便的考试组织与学习交流的平台。平台的主要功能包括用户管理、课程管理、在线考试、学习资料共享和交流论坛等。用户管理模块支持学生和教师的注册与登录，课程管理模块允许教师上传和管理课程资料，学生可以浏览和下载。在线考试模块支持随机组卷和自动评分，极大地提高了考试的效率和公正性。学习资料共享和交流论坛模块则促进了学生之间的学习交流和资源共享。通过这些功能，平台不仅提升了学习效率，还增强了师生互动，促进了学习社区的形成。项目为完整毕设源码，先看项目演示，希望对需要的同学有帮助。

    Java源码springboot基于web的人力资源管理系统的设计与实现-毕业设计论文-期末大作业.zip

    本项目是一个基于Spring Boot框架的Web人力资源管理系统，旨在为企业和组织提供高效、便捷的人力资源管理解决方案。系统具备员工信息管理、招聘管理、考勤管理、薪资管理等核心功能，能够实现对人力资源的全面管理与监控。 在技术架构方面，系统采用了Spring Boot框架，结合了Spring MVC、Thymeleaf模板引擎以及MySQL数据库，确保系统的稳定性和可扩展性。前端界面友好，操作简便，支持多种数据展示和交互方式。通过RESTful API设计，系统实现了前后端分离，提升了开发效率和系统的灵活性。 此外，系统还集成了安全性管理，确保数据的安全性和用户权限的控制。项目的开发不仅是为了满足企业对人力资源管理的需求，更是为了让读者通过实践了解和学习Spring Boot框架的应用，提升实际开发能力。 项目为完整毕设源码，先看项目演示，希望对需要的同学有帮助。

    halcon点云测量软件，3D测量软件，C#联合halcon视觉系统，通用视觉软件，通用点云处理软件，测量软件，3D视觉检测系统

    halcon点云测量软件，3D测量软件，C#联合halcon视觉系统，通用视觉软件，通用点云处理软件，测量软件，3D视觉检测系统

    Java源码springboot在线课程管理系统-毕业设计论文-期末大作业.zip

    本项目是一个基于Java和Spring Boot的在线课程管理系统，旨在为教育机构提供一个高效、便捷的课程管理解决方案。系统集成了课程创建、学生注册、教师管理、课程安排、成绩记录等多项功能，满足了教育管理的多样需求。通过使用Spring Boot框架，系统实现了快速开发和部署，确保了高并发情况下的性能和稳定性。前端采用了响应式设计，适配不同设备，提升了用户体验。系统还集成了安全机制，确保数据传输和存储的安全。开发此项目的目的是为了提高教育管理的效率，减少人工操作，提升教学质量，适应现代教育信息化、数字化的发展趋势。项目为完整毕设源码，先看项目演示，希望对需要的同学有帮助。

    电动汽车充电站 选址定容 参考文献：考虑交通网络流量的电动汽车充电站规划 matlab 主要内容：采用粒子群算法，结合交通网络流量和道路权重，求解IEEE33节点系统与道路耦合系统模型，得到最终充电站

    电动汽车充电站 选址定容 参考文献：考虑交通网络流量的电动汽车充电站规划 matlab 主要内容：采用粒子群算法，结合交通网络流量和道路权重，求解IEEE33节点系统与道路耦合系统模型，得到最终充电站规划方案，包括选址和定容

    Java源码springboot医疗挂号管理系统-毕业设计论文-期末大作业.zip

    本项目是一个基于Spring Boot框架的医疗挂号管理系统，旨在利用现代信息技术优化医疗资源的配置，提高医疗服务的效率和质量。系统集成了患者挂号、医生排班、预约管理、就诊记录等多项功能，实现了医疗挂号的信息化、智能化管理。通过该系统，患者可以方便快捷地进行在线挂号，查看医生的排班信息和就诊记录；医生可以灵活安排工作时间，实时管理预约情况；管理员则可以对整个系统的运行进行监控和维护。项目采用了B/S架构，前端使用Vue.js进行开发，后端则基于Spring Boot框架，数据存储采用MySQL数据库。系统的设计充分考虑了用户体验和系统的可扩展性，确保在实际应用中能够稳定高效地运行。项目为完整毕设源码，先看项目演示，希望对需要的同学有帮助。

    (175633038)三菱 FX5U PLC 4轴程序 控制松下伺服3个， 步进电机一个， 四轴自动堆垛码垛设备程序， 回原点动作用专用的原点

    三菱 FX5U PLC 4轴程序。 控制松下伺服3个， 步进电机一个， 四轴自动堆垛码垛设备程序， 回原点动作用专用的原点回归指令写的， 手动运行用三菱相对定位指令写的 ， 自动运行用绝对定位指令写的取料运行， 表格定位写的自动放料运行， 设备各种报警异常都有写出 程序每一步都有注释。 联系包括PLC程序、显控触摸屏 程序、松下伺服驱动器接线图。。内容来源于网络分享，如有侵权请联系我删除。另外如果没有积分的同学需要下载，请私信我。

Magicbox
Global site tag (gtag.js) - Google Analytics