开发了一个高性能memcached java client

	public Object read(String key) {

		GetCommand command = new GetCommand();

		command.setValue(key);

		GetReponse rsp = (GetReponse) pool.send(command, true);

		if (rsp != null && rsp.isSuccess()) {
			byte[] result = rsp.getResult();
			try {
				return bytes2Object(result);
			} catch (Exception e) {
				log.error(e.getMessage());
				e.printStackTrace();
			}

		}
		return null;
	}

	public void write(String key, Serializable value) {
		byte[] bytes = null;
		try {
			bytes = object2Bytes(value);
		} catch (Exception e) {
			log.error(e.getMessage());
			e.printStackTrace();
		}
		if (bytes != null) {
			SetCommand setCommand = new SetCommand();
			setCommand.setKey(key);
			setCommand.setValue(bytes);
			SetReponse rsp = (SetReponse) pool.send(setCommand, true);
			if (rsp != null && rsp.isSuccess()) {
			}
		}
	}

	public static Object bytes2Object(byte[] objBytes) throws Exception {
		if (objBytes == null || objBytes.length == 0) {
			return null;
		}
		ByteArrayInputStream bi = new ByteArrayInputStream(objBytes);
		ObjectInputStream oi = new ObjectInputStream(bi);
		return oi.readObject();
	}

	public static byte[] object2Bytes(Serializable obj) throws Exception {
		if (obj == null) {
			return null;
		}
		ByteArrayOutputStream bo = new ByteArrayOutputStream();
		ObjectOutputStream oo = new ObjectOutputStream(bo);
		oo.writeObject(obj);
		return bo.toByteArray();
	}

public class Test {

	/**
	 * @param args
	 * @throws IOException
	 */
	public static void main(String[] args) throws IOException {
		ByteArrayOutputStream bo = new ByteArrayOutputStream();
		ObjectOutputStream oo = new ObjectOutputStream(bo);
		oo.writeObject(new Example(1, "hello"));
		byte[]  buffer = bo.toByteArray();
		
		MemcachedClient  mc = new MemcachedClient("10.2.224.34",11211,2);
		 mc.set("aaa", buffer);
		 byte[] result = mc.get("aaa" );
		 
		 boolean b = Arrays.equals(buffer, result);
		System.out.println(b);
		 
	}

	private static class Example implements Serializable {
		private int age;
		private String desc;

		public Example(int age, String desc) {
			super();
			this.age = age;
			this.desc = desc;
		}

	}
}

public static void  main(String[] args){
//....
	MemcachedClient mc = new MemcachedClient(ip, port, size);

		CountDownLatch cdl = new CountDownLatch(thread);
		long t = System.currentTimeMillis();
		for (int i = 0; i < thread; i++) {
			new Thread(new TestRunnable(mc, i * 10000, cdl, repeat)).start();
		}

		try {
			cdl.await();
		} catch (InterruptedException e) {

		}

		long all = 2 * thread * repeat;
		long usingtime = (System.currentTimeMillis() - t);
		log
				.info(String
						.format(
								"thread num=%d, repeat=%d,size=%d, all=%d ,velocity=%d , using time:%d",
								thread, repeat, size, all, 1000 * all
										/ usingtime, usingtime));

		mc.pool.close();
}


static private class TestRunnable implements Runnable {

		private MemcachedClient mc;
		private CountDownLatch cd;
		int repeat;
		int start;

		public TestRunnable(MemcachedClient mc, int start, CountDownLatch cdl,
				int repeat) {
			super();
			this.mc = mc;
			this.start = start;
			this.cd = cdl;
			this.repeat = repeat;

		}

		public void run() {

			for (int i = 0; i < repeat; i++) {

				String key = Integer.toString(i);
				mc.set(key, key.getBytes());
				byte[] value = mc.get(key);
				if (log.isInfoEnabled()) {
					String result = new String(value);
					if (!result.equals(key)) {
						log.info(String
								.format("key:%s->result:%s", key, result));
						throw new IllegalStateException();
					}
				}

			}

			cd.countDown();
			// if (log.isDebugEnabled())
			// log.debug(String.format("%s count down", Thread.currentThread()
			// .getName()));
		}

	}