linux上部署rmi+memcache服务

本文是在学习中的总结，欢迎转载但请注明出处：http://blog.csdn.net/pistolove/article/details/50020437

最近在学习linux上搭建Rmi+Memcache服务等相关技术。开始学习的过程有些艰辛，也遇到了不少的问题，但问题最后都迎刃而解。下面将学习总结分享给大家，主要包括安装linux系统，在系统上搭建服务运行环境、部署代码、启动服务器端服务、客户端运行等。详情见下方讲解（写的不是特别的详细），希望本文对你有所帮助。

A、安装linux操作系统

1、CentOS 6.6 x86_64官方正式版系统（64位）

http://www.xitongzhijia.net/linux/201412/33603.html#download

2、CentOS 6.6 i386官方正式版系统（32位）

http://www.xitongzhijia.net/linux/201501/33945.html

B、安装JDK1.7

1、下载地址

http://www.oracle.com/technetwork/java/javase/downloads/jdk-7u4-downloads-1591156.html

2、将下载的文件解压缩到/usr/local/development/jdk1.7.0_04目录。

3、创建文件/etc/profile.d/development.sh，将下面的内容复制到该文件。

exportJAVA_HOME=/usr/local/development/jdk1.7.0_04

export JRE_HOME=$JAVA_HOME/jre

exportCLASSPATH=.:$JAVA_HOME/lib:$JRE_HOME/lib:$CLASSPATH

exportPATH=$JAVA_HOME/bin:$JRE_HOME/bin:$PATH

4、重启电脑，使用命令java-version检查JDK是否安装成功。

C、安装memcache、libevent

(1)检查libevent：

首先检查系统中是否安装了libevent

Shell代码

rpm -qa|grep libevent

如果安装了则查看libevent的安装路径，后续安装时需要用到

Shell代码

rpm -ql libevent

如果没有安装，则先安装libevent

(2)安装libevent：

1.首先下载libevent安装包

Shell代码

wget http://www.monkey.org/~provos/libevent-1.4.12-stable.tar.gz

2.解压缩安装包

Shell代码

tar zxvf libevent-1.4.12-stable.tar.gz -C /usr/local/

3.进入解压后的目录

Shell代码

cd libevent-1.4.12-stable/

4.配置编译、安装

Shell代码

./configure -prefix=/usr/libevent

make

make install

(3)安装memcached：

1.首先是下载memcached的安装包

Shell代码

wget http://memcached.googlecode.com/files/memcached-1.4.15.tar.gz

2.修改安装包的执行操作权限

Shell代码

chmod 777 memcached-1.4.15.tar.gz

3.解压安装包到指定目录

Shell代码

tar zxvf memcached-1.4.15.tar.gz -C /usr/local

4.进入解压后的目录

Shell代码

cd /usr/local/memcached-1.4.15/

5.配置、编译、安装

注：configure时需要指定libevent的安装路径

Shell代码

./configure -with-libevent=/usr/libevent/ -prefix=/usr/local/memcached

make

make install

6.安装成功后启动一下看安装是否成功

Shell代码

/usr/local/memcached/bin/memcached -d -m 2048 -p 11211 -u root

启动参数介绍如下：

-d选项是启动一个守护进程，

-m是分配给Memcache使用的内存数量，单位是MB，这里是10MB，

-u是运行Memcache的用户，这里是root，

-l是监听的服务器IP地址，如果有多个地址的话，这里指定了服务器的IP地址192.168.0.200，

-p是设置Memcache监听的端口，这里设置了12000，最好是1024以上的端口，

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

-P是设置保存Memcache的pid文件，我这里是保存在/tmp/memcached.pid，也可以启动多个守护进程，不过端口不能重复。

D、部署

1、下载winscp

http://rj.baidu.com/soft/detail/15150.html?ald

2、将本地代码打包成jar文件，连接服务器，通过scp将源码对应的jar文件和源码依赖的jar文件传输到服务器中，创建lib文件夹，将jar文件放入lib中；在同一目录创建bin文件夹，并在当前文件夹中创建startup.sh和stop.sh 等配置文件。startup.sh如下所示：

<span style="font-size:18px;"><span style="font-size:18px;">#!/bin/sh
root_path=$(cd "$(dirname "${0}")"; cd ..; pwd)
 -cp ${root_path}/lib/*:${root_path}/bin/ com.letv.main.Main >> ${root_path}/nohup.out 2>&1 &</span></span>

3、运行startup.sh，查看nohup.out，观察服务是否正常启动服务。也可通过ps -ef | grep java查看进程是否存在。如果进程启动成功，则成功创建RMI服务。

4、启动memcache服务，即可通过memcache存取数据。

5、此时，通过客户端调用远程服务，可对数据进行CRUD操作。

E、注意

1、在运行客户端程序时，可能报错：

java.rmi.ConnectException: Connection refused to host: 192.168.134.128; nested exception is:

java.net.ConnectException: Connection refused: connect

此时，要关闭linux服务器的防火墙。

service iptablesstatus 可以查看到iptables服务的当前状态。

启动和关闭防火墙的命令：

(1) 重启后生效

开启： chkconfig iptables on

关闭： chkconfig iptables off

(2) 即时生效，重启后失效

开启： service iptables start

关闭： service iptables stop

2、在执行start.sh文件启动服务时，可能会提示：

-bash: ./bin/start.sh: Permission denied

解决方法：在shell下执行：chmod a+x *.sh，例如执行chmod a+x start.sh即可。

3、在执行start.sh文件启动服务时，可能会提示：

nohup: redirecting stderr to stdout

解决方法：在start.sh中将“&” 改成 “2>&1 &”

F、服务器端

<span style="font-size:18px;"><span style="font-size:18px;">public class Main {
	public static void main(String[] args) {
		try {
			LocateRegistry.createRegistry(1099);
			RemoteInterface remote = new RemoteInterfaceImpl();
			Naming.rebind("RMI", remote);
		} catch (RemoteException e) {
			e.printStackTrace();
		} catch (MalformedURLException e) {
			e.printStackTrace();
		}
	}
}</span></span>

远程接口

<span style="font-size:18px;"><span style="font-size:18px;">public interface RemoteInterface extends Remote {

	public String get(String key) throws RemoteException;

	public void delete(String key) throws RemoteException;

	public int set(String key, Object obj) throws RemoteException;

}</span></span>

远程接口实现

<span style="font-size:18px;"><span style="font-size:18px;">public class RemoteInterfaceImpl extends UnicastRemoteObject implements RemoteInterface{
	private static final long serialVersionUID = -1808687292095223102L;
	private static final MemcacheInterface memcached = new MemcacheInterfaceImpl();

	public RemoteInterfaceImpl() throws RemoteException {
		super();
	}

	@Override
	public String get(String key) {
		return memcached.get(key);
	}

	@Override
	public void delete(String key) {
		memcached.delete(key);
	}

	@Override
	public int set(String key, Object obj) {
		return memcached.set(key, obj);
	}
}</span></span>

memcache持久化缓存实现

<span style="font-size:18px;"><span style="font-size:18px;">public interface MemcacheInterface {

	public String get(String key);

	public void delete(String key);

	public int set(String key, Object obj);
}</span></span>

<span style="font-size:18px;"><span style="font-size:18px;">public class MemcacheInterfaceImpl implements MemcacheInterface {

	protected MemcachedClientBuilder builder = new XMemcachedClientBuilder(
			AddrUtil.getAddresses("127.0.0.1:11211"));

	protected MemcachedClient client;

	public MemcacheInterfaceImpl() {
		builder.setSocketOption(StandardSocketOption.SO_RCVBUF, 12 * 1024);
		builder.setSocketOption(StandardSocketOption.SO_SNDBUF, 6 * 1024);
		builder.setConnectionPoolSize(2);
		builder.getConfiguration().setStatisticsServer(false);

		try {
			client = builder.build();
			client.setOptimizeMergeBuffer(false);
			client.setEnableHeartBeat(false);
			client.setOpTimeout(3000);
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	@Override
	public String get(String key) {
		if (key != null) {
			try {
				return client.get(key);
			} catch (TimeoutException e) {
				e.printStackTrace();
			} catch (InterruptedException e) {
				e.printStackTrace();
			} catch (MemcachedException e) {
				e.printStackTrace();
			}
		}
		return null;
	}

	@Override
	public void delete(String key) {
		if (key != null) {
			try {
				client.delete(key);
			} catch (TimeoutException e) {
				e.printStackTrace();
			} catch (InterruptedException e) {
				e.printStackTrace();
			} catch (MemcachedException e) {
				e.printStackTrace();
			}
		}
	}

	@Override
	public int set(String key, Object obj) {
		if (key != null) {
			try {
				client.set(key, 0, obj);
				return 0;
			} catch (Exception e) {
				e.printStackTrace();
				return 1;
			}
		}
		return 1;
	}

}</span></span>

G、客户端

<span style="font-size:18px;"><span style="font-size:18px;">public class Client {
	public static void main(String[] args) {
		try {
			// 注册服务
			Registry registry = LocateRegistry.getRegistry("192.168.242.128", 1099);
			RemoteInterface rmiService = (RemoteInterface) registry.lookup("RMI");

			// set
			rmiService.set("good", "good day");

			// get
			System.err.println("获取：" + rmiService.get("good"));

			// delete
			rmiService.delete("good");

			// set
			rmiService.set("Monday", "1000");
			System.err.println(rmiService.get("Monday"));
		} catch (RemoteException e) {
			e.printStackTrace();
		} catch (NotBoundException e) {
			e.printStackTrace();
		}
	}
}</span></span>