一：这里介绍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的客户端库。常见的Java ...
“memcached安装及java应用使用memcached”这一标题暗示了我们要讨论的是一个关于分布式内存缓存系统——memcached的安装过程以及如何在Java应用程序中使用它。Memcached是一个高性能、轻量级的分布式内存对象缓存...
标题中的"memcached java client jar包"指的是用于Java应用程序与Memcached服务器通信的Java库的JAR文件。 在Java应用中使用Memcached客户端，首先需要将`memcached.jar`添加到项目的类路径中。这个JAR文件包含了...
Memcached是一款高性能的分布式内存对象缓存系统，广泛应用于Web应用中，用于缓解数据库的负载。在Java环境中，我们常常使用Java客户端库来与Memcached服务器进行交互。这个文档将深入探讨"performance"分支的Java...
在实际开发中，使用`java_memcached-release_2.5.1.jar`，开发者可以轻松地将Memcached集成到Java应用中，从而提升应用的性能。`MemCachedManager.java`这个类可能包含了创建和管理Memcached连接、执行缓存操作等...
**Memcached Java客户端驱动包详解** Memcached是一种高性能的分布式内存对象缓存系统，用于减少数据库负载，提高网站性能。Java连接Memcached的驱动包使得Java开发者能够方便地与Memcached进行交互，实现数据的...
### Java使用Memcached简单教程 #### 一、简介 Memcached是一个高性能的分布式内存对象缓存系统，通过减轻数据库负载来加速动态Web应用，提高网站的浏览速度。它通过在内存中缓存数据和对象来减少读取数据库的次数...
对于Java应用程序来说，整合Memcached通常涉及以下几个方面： 1. **缓存工具类**：创建一个通用的缓存工具类，封装缓存操作，如get、put、remove等方法。这样可以使代码对具体缓存实现（如Memcached或Ehcache）不...
Memcached是一种高性能、分布式内存对象缓存系统，用于在分布式计算环境中缓解数据库负载，提高应用程序的性能。在Java开发中，有多个客户端库可供选择来与Memcached进行交互。本篇文章将详细介绍两个常用的Java ...
Memcached是一种广泛使用的分布式内存缓存系统，它能够有效地缓解数据库的负载，提高Web应用的性能。本篇学习笔记将重点介绍如何在Java环境中使用gwhalin提供的Memcached客户端进行开发。gwhalin的Memcached Java...
这些库提供了方便的API，使Java开发者能够轻松地将Memcached集成到他们的应用程序中。 **Spymemcached示例** Spymemcached是Java社区广泛使用的Memcached客户端，它的使用非常简单。以下是一个简单的Java实例，...
**标题：“memcached java简单实例”** 在Java开发中，我们常常会遇到缓存的需求，以提高应用程序的性能。Memcached是一款高效的分布式内存对象缓存系统，它能够将数据存储在内存中，从而减少对数据库的访问。这篇...
2. **Java客户端库**：为了在Java应用中使用memcached，我们需要一个客户端库，如spymemcached、xmemcached或者memcached-java-client等。这些库提供了与memcached服务器通信的接口和方法。 3. **安装与配置**：在...
- **客户端程序**：根据Memcached协议，用户可以自行开发客户端程序，或者使用官方提供的Perl、C、Java、Python、PHP等语言的客户端程序。 - **安装示例**：以Perl客户端程序为例，下载源码后，使用`perl Makefile....
在提供的压缩包中，包含了`java_memcached-release_2.6.6.jar`，这是一个Java客户端库，允许Java应用程序与memcached服务器通信。 1. **添加依赖**：将`java_memcached-release_2.6.6.jar`添加到你的项目类路径中，...
Java连接Memcached服务器是开发过程中常见的一环，尤其是在构建分布式系统时，利用Memcached作为缓存服务可以显著提升数据访问速度。Memcached是一款高性能、分布式内存对象缓存系统，能够临时存储键值对数据，减轻...
- Memcached-Java-Client是Java开发者与Memcached进行交互的主要工具，它提供了简单易用的API接口，允许开发者方便地在Java应用中存取缓存数据。 - 版本2.6.1是该客户端的一个稳定版本，包含了一系列优化和改进，...
安装Memcached通常包括下载源码、编译和配置服务器端，然后在Java应用中添加相应的客户端库，以实现Java应用与Memcached服务器之间的通信。 在实际应用中，Java应用会先尝试从Memcached获取数据，如果数据不存在，...
Java Memcached是一个流行的Java客户端库，用于与Memcached缓存服务器进行交互。...通过以上知识点的学习和实践，可以有效地利用Java Memcached客户端与Memcached服务器进行高效的数据交互，提升应用的性能和响应速度。