注意：本节代码基于《第七章 企业项目开发--本地缓存guava cache》
1、本地缓存的问题
- 本地缓存速度一开始高于分布式缓存，但是随着其缓存数量的增加，所占内存越来越大，系统运行内存越来越小，最后系统会被拖慢（这一点与第二点联系起来）
- 本地缓存存于本机，其缓存数量与大小受本机内存大小限制
- 本地缓存存于本机，其他机器的访问不到这样的缓存
解决方案：分布式缓存
- Jboss cache：缓存还存于本机，但是会同步更新到其他机器（解决了第三个问题，解决不了第一和第二个问题），如果缓存机器数量很多，同步更新很耗时
- memcached：缓存存于其他机器，理论上缓存数量与大小无限（因为集群可伸缩），且不需要同步，所以即使缓存机器数量很多，也无所谓，但是这样就会造成单点故障问题，最简单易行的解决方案是缓存备份，即缓存至少存两份。
2、memcached Java客户端的选用
当下常用的三种memcached Java客户端：
- Memcached Client for Java：memcached官方提供，基于Java BIO实现
- SpyMemcached：基于Java NIO
- XMemcached：基于Java NIO，并发性能优于XMemcached，实际上SpyMemcached性能也很高
三者的实验比较结果：
http://xmemcached.googlecode.com/svn/trunk/benchmark/benchmark.html
所以，我们选用XMemcached来实现客户端的编写。
3、代码
在原来的代码结构上，我增加了一个ssmm0-cache模块，专门用于放置分布式缓存相关（memcached、redis、spring cache）的代码。
项目整体结构：
说明：怎样新建maven项目，并加入原来项目，最后引入eclipse，见第一章《第一章 企业项目开发--maven+springmvc+spring+mybatis+velocity整合》
3.1、ssmm0
pom.xml
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd"> <modelVersion>4.0.0</modelVersion> <groupId>com.xxx</groupId>
<artifactId>ssmm0</artifactId>
<version>1.0-SNAPSHOT</version> <name>ssmm0</name>
<packaging>pom</packaging><!-- 父模块 --> <!-- 管理子模块 -->
<modules>
<module>userManagement</module><!-- 具体业务1-人员管理系统 -->
<module>data</module><!-- 封装数据操作 -->
<module>cache</module><!-- 缓存模块 -->
</modules> <properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
</properties> <!-- dependencyManagement不会引入实际的依赖，只是作为一个依赖池，供其和其子类使用 -->
<dependencyManagement>
<dependencies>
<!-- json -->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.1.39</version>
</dependency>
<!-- servlet -->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>3.0.1</version>
<scope>provided</scope>
</dependency>
<!-- spring -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>3.2.6.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-beans</artifactId>
<version>3.2.6.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>3.2.6.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-web</artifactId>
<version>3.2.6.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>3.2.6.RELEASE</version>
</dependency>
<!-- 这个是使用velocity的必备包 -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context-support</artifactId>
<version>3.2.6.RELEASE</version>
</dependency>
<!-- mysql -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.27</version>
<scope>runtime</scope>
</dependency>
<!-- 数据源 -->
<dependency>
<groupId>org.apache.tomcat</groupId>
<artifactId>tomcat-jdbc</artifactId>
<version>7.0.47</version>
</dependency>
<!-- mybatis -->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.1.1</version>
</dependency>
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis-spring</artifactId>
<version>1.1.1</version>
</dependency>
<!-- velocity -->
<dependency>
<groupId>org.apache.velocity</groupId>
<artifactId>velocity</artifactId>
<version>1.5</version>
</dependency>
<dependency>
<groupId>velocity-tools</groupId>
<artifactId>velocity-tools-generic</artifactId>
<version>1.2</version>
</dependency>
<!-- 用于加解密 -->
<dependency>
<groupId>commons-codec</groupId>
<artifactId>commons-codec</artifactId>
<version>1.7</version>
</dependency>
<dependency>
<groupId>org.bouncycastle</groupId>
<artifactId>bcprov-jdk15on</artifactId>
<version>1.47</version>
</dependency>
<!-- 集合工具类 -->
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-collections4</artifactId>
<version>4.0</version>
</dependency>
<!-- 字符串处理类 -->
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-lang3</artifactId>
<version>3.4</version>
</dependency>
<!-- http -->
<dependency>
<groupId>org.apache.httpcomponents</groupId>
<artifactId>httpclient</artifactId>
<version>4.2.6</version>
</dependency>
</dependencies>
</dependencyManagement> <!-- 引入实际依赖 -->
<dependencies>
<!-- json -->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
</dependency>
<!-- spring -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-beans</artifactId>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
</dependency>
<!-- 集合工具类 -->
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-collections4</artifactId>
</dependency>
<!-- 字符串处理类 -->
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-lang3</artifactId>
</dependency>
</dependencies> <build>
<resources>
<!-- 这里配置了这一块儿true，才可以让指定文件（这里是src/main/resources/spring-data.xml）读到pom.xml中的配置信息
， 值得注意的是，如果src/main/resources下还有其他文件，而你不想让其读pom.xml， 你还必须得把src/main/resources下的其余文件再配置一遍，配置为false（不可读pom.xml），
如下边的注释那样，否则，会报这些文件找不到的错误
-->
<resource>
<directory>src/main/resources</directory>
<filtering>true</filtering>
<includes>
<include>*.xml</include>
<include>*.properties</include>
</includes>
</resource>
<!--
<resource>
<directory>src/main/resources</directory>
<filtering>false</filtering>
<includes>
<include>*.properties</include>
</includes>
</resource>
-->
<resource>
<directory>src/main/resources</directory>
<filtering>false</filtering>
<includes>
<!-- 这里如果不加这一条，那么在spring-data.xml中配置的xml将找不到classpath:mapper/admin/AdminMapper.xml -->
<include>mapper/**/*.xml</include>
</includes>
</resource>
</resources>
</build> <!--
profiles可以定义多个profile，然后每个profile对应不同的激活条件和配置信息，从而达到不同环境使用不同配置信息的效果
注意两点：
1）<activeByDefault>true</activeByDefault>这种情况表示服务器启动的时候就采用这一套env（在这里，就是prod）
2）当我们启动服务器后，想采用开发模式，需切换maven的env为dev，如果env的配置本身就是dev，需要将env换成rc或prod，点击apply，然后再将env切换成dev，点击apply才行
-->
<profiles>
<!-- 开发env -->
<profile>
<id>dev</id>
<activation>
<!-- 这里为了测试方便，改为了true，在上线的时候一定要改成false，否则线上使用的就是这一套dev的环境了 -->
<activeByDefault>true</activeByDefault>
<property>
<name>env</name>
<value>dev</value>
</property>
</activation>
<properties>
<env>dev</env> <jdbc.driverClassName>com.mysql.jdbc.Driver</jdbc.driverClassName>
<!--
对于jdbc.url中内容的配置，如果需要配置 &时，有两种方法：
1）如下边这样，使用<![CDATA[XXX]]>包起来
2）使用jdbc.properties文件来读取此pom.xml，然后spring.xml再读取jdbc.properties文件 显然，前者更方便，而且还省了一个jdbc.properties的文件，但是，有的时候，还是会用后者的；
在使用后者的时候，注意三点：
1）需要修改上边的build中的内容
2）需要在spring.xml中配置<context:property-placeholder location="classpath:jdbc.properties"/>
3）将jdbc.properties放在ssmm0-data项目中，之后需要将ssmm0-data项目的env配置为dev
-->
<jdbc.url><![CDATA[jdbc:mysql://127.0.0.1:3306/blog?zeroDateTimeBehavior=convertToNull&useUnicode=true&characterEncoding=utf-8]]></jdbc.url>
<jdbc.username>root</jdbc.username>
<jdbc.password>123456</jdbc.password> <!-- memcache，多台服务器之间需要使用空格隔开，而不要使用英文逗号隔开，因为Xmemcached的AddrUtil源码是根据空格隔开的 -->
<memcached.servers><![CDATA[127.0.0.1:11211]]></memcached.servers>
<memcached.max.client>10</memcached.max.client><!-- 最多的客户端数 -->
<memcached.expiretime>900</memcached.expiretime><!-- 过期时间900s -->
<memcached.hash.consistent>true</memcached.hash.consistent><!-- 是否使用一致性hash算法 -->
<memcached.connection.poolsize>1</memcached.connection.poolsize><!-- 每个客户端池子的连接数 -->
<memcached.op.timeout>2000</memcached.op.timeout><!-- 操作超时时间 -->
</properties>
</profile>
<!-- 预上线env -->
<profile>
<id>rc</id>
<activation>
<activeByDefault>false</activeByDefault>
<property>
<name>env</name>
<value>rc</value>
</property>
</activation>
<properties>
<env>rc</env> <jdbc.driverClassName>com.mysql.jdbc.Driver</jdbc.driverClassName>
<!-- 假设的一个地址 -->
<jdbc.url><![CDATA[jdbc:mysql://10.10.10.100:3306/blog?zeroDateTimeBehavior=convertToNull&useUnicode=true&characterEncoding=utf-8]]></jdbc.url>
<jdbc.username>root2</jdbc.username>
<jdbc.password>1234562</jdbc.password>
</properties>
</profile>
<!-- 线上env -->
<profile>
<id>prod</id>
<activation>
<!-- 这里为了测试方便，改为了false，在上线的时候一定要改成true，否则线上使用的就不是这一套环境了 -->
<activeByDefault>false</activeByDefault>
<property>
<name>env</name>
<value>prod</value>
</property>
</activation>
<properties>
<env>prod</env> <jdbc.driverClassName>com.mysql.jdbc.Driver</jdbc.driverClassName>
<!-- 假设的一个地址 -->
<jdbc.url><![CDATA[jdbc:mysql://99.99.99.999:3307/blog?zeroDateTimeBehavior=convertToNull&useUnicode=true&characterEncoding=utf-8]]></jdbc.url>
<jdbc.username>sadhijhqwui</jdbc.username>
<jdbc.password>zxczkchwihcznk=</jdbc.password>
</properties>
</profile>
</profiles>
</project>
说明：这里给出了完整版，实际上只做了以下5点改动：
- 新增cache子module
- 引入了commons-lang3的jar包，该jar封装了一些对于字符串的处理方法，eg.isBlank()
- <resources>部分因为要将该pom.xml中的配置读取到ssmm0-cache模块的properties文件中去，所以添加了过滤目录
- 在dev环境下配置了与memcached相关的服务器列表及参数
- 最后一点，只是为了测试方便，将dev设为默认选用的环境，而prod不是，在实际上线之前，一定要改回来
注意：
- 在pom.xml中配置memcached服务器列表时，要以"ip1:port1 ip2:port2..."这样的形式，即每台服务器之间用空格隔开，这与Xmemcached的AddrUtil读取服务器列表的方式有关。
3.2、ssmm0-cache
模块结构：
3.2.1、pom.xml
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd"> <modelVersion>4.0.0</modelVersion> <!-- 指定父模块 -->
<parent>
<groupId>com.xxx</groupId>
<artifactId>ssmm0</artifactId>
<version>1.0-SNAPSHOT</version>
</parent> <groupId>com.xxx.ssmm0</groupId>
<artifactId>ssmm0-cache</artifactId> <name>ssmm0-cache</name>
<packaging>jar</packaging> <!-- 引入实际依赖 -->
<dependencies>
<!-- memcached -->
<dependency>
<groupId>com.googlecode.xmemcached</groupId>
<artifactId>xmemcached</artifactId>
<version>1.4.3</version>
</dependency>
</dependencies>
</project>
说明：在该pom.xml中引入了xmemcached的jar包，注意该jar依赖于slf4j.jar，如果不是用maven的话，需要手动导入slf4j.jar，但是用maven的话，maven自己会导入相关的依赖包。
3.2.2、cache_config.properties
#memcached配置#
#memcached服务器集群
memcached.servers = ${memcached.servers}
#缓存过期时间
memcached.expiretime = ${memcached.expiretime}
#是否使用一致性hash算法
memcached.hash.consistent = ${memcached.hash.consistent}
#memcached的最大客户端数量
memcached.max.client = ${memcached.max.client}
#每个客户端池子的连接数
memcached.connection.poolsize = ${memcached.connection.poolsize}
#操作超时时间
memcached.op.timeout = ${memcached.op.timeout}
说明：这里需要从根pom.xml（即ssmm0的pom.xml）中读取信息，所以在根pom.xml的资源过滤部分有相关的修改
3.2.3、FileUtil.java
package com.xxx.cache.util; import java.io.IOException;
import java.io.InputStream;
import java.util.Properties; import org.apache.commons.lang3.math.NumberUtils; /**
* 文件操作工具类
*/
public class FileUtil { /**
* 加载属性文件*.properties
* @param fileName 不是属性全路径名称，而是相对于类路径的名称
*/
public static Properties loadProps(String fileName){
Properties props = null;
InputStream is = null; try {
is = Thread.currentThread().getContextClassLoader().getResourceAsStream(fileName);//获取类路径下的fileName文件，并且转化为输入流
if(is != null){
props = new Properties();
props.load(is); //加载属性文件
}
} catch (Exception e) {
e.printStackTrace();
}finally{
if(is!=null){
try {
is.close();
} catch (IOException e) {
e.printStackTrace();
}
}
} return props;
} /*
* 从属性文件中获取int型数据
*/
public static int getInt(Properties props, String key, int defaultValue){
int value = defaultValue;
if(props.containsKey(key)){ //属性文件中是否包含给定键值
value = NumberUtils.toInt(props.getProperty(key), defaultValue);//从属性文件中取出给定键值的value,并且转换为int型
}
return value;
} /*
* 从属性文件中获取long型数据
*/
public static long getLong(Properties props, String key, long defaultValue){
long value = defaultValue;
if(props.containsKey(key)){ //属性文件中是否包含给定键值
value = NumberUtils.toLong(props.getProperty(key), defaultValue);//从属性文件中取出给定键值的value,并且转换为int型
}
return value;
} /*
* 从属性文件中获取boolean型数据
*/
public static boolean getBoolean(Properties props, String key, boolean defaultValue){
boolean value = defaultValue;
if(props.containsKey(key)){ //属性文件中是否包含给定键值
value = toBoolean(props.getProperty(key), defaultValue);
}
return value;
} public static boolean toBoolean(String str, boolean defaultValue) {
if(str == null) {
return defaultValue;
}
return Boolean.parseBoolean(str);
} /**
* 测试
*/
public static void main(String[] args) {
Properties props = FileUtil.loadProps("cache_config.properties");
//System.out.println(props);
System.out.println(props.getProperty("memcached.servers", "123"));//从属性文件中读取string
System.out.println(FileUtil.getInt(props, "httpclient.max.conn.per.route2", 10));//属性文件中没有这个key
}
}
说明：对于该类的介绍与注意点，参看"Java文件相关"系列的《第一章 属性文件操作工具类》
在该类中，添加了一些方法
- 从属性文件中将String转化为long型数据，与String转int一样，使用NumberUtil即可
- 从属性文件中将String转化为Boolean型数据，直接参考NumberUtil的相关源代码进行编写即可
- 从属性文件中读取String，props.getProperties(String key, String defaultValue)即可
注意：
- 如果直接运行该类中的main方法来读取properties文件中由根pom.xml传来的参数，可能读取不到；可以通过后边的MemcachedUtil中的main方法来获取，或者直接通过最后的浏览器访问来获取就好
3.2.4、CachePrefix.java
package com.xxx.cache.util; /**
* 在该类中定义一些缓存的前缀
* 方式：
* 1、定义一个类，在其中添加静态常量
* 2、使用枚举类（这是最好的方式）
* 作用：
* 1、防止缓存键值重复（通常情况下，每一种业务对应一种前缀）
* 2、可以起到根据前缀分类的作用
* 后者主要是在memcached中实现类似于redis的实现。
*/
public enum CachePrefix {
USER_MANAGEMENT, //人员管理业务类缓存前缀
HOTEL_MANAGEMENT; //酒店管理业务类缓存前缀
}
说明：在该类中定义一些缓存的前缀
作用：
- 防止缓存键值重复（通常情况下，每一种业务对应一种前缀）
- 以起到根据前缀分类的作用（后者主要是在memcached中实现类似于redis的实现），但是其实memcached可以通过使用命名空间来实现分类，具体的参看我的"Java缓存相关"系列中后续的文章
注意：定义常量类有两种方式
- 普通类，里边使用static final常量
- 枚举类（推荐），这里就是使用了枚举类
关于枚举类与普通类做常量类的优缺点对比，查看《effective Java：第二版》第30条，或者参考我"Java高效使用"系列中后续的文章
3.2.5、MemcachedUtil
package com.xxx.cache.memcached; import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;
import java.util.concurrent.TimeoutException; import org.apache.commons.lang3.StringUtils; import com.xxx.cache.util.CachePrefix;
import com.xxx.cache.util.FileUtil; import net.rubyeye.xmemcached.MemcachedClient;
import net.rubyeye.xmemcached.MemcachedClientBuilder;
import net.rubyeye.xmemcached.XMemcachedClientBuilder;
import net.rubyeye.xmemcached.command.BinaryCommandFactory;
import net.rubyeye.xmemcached.exception.MemcachedException;
import net.rubyeye.xmemcached.impl.KetamaMemcachedSessionLocator;
import net.rubyeye.xmemcached.transcoders.CompressionMode;
import net.rubyeye.xmemcached.transcoders.SerializingTranscoder;
import net.rubyeye.xmemcached.utils.AddrUtil; /**
* memcached工具类（基于Xmemcached实现）
*/
public class MemcachedUtil {
private static Map<Integer, MemcachedClient> clientMap
= new HashMap<Integer, MemcachedClient>();//client的集合
private static int maxClient = 3;
private static int expireTime = 900;//900s（默认的缓存过期时间）
private static int maxConnectionPoolSize = 1;//每个客户端池子的连接数
private static long op_time = 2000L;//操作超时时间 private static final String KEY_SPLIT = "-";//用于隔开缓存前缀与缓存键值 /**
* 构建MemcachedClient的map集合
*/
static{
//读取配置文件
Properties props = FileUtil.loadProps("cache_config.properties");
String servers = props.getProperty("memcached.servers", "127.0.0.1:11211");//获取memcached servers集合
maxClient = FileUtil.getInt(props, "", maxClient);
expireTime = FileUtil.getInt(props, "memcached.expiretime", expireTime);
maxConnectionPoolSize = FileUtil.getInt(props, "memcached.connection.poolsize", maxConnectionPoolSize);
op_time = FileUtil.getLong(props, "memcached.op.timeout", op_time); if(StringUtils.isNotBlank(servers)){
MemcachedClientBuilder builder = new XMemcachedClientBuilder(AddrUtil.getAddresses(servers));
builder.setConnectionPoolSize(1);//这个默认也是1
builder.setSessionLocator(new KetamaMemcachedSessionLocator(true));//使用一致性hash算法 SerializingTranscoder transcoder = new SerializingTranscoder(1024*1024);//序列化转换器，指定最大的数据大小1M
transcoder.setCharset("UTF-8");//默认为UTF-8，这里可去掉
transcoder.setCompressionThreshold(1024*1024);//单位：字节，压缩边界值，任何一个大于该边界值（这里是：1M）的数据都要进行压缩
transcoder.setCompressionMode(CompressionMode.GZIP);//压缩算法 builder.setTranscoder(transcoder);
builder.setCommandFactory(new BinaryCommandFactory());//命令工厂 //构建10个MemcachedCient,并放入clientMap
for(int i=0;i<maxClient;i++){
try {
MemcachedClient client = builder.build();
client.setOpTimeout(op_time);//设置操作超时时间，默认为1s
clientMap.put(i, client);
} catch (IOException e) {
e.printStackTrace();
}
}
}
} /**
* 从MemcachedClient中取出一个MemcachedClient
*/
public static MemcachedClient getMemcachedClient(){
/*
* Math.random()：产生[0,1)之间的小数
* Math.random()*maxClient：[0~maxClient)之间的小数
* (int)(Math.random()*maxClient)：[0~maxClient)之间的整数
*/
return clientMap.get((int)(Math.random()*maxClient));
} /**
* 设置缓存
* @param keyPrefix 缓存的键的前缀
* @param key 缓存的键
* @param value 缓存的值
* @param exp 缓存过期时间
*/
public static void setCacheWithNoReply(CachePrefix keyPrefix,
String key,
Object value,
int exp){
try {
MemcachedClient client = getMemcachedClient();
client.addWithNoReply(keyPrefix+KEY_SPLIT+key, exp, value);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (MemcachedException e) {
e.printStackTrace();
}
} /**
* 设置缓存
* @param exp 缓存过期时间（默认时间）
*/
public static void setCacheWithNoReply(CachePrefix keyPrefix,
String key,
Object value){
setCacheWithNoReply(keyPrefix, key, value, expireTime);
} /**
* 设置缓存，并返回缓存成功与否
* 注意：
* 1、设置已经设置过的key-value，将会返回false
*/
public static boolean setCache(CachePrefix keyPrefix,
String key,
Object value,
int exp){
boolean setCacheSuccess = false;
try {
MemcachedClient client = getMemcachedClient();
setCacheSuccess = client.add(keyPrefix+KEY_SPLIT+key, exp, value);
} catch (TimeoutException e) {
e.printStackTrace();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (MemcachedException e) {
e.printStackTrace();
}
return setCacheSuccess;
} /**
* 设置缓存，并返回缓存成功与否（缓存超时时间采用默认）
* @param key
* @param value
*/
public static boolean setCache(CachePrefix keyPrefix,
String key,
Object value){
return setCache(keyPrefix, key, value, expireTime);
} /**
* 获取缓存
*/
public static Object getCache(CachePrefix keyPrefix, String key){
Object value = null;
try {
MemcachedClient client = getMemcachedClient();
value = client.get(keyPrefix+KEY_SPLIT+key);
} catch (TimeoutException e) {
e.printStackTrace();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (MemcachedException e) {
e.printStackTrace();
}
return value;
} /**
* 删除缓存
*/
public static void removeCacheWithNoReply(CachePrefix keyPrefix, String key){
try {
MemcachedClient client = getMemcachedClient();
client.deleteWithNoReply(keyPrefix+KEY_SPLIT+key);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (MemcachedException e) {
e.printStackTrace();
}
} /**
* 删除缓存,并返回删除成功与否
*/
public static boolean removeCache(CachePrefix keyPrefix, String key){
boolean removeCacheSuccess = false;
try {
MemcachedClient client = getMemcachedClient();
removeCacheSuccess = client.delete(keyPrefix+KEY_SPLIT+key);
} catch (TimeoutException e) {
e.printStackTrace();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (MemcachedException e) {
e.printStackTrace();
}
return removeCacheSuccess;
} /**
* 测试
* @param args
*/
public static void main(String[] args) {
/*for(int i=0;i<100;i++){
System.out.println(Math.random());
}*/
System.out.println(MemcachedUtil.setCache(CachePrefix.USER_MANAGEMENT,"hello4", "world"));
System.out.println(MemcachedUtil.getCache(CachePrefix.USER_MANAGEMENT,"hello4"));
/*System.out.println(MemcachedUtil.getCache("hello2"));
System.out.println(MemcachedUtil.getCache("hello2"));
System.out.println(MemcachedUtil.getCache("hello2"));
System.out.println(MemcachedUtil.getCache("hello2"));
System.out.println(MemcachedUtil.getCache("hello2"));*/
}
}
首先给出该类的一个图（不知道该怎么称呼这个图）
说明：上述的图可以根据源代码的追踪画出来；该类是基于XMemcached实现了的一个工具类，主要包含以下6个部分
- 属性默认值的指定
- static静态块中读取属性文件，并与前边的默认值一起来指定最终参数值
- 根据服务器列表构建MemcachedClientBuilder，配置builder的相关属性，包括序列化转化器、二进制协议工厂等
- 通过上述的MemcachedClientBuilder构建指定个数（这里是3个）的MemcachedClient客户端，存于clientMap中
- 提供从clientMap获取MemcachedClient的方法（这里是随机获取）
- 提供缓存的基本操作，增删查操作
注意：
- 我们提供了三个MemcachedClient，那是不是说明同时只能处理三个并发请求呢？不是，Xmemcached基于Java NIO，每一个MemcachedClient都会启动一个reactor线程和一些工作线程，基于IO多路复用技术，一个reactor线程理论上可以接受极高的并发量，甚至可以说成，该reactor线程可以接过所有到达memcached的请求，然后通过事件机制（类似于观察者模式）将这些请求派发给工作线程，进行相应的操作。关于Java NIO、reactor线程模型、事件机制等可以参看《netty权威指南（第2版）》。
- 正如上边所说，每启动一个MemcachedClient，就必须启动一个reactor线程和一些工作线程，这其实是一个昂贵的操作，所以构建多个客户端是比较昂贵的，基于此，XMemcached提供了池化操作，即一个配置参数（setConnectionPoolSize），但是在实际使用中发现，当配置该参数>1的情况下会发生线程死锁现象，所以还是采用多客户端的方式吧！在我们的实际使用中，10个客户端接收百万级请求绝对是轻轻松松的！
- 这里需要注意的是，服务器列表的配置必须用空格隔开，原理查看AddrUtil的源代码
- 关于序列化与反序列化发生的时机，请参看《http://blog.csdn.net/tang9140/article/details/43445511》或者我的"Java缓存相关"的后续文章
- Xmemcached提供了很多的缓存操作API，这些API我会在"Java缓存相关"的后续文章介绍，这里想说，如果你需要提供很多的API方法，那么推荐将上述"说明"中的前5部分写在一个类中（MemcachedFactory），将第6部分（缓存相关操作）写在一个类中（MemcachedUtil），这样会很清晰
- 其他属性的配置，我也会在"Java缓存相关"的后续文章介绍
在这里，需要装一个memcached服务器了。
我们就简要的装一个windows版本的，我发了一个再云盘上，链接：http://pan.baidu.com/s/1dDMlov3，下载后，解压，
两种使用方法：
A、双击解压后的"x86"(32位)或"x64"(64位)文件夹中的memcached.exe，跳出窗口即可。
B、在C:\Windows\System32\cmd.exe右击"以管理员身份运行"-->在命令窗口进入E:\memcached\x86目录中-->"memcached.exe -d install"-->之后去"本地服务"看看是不是已经有memcached server的服务了，如果已经有了，说明安装成功-->之后启动服务，两种方式：
B1、手工在"本地服务部分"启动
B2、命令窗口下"memcached.exe -p 11211 -m 32 -c 1024 -d start"，该方法可以指定参数启动memcached服务，-p表示端口，-m表示分配的内存，-c表示最大的并发连接数
当然，我们在实际使用中，会装在Linux系统上，同时也需要指定一系列参数，例如分配的最大内存、最大并发数等等。
3.3、ssmm0-data
结构：
3.3.1、pom.xml
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd"> <modelVersion>4.0.0</modelVersion> <!-- 指定父模块 -->
<parent>
<groupId>com.xxx</groupId>
<artifactId>ssmm0</artifactId>
<version>1.0-SNAPSHOT</version>
</parent> <groupId>com.xxx.ssmm0</groupId>
<artifactId>ssmm0-data</artifactId> <name>ssmm0-data</name>
<packaging>jar</packaging><!-- 只是作为其他模块使用的工具 --> <!-- 引入实际依赖 -->
<dependencies>
<!-- mysql -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
</dependency>
<!-- 数据源 -->
<dependency>
<groupId>org.apache.tomcat</groupId>
<artifactId>tomcat-jdbc</artifactId>
</dependency>
<!-- mybatis -->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
</dependency>
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis-spring</artifactId>
</dependency>
<!-- servlet --><!-- 为了会用cookie -->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
</dependency>
<!-- bc-加密 -->
<dependency>
<groupId>org.bouncycastle</groupId>
<artifactId>bcprov-jdk15on</artifactId>
</dependency>
<!-- cc加密 -->
<dependency>
<groupId>commons-codec</groupId>
<artifactId>commons-codec</artifactId>
</dependency>
<!-- guava cache -->
<dependency>
<groupId>com.google.guava</groupId>
<artifactId>guava</artifactId>
<version>14.0.1</version>
</dependency>
<!-- 引入自定义cache模块 -->
<dependency>
<groupId>com.xxx.ssmm0</groupId>
<artifactId>ssmm0-cache</artifactId>
<version>1.0-SNAPSHOT</version>
</dependency>
</dependencies>
</project>
说明：只引入了上边的ssmm0-cache模块。
3.3.2、Admin
package com.xxx.model.userManagement; import java.io.Serializable; import com.alibaba.fastjson.JSON; /**
* 管理员
* 这里序列化，是为了向xmemcached中存储，否则会报异常；
* 当然除了用序列化之外，还可以将admin对象转化为json串，然后进行存储
*/
public class Admin implements Serializable{ private static final long serialVersionUID = 7149009421720474527L; private int id;
private String username;
private String password; public int getId() {
return id;
} public void setId(int id) {
this.id = id;
} public String getUsername() {
return username;
} public void setUsername(String username) {
this.username = username;
} public String getPassword() {
return password;
} public void setPassword(String password) {
this.password = password;
} //将json串转为Admin
public static Admin parseJsonToAdmin(String jsonStr){
try {
return JSON.parseObject(jsonStr, Admin.class);
} catch (Exception e) {
e.printStackTrace();
return null;
}
} //将当前实例转化为json串
public String toJson(){
return JSON.toJSONString(this);
}
}
说明：这里只添加了让该类实现java.io.Serializable接口，添加了序列号
注意：在实际使用中，把对象存入缓存有两种方式
- 序列化：使用上述的方式，或者使用其他序列化方式
- 将对象转化为json串，在该类中，有两个方法：一个将Admin-->Json，一个将Json-->Admin
这两种方式都可以，只是Java默认的序列化效率低且生成的码流大，但是使用方便，当然第二种方式使用也相当简单。
关于各种序列化的方式以及优缺点对比，查看《netty权威指南（第2版）》，或者查看我的"Java高效使用"系列的后续文章
3.3.3、AdminMapper
/**************memcached**************/
@Select("SELECT * FROM userinfo WHERE id = #{id}")
@Results(value = {
@Result(id = true, column = "id", property = "id"),
@Result(column = "username", property = "username"),
@Result(column = "password", property = "password") })
public Admin selectById(@Param("id") int id);
说明：添加了上述按照ID查找用户的方法。
3.3.4、AdminDao
/******************memcached********************/
public Admin getUserById(int id){
return adminMapper.selectById(id);
}
说明：添加了上述方法。
3.3.5、AdminService
/*********************memcached********************/
public Admin findAdminById(int id) {
//从缓存中获取数据
Admin admin = (Admin)MemcachedUtil.getCache(CachePrefix.USER_MANAGEMENT, String.valueOf(id));
//若缓存中有，直接返回
if(admin != null){
return admin;
}
//若缓存中没有，从数据库查询
admin = adminDao.getUserById(id);
//若查询出的数据不为null
if(admin!=null){
//将数据存入缓存
MemcachedUtil.setCacheWithNoReply(CachePrefix.USER_MANAGEMENT, String.valueOf(id), admin);
}
//返回从数据库查询的admin（当然也可能数据库中也没有，就是null）
return admin;
}
说明：添加了上述方法。
注意：
上述方法是缓存使用中最常见的模式，即"从缓存获取-->若没有，从数据库查询，存入缓存-->返回数据"，这就是guava cache的get(Object key)使用一个方法完成的原子操作。
3.4、ssmm0-userManagement
在该模块中，只在一个类中添加了一个方法。
AdminController.java
/**
* 根据id查找Admin
*/
@ResponseBody
@RequestMapping("/findAdminById")
public Admin findAdminById(@RequestParam(value="id") int id){ return adminService.findAdminById(id);
}
说明：下边这个方法就是该模块中唯一添加的一个方法。
4、测试
在浏览器输入"localhost:8080/ssmm0-userManagement/admin/findAdminById?id=1"，这样就可以测试缓存，具体测试方式看《第七章 企业项目开发--本地缓存guava cache》
这里要说明的是两点：
- 由于在根pom.xml文件中将dev改成了服务器启动后默认使用的环境，所以在之后的测试中，不需要再修改环境了，但是实际上线时，一定要将prod改成默认环境才行
- 我想在上述URL中不输入项目名ssmm0-userManagement也可以访问相关资源，使用如下方式：run as-->run configurations..-->Context参数改为"/"即可
关于memcached的相关内容和Xmemcached的相关内容，请参看下边链接或者我的"Java缓存相关"的后续文章：