MemcachedClient客户端连接方式pool+single

男娘i 2023-02-20 06:29 8阅读 0赞

> ### 下载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);
>     		}
> 
>