大型分布式缓存Memcached的使用

一、Memcached介绍

Memcached是danga.com开发的分布式内存对象缓存系统，所谓分布式，意味着它不是本地的，而是基于网络连接完成服务。Memcached把一些数据通过key=value数据存储到内存中，这样访问更加方便快捷。但是随之而来的问题是如果Memcached关闭或者Memcached的服务器关闭那么所保存的内容也就没有了。

二、安装Memcached服务端

我是在Win下做的实验。

      首先下载Win下的Memcached，解压到指定目录。

        memcached.exe -d install 安装memcached服务

       然后通过Memcached  start  memcached就启动了。

       常用命令：

          -p 监听的端口 
           -l 连接的IP地址, 默认是本机 
           -d start 启动memcached服务 
           -d restart 重起memcached服务 
           -d stop|shutdown 关闭正在运行的memcached服务 
           -d install 安装memcached服务 
           -d uninstall 卸载memcached服务 
           -u 以的身份运行 (仅在以root运行的时候有效) 
           -m 最大内存使用，单位MB。默认64MB 
           -M 内存耗尽时返回错误，而不是删除项 
           -c 最大同时连接数，默认是1024 
           -f 块大小增长因子，默认是1.25 
           -n 最小分配空间，key+value+flags默认是48 
           -h 显示帮助 

三、java下使用Memcached（java客户端程序）

目前常用客户端有三种，我使用的是java_memcached-release_2.6.6，该系列是最早推出也应用最为广泛的客户端。

所需全部的jar：commons-pool-1.5.6.jar、
java_memcached-release_2.6.6.jar、
slf4j-api-1.6.1.jar、
slf4j-simple-1.6.1.jar

其他次要依赖自行添加（可以不要）。

<dependency>
<groupId>net.spy</groupId>
<artifactId>spymemcached</artifactId>
<version>2.12.2</version>
</dependency>

1、基本使用：

  @Test
    public  void show(){
        MemCachedClient client=new MemCachedClient();
        //使用的服务器，由于是在本地测试，只有一个服务器地址。默认端口是11211
        //格式为 服务器IP:端口号
        String [] addr={"127.0.0.1:11211"};
        /**
         * 设置权重，与设定的服务器一一对应
         */
        Integer[] weight={3};

        //建立通信的连接池
        SockIOPool pool=SockIOPool.getInstance();
        //设置连接池可用cache服务器列表，服务器构成形式：ip地址+端口号
        pool.setServers(addr);
        //设置连接池可用cache服务器的权重，和server数组的位置一一对应
        pool.setWeights(weight);


        //设置初始连接数
        pool.setInitConn(5);
        //设置最小连接数
        pool.setMinConn(5);
        //设置最大连接数
        pool.setMaxConn(200);
        //设置可用连接的最长等待时间
        pool.setMaxIdle(1000*30*30);
        //设置连接池维护线程的睡眠时间，设置为0，维护线程不启动
        pool.setMaintSleep(30);
        //设置Nagle算法，设置为false，因为通讯数据量比较大要求相应及时
        pool.setNagle(false);
        //设置socket读取等待超时时间
        pool.setSocketTO(30);
        //设置连接等待超时值
        pool.setSocketConnectTO(0);
        //设置完参数后，启动pool
        pool.initialize();

        client.set("value","Ok");
        String value= (String) client.get("value");

         //设置定时时间2s后消失
        client.set("value1","OK2",new Date(2000));
        String value2= (String) client.get("value1");
        System.out.println(value);
        System.out.println(value2);
    }

2、spring整合memcached （applicationContext.xml）

  <bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
        <property name="locations">
            <list>
                <value>classpath:property/memcached.properties</value>
            </list>
        </property>
    </bean>
    <!--spring整合memched-->
    <bean id="memcachedPool" class="com.danga.MemCached.SockIOPool" factory-method="getInstance"
          init-method="initialize"   destroy-method="shutDown">
        <property name="servers">
            <list>
                <value>${memcached.server}</value>
            </list>
        </property>

        <property name="maxConn" value="${memcached.maxConn}"></property>
        <property name="maintSleep" value="${memcached.maniSleep}"></property>
        <property name="nagle" value="${memcached.nagle}"></property>
        <property name="socketTO" value="${memcached.socketTO}"></property>
    </bean>

memcached.properties配置文件：

#服务器地址
memcached.server=127.0.0.1:11211
#初始连接数目
memcached.initConn=20
#每个服务器建立最大连接数
memcached.maxConn=50
#自查线程周期工作，其每次休眠时间
memcached.maniSleep=3000
#是否使用nagle算法（Socket参数，如果是true，写数据不缓冲，直接发送）
memcached.nagle=false
#Socket阻塞读取数据的超时时间
memcached.socketTO=3000

测试：

@RunWith(SpringJUnit4ClassRunner.class)//表示整合JUnit进行测试
@ContextConfiguration(locations ={"classpath:applicationContext.xml"})
public class SpringTest {

    @Test
    public void test1(){
        MemCachedClient memCachedClient=new MemCachedClient();
        memCachedClient.set("username","luck");
        String value= (String) memCachedClient.get("username");
        System.out.println(value);
    }
}

更简单的用法：
1.引依赖
2.在application.yml中配置memcached的IP和端口号

memcached:
    ip: 127.0.0.1
    port: 11211

3、测试功能

import org.springframework.beans.factory.annotation.Value;
import java.util.concurrent.Future;
import net.spy.memcached.MemcachedClient;
import java.io.IOException;


	// 使用注解调用配置文件中的配置
	@Value("${memcached.ip}")
    private String ip;
    @Value("${memcached.port}")
    private int port;
 
    /**
     * 测试Memcached
     * @throws IOException
     */
    public void testMemcached() throws IOException {
       
        try {
       
            // 连接本地的 Memcached 服务
       		MemcachedClient mcc = new MemcachedClient(new InetSocketAddress(ip,port));
           
           	// 添加数据
           	Future fo = mcc.set("test", 0, "Memcached添加测试");

           	// 测试是否添加成功
			System.err.println(mcc.get("test"));
			
           	// 关闭连接
           	mcc.shutdown();

        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
    }

4.结果

成功存了缓存数据，并把缓存数据取出来了。