今天完成的事情：

1.修改了了昨天的代码，到今天才发现 虽然连接缓存成功 可get出来的却是空值

安装 memcached Windows 客户端

Memcached 工具类

import com.danga.MemCached.MemCachedClient;
import com.danga.MemCached.SockIOPool;

import java.util.Date;

/*
 * 客户端工具类
 */
public class MemcacheManager {

    // 创建全局的唯一实例
    private static MemCachedClient memcachedClient;

    private static MemcacheManager memcachedManager = new MemcacheManager();

    static {
        // 设置缓存服务器列表，当使用分布式缓存的时，可以指定多个缓存服务器。这里应该设置为多个不同的服务
        String[] servers = {"127.0.0.1:11211"};
        // 设置服务器权重
        Integer[] weights = {3};
        // 创建一个Socked连接池实例
        SockIOPool sockIOPool = SockIOPool.getInstance();

        sockIOPool.setServers(servers);// 设置memcached服务器地址
        sockIOPool.setWeights(weights);// 设置每个MemCached服务器权重
      // sockIOPool.setFailover(true); // 当一个memcached服务器失效的时候是否去连接另一个memcached服务器.
        sockIOPool.setInitConn(10); // 初始化时对每个服务器建立的连接数目
        sockIOPool.setMinConn(10); // 每个服务器建立最小的连接数
        sockIOPool.setMaxConn(100); // 每个服务器建立最大的连接数
        sockIOPool.setMaintSleep(30);// 自查线程周期进行工作，其每次休眠时间
        sockIOPool.setNagle(false); // Socket的参数，如果是true在写数据时不缓冲，立即发送出去。Tcp的规则是在发送一个包之前，包的发送方会等待远程接收方确认已收到上一次发送过来的包；这个方法就可以关闭套接字的缓存——包准备立即发出。
        sockIOPool.setSocketTO(3000);// Socket阻塞读取数据的超时时间
        sockIOPool.setAliveCheck(true);// 设置是否检查memcached服务器是否失效
        sockIOPool.setMaxIdle(1000 * 30 * 30);// 设置最大处理时间
        sockIOPool.setSocketConnectTO(0);// 连接建立时对超时的控制
        sockIOPool.setMaintSleep(30);// 设置主线程睡眠时间，每30秒苏醒一次，维持连接池大小

        sockIOPool.initialize();// 初始化连接池
        if (memcachedClient == null) {
            memcachedClient = new MemCachedClient();
        }
        // 压缩设置，超过指定大小（单位为K）的数据都会被压缩
        //memcachedClient.setCompressEnable(true);
       // memcachedClient.setCompressThreshold(64 * 1024);
    }

//    /**
//     * 获取唯一实例.
//     *
//     * @return
//     */
    public static MemcacheManager getInstance() {
        return memcachedManager;
    }

    private MemcacheManager() {
    }

    /**
     * 向缓存添加键值对并为该键值对设定逾期时间（即多长时间后该键值对从Memcached内存缓存中删除，比如： new
     * Date(1000*10)，则表示十秒之后从Memcached内存缓存中删除）。
     * 设置过期时间：设置10分钟后过期，是应该设置date为System.currentTimeInMillis()+10*60*1000
     * 还是10*60*1000 服务端是两种方式都兼容的，一个是多少秒后过期，一个是什么时候过期， 但后者因为设置时间是在客户端，
     * 存储在服务端，假如两台服务器时间差别很大，就会导致数据的过期时间和我要求的时间点不符合。
     *
     */
    public  boolean add(String key, Object value, Date expire) {
        return memcachedClient.add(key, value, expire);
    }

    /**
     * 根据键获取Memcached内存缓存管理系统中相应的值
     */
    public static Object get(String key) {
        return memcachedClient.get(key);
    }

    public boolean replace(String key, Object value) {
        return memcachedClient.replace(key, value);
    }

    public boolean replace(String key, Object value, Date expiry) {
        return memcachedClient.replace(key, value, expiry);
    }
}

测试

import java.util.Date;

public class Test {
    public static void main(String[] args) {
        User user = new User();
        user.setUserName("lucy");
        user.setPassword("abc123");
        MemcacheManager.getInstance().add("user", user, new Date(1000 * 60));  // 向Memcached中添加一个序列化的对象
        user = (User) (MemcacheManager.get("user"));
        System.out.println("用户名：" + user.getUserName() + "，密码：" + user.getPassword());
    }
}

结果：

2.spring MVC 整合memcached  

spring 配置文件

<!--memcached配置文件-->
    <import resource="classpath:memcached.xml" />

默认配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="memCachedPool" class="com.whalin.MemCached.SockIOPool"
          factory-method="getInstance" init-method="initialize"
          lazy-init="false" destroy-method="shutDown">
        <!-- 构造函数 -->
        <constructor-arg>
            <value>memCachedPool</value>
        </constructor-arg>

        <!-- 可以设置多个memcachePool服务器 -->
        <property name="servers">
            <list>
                <value>127.0.0.1:11211</value>
            </list>
        </property>

        <!-- 每台服务器的初始连接 -->
        <property name="initConn">
            <value>10</value>
        </property>

        <!-- 每台服务器的最小连接 -->
        <property name="minConn">
            <value>5</value>
        </property>

        <!-- 每台服务器的最大连接数 -->
        <property name="maxConn">
            <value>250</value>
        </property>

        <!-- 主线程睡眠时间 -->
        <property name="maintSleep">
            <value>30</value>
        </property>

        <!-- Tcp/Socket 的参数, 如果是true在写数据时不会缓冲, 会立即发出 -->
        <property name="nagle">
            <value>false</value>
        </property>

        <!-- 连接超时/阻塞读取时间的超时时间 -->
        <property name="socketTO">
            <value>3000</value>
        </property>
    </bean>

    <bean id="memCachedClient" class="com.whalin.MemCached.MemCachedClient"
          lazy-init="false">
        <constructor-arg>
            <value>memCachedPool</value>
        </constructor-arg>
    </bean>
</beans>

工具类

package com.Xmemcached;


import com.whalin.MemCached.MemCachedClient;

import java.io.PrintWriter;
import java.io.StringWriter;
import java.util.Date;

/*
 * @description: Memcache工具类
 **/
//工具类
public class MemcacheUtils {

    private static MemCachedClient cachedClient;

    /* 实例化 MemCachedClient, */
    static {
        if (cachedClient == null) {
            System.out.println("初始化中...");
            cachedClient = new MemCachedClient("memCachedPool"); // 带名字的连接池对象
        }
    }

    // 空的构造函数
    private MemcacheUtils() {
    }

    // set方法 由于形参不同,方法重载

    /*
     * @Description: 无过期时间, 向缓存添加新的键值对,如果键已经存在,那么值将被替换
     * @Param: [key, value] 键, 值
     * @return: boolean
     */
    public static boolean set(String key, Object value) {
        return setExp(key, value, null);
    }

    /*
     * @Description: 有过期时间, 向缓存添加新的键值对,如果键已经存在,那么值将被替换
     * @Param: [key, value, expire] 键, 值, 过期时间
     * @return: boolean
     */
    public static boolean set(String key, Object value, Date expire) {
        return setExp(key, value, expire);
    }

    /*
     * @Description: set实际执行方法 向缓存添加新的键值对。如果键已经存在，则之前的值将被替换。
     * @Param: [key, value, expire] 键, 值, 过期时间
     * @return: boolean
     */
    private static boolean setExp(String key, Object value, Date expire) {
        boolean flag = false;
        try {
            flag = cachedClient.set(key, value, expire);
        } catch (Exception e) {
            MemcachedLog.writeLog("Memcached get方法报错，key值：" + key + "\r\n" + exceptionWrite(e));
        }
        return flag;
    }
    /* set end */


    /* add 重载方法*/

    /*
     * @Description: 不带过期时间 仅当缓存中不存在键时，add 命令才会向缓存中添加一个键值对。
     * @Param: [key, value] 键, 值
     * @return: boolean
     */
    public static boolean add(String key, Object value) {
        return addExp(key, value, null);
    }

    /*
     * @Description: 带过期时间 仅当缓存中不存在键时，add 命令才会向缓存中添加一个键值对。
     * @Param: [key, value, date] 键, 值, 过期时间
     * @return: boolean
     */
    public static boolean add(String key, Object value, Date date) {
        return addExp(key, value, date);
    }

    /*
     * @Description: add实际执行方法 仅当缓存中不存在键时，add 命令才会向缓存中添加一个键值对。
     * @Param: [key, value, expire] 键, 值, 过期时间
     * @return: boolean
     */
    private static boolean addExp(String key, Object value, Date expire) {
        boolean flag = false;
        try {
            flag = cachedClient.add(key, value, expire);
        } catch (Exception e) {
            MemcachedLog.writeLog("Memcached add方法报错，key值：" + key + "\r\n" + exceptionWrite(e));
        }
        return flag;
    }
    /* add end*/

    /* replace 重载 */

    /*
     * @Description: 无过期时间 仅当键已经存在时，replace 命令才会替换缓存中的键。
     * @Param: [key, value] 键, 值
     * @return: boolean
     */
    public static boolean replace(String key, Object value) {
        return replaceExp(key, value, null);
    }

    /*
     * @Description: 有过期时间 仅当键存在时, replace 命令才会替换缓存中的键
     * @Param: [key, value, expire] 键, 值, 过期时间
     * @return: boolean
     */
    public static boolean replace(String key, Object value, Date expire) {
        return replaceExp(key, value, expire);
    }

    /*
     * @Description: replace 实际执行方法, 仅当键已经存在时，replace 命令才会替换缓存中的键。
     * @Param: [key, value, expire] 键, 值, 过期时间
     */
    private static boolean replaceExp(String key, Object value, Date expire) {
        boolean flag = false;
        try {
            flag = cachedClient.replace(key, value, expire);
        } catch (Exception e) {
            MemcachedLog.writeLog("Memcached replace方法报错，key值：" + key + "\r\n" + exceptionWrite(e));
        }
        return flag;
    }
    /* replace end */

    /* get */

    /*
     * @Description: 用于检索之前添加的键值 获取其相对的值
     * @Param: [key] 键
     */
    public static Object get(String key) {
        Object object = null;
        try {
            System.out.println("get key : " + key);
            object = cachedClient.get(key);
            System.out.println("nnnn" +  object );
        } catch (Exception e) {
            MemcachedLog.writeLog("Memcached get方法报错，key值：" + key + "\r\n" + exceptionWrite(e));
        }
        return object;
    }
    /* get end*/

    /* delete */
    /*
     * @Description: 删除 memcached 中的任何现有值。
     * @Param: [key] 键
     * @Param: @SuppressWarnings("deprecation") 抑制相对于弃用的警告
     */
    // @SuppressWarnings("deprecation") 这里不使用废弃的方法
    public static boolean delete(String key){
        boolean flag = false;
        try {
            flag = cachedClient.delete(key);
        } catch (Exception e){
            MemcachedLog.writeLog("Memcached delete方法报错，key值：" + key + "\r\n" + exceptionWrite(e));
        }
        return false;
    }
    /* delete end*/

    /* flash */
    /*
     * @Description: 清理缓存中的所有键/值对
     * @Param: []
     */
    public static boolean flashAll(){
        boolean flag = false;
        try {
            flag = cachedClient.flushAll();
        } catch (Exception e){
            MemcachedLog.writeLog("Memcached flashAll方法报错\r\n" + exceptionWrite(e));
        }
        return flag;
    }
    /* flash end*/

    /*
     * @Description: 返回堆栈信息
     * @Param: [e] 异常信息
     */
    private static String exceptionWrite(Exception e) {
        StringWriter sw = new StringWriter();
        PrintWriter pw = new PrintWriter(sw);
        e.printStackTrace(pw);
        pw.flush();
        return sw.toString();
    }
}

controller

@Controller
public class MemCacheController {
    private static Logger logger = LoggerFactory.getLogger(MemCacheController.class);

    @RequestMapping("Test1")
    public String test(){
        return "Test1";
    }

    @RequestMapping(value = "/findSessionByKey", method = {RequestMethod.GET,RequestMethod.POST})
    @ResponseBody
    public Object findByKey(@RequestBody String key){
        System.out.println(" MemcacheUtils 测试: " + key );
        logger.info("MemCacheController.findByKey param:key="+key);
        if(StringUtils.isEmpty(key)){
            return "key must not be empty or null!";
        }
        return MemcacheUtils.get(key);
    }
}

想调用工具类 

明天的计划 ：完成 spring 与memcached的整合 。