当前位置：首页 >服务端 > memcached 的配置及 spymemcached 客户端简单使用

memcached 的配置及 spymemcached 客户端简单使用

Memcached 是一个高性能的分布式内存对象缓存系统，用于动态Web应用以减轻数据库负载。同时也可以用作不同系统之间的数据共享。应用比较广泛。下面介绍一下环境的memcached环境的搭建及简单实用

1. 下载 libevent。官网下载 libevent
2. 下载 memcached。官网下载 memcached

3. 安装libevent，解压压缩包

1:  ./configure –prefix=/usr/local/libevent

2:  make

3:  make install

```
4.安装memcached。
```
```
1:  ./configure-prefix=/usr/local/memcached-with-libevent –with-libevent=/usr/local/libevent
```
```
2:  make
```
```
3:  make install
```
5. 运行
```
1:  ./memcached -u root
```
不出意外的话，服务器端的安装完毕了。
简单的Java客户端Demo。使用的是spymemcached客户端
最近上生产环境因为使用memcached差点导致宕机。由于spymemcached在发不通主机是会不断的请求连接。同时代码的写法有问题，每一次请求都新建了一个客户端。所以需要注意的是，SpyMemcachedManager 应该全局使用一个对象。减少开销。
/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package memcached;

import java.io.IOException;
import java.io.OutputStream;
import java.net.SocketAddress;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import net.spy.memcached.AddrUtil;
import net.spy.memcached.ConnectionObserver;
import net.spy.memcached.MemcachedClient;
import net.spy.memcached.transcoders.Transcoder;

/**
*
* @author yingzi.zhu
*/
public class SpyMemcachedManager {

    private List<String> servers;   // 192.168.159.129:11211
    private MemcachedClient memClient;
    public static int DEFAULT_TIMEOUT = 5;
    public static TimeUnit DEFAULT_TIMEUNIT = TimeUnit.SECONDS;

    public SpyMemcachedManager(List<String> servers) {
        this.servers = servers;
    }

    public void connect() throws IOException {
        if (memClient != null) {
            retu;
        }
        StringBuffer buf = new StringBuffer();
        for (int i = 0; i < servers.size(); i++) {
            String server = servers.get(i);
            buf.append(server).append(" ");
        }
        memClient = new MemcachedClient(AddrUtil.getAddresses(buf.toString()));
    }

    public void disConnect() {
        if (memClient == null) {
            retu;
        }
        memClient.shutdown();
    }

    public void addObserver(ConnectionObserver obs) {
        memClient.addObserver(obs);
    }

    public void removeObserver(ConnectionObserver obs) {
        memClient.removeObserver(obs);
    }


    public boolean set(String key, Object value, int expire) {
        Future<Boolean> f = memClient.set(key, expire, value);
        retu getBooleanValue(f);
    }

    public Object get(String key) {
        retu memClient.get(key);
    }

    public Object asyncGet(String key) {
        Object obj = null;
        Future<Object> f = memClient.asyncGet(key);
        try {
            obj = f.get(SpyMemcachedManager.DEFAULT_TIMEOUT,
                    SpyMemcachedManager.DEFAULT_TIMEUNIT);
        } catch (Exception e) {
            f.cancel(false);
        }
        retu obj;
    }

    public boolean add(String key, Object value, int expire) {
        Future<Boolean> f = memClient.add(key, expire, value);
        retu getBooleanValue(f);
    }

    public boolean replace(String key, Object value, int expire) {
        Future<Boolean> f = memClient.replace(key, expire, value);
        retu getBooleanValue(f);
    }

    public boolean delete(String key) {
        Future<Boolean> f = memClient.delete(key);
        retu getBooleanValue(f);
    }

    public boolean flush() {
        Future<Boolean> f = memClient.flush();
        retu getBooleanValue(f);
    }

    public Map<String, Object> getMulti(Collection<String> keys) {
        retu memClient.getBulk(keys);
    }

    public Map<String, Object> getMulti(String[] keys) {
        retu memClient.getBulk(keys);
    }

    public Map<String, Object> asyncGetMulti(Collection<String> keys) {
        Map map = null;
        Future<Map<String, Object>> f = memClient.asyncGetBulk(keys);
        try {
            map = f.get(SpyMemcachedManager.DEFAULT_TIMEOUT,
                    SpyMemcachedManager.DEFAULT_TIMEUNIT);
        } catch (Exception e) {
            f.cancel(false);
        }
        retu map;
    }

    public Map<String, Object> asyncGetMulti(String keys[]) {
        Map map = null;
        Future<Map<String, Object>> f = memClient.asyncGetBulk(keys);
        try {
            map = f.get(SpyMemcachedManager.DEFAULT_TIMEOUT,
                    SpyMemcachedManager.DEFAULT_TIMEUNIT);
        } catch (Exception e) {
            f.cancel(false);
        }
        retu map;
    }

    public long increment(String key, int by, long defaultValue, int expire) {
        retu memClient.incr(key, by, defaultValue, expire);
    }

    public long increment(String key, int by) {
        retu memClient.incr(key, by);
    }

    public long decrement(String key, int by, long defaultValue, int expire) {
        retu memClient.decr(key, by, defaultValue, expire);
    }

    public long decrement(String key, int by) {
        retu memClient.decr(key, by);
    }

    public long asyncIncrement(String key, int by) {
        Future<Long> f = memClient.asyncIncr(key, by);
        retu getLongValue(f);
    }

    public long asyncDecrement(String key, int by) {
        Future<Long> f = memClient.asyncDecr(key, by);
        retu getLongValue(f);
    }

    public void printStats() throws IOException {
        printStats(null);
    }

    public void printStats(OutputStream stream) throws IOException {
        Map<SocketAddress, Map<String, String>> statMap =
                memClient.getStats();
        if (stream == null) {
            stream = System.out;
        }
        StringBuffer buf = new StringBuffer();
        Set<SocketAddress> addrSet = statMap.keySet();
        Iterator<SocketAddress> iter = addrSet.iterator();
        while (iter.hasNext()) {
            SocketAddress addr = iter.next();
            buf.append(addr.toString() + "/n");
            Map<String, String> stat = statMap.get(addr);
            Set<String> keys = stat.keySet();
            Iterator<String> keyIter = keys.iterator();
            while (keyIter.hasNext()) {
                String key = keyIter.next();
                String value = stat.get(key);
                buf.append(" key=" + key + ";value=" + value + "/n");
            }
            buf.append("/n");
        }
        stream.write(buf.toString().getBytes());
        stream.flush();
    }

    public Transcoder getTranscoder() {
        retu memClient.getTranscoder();
    }

    private long getLongValue(Future<Long> f) {
        try {
            Long l = f.get(SpyMemcachedManager.DEFAULT_TIMEOUT,
                    SpyMemcachedManager.DEFAULT_TIMEUNIT);
            retu l.longValue();
        } catch (Exception e) {
            f.cancel(false);
        }
        retu -1;
    }

    private boolean getBooleanValue(Future<Boolean> f) {
        try {
            Boolean bool = f.get(SpyMemcachedManager.DEFAULT_TIMEOUT,
                    SpyMemcachedManager.DEFAULT_TIMEUNIT);
            retu bool.booleanValue();
        } catch (Exception e) {
            f.cancel(false);
            retu false;
        }
    }
}