第八章 企業項目開發--分布式緩存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