Java RMI 远程方法调用 (Remote Method Invocation)

一、简介

　　RMI是远程方法调用的简称，象其名称暗示的那样，它能够帮助我们查找并执行远程对象的方法。通俗地说，远程调用就象将一个class放在A机器上，然后在B机器中调用这个class的方法。

　　我个人认为，尽管RMI不是唯一的企业级远程对象访问方案，但它却是最容易实现的。与能够使不同编程语言开发的CORBA不同的是，RMI是一种纯Java解决方案。在RMI中，程序的所有部分都由Java编写。

　　在看本篇文章时，我假定读者都已经具备了较扎实的Java基础知识，在这方面有欠缺的读者请自行阅读有关资料。

　　概念

　　我在前面已经提到，RMI是一种远程方法调用机制，其过程对于最终用户是透明的：在进行现场演示时，如果我不说它使用了RNI，其他人不可能知道调用的方法存储在其他机器上。当然了，二台机器上必须都安装有Java虚拟机（JVM）。

　　其他机器需要调用的对象必须被导出到远程注册服务器，这样才能被其他机器调用。因此，如果机器A要调用机器B上的方法，则机器B必须将该对象导出到其远程注册服务器。注册服务器是服务器上运行的一种服务，它帮助客户端远程地查找和访问服务器上的对象。一个对象只有导出来后，然后才能实现RMI包中的远程接口。例如，如果想使机器A中的Xyz对象能够被远程调用，它就必须实现远程接口。

　　RMI需要使用占位程序和框架，占位程序在客户端，框架在服务器端。在调用远程方法时，我们无需直接面对存储有该方法的机器。

　　在进行数据通讯前，还必须做一些准备工作。占位程序就象客户端机器上的一个本机对象，它就象服务器上的对象的代理，向客户端提供能够被服务器调用的方法。然后，Stub就会向服务器端的Skeleton发送方法调用，Skeleton就会在服务器端执行接收到的方法。

　　Stub和Skeleton之间通过远程调用层进行相互通讯，远程调用层遵循TCP/IP协议收发数据。下面我们来大致了解一种称为为“绑定”的技术。

　　客户端无论何时要调用服务器端的对象，你可曾想过他是如何告诉服务器他想创建什么样的对象吗？这正是“绑定”的的用武之地。在服务器端，我们将一个字符串变量与一个对象联系在一起（可以通过方法来实现），客户端通过将那个字符串传递给服务器来告诉服务器它要创建的对象，这样服务器就可以准确地知道客户端需要使用哪一个对象了。所有这些字符串和对象都存储在的远程注册服务器中。 

　　在编程中需要解决的问题

　　在研究代码之前，我们来看看必须编写哪些代码：

　　•远程对象：这个接口只定义了一个方法。我们应当明白的是，这个接口并非总是不包括方法的代码而只包括方法的定义。远程对象包含要导出的每个方法的定义，它还实现Java.rmi中的远程接口。

　　•远程对象实现：这是一个实现远程对象的类。如果实现了远程对象，就能够覆盖该对象中的所有方法，因此，远程对象的实现类将真正包含我们希望导出的方法的代码。

　　•远程服务器：这是一个作为服务器使用的类，它是相对于要访问远程方法的客户端而言的。它存储着绑定的字符串和对象。

　　•远程客户端：这是一个帮助我们访问远程方法提供帮助的类，它也是最终用户。我们将使用查找和调用远程方法的方法在该类中调用远程方法。

　　编程

　　我们将首先编写远程对象，并将代码保存为名字为AddServer.Java的文件：

　　

import java.rmi.*;
public interface AddServer extends Remote {
	public int AddNumbers(int firstnumber,int secondnumber) throws RemoteException;
	}

　　我们来看看上面的代码。首先，为了使用其内容，我们导入rmi包。然后，我们创建一个扩展了Java.rmi中远程接口的接口。所有的远程对象必须扩展该远程接口，我们将该远程接口称为AddServer。在该远程对象中，有一个名字为AddNumbers的方法，客户端可以调用这一方法。我们必须记住的是，所有的远程方法都需要启动RemoteException方法，有错误发生时就会调用该方法。

　　下面我们开始编写远程对象的实现。这是一个实现远程对象并包含有所有方法代码的类，将下面的代码保存为名字为AddServerImpl.Java的文件：

　　

import java.rmi.*;
public class AddServerImpl  implements AddServer,java.io.Serializable {
	public AddServerImpl() {
		super();
		}
		public int AddNumbers(int firstnumber,int secondnumber) throws RemoteException {
			return firstnumber + secondnumber;
		}
} 

　　首先，我们导入rmi包，然后创建一个扩展UnicastRemoteObject和实现创建的远程对象的类；其次，我们可以为类创建一个缺省的构建器。我们还了解了AddNumbers方法的代码，它启动RemoteException。这样我们就覆盖了创建的远程对象中的方法。AddNumbers方法的代码非常好理解，它接受2个整型参数，然后相加并返回它们的和。

　　至此，我们已经有了二个Java文件：远程对象和远程对象的实现。下面我们将使用Javac命令编译这二个文件：

　　编译远程对象：

　　C:\jdk\bin\Javac workingdir\AddServer.Java 

　　编译远程对象实现：

　　C:\jdk\bin\Javac workingdir\AddServerImpl.Java 这样，就会达到二个Java文件和二个类文件，下面我们将创建stub和skeleton。为了创建stub和skeleton文件，我们必须使用rmic编译器编译远程对象实现文件。

　　用Rmic编译远程对象实现文件：

　　C:\jdk\bin\rmic workingdir\AddServerImpl 然后，我们就会发现多了1个新建的类文件AddServerImpl_Stub.class。

　　我们已经编译了所有的源代码，下面我们来创建客户端和服务器端，将下面的代码保存为名字为RmiServer.Java的文件：

　　

import java.rmi.*;
import java.net.*;
public class RmiServer {
	public static void main (String args[]) throws RemoteException, MalformedURLException {
		AddServerImpl add = new AddServerImpl();
		Naming.rebind("addnumbers",add);
		} 
}

　　首先，我们导入Java.rmi包和Java.net包。另外，我们还使用throws从句捕获任何异常。我们从对象中得出远程对象实现，使用rebind方法将字符串addnumbers与该对象绑定。下面的例子显示了绑定的含义：

　　从现在开始，无论何时客户端要调用远程对象，使用字符串addnumbers就可以实现。rebind方法有二个参数：第一个参数是字符串变量，第二个参数是远程对象实现类的对象。

　　下面我们来创建客户端，将下面的代码保存为名字为RmiClient.Java的文件：

　　

import java.rmi.*;
import java.net.*;
public class RmiClient {
	public static void main(String args[]) throws Exception {
		String url="rmi://127.0.0.1/addnumbers";
		AddServer add;
		add = (AddServer)Naming.lookup(url);
		int result = add.AddNumbers(10,5);
		System.out.println(result);
		}
} 

　　首先，我们导入Java.rmi包和Java.net包，并使用throws从句捕获所有必要的异常。然后通过利用Naming类中的静态lookup方法从远程对象中得到一个对象。（这也是我们无需从Naming类中得到一个对象并调用它。而只使用类名字的原因。）

　　lookup方法接受远程对象的完整的URL名字，该URL由完整的机器IP地址以及与对象绑定的字符串（也誻对象的绑定名）组成。在调用远程对象时，我们使用了RMI协议。lookup方法向我们返回一个对象，在能够使用它前，我们必须将它的数据类型转换为与远程对象的数据类型一致。

　　Since we have both our server and client source ready, let's compile them both: 

　　至此，我们已经有了服务器端和客户端的源代码，下面我们来编译这二个源文件：

　　编译远程服务器：

　　C:\jdk\bin\Javac workingdir\RmiServer.Java 

　　编译远程客户端：

　　C:\jdk\bin\Javac workingdir\RmiClient.Java 

　　在对我们的代码进行测试前，还必须首先启动RMI Registry。RMI Registry存储有所有绑定的数据，没有它，RMI就不能正常地运行！

　　启动Rmi Registry服务器：

　　C:\jdk\bin\start rmiregistry 

　　我们会注意到，这时会出现一个空白的DOS提示符窗口，这表明Rmi Registry服务器在运行，注意不要关闭该窗口。然后，我们首先在一个DOS提示符窗口中运行Rmi服务器，然后在另一个DOS提示符窗口中运行Rmi客户端。

　　启动RMI服务器： 

　　C:\jdk\bin\Java workingdir\RmiServer 

　　启动RMI客户端：

　　C:\jdk\bin\Java workingdir\RmiClient 

如果一切正常，我们应该能够得到15这个输出。我们向AddNumbers方法输入10和5二个数字，该方法将这二者加起来，并将其和15返回给我们。如果得到了15这个输出，说明我们已经成功地执行了一个远程方法。当然，在这里，我们并没有执行真正意义上的远程方法，因为我们的计算机既是服务器，又是客户机。如果有计算机网络，我们就可以方便地进行执行远程方法的试验了。

 

二、例子

例子1：

import java.rmi.Remote;
import java.rmi.RemoteException;
 
public interface IRmi extends Remote {
 
    public String helloRmi() throws RemoteException ;
 
    public String sayHelloRmi(String str) throws RemoteException ;
}
 
import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;
 
public class IRmiImpl extends UnicastRemoteObject implements IRmi {
 
    /**
     * 因为UnicastRemoteObject的构造方法抛出了RemoteException异常，因此这里默认的构造方法必须写，必须声明抛出RemoteException异常 
     * @throws RemoteException
     */
    protected IRmiImpl() throws RemoteException {
    }
 
    /**
     * 
     */
    private static final long serialVersionUID = 1L;
 
    public String helloRmi() throws RemoteException {
        return "This is my first rmi test...";
    }
 
    public String sayHelloRmi(String str) throws RemoteException {
        return "Hello ," + str + " welcome to here ...";
    }
 
}
 
import java.net.MalformedURLException;
import java.rmi.AlreadyBoundException;
import java.rmi.Naming;
import java.rmi.RemoteException;
import java.rmi.registry.LocateRegistry;
 
/**
 * 创建RMI注册表，启动RMI服务，并将远程对象注册到RMI注册表中。 
 */
public class RmiServer {
 
    public static void main(String[] args) {
        try {
            IRmi myRmi = new IRmiImpl();
          //本地主机上的远程对象注册表Registry的实例，并指定端口为7777，这一步必不可少（Java默认端口是1099），必不可缺的一步，缺少注册表创建，则无法绑定对象到远程注册表上 
            LocateRegistry.createRegistry(7777);
 
          //把远程对象注册到RMI注册服务器上，并命名为myRmiTest
          //绑定的URL标准格式为：rmi://host:port/name(其中协议名可以省略，下面两种写法都是正确的） 
            Naming.bind("rmi://localhost:7777/myRmiTest",myRmi);
            System.out.println(">>>>>>>>INFO：远程IRmi对象绑定成功！");
        } catch (RemoteException  e) {
           System.out.println("创建远程对象异常。") ;
            e.printStackTrace();
        } catch (AlreadyBoundException e) { 
            System.out.println("发生重复绑定对象异常！"); 
            e.printStackTrace(); 
        } catch (MalformedURLException e) { 
            System.out.println("发生URL畸形异常！"); 
            e.printStackTrace(); 
        } 
 
    }
}
 
import java.net.MalformedURLException;
import java.rmi.Naming;
import java.rmi.NotBoundException;
import java.rmi.RemoteException;
 
public class RmiClient {
 
    public static void main(String[] args) {
        try {
            IRmi myRmi = (IRmi) Naming.lookup("rmi://localhost:7777/myRmiTest");
            System.out.println(myRmi.helloRmi());
            System.out.println(myRmi.sayHelloRmi("张无忌")) ;
        } catch (MalformedURLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (RemoteException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (NotBoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}
 

例子2：

import java.rmi.Remote;
import java.rmi.RemoteException;
/**
 * 远程接口
 */
public interface IRMI extends Remote{
    public Object invoke(ITask task) throws RemoteException ;
}
 
import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;
/**
 * 远程接口实现
 */
public class IRMIImpl extends UnicastRemoteObject implements IRMI {
 
 
    protected IRMIImpl() throws RemoteException {
        super();
    }
 
    public Object invoke(ITask task) throws RemoteException {
        System.out.println("开始一次远程调用，执行IRMIImpl中的invoke方法...");
        Object obj = task.doWork() ;
        System.out.println("调用ITask.doWork方法，返回的值为：" + obj.toString());
        // 客户端调用，可以在服务器端播放需要的音乐
        ProcessCaller.callMp3();
        return obj;
    }
 
}
 
import java.io.Serializable;
/**
 * 任务接口
 */
public interface ITask extends Serializable {
    public Object doWork();
}
 
import java.util.Date;
/**
 * 任务实现类
 */
public class ITaskImpl implements ITask {
 
    public Object doWork() {
        System.out.println("当前程序处于远程调用中。。。");
        return Thread.currentThread().getName() + "   " + new Date(System.currentTimeMillis());
    }
 
}
 
import java.io.IOException;
 
public class ProcessCaller {
 
    public static void callMp3(){
 
        System.out.println("开始播放音乐。");
        /*
        Runtime runtime = Runtime.getRuntime() ;
        try {
            Process process = runtime.exec("C:\\Program Files\\Windows Media Player\\wmplayer D:\\Jack\\Mp3\\5.秋天不回来-王强.mp3") ;
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        */
    }
}
 
import java.rmi.Naming;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
 
public class RMIServer {
 
    public static void registRemoteObject() throws Exception {
        IRMIImpl impl = new IRMIImpl();
        Naming.rebind("rmi://localhost:1111/mytask", impl);
        System.out.println("bound success!");
    }
 
    private static Registry createRegistry() {
        Registry registry = null;
        int port = 1111;
        try {
            registry = LocateRegistry.getRegistry("localhost", port);
            registry.list();
            System.out.println("Register the exist server!");
        } catch (final Exception e) {
            try {
                registry = LocateRegistry.createRegistry(port);
                System.out.println("Register the exist server!port=" + port);
            } catch (final Exception ee) {
                ee.printStackTrace();
            }
        }
        return registry;
    }
 
    /**
     * 将对象注册到rmi服务器上
     */
    public static void bind() {
        Registry registry = null;
        registry = createRegistry();
        try {
            IRMIImpl impl = new IRMIImpl();
            registry.rebind("mytask", impl);
            System.out.println("mytask server start!");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
 
    /**
     * @param args
     */
    public static void main(String[] args) {
        try {
            bind();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
 
}
 
import java.rmi.Naming;
 
public class RMIClient {
    public static void getRemoteObject() throws Exception {
        IRMI obj = (IRMI) Naming.lookup("rmi://localhost:1111/mytask"); // 得到远程发布的服务
        ITaskImpl task = new ITaskImpl();
        Object result = obj.invoke(task); // 调用远程服务的方法
        System.out.println(result.toString());
    }
 
    public static void main(String[] args) {
        try {
            getRemoteObject();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
 

 

三、总结

1.Java RMI 简介

RMI（Remote Method Invocation），RMI是分布式对象软件包，它简化了在多台计算机上的JAVA应用之间的通信。

必须在jdk1.1以上，RMI用到的类：

java.rmi.Remote  所有可以被远程调用的对象都必须实现该接口

java.rmi.server.UnicastRemoteObject  所有可以被远程调用的对象都必须扩展该类

什么是RMI ？

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

在看一下wikipedia上的简介吧：

TheJava Remote Method InvocationApplication Programming Interface (API), or Java RMI,is a Java application programming interface that performs the object-oriented equivalent of remote procedure calls (RPC).

1. The original implementation depends on Java Virtual Machine (JVM) class representation mechanisms and it thus only supports making calls from one JVM to another. The protocol underlying this Java-only implementation is known as Java Remote Method Protocol (JRMP).

2. In order to support code running in a non-JVM context, a CORBA version was later developed.

Usage of the term RMI may denote solely the programming interface or may signify both the API and JRMP, whereas the term RMI-IIOP (read: RMI over IIOP) denotes the RMI interface delegating most of the functionality to the supporting CORBA implementation.

The programmers of the original RMI API generalized the code somewhat to support different implementations, such as a HTTP transport. Additionally, the ability to pass arguments "by value" was added to CORBA in order to support the RMI interface. Still, the RMI-IIOP and JRMP implementations do not have fully identical interfaces.

 

2.RMI的优势

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

1、面向对象：

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

2、可移动属性：

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

3、设计方式：

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

4、安全性：

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

5、便于编写和使用

RMI使得Java远程服务程序和访问这些服务程序的Java客户程序的编写工作变得轻松、简单。远程接口实际上就是Java接口。为了实现RMI的功能必须创建远程对象任何可以被远程调用的对象必须实现远程接口。但远程

接口本身并不包含任何方法。因而需要创建一个新的接口来扩展远程接口。

新接口将包含所有可以远程调用的方法。远程对象必须实现这个新接口，由于新的接口扩展了

远程接口，实现了新接口，就满足了远程对象对实现远程接口的要求，所实现的每个对象都将

作为远程对象引用。

一个国外的PPT上还还总结到，

Java RMI Advantages:

Full object support

Cross platform. capabilities

Robust communications

Large objects

Security for client and servers

Distribution/updates of codes

3.RMI的劣势

从上面的过程来看，RMI对服务器的IP地址和端口依赖很紧密，但是在开发的时候不知道将来的服务器IP和端口如何，但是客户端程序依赖这个IP和端口。这也是RMI的局限性之一。这个问题有两种解决途径：一是通过DNS来解决，二是通过封装将IP暴露到程序代码之外。

RMI的局限性之二是RMI是Java语言的远程调用，两端的程序语言必须是Java实现，对于不同语言间的通讯可以考虑用Web Service或者公用对象请求代理体系（CORBA）来实现。

一个国外的PPT上也总结到，

Java RMI Disadvantages:

Java RMI only supports Java

Proprietary protocol by single vendor

Requires RMI-lookup

Requires non-standard port

4.RMI与Socket的比较

RMI技术比较socket的网络编程主要有以下几个方面：

第一、RMI是面向对象的，而后者不是。

第二、RMI是与语言相绑定的。比如当你使用Java RMI技术的时候，客户端与服务器端都必须使用Java开发。而socket的网络编程是使用独立于开发语言的，甚至独立于平台。基于socket的网络 编程，客户端与服务器端可以使用不同开发语言和不同的平台。

第三、从网络协议栈的观点来看，RMI与socket的网络编程处于不同层次上。基于socket的网络编程位于TCP协议之上，而RMI在TCP协议之 上，又定义了自己的应用协议，其传输层采用的是Java远程方法协议(JRMP)。可见，在网络协议栈上，基于RMI的应用位置更高一些，这也决定了，与 socket的网络编程相比，RMI会丧失一些灵活性和可控性，但是好处是它带给了应用开发者更多的简洁，方便和易用。比如：如果你用的是RMI,你不需 要关心消息是怎么序列化的，你只需要像本地方法调用一样，使用RMI。代价是：应用开发者无法很好地控制消息的序列化机制。

第四、这是最后一点不同，我认为也是比较重要的一点，就是两种方法的性能比较，其往往决定着你将使用那种技术来开发你的应用。

实验的结果是：RMI与TCP based socket相比，传输相同的有效数据，RMI需要占用更多的网络带宽（protocol overhead）。从这里，我们可以得出一个一般性的结论：RMI主要是用于远程方法的”调用“（RMI是多么的名符其实:)），其技术内涵强调的是 “调用”，基于此，我能想到的是：移动计算，和远程控制，当你的应用不需要在client与server之间传输大量的数据时，RMI是较好的选择，它简洁、易于开发。但是，一旦你的应用需要在client与server之间传输大量的数据，极端的，比如FTP应用，则RMI是不适合的，我们应该使用 socket。

PS: RMI的效率还是很高的，一般情况下会比Hessian更高效，比Web Service更是高效很多；当然和socket这种东东相比，当然要低效一点了，socket更底层一些啊。RMI的具体实现，依然是依赖于底层的Socket编程。

 

参考资料：

http://java.sun.com/developer/onlineTraining/Programming/JDCBook/rmi.html

http://en.wikipedia.org/wiki/Java_remote_method_invocation

http://csevan.javaeye.com/blog/284613

http://dev.firnow.com/course/3_program/java/javajs/2009110/154540.html

http://developer.51cto.com/art/200906/130417.htm  （这篇非常不错:用RMI实现基于Java的分布式计算）