[Java] Memcached Client For Java使用

What is Memcached ?

Memcached是一个免费开源、高性能、分布式的内存对象缓存系统。Memcached是在内存中，为特定数据（字符串或对象）构建key-value的小块数据存储。

简介：

Memcached 是一个高性能的分布式内存对象缓存系统，用于动态Web应用以减轻数据库负载。它通过在内存中缓存数据和对象来减少读取数据库的次数，从而提高动态、数据库驱动网站的速度。Memcached基于一个存储键/值对的hashmap。其守护进程（daemon
）是用C写的，但是客户端可以用任何语言来编写，并通过memcached协议与守护进程通信。

存储方式：

为了提高性能，memcached中保存的数据都存储在memcached内置的内存存储空间中。由于数据仅存在于内存中，因此重启memcached、重启操作系统会导致全部数据消失。另外，内容容量达到指定值之后，就基于LRU(Least
Recently Used)算法自动删除不使用的缓存。memcached本身是为缓存而设计的服务器，因此并没有过多考虑数据的永久性问题。

通信分布式：

Memcached尽管是“分布式”缓存服务器，但服务器端并没有分布式功能。各个memcached不会互相通信以共享信息。那么，怎样进行分布式呢？这完全取决于客户端的实现。本文也将介绍memcached的分布式。

Memcached win 下载：memcached-win32-1.4.4-14
下载

安装：

1. 下载memcache的windows稳定版，解压放某个盘下面，比如在D:\memcached;

2. 在cmd下输入 'D:\memcached\memcached.exe -d install' 安装;

3. 再输入： 'D:\memcached\memcached.exe -d start' 启动;

以后memcached将作为windows的一个服务每次开机时自动启动。这样服务器端已经安装完毕了;

客户端:

Memcached本身是使用C开发的，客户端可以是php、C#、或者java，这里只介绍基于java的客户端。

1. java_memcached-release_2.6.6

这是比较通用的Memcached客户端框架；

依赖jar包：

2. alisoft-xplatform-asf-cache-2.5.1

这个是阿里软件的架构师岑文初进行封装的，里面的注释都是中文的比较好；
依赖jar包：

实例开发：

【这里只放出基本的Java代码，完整Demo下面打包并发！】

1. 基于java_memcached-release_2.6.6

package com.memcached.client;

import java.util.Date;
import com.danga.MemCached.MemCachedClient;
import com.danga.MemCached.SockIOPool;

public class MemcacheManager {
/**
* 构建缓存客户端
*/
private static MemCachedClient cachedClient;
/**
* 单例模式实现客户端管理类
*/
private static MemcacheManager INSTANCE = new MemcacheManager();

private MemcacheManager() {
cachedClient = new MemCachedClient();
// 获取连接池实例
SockIOPool pool = SockIOPool.getInstance();
// 设置缓存服务器地址，可以设置多个实现分布式缓存
pool.setServers(new String[] {"127.0.0.1:11211"});
// 设置初始连接5
pool.setInitConn(5);
// 设置最小连接5
pool.setMinConn(5);
// 设置最大连接250
pool.setMaxConn(250);
// 设置每个连接最大空闲时间3个小时
pool.setMaxIdle(1000 * 60 * 60 * 3);
// 设置连接池维护线程的睡眠时间
// 设置为0，维护线程不启动
// 维护线程主要通过log输出socket的运行状况，监测连接数目及空闲等待时间等参数以控制连接创建和关闭。
pool.setMaintSleep(30);
// 设置是否使用Nagle算法，因为我们的通讯数据量通常都比较大（相对TCP控制数据）而且要求响应及时，因此该值需要设置为false（默认是true）
pool.setNagle(false);
// 设置socket的读取等待超时值
pool.setSocketTO(3000);
// 设置socket的连接等待超时值
pool.setSocketConnectTO(0);
// 设置完pool参数后最后调用该方法，启动pool。
pool.initialize();
}

/**
* 获取缓存管理器唯一实例
* @return
*/
public static MemcacheManager getInstance() {
return INSTANCE;
}

public void add(String key, Object value) {
cachedClient.set(key, value);
}

public void add(String key, Object value, int milliseconds) {
cachedClient.set(key, value, milliseconds);
}

public void remove(String key) {
cachedClient.delete(key);
}

public void remove(String key, int milliseconds) {
cachedClient.delete(key, milliseconds, new Date());
}

public void update(String key, Object value, int milliseconds) {
cachedClient.replace(key, value, milliseconds);
}

public void update(String key, Object value) {
cachedClient.replace(key, value);
}

public Object get(String key) {
return cachedClient.get(key);
}
}

2.基于
alisoft-xplatform-asf-cache-2.5.1

package com.memcached.client;

import com.alisoft.xplatform.asf.cache.ICacheManager;
import com.alisoft.xplatform.asf.cache.IMemcachedCache;
import com.alisoft.xplatform.asf.cache.memcached.CacheUtil;
import com.alisoft.xplatform.asf.cache.memcached.MemcachedCacheManager;

/**
* @功能描述 基于alisoft-xplatform-asf-cache-2.5.1
* @author 吥 悔
* @QQ 379839355
* @时间 2015年12月8日 下午4:21:31
*/
public class AlisoftManager {
private static ICacheManager<IMemcachedCache> cacheManager;
private static AlisoftManager manager;

private AlisoftManager() {
cacheManager = CacheUtil.getCacheManager(IMemcachedCache.class, MemcachedCacheManager.class.getName());
cacheManager.setConfigFile("memcached.xml");
cacheManager.start();
}

/**
* 单态模式
* @return
*/
public static AlisoftManager getInstance() {
if(null == manager) {
manager = new AlisoftManager();
}
return manager;
}

public void clusterCopy(String arg0, String arg1) {
cacheManager.clusterCopy(arg0, arg1);
}

public IMemcachedCache getCache(String arg0) {
return cacheManager.getCache(arg0);
}

public void reload(String arg0) {
cacheManager.reload(arg0);
}

public void setResponseStatInterval(int arg0) {
cacheManager.setResponseStatInterval(arg0);
}

public void stop() {
cacheManager.stop();
}
}

memcached.xml配置文件：

<?xml version="1.0" encoding="UTF-8"?>
<memcached>
<!-- name 属性是程序中使用Cache的唯一标识;socketpool 属性将会关联到后面的socketpool配置; -->
<client name="mclient_0" compressEnable="true" defaultEncoding="UTF-8" socketpool="pool_0">
<!-- 可选，用来处理出错情况 -->
<errorHandler>com.alisoft.xplatform.asf.cache.memcached.MemcachedErrorHandler</errorHandler>
</client>

<!-- name 属性和client 配置中的socketpool 属性相关联。 maintSleep属性是后台线程管理SocketIO池的检查间隔时间，如果设置为0，则表明不需要后台线程维护SocketIO线程池，默认需要管理。
socketTO 属性是Socket操作超时配置，单位ms! aliveCheck 属性表示在使用Socket以前是否先检查Socket状态。 -->
<socketpool name="pool_0" maintSleep="5000" socketTO="3000" failover="true" aliveCheck="true" initConn="5" minConn="5" maxConn="250" nagle="false">
<!-- 设置memcache服务端实例地址.多个地址用","隔开 -->
<servers>127.0.0.1:11211</servers>
<!-- 可选配置。表明了上面设置的服务器实例的Load权重. 例如 <weights>3,7</weights> 表示30% load 在
10.2.224.36:33001, 70% load 在 10.2.224.46:33001 <weights>3,7</weights> -->
</socketpool>
</memcached>

数据库JDBC连接：

package com.memcached.jdbc;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.logging.Logger;

public class JDBC_Tool {
private static final Logger LOG = Logger.getLogger("memcached");
/**
* 数据库连接
* @return
*/
public static Connection getConn() {
Connection conn = null;
try {
// 加载驱动
Class.forName("com.mysql.jdbc.Driver");
// 获得连接
String url = "jdbc:mysql://127.0.0.1:3306/memcache?useUnicode=true&characterEncoding=gbk";
String user = "root";
String password = "root";
conn = DriverManager.getConnection(url, user, password);
LOG.info("****************** 数据库连接成功 ******************");
} catch (Exception e) {
LOG.info("****************** 数据库连接失败 ******************");
e.printStackTrace();
}
return conn;
}

/**
* 通用的数据库[增 删 改]
* @param sql sql语句
* @param o 数组参数
* @return 返回处理结果boolean类型
*/
public static boolean operSQL(String sql, Object[] o) {
boolean flag = true;
// 获得连接
Connection conn = JDBC_Tool.getConn();
PreparedStatement pstmt = null;
try {
conn.setAutoCommit(false);
// 发送sql
pstmt = conn.prepareStatement(sql);
// 设置参数
for(int i = 0, len = o.length; i < len; ++i) {
pstmt.setObject(i + 1, o[i]);
}
// 执行操作
pstmt.executeUpdate();
conn.commit();
LOG.info("****************** 数据操作成功 ******************");
} catch (SQLException e) {
try {
LOG.info("****************** 数据操作失败 ******************");
// 数据回滚
conn.rollback();
flag = false;
} catch (SQLException e1) {
e1.printStackTrace();
}
e.printStackTrace();
} finally {
JDBC_Tool.closeResour(conn, pstmt, null);
}
return flag;
}

/**
* 释放资源
* @param conn
* @param pstmt
* @param rs
*/
public static void closeResour(Connection conn, PreparedStatement pstmt, ResultSet rs) {
try {
if(null != conn) {
conn.close();
}
if(null != pstmt) {
pstmt.close();
}
if(null != rs){
rs.close();
}
LOG.info("****************** 资源关闭 ******************");
} catch (Exception e) {
e.printStackTrace();
}
}
}

3.测试

package com.memcached.test;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.logging.Logger;
import com.memcached.bean.User;
import com.memcached.client.MemcacheManager;
import com.memcached.dao.UserDao;

public class Test {
// 日志打印对象
private static final Logger LOG = Logger.getLogger("memcached");
/**
* ---------- java_memcached-release ----------
*/
private static MemcacheManager memcacheManager = MemcacheManager.getInstance();

public static void addCached() {
User user = null;
for(int i=1; i<=8; ++i) {
user = new User(i, "第 " + i + " 个用户创建成功！", "000000");
// 将User对象添加memcache缓存
memcacheManager.add("T" + i, user);
}
}

public static void showCached() {
for(int i=1; i<=8; ++i) {
// 获取memcache缓存中的对象
LOG.warning(memcacheManager.get("T" + i).toString());
}
}

/**
* 添加数据到数据库
*/
public static void addData() {
UserDao dao = new UserDao();
User user = new User();
user.setName("张三");
user.setPassword("0000");
dao.addData(user);
}

/**
* 初始化数据到memcache缓存
*/
public static void databaseCached() {
User user = null;
if(null == memcacheManager.get("user")) {
UserDao dao = new UserDao();
user = dao.selectData(1);
LOG.warning("初始化数据到memcache缓存......");
memcacheManager.add("user", user);
} else {
LOG.warning("读取memcache缓存数据______");
user = (User) memcacheManager.get("user");
}
LOG.info(user.toString());
}

/**
* 初始化所有用户信息到memcached缓存
*/
public static List<User> databaseAllCached() {
UserDao dao = new UserDao();
Date date = new Date(2000);
List<User> list = new ArrayList<User>();
if(null == memcacheManager.get("users")) {
list = dao.selectAllData();
memcacheManager.add("users", list, date);
} else {
LOG.warning("读取memcache缓存数据______");
list = (List<User>) memcacheManager.get("users");
}
LOG.info(list.toString());
return list;
}

public static void main(String[] args) {
// ---------- java_memcached-release ----------
String loginName = "admin";
String loginPass = "0000";
List<User> list = databaseAllCached();
for (User user : list) {
if(!loginName.equals(user.getName())) {
LOG.info(" -->> 该用户不存在，请检查并使用正确的帐号登录！");
return;
}
if(loginName.equals(user.getName()) && !loginPass.equals(user.getPassword())) {
LOG.info(" -->> 密码错误，请重新登陆！");
return;
}
if(loginName.equals(user.getName()) && loginPass.equals(user.getPassword())) {
LOG.info(user.getName() + " -->> 登录成功");
return;
}
}
}
}

打印结果：

package com.memcached.test;

import java.util.ArrayList;
import java.util.List;
import java.util.logging.Logger;
import com.alisoft.xplatform.asf.cache.IMemcachedCache;
import com.memcached.bean.User;
import com.memcached.client.AlisoftManager;
import com.memcached.dao.UserDao;

/**
* @功能描述 alisoft-xplatform-asf-cache测试
* @author 吥 悔
* @QQ 379839355
* @时间 2015年12月9日 上午1:04:36
*/
public class AlisoftTest {
/**
* 日志打印对象
*/
private static final Logger LOG = Logger.getLogger("memcached");
/**
* ---------- alisoft-xplatform-asf-cache ----------
*/
private static AlisoftManager manager = AlisoftManager.getInstance();
private static IMemcachedCache cache = manager.getCache("mclient_0");

/**
* 初始化所有用户信息到alisoft-xplatform-asf-cache缓存
*/
public static List<User> databaseAllCachedAlisoft() {
UserDao dao = new UserDao();
List<User> list = new ArrayList<User>();
System.out.println("alisoft-xplatform-asf-cache   " + cache.get("users"));
if(null == cache.get("users")) {
list = dao.selectAllData();
cache.put("users", list);
} else {
LOG.warning("读取alisoft-xplatform缓存数据______");
list = (List<User>) cache.get("users");
}
LOG.info(list.toString());
return list;
}

public static void main(String[] args) {
// ---------- alisoft-xplatform-asf-cache ----------
List<User> list2 = databaseAllCachedAlisoft();
for (User user : list2) {
System.out.println(user.getName() + " __ " + user.getPassword());
}
manager.stop();
}
}

打印结果：

文件下载：

【Jar包就不一一上传了，项目中已分好了！】
memcached-win32-1.4.4-14：memcached-win32-1.4.4-14.zip
Demo案例源码：MemCached[案例源码].zip