java rmi 介绍和实例

1、RMI概述

RMI（Remote Method Invocation）
RMI是分布式对象软件包，它简化了在多台计算机上的JAVA应用之间的通信。
必须在jdk1.1以上
RMI用到的类
java.rmi.Remote
所有可以被远程调用的对象都必须实现该接口
java.rmi.server.UnicastRemoteObject
所有可以被远程调用的对象都必须扩展该类

什么是RMI

远程方法调用是一种计算机之间对象互相调用对方函数，启动对方进程的一种机制，
使用这种机制，某一台计算机上的对象在调用另外一台计算机上的方法时，使用的程
序语法规则和在本地机上对象间的方法调用的语法规则一样。


优点

这种机制给分布计算的系统设计、编程都带来了极大的方便。
只要按照RMI规则设计程序，可以不必再过问在RMI之下的网络细节了，如：TCP和Socket等等。
任意两台计算机之间的通讯完全由RMI负责。调用远程计算机上的对象就像本地对象一样方便。

1、面向对象：

RMI可将完整的对象作为参数和返回值进行传递，而不仅仅是预定义的数据类型。
也就是说，可以将类似Java哈西表这样的复杂类型作为一个参数进行传递。

2、可移动属性：

RMI可将属性从客户机移动到服务器，或者从服务器移动到客户机。

3、设计方式：

对象传递功能使您可以在分布式计算中充分利用面向对象技术的强大功能，如二层和三层结构系统。
如果用户能够传递属性，那么就可以在自己的解决方案中使用面向对象的设计方式。
所有面向对象的设计方式无不依靠不同的属性来发挥功能，如果不能传递完整的对象——包括实现和类型
——就会失去设计方式上所提供的优点。

4、安全性：

RMI使用Java内置的安全机制保证下载执行程序时用户系统的安全。
RMI使用专门为保护系统免遭恶意小程序侵害而设计的安全管理程序。

5、便于编写和使用

RMI使得Java远程服务程序和访问这些服务程序的Java客户程序的编写工作变得轻松、简单。
远程接口实际上就是Java接口。
为了实现RMI的功能必须创建远程对象任何可以被远程调用的对象必须实现远程接口。但远程
接口本身并不包含任何方法。因而需要创建一个新的接口来扩展远程接口。
新接口将包含所有可以远程调用的方法。远程对象必须实现这个新接口，由于新的接口扩展了
远程接口，实现了新接口，就满足了远程对象对实现远程接口的要求，所实现的每个对象都将
作为远程对象引用。

---

RMI一步一步来
         RMI，远程方法调用（Remote Method Invocation）是Enterprise JavaBeans的支柱，是建立分布式Java应用程序的方便途径。RMI是非常容易使用的，但是它非常的强大。

         RMI的基础是接口，RMI构架基于一个重要的原理：定义接口和定义接口的具体实现是分开的。下面我们通过具体的例子，建立一个简单的远程计算服务和使用它的客户程序

一个正常工作的RMI系统由下面几个部分组成： 
        远程服务的接口定义
        远程服务接口的具体实现
        桩（Stub）和框架（Skeleton）文件 
        一个运行远程服务的服务器 
        一个RMI命名服务，它允许客户端去发现这个远程服务
        类文件的提供者（一个HTTP或者FTP服务器）
        一个需要这个远程服务的客户端程序

 

下面我们一步一步建立一个简单的RMI系统。首先在你的机器里建立一个新的文件夹，以便放置我们创建的文件，为了简单起见，我们只使用一个文件夹存放客户端和服务端代码，并且在同一个目录下运行服务端和客户端。

如果所有的RMI文件都已经设计好了，那么你需要下面的几个步骤去生成你的系统：

 

1、 编写并且编译接口的Java代码

          2、 编写并且编译接口实现的Java代码

          3、 从接口实现类中生成桩（Stub）和框架（Skeleton）类文件

          4、 编写远程服务的主运行程序

          5、 编写RMI的客户端程序

          6、 安装并且运行RMI系统

1、 接口

        第一步就是建立和编译服务接口的Java代码。这个接口定义了所有的提供远程服务的功能，下面是源程序：

import java.rmi.Remote;
public interface Calculator extends Remote{
    public long add(long a, long b) throws java.rmi.RemoteException;
    public long sub(long a, long b) throws java.rmi.RemoteException;
    public long mul(long a, long b) throws java.rmi.RemoteException;
    public long div(long a, long b) throws java.rmi.RemoteException;
}

import java.rmi.Remote;
public interface Calculator extends Remote{
	public long add(long a, long b) throws java.rmi.RemoteException;
	public long sub(long a, long b) throws java.rmi.RemoteException;
	public long mul(long a, long b) throws java.rmi.RemoteException;
	public long div(long a, long b) throws java.rmi.RemoteException;
}

 

注意，这个接口继承自Remote，每一个定义的方法都必须抛出一个RemoteException异常对象。

建立这个文件，把它存放在刚才的目录下，并且编译。

>javac Calculator.java

 

2、 接口的具体实现

下一步，我们就要写远程服务的具体实现，这是一个CalculatorImpl类文件：

import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;

public class CalculatorImpl extends UnicastRemoteObject implements Calculator
{
    protected CalculatorImpl() throws RemoteException {
        super();
    }

    public long add(long a, long b) throws RemoteException {
        return a+b;
    }

    public long div(long a, long b) throws RemoteException {
        // TODO Auto-generated method stub
        return a-b;
    }

    public long mul(long a, long b) throws RemoteException {
        // TODO Auto-generated method stub
        return a*b;
    }

    public long sub(long a, long b) throws RemoteException {
        // TODO Auto-generated method stub
        return a/b;
    }

}

import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;

public class CalculatorImpl extends UnicastRemoteObject implements Calculator
{
	protected CalculatorImpl() throws RemoteException {
		super();
	}

	public long add(long a, long b) throws RemoteException {
		return a+b;
	}

	public long div(long a, long b) throws RemoteException {
		// TODO Auto-generated method stub
		return a-b;
	}

	public long mul(long a, long b) throws RemoteException {
		// TODO Auto-generated method stub
		return a*b;
	}

	public long sub(long a, long b) throws RemoteException {
		// TODO Auto-generated method stub
		return a/b;
	}

}

 

同样的，把这个文件保存在你的目录里然后编译他。

 

        这个实现类使用了UnicastRemoteObject去联接RMI系统。在我们的例子中，我们是直接的从UnicastRemoteObject这 个类上继承的，事实上并不一定要这样做，如果一个类不是从UnicastRmeoteObject上继承，那必须使用它的exportObject()方 法去联接到RMI。

 

        如果一个类继承自UnicastRemoteObject，那么它必须提供一个构造函数并且声明 抛出一个RemoteException对象。当这个构造函数调用了super()，它久激活UnicastRemoteObject中的代码完成RMI 的连接和远程对象的初始化。

 

3、 桩（Stubs）和框架（Skeletons）

 

        下一步就是要使用RMI编译器rmic来生成桩和框架文件，这个编译运行在远程服务实现类文件上。

 

>rmic CalculatorImpl

 

        在你的目录下运行上面的命令，成功执行完上面的命令你可以发现一个Calculator_stub.class文件，如果你是使用的Java2SDK，那么你还可以发现Calculator_Skel.class文件。

 

4、 主机服务器

 

        远程RMI服务必须是在一个服务器中运行的。CalculatorServer类是一个非常简单的服务器。

 

import java.rmi.Naming;
public class CalculatorServer {
    public CalculatorServer() {
    try {
        Calculator c = new CalculatorImpl();
        Naming.rebind("rmi://localhost:1099/CalculatorService", c);
    } catch (Exception e) {
      System.out.println("Trouble: " + e);
        }
    }
    public static void main(String args[]) {
        new CalculatorServer();
    }
}

import java.rmi.Naming;    
public class CalculatorServer {    
	public CalculatorServer() {    
	try {    
		Calculator c = new CalculatorImpl();    
		Naming.rebind("rmi://localhost:1099/CalculatorService", c);    
	} catch (Exception e) {    
	  System.out.println("Trouble: " + e);    
		}    
	}    
	public static void main(String args[]) {    
		new CalculatorServer();    
	}    
}    

 建立这个服务器程序，然后保存到你的目录下，并且编译它。

5、 客户端

        客户端源代码如下：

import java.rmi.Naming;
import java.rmi.RemoteException;
import java.net.MalformedURLException;
import java.rmi.NotBoundException;

public class CalculatorClient {
    public static void main(String[] args) {
        try {
            Calculator c = (Calculator)
            Naming.lookup("rmi://localhost/CalculatorService");
            System.out.println( c.sub(4, 3) );
            System.out.println( c.add(4, 5) );
            System.out.println( c.mul(3, 6) );
            System.out.println( c.div(9, 3) );
        }
        catch (MalformedURLException murle) {
            System.out.println();
            System.out.println("MalformedURLException");
            System.out.println(murle);
        }
        catch (RemoteException re) {
            System.out.println();
            System.out.println("RemoteException");
            System.out.println(re);
        }
        catch (NotBoundException nbe) {
            System.out.println();
            System.out.println("NotBoundException");
            System.out.println(nbe);
        }
        catch (java.lang.ArithmeticException  ae) {
            System.out.println();
            System.out.println("java.lang.ArithmeticException");
            System.out.println(ae);
        }
    }
}

import java.rmi.Naming;
import java.rmi.RemoteException;
import java.net.MalformedURLException;
import java.rmi.NotBoundException;

public class CalculatorClient {
	public static void main(String[] args) {
		try {
			Calculator c = (Calculator)
			Naming.lookup("rmi://localhost/CalculatorService");
			System.out.println( c.sub(4, 3) );
			System.out.println( c.add(4, 5) );
			System.out.println( c.mul(3, 6) );
			System.out.println( c.div(9, 3) );
		}
		catch (MalformedURLException murle) {
			System.out.println();
			System.out.println("MalformedURLException");
			System.out.println(murle);
		}
		catch (RemoteException re) {
			System.out.println();
			System.out.println("RemoteException");
			System.out.println(re);
		}
		catch (NotBoundException nbe) {
			System.out.println();
			System.out.println("NotBoundException");
			System.out.println(nbe);
		}
		catch (java.lang.ArithmeticException  ae) {
			System.out.println();
			System.out.println("java.lang.ArithmeticException");
			System.out.println(ae);
		}
	}
}

 保存这个客户端程序到你的目录下（注意这个目录是一开始建立那个，所有的我们的文件都在那个目录下），并且编译他。

 

6、 运行RMI系统

 

        现在我们建立了所有运行这个简单RMI系统所需的文件，现在我们终于可以运行这个RMI系统啦！来享受吧。

 

        我们是在命令控制台下运行这个系统的，你必须开启三个控制台窗口，一个运行服务器，一个运行客户端，还有一个运行RMIRegistry。

 

        首先运行注册程序RMIRegistry，你必须在包含你刚写的类的那么目录下运行这个注册程序。

 

>rmiregistry

 

        好，这个命令成功的话，注册程序已经开始运行了，不要管他，现在切换到另外一个控制台，在第二个控制台里，我们运行服务器 CalculatorService，因为RMI的安全机制将在服务端发生作用,所以你必须增加一条安全策略。以下是对应安全策略的例子

grant {
permission java.security.AllPermission , ;

};

grant {
permission java.security.AllPermission , ;

};

 

注意:这是一条最简单的安全策略,它允许任何人做任何事,对于你的更加关键性的应用,你必须指定更加详细安全策略。

现在为了运行服务端，你需要除客户类(CalculatorClient.class)之外的所有的类文件。确认安全策略在policy.txt文件之后,使用如下命令来运行服务器。

> java -Djava.security.policy=policy.txt CalculatorServer

 

        这个服务器就开始工作了，把接口的实现加载到内存等待客户端的联接。好现在切换到第三个控制台，启动我们的客户端。

为了在其他的机器运行客户端程序你需要一个远程接口(Calculator.class) 和一个stub(CalculatorImpl_Stub.class)。 使用如下命令运行客户端

prompt> java -Djava.security.policy=policy.txt CalculatorClient

 

        如果所有的这些都成功运行，你应该看到下面的输出：

1
9
18
3

1
9
18
3

 如果你看到了上面的输出，恭喜你，你成功了，你已经成功的创建了一个RMI系统，并且使他正确工作了。即使你运行在同一个计算机上，RMI还是使用了你的网络堆栈和TCP/IP去进行通讯，并且是运行在三个不同的Java虚拟机上。这已经是一个完整的RMI系统

---

RMI是Java对象进 行远程访问的一种规范——也就是说，从Java虚拟机（Java Virtual Machine，JVM）而不是特定对象的主机访问。这些对象可能位于拥有JVM的同一个物理主机上，或者位于其他计算机上，并通过某个网络连接到宿主主 机（服务器）。规范包括这些对象进行编码的规则，如何定位对象，如何远程调用，方法的参数和计算结果如何在JVM之间传递。RMI的缺省实现是JRMP（Java Remote Method Protocol），这是一个百分之百的Java实现。此外，RMI也可以使用其它的协议，例如IIOP。

RMI可利用标准Java本机方法接口JNI与现有的和原有的系统相连接。RMI还可利用标准JDBC包与现有的关系数据库连接。RMI/JNI和RMI/JDBC相结合，可帮助您利用RMI与目前使用非Java语言的现有服务器进行通信，而且在您需要时可扩展Java在这些服务器上的使用。RMI可帮助您在扩展使用时充分利用Java的强大功能。

下面我们通过一个例子，来说明怎么构建RMI应用。我们写一个例子，通过RMI获取服务器端的时间。下面是构造这个例子的全部过程。

首先定义一个接口，因为RMI的调用都是通过接口进行的，因此我们只能定义接口。代码如下：

import java.rmi.Remote;
import java.rmi.RemoteException;

/**
* 定义一个远程接口，这个接口应该继承Remote
* @author Dirac
*/
public interface PerfectTime extends Remote
{
/**
* 因为这个方法是远程调用的，所以它应该抛出RemoteException
* @param param
* @return
* @throws RemoteException
*/
String getPerfectTime(String param) throws RemoteException;
}

import java.rmi.Remote;
import java.rmi.RemoteException;

/**
* 定义一个远程接口，这个接口应该继承Remote
* @author Dirac
*/
public interface PerfectTime extends Remote
{
/**
* 因为这个方法是远程调用的，所以它应该抛出RemoteException
* @param param
* @return
* @throws RemoteException
*/
String getPerfectTime(String param) throws RemoteException;
}

 

第二步，给出具体实现，这里为了增加一些趣味，我们加入了一个名字，并把时间格式化成我们所习惯的格式，然后返回给客户。这个实现和普通类没有什么区别，只是需要继承一个特殊的类：

public class PerfectTimeImpl extends UnicastRemoteObject implements PerfectTime
{
private static final long serialVersionUID = 1793177637034935906L;
String name = "";
public PerfectTimeImpl(String name) throws RemoteException
{
this.name = name;
}

/**
* 返回的字符串中包含了服务器端的时间
*/
public String getPerfectTime(String param) throws RemoteException
{
return param + ": " + name + " is " + new SimpleDateFormat("yyyy年MM月dd
日HH时mm分ss秒SSS毫秒").format (new Date(System.currentTimeMillis()));
}
}

public class PerfectTimeImpl extends UnicastRemoteObject implements PerfectTime
{
private static final long serialVersionUID = 1793177637034935906L;
String name = "";
public PerfectTimeImpl(String name) throws RemoteException
{
this.name = name;
}

/**
* 返回的字符串中包含了服务器端的时间
*/
public String getPerfectTime(String param) throws RemoteException
{
return param + ": " + name + " is " + new SimpleDateFormat("yyyy年MM月dd
日HH时mm分ss秒SSS毫秒").format (new Date(System.currentTimeMillis()));
}
}

 

我们还可以通过继承RemoteServer来实现这个类，但是需要自己将它导出，方法是在构造函数中调用 UnicastRemoteObject.exportObject(this, 1099)，第二个参数是要绑定的端口号。这里之所以没有显式导入，是因为UnicastRemoteObject已经为我们做了这步工作。

第三步，生成远程接口实现对应的stub，这是通过JDK自带的rmic实现的，命令如下：
rmic cn.zxm.rmi.PerfectTimeImpl

生成的stub对应的文件名是PerfectTimeImpl_Stub。我们可以在rmic后面跟-keep参数，保留生成的stub源码，这实际上是PerfectTimeImpl的代理，客户端调用的实际上就是这个stub。

第四步，在服务器端绑定这个远程对象，代码如下：

import java.net.MalformedURLException;
import java.rmi.Naming;
import java.rmi.RMISecurityManager;
import java.rmi.RemoteException;

/**
* @author Dirac
*/
public class PerfectTimeServer
{
public static void main(String [] agrs) throws RemoteException
{
try
{
//服务器端注册远程对象
PerfectTimeImpl p1 = new PerfectTimeImpl ("Black Stone");
PerfectTimeImpl p2 = new PerfectTimeImpl ("Anders Heijlsberg");
Naming.rebind ("p1", p1);
Naming.rebind ("p2", p2);
//获得注册的名字列表，并打印出来
String[] list = Naming.list("");
for(int i = 0; i < list.length; i++)
{
System.out.println("list[" + (i + 1) + "]=" + list[i]);
}
}
catch(MalformedURLException mue)
{
mue.printStackTrace ();
}
}
}

import java.net.MalformedURLException;
import java.rmi.Naming;
import java.rmi.RMISecurityManager;
import java.rmi.RemoteException;

/**
* @author Dirac
*/
public class PerfectTimeServer
{
public static void main(String [] agrs) throws RemoteException
{
try
{
//服务器端注册远程对象
PerfectTimeImpl p1 = new PerfectTimeImpl ("Black Stone");
PerfectTimeImpl p2 = new PerfectTimeImpl ("Anders Heijlsberg");
Naming.rebind ("p1", p1);
Naming.rebind ("p2", p2);
//获得注册的名字列表，并打印出来
String[] list = Naming.list("");
for(int i = 0; i < list.length; i++)
{
System.out.println("list[" + (i + 1) + "]=" + list[i]);
}
}
catch(MalformedURLException mue)
{
mue.printStackTrace ();
}
}
}

 

第五步，编写客户端调用代码，代码如下：

import java.net.MalformedURLException;
import java.rmi.Naming;
import java.rmi.NotBoundException;
import java.rmi.RMISecurityManager;
import java.rmi.RemoteException;

/**
* @author Dirac
*/
public class PerfectTimeClient
{
public static void main(String [] args)
{
try
{
//客户端获取远程接口
PerfectTime p1 = (PerfectTime)Naming.lookup ("rmi://localhost:1099/p1");
PerfectTime p2 = (PerfectTime)Naming.lookup ("rmi://localhost:1099/p2");
//调用远程接口的方法
System.out.println (p1.getPerfectTime ("p1"));
System.out.println (p2.getPerfectTime ("p2"));
}
catch(RemoteException re)
{
re.printStackTrace ();
}
catch(MalformedURLException mue)
{
mue.printStackTrace ();
}
catch(NotBoundException nbe)
{
nbe.printStackTrace ();
}
}
}

import java.net.MalformedURLException;
import java.rmi.Naming;
import java.rmi.NotBoundException;
import java.rmi.RMISecurityManager;
import java.rmi.RemoteException;

/**
* @author Dirac
*/
public class PerfectTimeClient
{
public static void main(String [] args)
{
try
{
//客户端获取远程接口
PerfectTime p1 = (PerfectTime)Naming.lookup ("rmi://localhost:1099/p1");
PerfectTime p2 = (PerfectTime)Naming.lookup ("rmi://localhost:1099/p2");
//调用远程接口的方法
System.out.println (p1.getPerfectTime ("p1"));
System.out.println (p2.getPerfectTime ("p2"));
}
catch(RemoteException re)
{
re.printStackTrace ();
}
catch(MalformedURLException mue)
{
mue.printStackTrace ();
}
catch(NotBoundException nbe)
{
nbe.printStackTrace ();
}
}
}

 
第六步，设置CLASSPATH变量，方式是在命令行中使用命令set CLASSPATH=类路径，比如我的类路径是E:\study\rmi\classes，那么命令如下：
set CLASSPATH=E:\study\rmi\classes
这一步是必须的，不然向RMI注册机注册的时候会找不到stub。
第七步，启动RMI注册机，启动它的命令也是通过JDK自带的工具完成的，它和javac等工具位于一个目录下，命令如下：
start rmiregistry
start表示另起一个命令行窗口，新窗口和现在的命令行窗口共享同样的设置，比如上面的CLASSPATH。
第八步，启动服务器注册程序，命令如下：
start java cn.zxm.rmi.PerfectTimeServer
第九步，启动客户端调用程序，命令如下：
java cn.zxm.rmi.PerfectTimeClient
输出如图1：

图1 RMI客户端调用结果

部署时候需要注意的是，客户端都应该包含接口和实现对应的stub，其它的则不是必需的。
注册远程接口的时候，如果抛出ClassNotFound stub这样的错误，可能的原因，一是没有手工设置CLASSPATH，二是PATH变量当中，包含了多个JDK或者JRE的bin路径，这两个错误往往很难找，需要格外的注意。

除了在客户端直接部署stub外，还有一种方式，是通过网络获取。比如我把stub放在 /order/perfect/下，当然要包含完整的包结构，stub这个例子中stub实际上位于 /order/perfect/cn/zxm/rmi/下。客户端调用的方式如下：

java -Djava.rmi.server.codebase=/order/perfect/
cn.zxm.rmi.PerfectTimeClient

注意URL后面的/不可省略。由于从远程加载类，因此涉及到安全问题，java使用许可的方式，来保证安全。这是通过培植一个policy文件实现 的，policy文件的配置很麻烦，我们这里由于是测试，不涉及安全问题，因此我们给它全部的许可，许可文件命名为server.policy，和 PerfectTimeClient放在一个目录下，server.policy的内容如下：

grant{
    permission java.security.AllPermission;
}

然后，我们需要在客户端手工加载这个文件，并为客户端安装一个安全管理器，代码如下：

System.setProperty ("java.security.policy",
PerfectTimeClient.class.getResource ("server.policy").toString ());
System.setSecurityManager(new RMISecurityManager());

这样我们就可以使用动态类加载功能加载服务器上的stub文件了