第八章企业项目开发--分布式缓存memcached

注意：本节代码基于《第七章企业项目开发--本地缓存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中内容的配置，如果需要配置 &amp;时，有两种方法：
                     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&amp;useUnicode=true&amp;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&amp;useUnicode=true&amp;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&amp;useUnicode=true&amp;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缓存相关"的后续文章：

http://code.google.com/p/memcached/wiki/NewStart?tm=6

https://code.google.com/p/xmemcached/wiki/User_Guide_zh

第八章企业项目开发--分布式缓存memcached的更多相关文章

企业项目开发--分布式缓存memcached（3）
此文已由作者赵计刚授权网易云社区发布. 欢迎访问网易云社区,了解更多网易技术产品运营经验. 3.3.ssmm0-data 结构: 3.3.1.pom.xml 1 <?xml version=& ...
企业项目开发--分布式缓存Redis
第九章企业项目开发--分布式缓存Redis(1) 注意:本章代码将会建立在上一章的代码基础上,上一章链接<第八章企业项目开发--分布式缓存memcached> 1.为什么用Redis ...
第九章企业项目开发--分布式缓存Redis(1)
注意:本章代码将会建立在上一章的代码基础上,上一章链接<第八章企业项目开发--分布式缓存memcached> 1.为什么用Redis 1.1.为什么用分布式缓存(或者说本地缓存存在的问题 ...
第十章企业项目开发--分布式缓存Redis(2)
注意:本章代码是在上一章的基础上进行添加修改,上一章链接<第九章企业项目开发--分布式缓存Redis(1)> 上一章说了ShardedJedisPool的创建过程,以及redis五种数据 ...
第七章企业项目开发--本地缓存guava cache
1.在实际项目开发中,会使用到很多缓存技术,而且数据库的设计一般也会依赖于有缓存的情况下设计. 常用的缓存分两种:本地缓存和分布式缓存. 常用的本地缓存是guava cache,本章主要介绍guava ...
企业项目开发--本地缓存guava cache（1）
此文已由作者赵计刚授权网易云社区发布. 欢迎访问网易云社区,了解更多网易技术产品运营经验. 1.在实际项目开发中,会使用到很多缓存技术,而且数据库的设计一般也会依赖于有缓存的情况下设计. 常用的缓存分 ...
企业项目开发--本地缓存guava cache（2）
此文已由作者赵计刚授权网易云社区发布. 欢迎访问网易云社区,了解更多网易技术产品运营经验. AdminCacheKey: package com.xxx.vo.userManagement; /** ...
第十一章企业项目开发--消息队列activemq
注意:本章代码基于第十章企业项目开发--分布式缓存Redis(2) 代码的github地址:https://github.com/zhaojigang/ssmm0 消息队列是分布式系统中实现RPC ...
CYQ.Data V5 分布式缓存MemCached应用开发介绍
前言今天大伙还在热议关于.NET Core的东西,我只想说一句:在.NET 跨平台叫了这么多年间,其实人们期待的是一个知名的跨平台案例,而不是一堆能跨平台的消息. 好,回头说说框架: 在框架完成数据 ...

随机推荐

对于家政020 APP平台如何走出资本寒冬？
成都亿合科技小编了解到,随着O2O烧钱大战过去,网络上流传的一份O2O项目死亡名单上显示,近年来,汽车.社区.旅游.教育等16个领域的多个O2O项目关门大吉,仅外卖餐饮O2O项目倒闭的就有十几个.只有 ...
Neither the JAVA_HOME nor the JRE_HOME environment variable is defined At least one of these environment variable is needed to run this program
开启tomcat时出现以上错误 // 进入root帐户在普通用户也可以 sudo -s //用编辑器打开.bashrc文件 gedit .bashrc 在普通用户下注意加上sudo //在最后一行添 ...
Oracle常用操作-----（二）
Oracle主要类型函数: 单行函数:只能输入一行结果,返回一个结果.常见的单行函数有: 字符函数数字函数转换函数日期函数 2.聚合函数:同时可以对多行数据进行操作,并返回一个结果.(AVG.S ...
解决Ruby在IE11中报Unable to get browser (Selenium::WebDriver::Error::NoSuchWindowError)的错误
转载地址:http://www.tuicool.com/articles/BRnqeu2 I was updating the browser WebDrivers for Seleno ...
0512 Scrum 4.0
看板设计每日例会时间定于下午放学回到宿舍,地点是在宿舍外的走廊或宿舍里,特殊情况待定: 团队开会照片任务认领: 首页设计-------王俊杰鸡汤版面-------列志华论“汤”版面------ ...
opencv的学习笔记2
继续昨晚的学习总结,昨晚看到轨迹条的创建就没有看下去了,今天继续: 1.轨迹条的创建: 轨迹条往往会和一个回调函数配合使用,当轨迹条发生改变,就调用这个轨迹条的回调函数 int createTrack ...
初识Python第二天（1）
在Python中,一切事物都是对象,对象是基于类创建的,对象继承了类的属性,方法等. 一.传递参数 1.1新建python文件,名为twoday_args.py,输出以下代码 import sys p ...
Object类型与Array类型
总结--JS中的引用类型: Object类型,Array类型,Boolean类型,Number类型,String类型,Date类型, Function类型,RegExp类型,单体内置对象(Global ...
js与jsp
jsp :j2ee 中的一样模版技术,运行于服务器端javascript :一种运行于客户端的脚本语言,动态性.JavaScript是一种采用事件驱动的脚本语言,它不需要经过Web服务器就可以对用户的 ...
Js 实现tab切换效果
今天商城系统的后台要添加一个Tab切换的效果,一开始没有思路想要自己去实践这个效果从网上找jquery 已经有了很好看的案例,实现之后我来学习下思路是如何完成的

第八章 企业项目开发--分布式缓存memcached

第八章 企业项目开发--分布式缓存memcached的更多相关文章

随机推荐

热门专题

第八章企业项目开发--分布式缓存memcached

第八章企业项目开发--分布式缓存memcached的更多相关文章