用泛型实现了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)); } }