第一种：
1、所需jar包
2、config/memcached.properties配置文件
memcached.servers=192.168.1.201:12000
memcached.weights=1
memcached.failureMode=fasle
3、java代码实现
package com.memcache.pool;
import java.util.ArrayList;
import java.util.Date;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.alisoft.xplatform.asf.cache.memcached.client.MemCachedClient;
import com.alisoft.xplatform.asf.cache.memcached.client.SockIOPool;
import com.util.PropertiesUtil;
public class MemcacheConnectTool {
private static final Logger LOG = LoggerFactory.getLogger(MemcacheConnectTool.class);
public static final MemCachedClient mcc = new MemCachedClient();
private final static String server = PropertiesUtil.getPropertiesVal("/memcached.properties", "memcached.servers");
private final static Integer weight = Integer.valueOf(PropertiesUtil.getPropertiesVal("/memcached.properties", "memcached.weights"));
private final static String failureMode = PropertiesUtil.getPropertiesVal("/memcached.properties", "memcached.failureMode");
static SockIOPool pool=null;
/**
* 创建静态块 连接
*/
static {
/**
* memcached服务器
*/
String[] servers = {server};
/**
* 设置连接池可用cache服务器的权重，和server数组的位置一一对应
*/
Integer[] weights = {weight};
/**
* 这个类用来创建管理客户端和服务器通讯连接池，客户端主要的工作包括数据通讯、服务器定位、hash码生成等都是由这个类完成的。
* 获得连接池的单态方法。这个方法有一个重载方法getInstance( String poolName )，每个poolName只构造一个SockIOPool实例。
* 缺省构造的poolName是default。
*/
pool = SockIOPool.getInstance();
/**
* 设置memcached服务器
*/
pool.setServers(servers);
/**
* 设置memcached服务器权重
*/
pool.setWeights(weights);
/**
* 设置容错开关设置为TRUE，当前socket不可用时，程序会自动查找可用连接并返回，否则返回NULL，默认状态是true，建议保持默认
*/
pool.setFailover( true );
/**
* 设置开始时每个cache服务器的可用连接数
*/
pool.setInitConn( 10 );
/**
* 设置每个服务器最少可用连接数
*/
pool.setMinConn( 5 );
/**
* 设置每个服务器最大可用连接数
*/
pool.setMaxConn( 250 );
/**
* 设置连接池维护线程的睡眠时间
* 设置为0，维护线程不启动
* 维护线程主要通过log输出socket的运行状况，监测连接数目及空闲等待时间等参数以控制连接创建和关闭。
*/
pool.setMaintSleep( 30 );
/**
* 设置是否使用Nagle算法，因为我们的通讯数据量通常都比较大（相对TCP控制数据）而且要求响应及时，因此该值需要设置为false（默认是true）
*/
pool.setNagle( false );
/**
* 设置socket的读取等待超时值
*/
pool.setSocketTO( 3000 );
/**
* 设置连接心跳监测开关。
* 设为true则每次通信都要进行连接是否有效的监测，造成通信次数倍增，加大网络负载，因此该参数应该在对HA要求比较高的场合设为TRUE，默认状态是false。
*/
pool.setAliveCheck( true );
/**
* 最长租用时间，其使用主要有两点，一是自查线程会检查正在被租用的连接，
* 如果发现已经被租用的时间超过这个值得，会将其从被租用的记录里剔除，并关闭这个连接；另一个应用是
* 上层进行MUTIL操作时，读取所有的数据的时间不能超过这个时间。
*/
pool.setMaxBusyTime(100);
pool.setMaxIdle(1000);
/**
* 设置完pool参数后最后调用该方法，启动pool。
*/
pool.initialize();
}
/**
* 根据 key获取value
* @param key
* @return
*/
public static String get(String key) {
String value = "";
try {
if (mcc.get(key) != null) {
value = mcc.get(key).toString();
}
} catch (Exception e) {
LOG.error("memcached get exception: " + key, e);
}
LOG.debug("GET: key:{}, value:{}", key, value);
return value;
}
/**
* 更新数据（修改）
* @param key
* @param val 要更新的值
* @return 返回更新状态
*/
public static boolean update(String key,String val) {
boolean replace=false;
try {
if (mcc.get(key) != null) {
replace = mcc.replace(key,val);
}
} catch (Exception e) {
LOG.error("memcached get exception: " + key, e);
}
LOG.debug("GET: key:{}, value:{}", key, replace);
return replace;
}
/**
* 根据key删除指定的key-value
* @param key
* @return
*/
public static boolean delete(String key) {
try {
LOG.info("DEL: key:{}", key);
return mcc.delete(key);
} catch (Exception e) {
LOG.error("memcached delete exception: " + key, e);
}
return false;
}
/**
* 新增key-value缓存，以及有效时间
* @param key
* @param value
* @param millisecond
* @return
*/
public static boolean set(String key, String value, long millisecond) {
try {
Date expiry = new Date(millisecond);
return mcc.set(key, value, expiry);
} catch (Exception e) {
LOG.error("memcached set exception: " + key, e);
}
return false;
}
/**
* 新增key-value
* @param key
* @param value
* @return
*/
public static boolean set(String key, String value) {
try {
LOG.info("SET: key:{}, value:{}", key, value);
return mcc.set(key, value);
} catch (Exception e) {
LOG.error("memcached set exception: " + key, e);
}
return false;
}
/**
* val增加1（步长为1），原子性增加
* @param key
* @return
*/
public static long incr(String key) {
return mcc.incr(key);
}
/**
* val增加value(步长为value)，原子性增加
* @param key
* @param value 步长
* @return
*/
public static long addOrIncr(String key, long value) {
LOG.info("SET: key:{}, value:{}", key, value);
return mcc.addOrIncr(key, value);
}
/**
* 获取服务器中所有的key
* @param mcc
* @return
*/
public static List<String> getAllKeys(MemCachedClient mcc) {
LOG.info("Get all key.......");
List<String> list = new ArrayList<String>();
Map<String, Map<String, String>> items = mcc.statsItems();
for (Iterator<String> itemIt = items.keySet().iterator(); itemIt.hasNext();) {
String itemKey = itemIt.next();
Map<String, String> maps = items.get(itemKey);
for (Iterator<String> mapsIt = maps.keySet().iterator(); mapsIt.hasNext();) {
String mapsKey = mapsIt.next();
String mapsValue = maps.get(mapsKey);
if (mapsKey.endsWith("number")) { // memcached key 类型
// item_str:integer:number_str
String[] arr = mapsKey.split(":");
int slabNumber = Integer.valueOf(arr[1].trim());
int limit = Integer.valueOf(mapsValue.trim());
Map<String, Map<String, String>> dumpMaps = mcc.statsCacheDump(slabNumber,
limit);
for (Iterator<String> dumpIt = dumpMaps.keySet().iterator(); dumpIt
.hasNext();) {
String dumpKey = dumpIt.next();
Map<String, String> allMap = dumpMaps.get(dumpKey);
for (Iterator<String> allIt = allMap.keySet().iterator(); allIt
.hasNext();) {
String allKey = allIt.next();
list.add(allKey.trim());
}
}
}
}
}
LOG.info("获取服务器中所有的key完成.......");
return list;
}
/**
* 全量模糊查询key 前缀模式
* @param key
* @return 模糊匹配上的全量key
*/
public static List<String> getAllKeyVal(String key) {
LOG.info("--------------------getAllKeyVal");
List<String> keys = getAllKeys(mcc);
List<String> list = new ArrayList<String>();
if(keys!=null) {
for (int i = 0; i < keys.size(); i++) {
String k = keys.get(i).toString();
if(k.indexOf(key, 0)>-1) {
list.add(k);
}
}
}
return list;
}
/**
* 批量删除keys
* @param keys
*/
public static void delAllKeys(List<String> keys) {
LOG.info("--------------------delAllKeys");
for (String key : keys) {
boolean ret = mcc.delete(key);
LOG.info("delete key: {} , succ:{}", key, ret);
}
}
/**
* 根据正则过滤出key集合
* @param keyList
* @param regex
*/
public static List<String> regexGetKey(List<String> keyList, String regex) {
List<String> list=new ArrayList<String>();
for (String key : keyList) {
if (key.matches(regex)) {
list.add(key);
}
}
return list;
}
public static void main(String[] args) {
// System.out.println(mcc.set("ab-1fasd11f", "1"));
// System.out.println(mcc.set("ab-2fa1sdf", "1"));
// System.out.println(mcc.set("ab-3dd1d", "1"));
// System.out.println(mcc.set("ab-4d1d", "1"));
// System.out.println(mcc.set("ab-5d1d", "1"));
// System.out.println(mcc.set("ab-6dd1fa", "1"));
List<String> allKeyVal = MemcacheConnectTool.getAllKeyVal("ab-");
System.out.println(allKeyVal);
// MemcacheConnectTool.delAllKeys(MemcacheConnectTool.getAllKeyVal("ab-"));
}
}
第二种：
1、所需jar包
2、config/xmemcacheConfig.properties配置文件
memcached.servers=192.168.1.201:12000
3、java代码实现
package com.memcache.pool;
import java.util.ArrayList;
import java.util.List;
import com.util.PropertiesUtil;
import net.rubyeye.xmemcached.KeyIterator;
import net.rubyeye.xmemcached.MemcachedClient;
import net.rubyeye.xmemcached.MemcachedClientBuilder;
import net.rubyeye.xmemcached.XMemcachedClientBuilder;
import net.rubyeye.xmemcached.utils.AddrUtil;
public class MemcaheFunctionUtil {
/**
* 根据key值前缀，全文检索key
* @return
*/
public static List<String> getAllKey(String key_prefix){
List<String> list=new ArrayList<String>();
try {
String url = PropertiesUtil.getPropertiesVal("/xmemcacheConfig.properties", "memcached.servers");
MemcachedClientBuilder builder = new XMemcachedClientBuilder(AddrUtil.getAddresses (url));
MemcachedClient mc = builder.build();
KeyIterator it=mc.getKeyIterator(AddrUtil.getOneAddress(url));
while(it.hasNext()){
String key=it.next();
if(key.indexOf(key_prefix)>-1){
list.add(key);
}
}
} catch (Exception e) {
e.printStackTrace();
}
return list;
}
public static void main(String[] args) {
System.out.println(MemcaheFunctionUtil.getAllKey("ab-"));
}
}
扫一扫
810
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
