1. public class RemoteImpl extends UnicastRemoteObject implements RemoteInterface

1. public class RemoteImpl extends OtherClass implements RemoteInterface{
2. private String name;
3. public RemoteImpl (String name)throws RemoteException{
4. this.name=name;
5. UnicastRemoteObject.exportObject(this,0);
6. }

1. protected UnicastRemoteObject(int port) throws RemoteException
2. {
3. this.port = port;
4. exportObject((Remote) this, port);
5. }

1. public static Remote exportObject(Remote obj, int port)
2. throws RemoteException
3. {
4. return exportObject(obj, new UnicastServerRef(port));
5. }

1. RemoteInterface remoteObj2 = new RemoteImpl();// 创建远程对象
2. Context namingContext = new InitialContext();// 初始化命名内容
3. LocateRegistry.createRegistry(8892);// 在本地主机上创建和导出注册表实例，并在指定的端口上接受请求
4. namingContext.rebind(”rmi://localhost:8892/RemoteObj2”, remoteObj2);// 注册对象，即把对象与一个名字绑定。

1. RemoteInterface remoteObj = new RemoteImpl();
2. LocateRegistry.createRegistry(8891);
3. Naming.rebind(”rmi://localhost:8891/RemoteObj”, remoteObj);

1. Context namingContext = new InitialContext();// 初始化命名内容
2. RemoteInterface RmObj2 = (RemoteInterface) namingContext.lookup(”rmi://localhost:8892/RemoteObj2”);//获得远程对象的存根对象
3. System.out.println(RmObj2.doSomething());//通过远程对象，调用doSomething方法

1. RemoteInterface RmObj = (RemoteInterface) Naming.lookup(“rmi://localhost:8891/RemoteObj”);
2. System.out.println(RmObj.doSomething());

1. package rmi;
2. import java.rmi.Remote;
3. import java.rmi.RemoteException;
4. //声明一个远程接口RemoteInterface，该接口必须继承Remote接口
5. //接口中需要被远程调用的方法，必须抛出RemoteException异常
6. public interface RemoteInterface extends Remote {
7. // 声明一个doSomething方法
8. public String doSomething() throws RemoteException;
9. // 声明一个计算方法Calculate
10. public int Calculate(int num1, int num2) throws RemoteException;
11. }

1. package rmi;
2. import java.rmi.RemoteException;
3. import java.rmi.server.UnicastRemoteObject;
4. //实现远程接口RemoteInterface，并继承UnicastRemoteObject
5. //注意RemoteObject这个类，实现了Serializable, Remote这两个接口
6. public class RemoteImpl extends UnicastRemoteObject implements RemoteInterface {
7. // 这个实现必须有一个显式的构造函数，并且要抛出一个RemoteException异常
8. public RemoteImpl() throws RemoteException {
9. }
10. // 实现doSomething方法
11. public String doSomething() throws RemoteException {
12. return “OK ,You can do……”;
13. }
14. // 实现Calculate方法,返回计算结果
15. public int Calculate(int num1, int num2) throws RemoteException {
16. return (num1 + num2);
17. }
18. }

package rmi2;
import javax.naming.Context;
import javax.naming.InitialContext;import rmi.RemoteInterface;public class ClientTest {public static void main(String args[]) {try {Context namingContext = new InitialContext();// 初始化命名内容RemoteInterface RmObj2 = (RemoteInterface) namingContext.lookup("rmi://localhost:8892/RemoteObj2");//获得远程对象的存根对象System.out.println(RmObj2.doSomething());//通过远程对象，调用doSomething方法System.out.println("远程服务器计算结果为：" + RmObj2.Calculate(90, 2));} catch (Exception e) {}}
}

在JDK1.3版本或更低的版本，如下方式注册;

package rmi;
import java.net.MalformedURLException;
import java.rmi.AlreadyBoundException;
import java.rmi.Naming;
import java.rmi.RemoteException;
import java.rmi.registry.LocateRegistry;
//在JDK1.3版本或更低的版本，需要使用java.rmi.Naming来注册远程对象
//创建RMI注册表，启动RMI服务，并将远程对象注册到RMI注册表中。
public class RMIServer {public static void main(String args[])throws java.rmi.AlreadyBoundException {try {// 创建一个远程对象RemoteObj，实质上隐含了是生成stub和skeleton,并返回stub代理引用RemoteInterface remoteObj = new RemoteImpl();// 本地创建并启动RMI Service，被创建的Registry服务将在指定的端口,侦听请求// Java默认端口是1099，缺少注册表创建，则无法绑定对象到远程注册表上LocateRegistry.createRegistry(8891);// 把远程对象注册到RMI注册服务器上，并命名为RemoteObj（名字可自定义，客户端要对应）// 绑定的URL标准格式为：rmi://host:port/name(其中协议名可以省略，下面两种写法都是正确的）Naming.rebind("rmi://localhost:8891/RemoteObj", remoteObj);// 将stub代理绑定到Registry服务的URL上// Naming.bind("//localhost:8880/RemoteObj",remoteObj);System.out.println(">>>>>INFO:远程IHello对象绑定成功！");} catch (RemoteException e) {System.out.println("创建远程对象发生异常！");e.printStackTrace();} catch (MalformedURLException e) {System.out.println("发生URL畸形异常！");e.printStackTrace();}}
}

  4. 客户端代码

package rmi2;
import javax.naming.Context;
import javax.naming.InitialContext;import rmi.RemoteInterface;
public class ClientTest {public static void main(String args[]) {try {Context namingContext = new InitialContext();// 初始化命名内容RemoteInterface RmObj2 = (RemoteInterface) namingContext.lookup("rmi://localhost:8892/RemoteObj2");//获得远程对象的存根对象System.out.println(RmObj2.doSomething());//通过远程对象，调用doSomething方法System.out.println("远程服务器计算结果为：" + RmObj2.Calculate(90, 2));} catch (Exception e) {}}
}

在JDK1.3版本或更低的版本，如下方式调用

import java.net.MalformedURLException;
import java.rmi.Naming;
import java.rmi.NotBoundException;
import java.rmi.RemoteException;public class ClientTest {public static void main(String args[]) {try {// 在RMI服务注册表中查找名称为RemoteObj的对象，并调用其上的方法// 客户端通过命名服务Naming获得指向远程对象的远程引用RemoteInterface RmObj = (RemoteInterface) Naming.lookup("rmi://localhost:8881/RemoteObj");System.out.println(RmObj.doSomething());System.out.println("远程服务器计算结果为：" + RmObj.Calculate(1, 2));} catch (NotBoundException e) {e.printStackTrace();} catch (MalformedURLException e) {e.printStackTrace();} catch (RemoteException e) {e.printStackTrace();}}
}

OK ,You can do......
远程服务器计算结果为：92

例子代码下载：http://download.csdn.net/detail/guyuealian/9583633