Memcached两种MemcachedClient客户端连接方式

朱雀 2021-11-27 00:52 508阅读 0赞

### 第一种： ###

## 1、所需jar包 ##

![2019072313440116.png][]

### 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包 ###

![20190723134806280.png][]

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

[2019072313440116.png]: /images/20211126/c0f8d995e24247e1a4c19b159a229180.png
[20190723134806280.png]: /images/20211126/0e1077152a9942bdb1b443d2075d99a6.png