memcached的使用
Posted Bert__
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了memcached的使用相关的知识，希望对你有一定的参考价值。
一、windows下安装
环境：win7专业版+memcached_win32_1.4.5
步骤：
1、cmd切换到指定解压目录 2、memcached -d install安装 3、输入memcached –h，出现下图窗口说明已经安装成功
4、telnet测试是否正常运行 telnet 127.0.0.1 11211 如下图：
5、stats命令查看运行状态如下图：
二、linux下安装
环境：redhat5+memcached-1.4.25 所需安装包：
步骤：
1、解压libevent
tar -zxvf libevent-2.0.21-stable.tar.gz
2、安装libevent
./configure --prefix /etc/libevent/
make clean
make
make install
3、解压memcached
tar -zxvf memcached-1.4.21.tar.gz4、安装memcached
./configure --prefix /etc/memcached/ --with-libevent=/etc/libevent/
make clean
make
make install
5.启动memcached
cd /etc/memcached/bin
./memcached -d -u root
6.telnet看memcached是否启动成功，stat查看运行状态
7.查看memcached运行的进程
8.关闭memcached
三、使用memcached
http://www.cnblogs.com/netWild/archive/2013/05/14/memcached.html3.1 所需jar包
3.2 MemCachedConfig.xml
3.3 MemCached.java<?xml version="1.0" encoding="UTF-8"?> <!-- ***** memcached数据库配置文件 ***** *********************************** --> <MemCachedConfig> <!-- Enabled : 是否启用memcached内存数据库选项 可选值 : true - 启用; false - 停用 --> <Enabled>true</Enabled> <!-- Servers : 可用的memcached服务器列表，各服务器根据weight（负载权重值）实现分布式任务均衡 注意 : 各memcached服务器负载权重值的最大公约数最好为1，可在一定程度上简化其内部的负载均衡算法 规则 : <Server host="memcached服务器IP或域名" post="memcached服务端口（默认11211）" weight="负载权重值" /> --> <Servers> <!-- <Server host="192.168.1.10" post="11211" weight="2" /> <Server host="192.168.1.11" post="11211" weight="1" /> <Server host="192.168.1.12" post="11211" weight="1" /> --> <Server host="192.168.78.128" post="11211" weight="1" /> </Servers> <!-- Config : memcached数据库配置选项 initConn : 初始连接数 minConn : 最小连接数 maxConn : 最大连接数 maxIdle : 连接最大空闲时间（毫秒） maintSleep : 主线程的维护周期（每隔多少秒维护一次连接池，0表示不启用主线程） socketTO : 读取操作的超时限制（毫秒） socketConnTO : 连接操作的超时限制（毫秒，0表示不限制） compressEnable : 是否启用自动压缩（该参数从java_memcached-release_2.6.1开始不再支持） compressThreshold : 超过指定大小（bytes）的数据都会被压缩（该参数从java_memcached-release_2.6.1开始不再支持） --> <Config> <property name="initConn">5</property> <property name="minConn">5</property> <property name="maxConn">250</property> <property name="maxIdle">21600000</property> <property name="maintSleep">30</property> <property name="socketTO">10000</property> <property name="socketConnTO">0</property> <property name="compressEnable">true</property> <property name="compressThreshold">65536</property> </Config> </MemCachedConfig>package com.kysis.util; import java.io.File; import java.text.DecimalFormat; import java.util.ArrayList; import java.util.Arrays; import java.util.Calendar; import java.util.Iterator; import java.util.LinkedList; import java.util.List; import java.util.Date; import java.util.HashMap; import java.util.LinkedHashMap; import java.util.Map; import org.apache.commons.net.telnet.TelnetClient; import org.dom4j.Document; import org.dom4j.Element; import org.dom4j.Node; import org.dom4j.io.SAXReader; import com.danga.MemCached.MemCachedClient; import com.danga.MemCached.SockIOPool; /** * @category memcached内存数据库操作类 * @version 1.0 */ public class MemCached { //是否启用MemCached内存数据库 protected static boolean enUsed = true; //创建全局唯一的可实例化对象 protected static MemCached memCached = new MemCached(); //初始化MemCached客户端对象 protected static MemCachedClient memClient = new MemCachedClient(); //定义MemCached服务器运行环境配置文件名称 private static final String MemCachedConfigFile_NAME = "MemCachedConfig.xml"; //定义可用的MemCached服务器列表，用于分布式存储 private static String[] serverListArr = new String[1]; //定义各MemCached服务器的负载权重列表，与服务器列表按先后顺序对应 private static Integer[] weightListArr = new Integer[1];; //定义MemCached服务器运行环境表，配置文件中关于参数相关数据将保存到该表 private static Map<String, String> serverConfig; //定义MemCached服务器运行状态表，用于保存各状态的中文解释 protected static HashMap<String, String> statsItems; //设置全局静态参数，以下代码在整个服务器运行周期内仅运行一次！ static { //初始化MemCached运行环境配置 //首先初始化各参数默认值，然后加载配置文件，遍历其中的参数值并进行覆盖。 initConfig(); if(enUsed){ //如果已启用memcached缓存服务 //获取socke连接池的实例对象 SockIOPool pool = SockIOPool.getInstance(); //设置可用的MemCached服务器信息，实现分布式存储 pool.setServers(serverListArr); //设置各MemCached服务器的负载权重，根据可支配内存实现负载均衡 pool.setWeights(weightListArr); //设置初始连接数 pool.setInitConn(Integer.parseInt(serverConfig.get("initConn").toString())); //设置最小连接数 pool.setMinConn(Integer.parseInt(serverConfig.get("minConn").toString())); //设置最大连接数 pool.setMaxConn(Integer.parseInt(serverConfig.get("maxConn").toString())); //设置连接最大空闲时间 pool.setMaxIdle(Long.parseLong(serverConfig.get("maxIdle").toString())); //设置主线程的睡眠时间，每隔该时间维护一次各连接线程状态 pool.setMaintSleep(Long.parseLong(serverConfig.get("maintSleep").toString())); //关闭nagle算法 pool.setNagle(false); //读取操作的超时限制 pool.setSocketTO(Integer.parseInt(serverConfig.get("socketTO").toString())); //连接操作的超时限制，0为不限制 pool.setSocketConnectTO(Integer.parseInt(serverConfig.get("socketConnTO").toString())); //初始化连接池 pool.initialize(); //压缩设置，超过指定大小的数据都会被压缩 //从java_memcached-release_2.6.1开始已经不再支持内置的数据压缩功能 //memClient.setCompressEnable(Boolean.parseBoolean(serverConfig.get("compressEnable").toString())); //memClient.setCompressThreshold(Long.parseLong(serverConfig.get("compressThreshold").toString())); } } /** * @category 初始化MemCached运行环境配置 * @category 注：该方法在整个服务器周期内仅运行一次 */ protected static void initConfig(){ //初始化可用的MemCached服务器列表默认值（本机） serverListArr[0] = "127.0.0.1:11211"; weightListArr[0] = 1; //初始化MemCached服务器运行环境表（默认值），当某参数未在配置文件中进行定义时，将使用该默认值 serverConfig = new HashMap<String, String>(){ private static final long serialVersionUID = 1L; { put("initConn", "5"); //设置初始连接数 put("minConn", "5"); //设置最小连接数 put("maxConn", "250"); //设置最大连接数 put("maxIdle", "21600000"); //设置连接最大空闲时间（6小时） put("maintSleep", "30"); //设置主线程的睡眠时间（30秒） put("socketTO", "10000"); //读取操作的超时限制（10秒） put("socketConnTO", "0"); //连接操作的超时限制（不限制） put("compressEnable", "true"); //是否启用自动压缩（启用） put("compressThreshold", "65536"); //超过指定大小的数据都会被压缩（64K） } }; //开始读取配置文件，并将其中的参数值向默认环境表中进行覆盖 String filePath = Thread.currentThread().getContextClassLoader().getResource("MemCachedConfig.xml").getPath().substring(1); File file = new File(filePath.replaceAll("%20"," ")); try{ if(file.exists()){ //如果可以成功加载配置文件 SAXReader sr = new SAXReader(); Document doc = sr.read(file); Element Root = doc.getRootElement(); //获得根节点 Element Enabled = (Element)Root.selectSingleNode("Enabled"); //获得是否启用memcached节点 Element Servers = (Element)Root.selectSingleNode("Servers"); //获得可用的服务器列表父节点 Element Config = (Element)Root.selectSingleNode("Config"); //获得运行环境参数列表父节点 enUsed = Boolean.parseBoolean(Enabled.getText()); //是否启用memcached缓存服务 List<Element> serverDoms = Servers.elements(); //备用的服务器列表 List<Element> serverUsed = new ArrayList<Element>(); //经检测，实际可用的服务器列表 TelnetClient telnet = new TelnetClient(); //初始化Telnet对象，用来检测服务器是否可以成功连接 telnet.setConnectTimeout(5000); //连接超时：5秒 for(Element serverTmp : serverDoms){ try{ telnet.connect(serverTmp.attributeValue("host"), Integer.parseInt(serverTmp.attributeValue("post"))); //连接到服务器 telnet.disconnect(); //断开连接 serverUsed.add(serverTmp); //连接成功，将服务器添加到实际可用列表 }catch(Exception e){} } int serverCount = serverUsed.size(); //经检测，实际可用的服务器个数 if(serverCount == 0){ //没有发现实际可用的服务器，返回 enUsed = false; return; } serverListArr = new String[serverCount]; //初始化服务器地址及端口号数组 weightListArr = new Integer[serverCount]; //初始化服务器负载权重数组 for(int ind=0; ind < serverCount; ind++){ //向服务器数组进行赋值 serverListArr[ind] = serverUsed.get(ind).attributeValue("host") + ":" + serverUsed.get(ind).attributeValue("post"); weightListArr[ind] = Integer.parseInt(serverUsed.get(ind).attributeValue("weight").toString()); } Object[] serverConfigArr = serverConfig.keySet().toArray(); //返回服务器运行环境参数列表，用于遍历配置文件 for(Object cfgItem : serverConfigArr){ Node node = Config.selectSingleNode("//property[@name='" + cfgItem + "']"); //查找指定的参数节点 if(node == null) continue; //如果该参数节点不存在，则继续查找下一个参数，该参数将采用默认值 Element configNode = (Element)node; serverConfig.put(cfgItem.toString(), configNode.getTextTrim()); //添加配置文件中定义的参数值 } } }catch(Exception e){ System.out.println(e.toString()); } //初始化MemCached服务器运行状态表，对各状态进行中文解释 statsItems = new HashMap<String, String>(){ { put("pid", "MemCached服务进程ID"); put("version", "MemCached服务版本"); put("pointer_size", "MemCached服务器架构"); put("time", "服务器当前时间"); put("uptime", "服务器本次启动以来，总共运行时间"); put("connection_structures", "服务器分配的连接结构数"); put("total_connections", "服务器本次启动以来，累计响应连接总次数"); put("curr_connections", "当前打开的连接数"); put("limit_maxbytes", "允许服务支配的最大内存容量"); put("bytes", "当前已使用的内存容量"); put("bytes_written", "服务器本次启动以来，写入的数据量"); put("bytes_read", "服务器本次启动以来，读取的数据量"); put("total_items", "服务器本次启动以来，曾存储的Item总个数"); put("curr_items", "当前存储的Item个数"); put("cmd_get", "服务器本次启动以来，执行Get命令总次数"); put("get_hits", "服务器本次启动以来，Get操作的命中次数"); put("get_misses", "服务器本次启动以来，Get操作的未命中次数"); put("cmd_set", "服务器本次启动以来，执行Set命令总次数"); } }; } /** * @category 保护型构造方法，不允许实例化！ */ protected MemCached() { } /** * @category 操作类入口：获取唯一实例. * * @return MemCached对象 */ public static MemCached getInstance() { return memCached; } /** * @category 返回是否已经启用memcached内存服务器 * * @return boolean */ public static boolean used(){ return enUsed; } /** * @category 插入新记录. * @category 前提：记录的Key在缓存中不存在 * @param key 记录的主键 * @param value 记录的内容 * @return boolean 操作结果 */ public boolean add(String key, Object value) { if(!enUsed){ return false; }else{ return memClient.add(key, value); } } /** * @category 插入新记录并设置超时日期 * @category 前提：记录的Key在缓存中不存在 * @param key 记录的主键 * @param value 记录的内容 * @param expiryDate 超时日期 * @return boolean 操作结果 */ public boolean add(String key, Object value, Date expiryDate) { if(!enUsed){ return false; }else{ return memClient.add(key, value, expiryDate); } } /** * @category 插入新记录并设置超时天数 * @category 前提：记录的Key在缓存中不存在 * @param key 记录的主键 * @param value 记录的内容 * @param expiryDays 超时天数 * @return boolean 操作结果 */ public boolean add(String key, Object value, int expiryDays){ if(!enUsed){ return false; }else{ Calendar calendar = Calendar.getInstance(); calendar.setTime(new Date()); calendar.add(Calendar.DATE,expiryDays); //增加天数 return memClient.add(key, value, calendar.getTime()); } } /** * @category 插入新记录或更新已有记录 * @category 解释：记录的Key在缓存中不存在则插入；否则更新 * @param key 记录的主键 * @param value 记录的内容 * @return boolean 操作结果 */ public boolean set(String key, Object value){ if(!enUsed){ return false; }else{ return memClient.set(key, value); } } /** * @category 插入新记录或更新已有记录，并设置超时日期 * @category 解释：记录的Key在缓存中不存在则插入；否则更新 * @param key 记录的主键 * @param value 记录的内容 * @param expiryDate 超时日期 * @return boolean 操作结果 */ public boolean set(String key, Object value, Date expiryDate){ if(!enUsed){ return false; }else{ return memClient.set(key, value, expiryDate); } } /** * @category 插入新记录或更新已有记录，并设置超时天数 * @category 解释：记录的Key在缓存中不存在则插入；否则更新 * @param key 记录的主键 * @param value 记录的内容 * @param expiryDate 超时天数 * @return boolean 操作结果 */ public boolean set(String key, Object value, int expiryDays){ if(!enUsed){ return false; }else{ Calendar calendar = Calendar.getInstance(); calendar.setTime(new Date()); calendar.add(Calendar.DATE,expiryDays); //增加天数 return memClient.set(key, value, calendar.getTime()); } } /** * @category 更新已有记录 * @category 前提：记录的Key在缓存中已经存在 * @param key 记录的主键 * @param value 记录的内容 * @return boolean 操作结果 */ public boolean replace(String key, Object value) { if(!enUsed){ return false; }else{ return memClient.replace(key, value); } } /** * @category 更新已有记录，并设置超时日期 * @category 前提：该值在缓存中已经存在 * @param key 记录的主键 * @param value 记录的内容 * @param expiryDate 超时日期 * @return boolean 操作结果 */ public boolean replace(String key, Object value, Date expiryDate) { if(!enUsed){ return false; }else{ return memClient.replace(key, value, expiryDate); } } /** * @category 更新已有记录，并设置超时天数 * @category 前提：该值在缓存中已经存在 * @param key 记录的主键 * @param value 记录的内容 * @param expiryDays 超时天数 * @return boolean 操作结果 */ public boolean replace(String key, Object value, int expiryDays) { if(!enUsed){ return false; }else{ Calendar calendar = Calendar.getInstance(); calendar.setTime(new Date()); calendar.add(Calendar.DATE,expiryDays); //增加天数 return memClient.replace(key, value, calendar.getTime()); } } /** * @category 返回单条记录 * * @param key 记录的主键 * @return 记录的内容 */ public Object get(String key) { if(!enUsed){ return null; }else{ return memClient.get(key); } } /** * @category 返回多条记录 * * @param keys 记录的主键数组 * @return Map<String, Object> 多条记录的内容 */ public Map<String, Object> get(String[] keys) { if(!enUsed){ return null; }else{ return memClient.getMulti(keys); } } /** * @category 返回所有key值 * * @return Arraylist<String> 多条记录的内容 */ public static ArrayList<String> getAllKey() { if(!enUsed){ return null; }else{ ArrayList<String> list = new ArrayList<String>(); Map<String, Map<String, String>> items = memClient.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 = memClient.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()); } } } } } return list; } } /** * 获取存储的key值 * 已存在的prefix:FlightFocusInfo * 新增加的prefix命名时需确保唯一性，避免取值出问题 */ public static String getKey(String prefix,ArrayList<String> parms) { StringBuffer generateKey = new StringBuffer(""); if(!ToolUtil.isNull(parms)){ Iterator<String> itr = parms.iterator(); generateKey=generateKey.append(prefix).append("_"); while(itr.hasNext()){ generateKey.append(itr.next()).append("_"); } } return generateKey.toString(); } /** * 匹配符合条件的key值 */ public static ArrayList<String> matchKey(String prefix,ArrayList<String> parms) { ArrayList<String> matchKeys = new ArrayList<String>(); if(!ToolUtil.isNull(parms)){ ArrayList<String> keys = new ArrayList<String>(); boolean findFlag = true; parms.add(prefix); keys = getAllKey(); Iterator<String> keysItr = keys.iterator(); while(keysItr.hasNext()){ String key = keysItr.next(); String[] k = key.split("_"); List k_a = Arrays.asList(k); Iterator<String> parmsItr = parms.iterator(); while(parmsItr.hasNext()){ if(!k_a.contains(parmsItr.next())){ findFlag = false; } } if(findFlag){ matchKeys.add(key); } findFlag = true; } } return matchKeys; } /** * @category 删除记录 * @category 执行该方法之后，使用stats的统计结果会同步更新 * @param key 记录的主键 * @return 操作结果 */ public boolean delete(String key){ if(!enUsed){ return false; }else{ return memClient.delete(key); } } /* * **************************************************************************************************************** * 下面的6个方法都是为了对memcached服务器进行监控及管理所用的，可能对服务器造成阻塞，所以除Debug以外，不推荐使用！ */ /** * @category 清空全部缓存数据。*慎用！！ * @category 执行该方法之后，使用stats的统计结果不会马上发生变化，每get一个不存在的item之后，该item的值才会被动清空 * @return 操作结果 */ public boolean flushAll(){ if(!enUsed){ return false; }else{ return memClient.flushAll(); } } /** * @category 返回可用的服务器列表 * @return 数组（服务器地址:端口） */ public String[] servers(){ if(!enUsed) return null; return serverListArr; } /** * @category 返回所有缓存服务器当前的运行状态 * @return * * Map * |-- Key : ServerName01, Value : LinkedHashMap * | |-- Key : statName01, Value : statValue * | |-- ... * | * |-- Key : ServerName02, Value : LinkedHashMap * | |-- Key : statName01, Value : statValue * | |-- ... * | * |-- ... * */ public Map<String,LinkedHashMap<String, String>> stats(){ if(!enUsed) return null; Map<String,LinkedHashMap<String, String>> retMap = new HashMap<String,LinkedHashMap<String, String>>(); for(String server : serverListArr){ LinkedHashMap<String, String> serverStats = this.stats(server); retMap.put(server, serverStats); } return retMap; } /** * @category 返回指定服务器当前的运行状态 * @param server 服务器地址:端口 * * 优化： 参数名称中文显示 * 优化： 毫秒数转换为小时 * 优化： 字节数转换为MB或KB * 优化： UNIX时间戳转换为标准时间 * 优化： 参数显示顺序更加直观 * * @return LinkedHashMap<String, String> 可对Map进行有序遍历 * */ public LinkedHashMap<String, String> stats(String server){ if(!enUsed) return null; LinkedHashMap<String, String> retMap = new LinkedHashMap<String, String>(); Map<String, Map<String, String>> statsList = memClient.stats(new String[]{server}); //System.out.println(memClient.stats().toString()); DecimalFormat format = new DecimalFormat("0.0"); for(Object serverTitle : statsList.keySet().toArray()){ Map<String, String> serverStats = (Map<String, String>)statsList.get(serverTitle); retMap.put(statsItems.get("pid"), serverStats.get("pid").replaceAll("\\\\r\\\\n", "")); retMap.put(statsItems.get("version"), serverStats.get("version").replaceAll("\\\\r\\\\n", "")); retMap.put(statsItems.get("pointer_size"), serverStats.get("pointer_size").replaceAll("\\\\r\\\\n", "") + "位"); retMap.put(statsItems.get("time"), new java.text.SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date(Long.parseLong(serverStats.get("time").replaceAll("\\\\r\\\\n", "")) * 1000)).toString()); retMap.put(statsItems.get("uptime"), format.format(Double.parseDouble(serverStats.get("uptime").replaceAll("\\\\r\\\\n", ""))/(60*60)) + "小时"); retMap.put(statsItems.get("connection_structures"), serverStats.get("connection_structures").replaceAll("\\\\r\\\\n", "")); retMap.put(statsItems.get("total_connections"), serverStats.get("total_connections").replaceAll("\\\\r\\\\n", "")); retMap.put(statsItems.get("curr_connections"), serverStats.get("curr_connections").replaceAll("\\\\r\\\\n", "")); retMap.put(statsItems.get("limit_maxbytes"), format.format(Double.parseDouble(serverStats.get("limit_maxbytes").replaceAll("\\\\r\\\\n", ""))/(1024*1024)) + "MB"); retMap.put(statsItems.get("bytes"), format.format(Double.parseDouble(serverStats.get("bytes").replaceAll("\\\\r\\\\n", ""))/(1024*1024)) + "MB"); retMap.put(statsItems.get("bytes_written"), format.format(Double.parseDouble(serverStats.get("bytes_written").replaceAll("\\\\r\\\\n", ""))/(1024)) + "KB"); retMap.put(statsItems.get("bytes_read"), format.format(Double.parseDouble(serverStats.get("bytes_read").replaceAll("\\\\r\\\\n", ""))/(1024)) + "KB"); retMap.put(statsItems.get("total_items"), serverStats.get("total_items").replaceAll("\\\\r\\\\n", "")); retMap.put(statsItems.get("curr_items"), serverStats.get("curr_items").replaceAll("\\\\r\\\\n", "")); retMap.put(statsItems.get("cmd_get"), serverStats.get("cmd_get").replaceAll("\\\\r\\\\n", "")); retMap.put(statsItems.get("get_hits"), serverStats.get("get_hits").replaceAll("\\\\r\\\\n", "")); retMap.put(statsItems.get("get_misses"), serverStats.get("get_misses").replaceAll("\\\\r\\\\n", "")); retMap.put(statsItems.get("cmd_set"), serverStats.get("cmd_set").replaceAll("\\\\r\\\\n", "")); } return retMap; } /** * @category 返回指定服务器及Slab中当前使用的item列表 * @param server 服务器地址:端口 * @param slab SlabId * @param counter 最多显示items条数 * @return */ public LinkedList<String> items(String server, int slab, int counter){ if(!enUsed) return null; LinkedList<String> ret = new LinkedList<String>(); Map<String, String> itemsKey = memClient.statsCacheDump(new String[]{server}, slab, counter).get(server); for(Object key : itemsKey.keySet().toArray()){ ret.add(key.toString()); } return ret; } /** * @category 返回指定服务器当前使用的SlabsID列表 * @param server 服务器地址:端口 * @return */ public LinkedList<Integer> slabs(String server){ if(!enUsed) return null; LinkedList<Integer> slabsId = new LinkedList<Integer>(); Map<String, String> itemsMap = memClient.statsItems(new String[]{server}).get(server); Object[] itemsArr = itemsMap.keySet().toArray(); for(int i=0, len=itemsArr.length; i<len; i+=2){ slabsId.add(Integer.parseInt(itemsArr[i].toString().split(":")[1])); } return slabsId; } /* * 上面的6个方法都是为了对memcached服务器进行监控及管理所用的，可能对服务器造成阻塞，所以除Debug以外，不推荐使用！ * **************************************************************************************************************** */ /** * 使用示例 */ public static void main(String[] args) { //初始化memcached操作类对象 MemCached cache = MemCached.getInstance(); //验证memcached服务是否已启用 if(!cache.used()){ System.out.println("memcached服务未启用！"); return; } //插入新记录 System.out.println("开始插入新记录（add）：\\r\\n==================================="); System.out.println("keyTest01:" + cache.add("keyTest01", "keyTest01Content")); System.out.println("keyTest02:" + cache.add("keyTest02", "keyTest02Content")); System.out.println("插入新记录操作完成\\r\\n==================================="); //读取单条记录 System.out.println("读取单条记录（get）：\\r\\n==================================="); System.out.println("keyTest01:" + cache.get("keyTest01")); System.out.println("keyTest02:" + cache.get("keyTest02")); System.out.println("读取单条记录操作完成\\r\\n==================================="); //读取多条记录 System.out.println("读取多条记录（add）：\\r\\n==================================="); System.out.println("keyTest01、keyTest02:" + cache.get(new String[]{"keyTest01", "keyTest02"})); System.out.println("读取多条记录操作完成\\r\\n==================================="); //修改记录值 System.out.println("修改记录值（replace）：\\r\\n==================================="); System.out.println("keyTest01:" + cache.get("keyTest01")); System.out.println("keyTest01:" + cache.replace("keyTest01", "keyTest01ContentReplace!")); System.out.println("keyTest01:" + cache.get("keyTest01")); System.out.println("修改记录值操作完成\\r\\n==================================="); //添加或修改记录 System.out.println("添加或修改记录（set）：\\r\\n==================================="); System.out.println("keyTest03:" + cache.set("keyTest03", "keyTest03Content")); System.out.println("keyTest03:" + cache.get("keyTest03")); System.out.println("keyTest03:" + cache.set("keyTest03", "keyTest03ContentReplace!")); System.out.println("keyTest03:" + cache.get("keyTest03")); System.out.println("添加或修改记录操作完成\\r\\n==================================="); //删除记录 System.out.println("删除记录（delete）：\\r\\n==================================="); System.out.println("keyTest01:" + cache.delete("keyTest01")); System.out.println("keyTest02:" + cache.delete("keyTest02")); System.out.println("keyTest03:" + cache.get("keyTest03")); System.out.println("keyTest03:" + cache.delete("keyTest03")); System.out.println("keyTest03:" + cache.get("keyTest03")); System.out.println("修改记录值操作完成\\r\\n==================================="); //打印当前的服务器参数及统计信息 System.out.println("服务器参数及统计信息（stats）：\\r\\n==================================="); Map statsList = cache.stats(); for(Object server : statsList.keySet().toArray()){ System.out.println("-------------------------\\r\\n服务器：" + server + " : \\r\\n-------------------------"); LinkedHashMap serverStats = (LinkedHashMap)statsList.get(server); for(Object statKey : serverStats.keySet().toArray()){ System.out.println(statKey + " : " + serverStats.get(statKey)); } } } }
以上是关于memcached的使用的主要内容，如果未能解决你的问题，请参考以下文章