一：这里介绍windows环境的安装。
1.下载memcache的windows稳定版，解压放某个盘下面，比如在c:\memcached
2.首先要以管理员身份运行cmd。
3.在cmd下输入 'c:\memcached\memcached.exe -d install' 安装
4.再输入： 'c:\memcached\memcached.exe -d start' 启动。
5.然后在我的计算机右键-->管理-->服务里面可以看到memcached已经启动。
以后memcached将作为windows的一个服务每次开机时自动启动。这样服务器端已经安装完毕了。
二：memcached需要的jar。
1.java_memcached-release_2.6.3
1)简介
这是比较通用的Memcached客户端框架。具体原创不详。
2)依赖的jar
A.commons-pool-1.5.6.jar
B.java_memcached-release_2.6.3.jar
C.slf4j-api-1.6.1.jar
D.slf4j-simple-1.6.1.jar
三、范例（面向对象的封装）
import java.text.DecimalFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;
import com.danga.MemCached.MemCachedClient;
import com.danga.MemCached.SockIOPool;
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）
}
};
//初始化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 删除记录
* @category 执行该方法之后，使用stats的统计结果会同步更新
* @param key 记录的主键
* @return 操作结果
*/
public boolean delete(String key){
if(!enUsed){
return false;
}else{
return memClient.delete(key);
}
}
/**
* @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});
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;
}
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===================================");
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));
}
}
}
}
相关推荐
Java 配置Memcached 应用详解
本文档主要讲述的是Java环境下Memcached应用详解；这里将介绍Java环境下Memcached应用，Memcached主要是集群环境下的缓存解决方案，希望本文对大家有所帮助。 本文将对在Java环境下Memcached应用进行详细介绍。...
较早推出的memcached JAVA客户端API，应用广泛，运行比较稳定。 2.spymemcached，支持异步，单线程的memcached客户端，用到了java1.5版本的concurrent和nio，存取速度会高于前者，但是稳定性不好，测试中常 报time...
NULL 博文链接：https://da-zhuang.iteye.com/blog/2234078
memcached在JAVA项目中的应用
这次主要的优化工作还是在三个方面：应用服务器（Apache,JBoss）配置，业务流程，Cache Client包（http://code.google.com/p/memcache-client-forjava/ ）。这里把过去和这次优化对于Cache的使用作一个经验分享，...
讲述的是在java环境下进行使用内存缓存技术的一些实现手段
MemCached-在Widnows环境下的Java之简单应用.docx
Memcached 是一个高性能的分布式内存对象缓存系统，用于动态Web应用以减轻数据库负载，很好的提高了Web性能。Memcached需要有缓存服务端，采用java编程的话还需要memcached.jar，这就是java中实现memcached服务的...
我们将java_memcached-release_1.6.zip解压后的目录中的java_memcached-release_1.6.jar文件复制到java项目的lib目录下，然后我们来编写代码，比如我提供的一个应用类如下： package utils.cache; import java....
memcached-1.6.0_beta1.tar.gz，缓存memcached的应用，这个是在JAVA中使用的
memcached全面剖析， 密码 1234!@#$ memcached完全剖析–1. memcached的基础 memcached全面剖析–2. 理解memcached的内存存储 memcached全面剖析–3.... memcached的应用和兼容程序 可关注公众号：Java与大数据进阶
Xmemcached是基于java nio实现的高性能可扩展的memcached客户端。它的主要特点： 高性能，稳定可靠，已经在众多公司的众多项目里得到应用。 功能完备：客户端分布式、权重、最新最完整的协议支持。 ...
Java 3DMenu 界面源码，有人说用到游戏中不错，其实平时我信编写Java应用程序时候也能用到吧，不一定非要局限于游戏吧，RES、SRC资源都有，都在压缩包内。 Java zip压缩包查看程序源码 1个目标文件 摘要:Java源码...
Java 3DMenu 界面源码，有人说用到游戏中不错，其实平时我信编写Java应用程序时候也能用到吧，不一定非要局限于游戏吧，RES、SRC资源都有，都在压缩包内。 Java zip压缩包查看程序源码 1个目标文件 摘要:Java源码...
系统的讲解了memcached、安装、应用以及java调用
java 开发技术，网络框架应用及发开的适配器，分部式缓存服务器，各大网站都在使用。
WebSocket4J 是一个用 Java 实现的 WebSocket 协议的类库，可使用 Java 来构建交互式 Web 应用。WebSocket4J 并未实现客户端通讯协议，所以不能用它来连接 WebSocket 服务器。 Struts验证码插件 JCaptcha4Struts2 ...
WebSocket4J 是一个用 Java 实现的 WebSocket 协议的类库，可使用 Java 来构建交互式 Web 应用。WebSocket4J 并未实现客户端通讯协议，所以不能用它来连接 WebSocket 服务器。 Struts验证码插件 JCaptcha4Struts2 ...
本文主要总结了在Ubuntu10下常用Java Web应用软件的安装，特别是LNMJ Web(Linux+Nginx+Mysql+Java Tomcat)架构和LAMJ Web(Linux+Apache+Mysql+Java Tomcat)架构下的软件安装。为进一步配置和实现LNMJ和LAMJ架构(负载...