memcached

一、启动参数

-p <num>      设置TCP端口号(默认不设置为: 11211)

-U <num>      UDP监听端口(默认: 11211, 0 时关闭) 

-l <ip_addr>  绑定地址(默认:所有都允许,无论内外网或者本机更换IP，有安全隐患，若设置为127.0.0.1就只能本机访问)

-d                    以daemon方式运行

-u <username> 绑定使用指定用于运行进程<username>

-m <num>      允许最大内存用量，单位M (默认: 64 MB)

-P <file>     将PID写入文件<file>，这样可以使得后边进行快速进程终止, 需要与-d 一起使用

启动例子：/usr/local/memcached/bin/memcached -d -m 512 -u www -l 192.168.20.100 -p 11211 -c 512 -P /usr/local/memcached/memcached.pid

二、常用命令

<command name> <key> <flag> <expire> <bytes>

<data block>

说明:

command name：如，set/add/replace

key：缓存的key

flag：客户机使用它存储关于键值对的额外信息

expire：缓存过期时间 单位为秒 0 表示永远存储

bytes：缓存值的字节数

data block：数据块

例子：

首先telnet 127.0.0.1 11211 连上memcached

set myKey 0 0 6

myValu

STORED

get myKey

VALUE myKey 0 5

myValu

STORED

 delete myKey

DELETED

三、java使用memcached

1.

Socket socket = null;
        OutputStreamWriter outputStreamWriter = null;
        BufferedReader bufferedReader = null;
        try {
            socket = new Socket("127.0.0.1", 11211);
            outputStreamWriter = new OutputStreamWriter(socket.getOutputStream()); 
            
            String command = "get firstKey\r\n";
            /*String command = "set firstKey 0 0 6\r\n";
            outputStreamWriter.write(command);
            command = "second\r\n";*/
            //command = "delete firstKey\r\n";
            outputStreamWriter.write(command);
            outputStreamWriter.flush();
            
            bufferedReader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            String line = null;
            StringBuilder sb = new StringBuilder();
            while((line = bufferedReader.readLine()) != null){
                sb.append(line).append("\r\n");
                if(line.equals("END")) break;
                if(line.equals("STORED")) break;
                if(line.equals("NOT_STORED")) break;
                if(line.equals("DELETED")) break;
                if(line.equals("EXISTS")) break;
                if(line.equals("ERROR")) break;
            }
            
            System.out.println(sb.toString());
        } catch (IOException e) {
            e.printStackTrace();
        } finally{
            try {
                if(outputStreamWriter != null){
                    outputStreamWriter.close();
                }
                if(bufferedReader != null){
                    bufferedReader.close();
                }
                if(socket != null && socket.isConnected()){
                    socket.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

2、使用java连接memcached的客户端

需要jar包：

commons-pool-1.6.jar

java_memcached-release_2.6.6.jar

slf4j-api-1.6.1.jar

slf4j-simple-1.6.1.jar

public class MemCachedServer {
    
    private static MemCachedClient memCachedClient;
    
    private static SockIOPool sockIOPool;
    
    private static MemCachedServer instance = new MemCachedServer();
    
    private MemCachedServer(){}
    
    public static MemCachedServer getInstance(){
        return instance;
    }
    
    public void init(){
        sockIOPool = SockIOPool.getInstance();
        
        String[] servers = {"127.0.0.1:11211"};
        sockIOPool.setServers(servers);
        //设置每个MemCached服务器的权重
        Integer[] weights = {3};
        sockIOPool.setWeights(weights);
        //当一个memcached服务器失效的时候是否去连接另一个memcached服务器
        sockIOPool.setFailover(true);
        sockIOPool.setInitConn(3);
        sockIOPool.setMinConn(3);
        sockIOPool.setMaxConn(5);
        //自查线程周期进行工作，其每次休眠时间
        sockIOPool.setMaintSleep(30);
        //socket的参数，true:写数据不缓存，立即发送出去
        sockIOPool.setNagle(false);
        //socket阻塞数据的超时时间
        sockIOPool.setSocketTO(3000);
        //设置是否检查memcached的服务器是否失效
        sockIOPool.setAliveCheck(true);
        //设置最大的处理时间
        sockIOPool.setMaxIdle(1000 * 30 * 30);
        sockIOPool.setSocketConnectTO(0);
        
        sockIOPool.initialize();

        if(memCachedClient == null){
            memCachedClient = new MemCachedClient();
        }
    }
    
    public void destroy(){
        if(sockIOPool != null){
            sockIOPool.shutDown();
        }
    }
    
    public MemCachedClient getMemCachedClient(){
        return memCachedClient;
    }
    
}

public class MemcachedTest {
    
    public static void main(String[] args){
        
        MemCachedServer server = MemCachedServer.getInstance();
        server.init();
        MemCachedClient client = server.getMemCachedClient();
        
        //client.set("firstKey", "firstValue", new Date(1000 * 1));
        
        //client.delete("firstKey");
        
        System.out.println(client.get("firstKey"));
        
        server.destroy();
    }

}

...