memcache 批量插入

candy

　　用泛型实现了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.getBytes().length>250 || (value.toString().getBytes().length + key.getBytes().length) > (1024*1024)) {
log.warning("memcache对存储值有限制key为250个字节，key+value为1m！");
}
client.set(key, value);
}
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.toString().getBytes().length + key.get(i).getBytes().length) > (1024*1024)) {
log.warning("memcache对存储值有限制key为250个字节，key+value为1m！");
}
client.set(key.get(i), value);
}
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.getBytes().length>250 || (value.get(i).toString().getBytes().length + key.getBytes().length) > (1024*1024)) {
log.warning("memcache对存储值有限制key为250个字节，key+value为1m！");
}
client.set(key, 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.getBytes().length>250) {
log.warning("memcache对存储值有限制key为250个字节，key+value为1m！");
}
client.delete(key);
}
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));

}
}