memcache 批量插入

用泛型实现了memcache各种适合各种类型的批量插入等。

package com.payeco.memcache;

import java.lang.reflect.Field;
import java.sql.Timestamp;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.logging.Logger;

import com.danga.MemCached.MemCachedClient;
import com.danga.MemCached.SockIOPool;

public class MemcacheClient extends MemCachedClient{
	
	private static final Logger log=Logger.getLogger(MemcacheClient.class.getName());
	private static boolean status=false;
	
	/**
	 * 初始化memcache管理客户端和服务器通讯连接池
	 * @param servers 设置memcache连接池可用的cache服务器列表
	 * @param weights 设置连接池可用cache服务器的权重
	 * @param initConn 设置开始时每个cache服务器的可用连接数
	 * @param minConn 设置每个服务器最少可用连接数
	 * @param maxConn 设置每个服务器最大可用连接数
	 * @param maxIdle 设置可用连接池的最长等待时间
	 * @param maintSleep 设置连接池维护线程的睡眠时间
	 * @param nagle 设置是否使用Nagle算法，当通讯数据量通常都比较大（相对TCP控制数据）而且要求响应及时，因此该值需要设置为false
	 * @param socketto 设置socket的读取等待超时值
	 * @param socketConnectTo 设置socket的连接等待超时值
	 * @return 是否初始化成功
	 */
	public boolean init(String[] servers,Integer[] weights,int initConn,int minConn,int maxConn,int maxIdle,int maintSleep,boolean nagle,int socketto,int socketConnectTo){
		try {
			SockIOPool pool=SockIOPool.getInstance();
			pool.setServers(servers);
			pool.setWeights(weights);
			pool.setInitConn(initConn);
			pool.setMinConn(minConn);
			pool.setMaxConn(maxConn);
			pool.setMaxIdle(maxIdle);
			pool.setMaintSleep(maintSleep);
			pool.setNagle(nagle);
			pool.setSocketTO(socketto);
			pool.setSocketConnectTO(socketConnectTo);
			pool.initialize();
			status=true;
		} catch (Exception e) {
			status=false;
			log.severe("Memcache Init() failure!");
			e.printStackTrace();
		}
		return status;
	}
	
	/**
	 * 批量插入(字符串数组)
	 * @param key key的数组
	 * @param value value的数组
	 * @return 插入是否成功
	 */
	public <T> boolean set(String[] key,T[] value) {
		boolean set=false;
		int min=0;
		if (status==false) {
			log.warning("memcache未初始化！请先初始化在做此操作");
			return set;
		}
		if (key.length==0 || value.length==0) {
			log.warning("插入的数据长度不能小于或等于0！");
			return set;
		}
		if (key.length>value.length) {
			min=value.length;
		}else if (key.length<value.length) {
			min=key.length;
		}else {
			min=key.length;
		}
		MemcacheClient client=new MemcacheClient();
		try {
			for (int i = 0; i < min; i++) {
				if (key[i].getBytes().length>250 || (value[i].toString().getBytes().length + key[i].getBytes().length) > (1024*1024)) {
					log.warning("memcache对存储值有限制key为250个字节，key+value为1m！");
				}
				client.set(key[i], value[i]);
			}
			set=true;
		} catch (Exception e) {
			set=false;
			log.severe("插入失败！");
			e.printStackTrace();
		}
		return set;
	}
	
	/**
	 * 批量插入(List数组和字符串数组)
	 * @param key key的数组
	 * @param value value的数组
	 * @return 插入是否成功
	 */
	public <T> boolean set(List<String> key,T[] value) {
		boolean set=false;
		int min=0;
		if (status==false) {
			log.warning("memcache未初始化！请先初始化在做此操作");
			return set;
		}
		if (key.size()==0 || value.length==0) {
			log.warning("插入的数据长度不能小于或等于0！");
			return set;
		}
		if (key.size()>value.length) {
			min=value.length;
		}else if (key.size()<value.length) {
			min=key.size();
		}else {
			min=key.size();
		}
		MemcacheClient client=new MemcacheClient();
		try {
			for (int i = 0; i < min; i++) {
				if (key.get(i).getBytes().length>250 || (value[i].toString().getBytes().length + key.get(i).getBytes().length) > (1024*1024)) {
					log.warning("memcache对存储值有限制key为250个字节，key+value为1m！");
				}
				client.set(key.get(i), value[i]);
			}
			set=true;
		} catch (Exception e) {
			set=false;
			log.severe("插入失败！");
			e.printStackTrace();
		}
		return set;
	}
	
	/**
	 * 批量插入(字符串数组和List数组)
	 * @param key key的数组
	 * @param value List的数组
	 * @return 插入是否成功
	 */
	public <T> boolean set(String[] key,List<T> value) {
		boolean set=false;
		int min=0;
		if (status==false) {
			log.warning("memcache未初始化！请先初始化在做此操作");
			return set;
		}
		if (key.length==0 || value.size()==0) {
			log.warning("插入的数据长度不能小于或等于0！");
			return set;
		}
		if (key.length>value.size()) {
			min=value.size();
		}else if (key.length<value.size()) {
			min=key.length;
		}else {
			min=key.length;
		}
		MemcacheClient client=new MemcacheClient();
		try {
			for (int i = 0; i < min; i++) {
				if (key[i].getBytes().length>250 || (value.get(i).toString().getBytes().length + key[i].getBytes().length) > (1024*1024)) {
					log.warning("memcache对存储值有限制key为250个字节，key+value为1m！");
				}
				client.set(key[i], value.get(i));
			}
			set=true;
		} catch (Exception e) {
			set=false;
			log.severe("插入失败！");
			e.printStackTrace();
		}
		return set;
	}
	
	/**
	 * 批量插入(List集合)
	 * @param key key的数组
	 * @param value value的数组
	 * @return 插入是否成功
	 */
	public <T> boolean set(List<String> key,List<T> value) {
		boolean set=false;
		int min=0;
		if (status==false) {
			log.warning("memcache未初始化！请先初始化在做此操作");
			return set;
		}
		if (key.size()==0 || value.size()==0) {
			log.warning("插入的数据长度不能小于或等于0！");
			return set;
		}
		if (key.size()>value.size()) {
			min=value.size();
		}else if (key.size()<value.size()) {
			min=key.size();
		}else {
			min=key.size();
		}
		MemcacheClient client=new MemcacheClient();
		try {
			for (int i = 0; i < min; i++) {
				if (key.get(i).getBytes().length>250 || (value.get(i).toString().getBytes().length + key.get(i).getBytes().length) > (1024*1024)) {
					log.warning("memcache对存储值有限制key为250个字节，key+value为1m！");
				}
				client.set(key.get(i), value.get(i));
			}
			set=true;
		} catch (Exception e) {
			set=false;
			log.severe("插入失败！");
			e.printStackTrace();
		}
		return set;
	}
	
	/**
	 * 批量插入(map集合)
	 * @param key key的数组
	 * @param value value的数组
	 * @return 插入是否成功
	 */
	public <T> boolean set(Map<String,T> map) {
		boolean set=false;
		if (status==false) {
			log.warning("memcache未初始化！请先初始化在做此操作");
			return set;
		}
		if (map.size()==0) {
			log.warning("插入的数据长度不能小于或等于0！");
			return set;
		}
		MemcacheClient client=new MemcacheClient();
		try {
			for (Map.Entry<String, T> m : map.entrySet()) {
				if (!m.getKey().equals("") && m.getValue().equals("")) {
					if (m.getKey().getBytes().length>250 || (m.getValue().toString().getBytes().length + m.getKey().getBytes().length) > (1024*1024)) {
						log.warning("memcache对存储值有限制key为250个字节，key+value为1m！");
					}
					client.set(m.getKey(), m.getValue());
				}
			}
			set=true;
		} catch (Exception e) {
			set=false;
			log.severe("插入失败！");
			e.printStackTrace();
		}
		return set;
	}
	
	/**
	 * 批量删除(字符串集合)
	 * @param key key的数组
	 * @param value value的数组
	 * @return 删除是否成功
	 */
	public <T> boolean delete(String[] key) {
		boolean set=false;
		if (status==false) {
			log.warning("memcache未初始化！请先初始化在做此操作");
			return set;
		}
		if (key.length==0) {
			log.warning("删除的数据长度不能小于或等于0！");
			return set;
		}
		MemcacheClient client=new MemcacheClient();
		try {
			for (int i = 0; i < key.length; i++) {
				if (key[i].getBytes().length>250) {
					log.warning("memcache对存储值有限制key为250个字节，key+value为1m！");
				}
				client.delete(key[i]);
			}
			set=true;
		} catch (Exception e) {
			set=false;
			log.severe("删除失败！");
			e.printStackTrace();
		}
		return set;
	}
	
	/**
	 * 批量删除(list集合)
	 * @param key key的数组
	 * @param value value的数组
	 * @return 删除是否成功
	 */
	public <T> boolean delete(List<String> key) {
		boolean set=false;
		if (status==false) {
			log.warning("memcache未初始化！请先初始化在做此操作");
			return set;
		}
		if (key.size()==0) {
			log.warning("删除的数据长度不能小于或等于0！");
			return set;
		}
		MemcacheClient client=new MemcacheClient();
		try {
			for (int i = 0; i < key.size(); i++) {
				if (key.get(i).getBytes().length>250) {
					log.warning("memcache对存储值有限制key为250个字节，key+value为1m！");
				}
				client.delete(key.get(i));
			}
			set=true;
		} catch (Exception e) {
			set=false;
			log.severe("删除失败！");
			e.printStackTrace();
		}
		return set;
	}
	
	/**
	 * 批量删除(list集合)
	 * @param key key的数组
	 * @param value value的数组
	 * @return 删除是否成功
	 */
	public <T> boolean delete(Map<String,T> map) {
		boolean set=false;
		if (status==false) {
			log.warning("memcache未初始化！请先初始化在做此操作");
			return set;
		}
		if (map.size()==0) {
			log.warning("删除的数据长度不能小于或等于0！");
			return set;
		}
		MemcacheClient client=new MemcacheClient();
		try {
			for (Map.Entry<String, T> m : map.entrySet()) {
				if (m.getKey().getBytes().length>250) {
					log.warning("memcache对存储值有限制key为250个字节，key+value为1m！");
				}
				client.delete(m.getKey());
			}
			set=true;
		} catch (Exception e) {
			set=false;
			log.severe("删除失败！");
			e.printStackTrace();
		}
		return set;
	}
	
	public static void main(String[] args) {
		MemcacheClient client=new MemcacheClient();
		String[] servers={"10.123.1.12:12000"};
		Integer[] weights={3};
		int initConn=5;
		int minConn=5;
		int maxConn=250;
		int maxIdle=1000*60*60*6;
		int maintSleep=30;
		boolean nagle=false;
		int socketto=3000;
		int socketConnectTo=0;
		client.init(servers, weights, initConn, minConn, maxConn, maxIdle, maintSleep, nagle, socketto, socketConnectTo);
		//字符串数组添加
		String[] key={"zz","a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z"};
		String[] value={"测试zz","测试a","测试b","测试c","测试d","测试e","测试f","测试g","测试h","测试i","测试j","测试k","测试l","测试m","测试n","测试o","测试p","测试q","测试r","测试s","测试t","测试u","测试v","测试w","测试x","测试y","测试z"};
		log.info("...."+key.length);
		log.info("..."+value.length);
		//boolean add= client.set(key, value);
		//System.out.println("插入状态："+add);
		String[] gets={"a","b","c","d","e","zz"};
		System.out.println("字符串插入后查询："+client.getMulti(gets));
		//对象添加
		//String[] entitykey={"a","b","c","d","e","f","g","h","i","j","k"};
		//client.delete(entitykey);
		String[] keyentity={"aa","bb","cc","dd","ee","ff","gg","hh","ii","jj","kk"};
		List<StudentDemo> list=new ArrayList<StudentDemo>();
		StudentDemo demo=null;
		for (int i = 0; i < 10; i++) {
			try {
				demo=new StudentDemo();
				demo.setId(i);
				demo.setName("测试"+i);
				demo.setSex("男");
				demo.setAge(23);
				SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");
				Date date = sdf.parse("1992-"+(i+1)+"-05");
				Timestamp timestamp=new Timestamp(date.getTime());
				demo.setBirthday(timestamp);
				list.add(demo);
			} catch (ParseException e) {
				e.printStackTrace();
			}
		}
		client.set(keyentity,list);
		String[] li={"aa","bb","cc","kk"};
		System.out.println("对象插入后查询："+client.getMulti(li));
		Map<String, Object> mapentity=client.getMulti(li);
		for (Map.Entry<String, Object> string : mapentity.entrySet()) {
			System.out.println("key-->"+string.getKey());
			if (string.getValue() instanceof StudentDemo) {
				StudentDemo student=(StudentDemo) string.getValue();
				System.out.println(student.getId()+"<--value-->"+student);
			}
		}
		
		//list添加
		List<String> keylist=new ArrayList<String>();
		keylist.add("seta");
		keylist.add("setb");
		keylist.add("setd");
		keylist.add("sete");
		keylist.add("setf");
		keylist.add("setg");
		keylist.add("seth");
		keylist.add("seti");
		keylist.add("setj");
		keylist.add("setk");
		List<Object> valuelist=new ArrayList<Object>();
		valuelist.add("测试add1");
		valuelist.add("测试add2");
		valuelist.add("测试add3");
		valuelist.add("测试add4");
		valuelist.add("测试add5");
		valuelist.add("测试add6");
		valuelist.add("测试add7");
		valuelist.add("测试add8");
		valuelist.add("测试add9");
		valuelist.add("测试add10");
		//boolean addlist=client.set(keylist, valuelist);
		//log.info("list添加状态："+addlist);
		String[] get={"seta","setb","setc","setd","sete","setzz"};
		System.out.println("list插入后查询的结果："+client.getMulti(get));
		//map添加
		Map<String, Object> map=new HashMap<String, Object>();
		map.put("adda", "测试1");
		map.put("addb", "测试2");
		map.put("addc", "测试3");
		map.put("addd", "测试4");
		map.put("adde", "测试5");
		map.put("addf", "测试6");
		map.put("addg", "测试7");
		map.put("addh", "测试8");
		map.put("addi", "测试9");
		map.put("addj", "测试10");
		map.put("addk", "测试11");
		map.put("addl", "测试12");
		//boolean addmap=client.set(map);
		//log.info("map添加状态："+addmap);
		String[] m={"adda","addb","addc","addd","adde","addzz"};
		System.out.println("map插入后查询的结果："+client.getMulti(m));
		
		//字符串批量删除测试
		String[] dels={"a","b","c","ssss"};
		System.out.println("字符串删除前查询："+client.getMulti(dels));
		client.delete(dels);
		System.out.println("字符串删除后查询："+client.getMulti(dels));
		
		String[] mapKey={"adda","addb","addd","ssss"};
		Map<String, Object> keyMap=new HashMap<String, Object>();
		keyMap.put("adda", "111");
		keyMap.put("addb", "222");
		keyMap.put("addd", "333");
		keyMap.put("ssss", "444");
		System.out.println("map数组前查询："+client.getMulti(mapKey));
		client.delete(keyMap);
		System.out.println("map数组后查询："+client.getMulti(mapKey));
		
		String[] delList={"seta","setb","setd","setdsadasdasdasdasdasdasdadadadsadsadasdasdsdadasdsetdsadasdasdasdasdasdasdadadadsadsadasdasdsdadasdasdadsadsaddasdasdasdsadsadsadasdsdasdadsdasdsadasdsadsadasdsadsadasdsadasdsadsadsadsaasdadsadsaddasdasdasdsadsadsadasdsdasdadsdasdsadasdsadsadasdsadsadasdsadasdsadsadsadsa"};
		List<String> keyList=new ArrayList<String>();
		keyList.add("seta");
		keyList.add("setb");
		keyList.add("setd");
		keyList.add("setdsadasdasdasdasdasdasdadadadsadsadasdasdsdadasdsetdsadasdasdasdasdasdasdadadadsadsadasdasdsdadasdasdadsadsaddasdasdasdsadsadsadasdsdasdadsdasdsadasdsadsadasdsadsadasdsadasdsadsadsadsaasdadsadsaddasdasdasdsadsadsadasdsdasdadsdasdsadasdsadsadasdsadsadasdsadasdsadsadsadsa");
		System.out.println("list数组前查询："+client.getMulti(delList));
		client.delete(keyList);
		System.out.println("list数组后查询："+client.getMulti(delList));
		
		
	}
	
}