[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