java 连接memcached,MemCached的安装和JAVA客户端连接Memcached示例代码

一：下载安装Memcached的依赖libevent

1：下载memcached的依赖  http://libevent.org/

下载后的文件为：《libevent-2.0.22-stable.tar.gz》

2：把libevent文件放到自己将要安装的主机对应文件夹下面

3：解压libevent文件

tar -xvf libevent-2.0.22-stable.tar.gz

4：安装libevent

./configure -prefix=/usr

make && make install

5：验证安装是否成功

ls -al /usr/lib | grep libevent-

正确的安装结果截图如下：

二：下载安装Memcached

1：官网下载压缩包文件：http://memcached.org/downloads

下载后的文件为：《memcached-1.4.25.tar.gz》

2：把memcached文件放到自己将要安装的主机对应文件夹下面

3：解压memcached文件tar -xvf memcached-1.4.25.tar.gz

PS：官网示例是tar -zxvf memcached-1.x.x.tar.gz，其实参数是不用的

4：安装memcached

./configure --with-libevent=/usr --enable-64bit --enable-threads

注意：默认memcached单个进程只支持到2G内存，需要更大内存支持的话，需要打开64位支持，编译的时候加参数：--enable-64bit

make && make install

5：验证安装是否成功

ls –al /usr/local/bin/memcached

正确的安装结果截图如下：

三：各种配置

1：创建启动用户memcached：

groupadd memcached

useradd -g memcached memcached

2：创建PID进程目录：

cd /var/run

mkdir memcached

chown –R memcached.memcached memcached

四：服务的启动和关闭(这一步完成就可以用Java客户端连接Memcached了)

1：启动memcached(su用户memcached，之前安装都是用的root，不然会报错，第二次重新进入就可以用root启动了，也可以用守护进程运行了)：

/usr/local/bin/memcached -d -m 128 -u root -p 11211 -c 256 -P /var/run/memcached/memcached.pid

参数解释说明： (默认端口11211)

-d 以守护程序(daemon)方式运行 memcached；

-m 设置 memcached 可以使用的内存大小，单位为 M；

-u 指定用户，如果当前为 root 的话，需要使用此参数指定用户。

-l 设置监听的 IP 地址，如果是本机的话，通常可以不设置此参数；

-p 设置监听的端口，默认为 11211，所以也可以不设置此参数；

-h 帮助

-c 选项是最大运行的并发连接数，默认是1024，按照你服务器的负载量来设定

-P 是设置保存Memcache的pid文件

2：查看是否启动成功：

ps -ef | grep memcached

看到类似如下截图，说明memecached启动成功

3：关闭memcached服务

kill `cat /var/run/memcached/memcached.pid`

4：查看是否关闭成功

ps -ef | grep memcached

五：配置以服务方式启动memcached：

1：生成启动和关闭脚本：

cp /tmp/memcached-1.4.25/scripts/memcached.sysv /etc/init.d/memcached

2：修改启动帐号：

chown memcached.memcached /etc/init.d/memcached

3：赋予执行权限：

chmod 755 /etc/init.d/memcached

4：修改/etc/init.d/memcached配置参数值：

PORT=11211

USER=memcached

MAXCONN=1024

CACHESIZE=128

OPTIONS=””

chown $USER /usr/local/bin/memcached

/usr/local/bin/memcached –d –p $PORT –u $USER –m $CACHESIZE –c $MAXCONN –P /var/run/memcached/memcached.pid $OPTIONS

5：加入系统服务，并启动memcached服务，同时查看是否启动成功：

chkconfig –add memcached

chkconfig –level 235 memcached on

chkconfig –list memcached

6：启动memcached服务，并检查memcached是否启动，并关闭memcached：

service memcached start

ps –ef | grep memcached

service memcached stop

六：配置防火墙策略

通过telnet ip port来测试外部服务器对memcached是否可以访问，如果不能访问，添加防火墙策略：

iptables –I INPUT –p tcp –dport 11211 –j ACCEPT;  iptables –I OUTPUT –p tcp –sport 11211 –j ACCEPT;

iptables-save

service iptables save;

再次测试端口是否可访问。

七：JAVA客户端连接上面的memcached服务，并缓存资源 取资源

先编写一个操作缓存的接口，用于操作规范

package com.cloud.shop.core.cache;

/**

* @dese 缓存客户端接口类

* @author cheng.yun

* @version 2016年5月9日 下午8:56:25

*/

public interface CacheClient {

/**

* 设置cache

* @param key

* @param expireInSeconds 缓存时间

* @param o缓存对象

*/

public void set(String key, int expireInSeconds, Object o);

/**

* 根据Key 获得Key对应的value

* @param key

* @param classz 需要返回的object类型

* @return

*/

public T get(String key, Class classz);

/**

* 根据key，删除缓存的值

* @param key

*/

public void delete(String key);

}再编写实现Memcached缓存的实现类(后面也可以写Redis实现类)

import java.io.IOException;

import java.net.InetSocketAddress;

import java.util.ArrayList;

import java.util.List;

import java.util.concurrent.TimeUnit;

import javax.annotation.PostConstruct;

import org.apache.log4j.Logger;

import org.springframework.beans.factory.annotation.Value;

import org.springframework.stereotype.Component;

import com.alibaba.fastjson.JSON;

import com.cloud.shop.core.cache.CacheClient;

import net.spy.memcached.ConnectionFactoryBuilder;

import net.spy.memcached.MemcachedClient;

/**

* @dese memcached缓存客户端持有者，交于Spring实例化

* @author cheng.yun

* @version 2016年5月9日 下午8:27:53

*/

@Component

public class MemcachedClientHolder implements CacheClient{

private static final Logger logger =Logger.getLogger(MemcachedClientHolder.class);

//memecached超时时间 150 毫秒

private static final long MEMCACHED_OP_TIMEOUT = 150;

//Maximum number + 2 of timeout exception for shutdown connection.

private static final int DEFAULT_MAX_TIMEOUTEXCEPTION_THRESHOLD = 998;

@Value("${cache.servers.memcached.address:null}")

//从Spring管理的属性配置文件中取属性

private String memcachedServiceAddress ;

@Value("${cache.servers.memcached.expire:1800}")

//从Spring管理的属性配置文件中取属性

private String memcachedServiceExpire ;

private final ConnectionFactoryBuilder connectionFactoryBuilder = new ConnectionFactoryBuilder();

private MemcachedClient memcachedClient ;

@PostConstruct

public void initCache(){

String[] host_port=memcachedServiceAddress.split(":");

InetSocketAddress cacheAddress = new InetSocketAddress(host_port[0], Integer.parseInt(host_port[1]));

connectionFactoryBuilder.setOpTimeout(MEMCACHED_OP_TIMEOUT);

connectionFactoryBuilder.setTimeoutExceptionThreshold(DEFAULT_MAX_TIMEOUTEXCEPTION_THRESHOLD);

List addressList=new ArrayList();

addressList.add(cacheAddress);

try {

memcachedClient=new MemcachedClient(connectionFactoryBuilder.build(), addressList);

logger.info("Init MemcachedClient success");

} catch (IOException e) {

logger.info("Init MemcachedClient error"+e.getMessage());

}

}

@Override

public void set(String key, int expireInSeconds, Object o) {

try {

memcachedClient.set(key, expireInSeconds, JSON.toJSONString(0,SerializerFeature.WriteClassName));

} catch (Exception e) {

logger.info("set memcached value exception"+e.getMessage());

}

}

@Override

public T get(String key, Class classz) {

T t = null ;

try {

Object object = memcachedClient.get(key);

if(null != object){

t = JSON.parseObject((String) object, classz) ;

}

} catch (Exception e) {

logger.info("get memcached value exception"+e.getMessage());

}

return t ;

}

@Override

public void delete(String key) {

try {

memcachedClient.delete(key);

} catch (Exception e) {

logger.info("delete memcached value exception"+e.getMessage());

}

}

}Spring管理的属性文件

# ********************  memcached servers(缓存IP:端口   默认缓存时间)  ********************

cache.servers.memcached.address=111.111.111.111:11211

cache.servers.memcached.expire=1800