memcached的简单安装与使用

memcached的安装与使用：
步骤：
1.安装memcached服务端
下载一个window版本的memcached,解压到硬盘：
下载地址：http://pan.baidu.com/s/1skKhljZ

进入到安装目录下执行：
> memcached.exe -d install 安装memcached成为服务，
>memcached.exe -l 127.0.0.1 -m 32 -d start，监听本机端口运行，分配32M内存

安装服务后，也可以通过手动启动memcache服务，都是可以的。

测试缓存服务器是否可用：
>telnet 127.0.0.1 11211,
memcached端口如果没有设置，默认为11211
常用参数介绍
在安装时可设置如下参数：
-p 设置端口号(默认为11211)
-l 绑定地址(默认:所有网络都允许,设置为127.0.0.1就只能本机访问)
-d start 启动memcached服务
-d restart 重新启动memcached服务
-d stop|shutdown 关闭正在运行的memcached服务
-d install 安装memcached服务
-d uninstall 卸载memcached服务
-c 最大同时连接数，默认是1024
-m 允许最大内存用量，单位M
比如：>memcached -d install -l 127.0.0.1 -m 512 -c 512 表示安装memcached服务，并监听本机端口运行，最多内存使用量512M,最多连接数512个
2.下载客户端
我下载的版本是java_memcached-release_2.0.1.jar
下载地址：http://pan.baidu.com/s/1kV6w3p9
3.使用

新建java工程，引入java_memcached-release_2.0.1.jar包，还需要引入log4j的jar包

代码：

import java.util.Date;
import com.danga.MemCached.MemCachedClient;
import com.danga.MemCached.SockIOPool;
public class MemcachedUtil {
    private static MemCachedClient mc = new MemCachedClient();
    static {
        // 获取连接池的实例
        SockIOPool pool = SockIOPool.getInstance();
        // 服务器列表及其权重
        String[] servers = { "127.0.0.1:11211" };
        Integer[] weights = { 3 };
        // 设置服务器信息
        pool.setServers(servers);
        pool.setWeights(weights);
        // 设置初始连接数、最小连接数、最大连接数、最大处理时间
        pool.setInitConn(10);
        pool.setMinConn(10);
        pool.setMaxConn(1000);
        pool.setMaxIdle(1000 * 60 * 60);
        // 设置连接池守护线程的睡眠时间
        pool.setMaintSleep(60);
        // 设置TCP参数，连接超时
        pool.setNagle(false);
        pool.setSocketTO(60);
        pool.setSocketConnectTO(0);
        // 初始化并启动连接池
        pool.initialize();

        // 压缩设置，超过指定大小的都压缩
        // cachedClient.setCompressEnable(true);
        // cachedClient.setCompressThreshold(1024*1024);

        mc.setPrimitiveAsString(true);// 设置序列化

    }
    /** * 私有化构造函数 */
    private MemcachedUtil() {
    }

    /*** * 功能描述:新增一个缓存数据，如果key存在不会新增 * @param 缓存的key * @param 缓存的值 * @return 操作结果 */
    public static boolean add(String key, Object value) {
        return mc.add(key, value);
    }

    /** * 功能描述:新增一个缓存数据，设置过期时间 * @param 缓存的key * @param 缓存的值 * @param 缓存时间,过期时间 New Date(1000*10)：十秒后过期 * @return 操作结果 */
    public static boolean add(String key, Object value, Date expire) {
        return mc.add(key, value, expire);
    }

    /** * 功能描述:新增一个缓存数据，如果存在key，则更新该key的值 * @param 缓存的key * @param 缓存的值 * @return 操作结果 */
    public static boolean set(String key, Object value) {
        return mc.set(key, value);
    }

    /** * 功能描述:新增一个缓存数据，如果存在key，则更新该key的值 * @param 缓存的key * @param 缓存的值 * @param 缓存时间,过期时间 New Date(1000*10)：十秒后过期 * @return 操作结果 */
    public static boolean set(String key, Object value, Date expire) {
        return mc.set(key, value, expire);
    }

    /** * 功能描述:替换一个缓存数据，如果存在key则替换，否则返回false * @param key * @param value * @return 操作结果 */
    public static boolean replace(String key, Object value) {
        return mc.replace(key, value);
    }

    /** * 功能描述:替换一个缓存数据，如果存在key则替换，否则返回false * @param key * @param value * @param 缓存时间 * @return 操作结果 */
    public static boolean replace(String key, Object value, Date expire) {
        return mc.replace(key, value, expire);
    }

    /** * 功能描述:根据key得到一个缓存数据 * @param key * @return 操作结果 */
    public static Object get(String key) {
        return mc.get(key);
    }

    /** * 功能描述:刷新全部缓存(就是将所有缓存设置为过期，以后放入的会覆盖掉这些过期的缓存数据) * * @return 操作结果 */
    public static boolean flushAll() {
        return mc.flushAll();
    }

    /*** * 功能描述:根据key删除一个缓存数据 * @return 操作结果 */
    public static boolean delete(String key){
        return mc.delete(key);
    }


}

import java.util.Date;
public class TestMemcached {
   public static void main(String[] args) throws InterruptedException {
      /*测试存数据set方法，并测试过期*/
      MemcachedUtil.set("test1", "test1_value",new Date(10000));
      System.out.println("有效期内取数据："+MemcachedUtil.get("test1"));
      //线程休息11秒后，去取数据,此时已经过期
      Thread.sleep(11000);
      System.out.println("过期后取数据："+MemcachedUtil.get("test1"));

      /*测试删除数据*/
      MemcachedUtil.set("test2", "test2_value");
      System.out.println("取key为test2的数据："+MemcachedUtil.get("test2"));
      boolean isDelete=MemcachedUtil.delete("test2");
      System.out.println("是否删除成功："+isDelete+",取取key为test2的数据"+MemcachedUtil.get("test2"));


      /*测试add是否会覆盖*/ 
      MemcachedUtil.add("test3", "test3_value");
      System.out.println("取key为test3的数据："+MemcachedUtil.get("test3"));
      boolean isAdd= MemcachedUtil.add("test3", "test3_value_copy");
      System.out.println("是否更新成功："+isAdd+",取取key为test3的数据"+MemcachedUtil.get("test3"));

      /*测试add是否会覆盖*/ 
      MemcachedUtil.set("test4", "test4_value");
      System.out.println("取key为test4的数据："+MemcachedUtil.get("test4"));
      boolean isSet= MemcachedUtil.set("test4", "test4_value_copy");
      System.out.println("是否更新成功："+isSet+",取取key为test4的数据"+MemcachedUtil.get("test4"));

}
} 

实验结果：