MemcachedClient客户端连接方式pool+single

下载alisoft-xplatform-asf-cache-2.5.1.jar，并添加到本地maven仓库中

mvn install:install-file -DgroupId=com.alisoft.xplatform.asf.cache -DartifactId=memcached -Dversion=2.5.1 -Dpackaging=jar -Dfile=D:\tool\maven\local-jar\alisoft-xplatform-asf-cache-2.5.1.jar

pom文件引用

<dependency>
	<groupId>com.alisoft.xplatform.asf.cache</groupId>
	<artifactId>memcached</artifactId>
	<version>2.5.1</version>
</dependency>

MemcacheClientConnect.java  client连接类                双端检索单例模式

package com.sxt.util;

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;
/**   双端检索单例模式--》适用于并发场景
 * @ClassName:  MemcacheClientConnect   
 * @Description:TODO(连接方式1：memcache连接池)推荐使用      
 * @author: wd
 * @date:  2019年11月22日  上午10:17:44
 */
public class MemcacheClientConnect {
	
	    private static final Logger LOG = LoggerFactory.getLogger(MemcacheClientConnect.class);
	 
	    public volatile static MemCachedClient mcc = null;

	    
	    private final static String server = "192.168.152.15:11211";
		private final static Integer weight = 1;
		private final static String failureMode = "fasle";//当一个memcached节点down掉的时候，发往这个节点的请求将直接失败，而不是发送给下一个有效的memcached节点
	    
		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( 10000 );
	        /**
	         * 设置是否使用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();
	        
	    }
	    //获取客户端连接
	    public static MemCachedClient getMemCachedClient() {
			System.out.println("获取  MemCachedClient()");
			if (mcc == null) {
				System.out.println("MemCachedClient()为空,创建中");
				synchronized (MemCachedClient.class) {
					if (mcc == null) {
						System.out.println("进入同步实例化MemCachedClient");
						mcc = new MemCachedClient();
						// 压缩设置，超过指定大小（单位为K）的数据都会被压缩
				        mcc.setCompressEnable( true );
				        mcc.setCompressThreshold( 64 * 1024 );
					}
				}
			}
			return mcc;
	    }
}

MemCachedUtil.java     工具类

package com.sxt.util;

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;

public class MemCachedUtil {
	private static final Logger LOG = LoggerFactory.getLogger(MemcacheClientConnect.class);
	public static final MemCachedClient mcc=MemcacheClientConnect.getMemCachedClient();
    /**
     * 根据 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;
    }
}

测试

for (int i = 0; i < 10000; i++) {
			System.out.println(MemCachedUtil.set("ab-1fasd11f", "1"));
			System.out.println(MemCachedUtil.set("ab-2fa1sdf", "1"));
			System.out.println(MemCachedUtil.set("ab-3dd1d", "1"));
			System.out.println(MemCachedUtil.set("ab-4d1d", "1"));
			System.out.println(MemCachedUtil.set("ab-5d1d", "1"));
			System.out.println(MemCachedUtil.set("ab-6dd1fa", "1"));
			List<String> allKeyVal = MemCachedUtil.getAllKeyVal("ab-");
			System.out.println(allKeyVal);
		}