① java RMI問題
rmiregistry的默認埠是1099....你這里指定的埠是3000
所以你在CMD中要這樣 start rmiregistry 3000
或者將你的Naming.bind("/localhost:3000/getStudent", obj);
改為Naming.bind("rmi://localhost:1099/getStudent", obj);
額,突然發現你沒有在前面加rmi前綴...不知道這個有關系沒~~~~
額,查了下,不加rmi前綴也可以,加了rmi前綴後會如果你沒有指定埠就會將obj注冊到主機上監聽1099埠的rmiregistry進程上去...
如果還出現錯誤就不知道了
② 求好心人給個java RMI的源代碼！！萬分感謝！！
1. 用命令rmiregistry啟動RMI注冊服務的
2. 同時創建存根(stub)和骨架(skeleton)的
3. 只創建存根類的的(jdk1.2以後版本)
4. 通過RemoteRef和rmi://協議字串方式的
5. 比較少講到的用LocateRegistry直接在代碼上啟動RMI注冊服務的。
以上描述並非明顯分類，比如，你總是可以選擇用rmiregistry或者代碼LocateRegistry啟動RMI注冊服務
下面我將介紹一個完整的實例，讓初學者能快速體驗RMI的功用。
分為以下四個步驟
1. 創建遠程介面及聲明遠程方法（HelloInterface.java）
2. 實現遠程介面及遠程方法（繼承UnicastRemoteObject）(Hello.java)
3. 啟動RMI注冊服務，並注冊遠程對象（HelloServer.java）
4. 客戶端查找遠程對象，並調用遠程方法（HelloClient）
5. 執行程序：啟動服務HelloServer；運行客戶端HelloClient進行調用
具體代碼及對應步驟如下：
1. 創建遠程介面及聲明遠程方法（HelloInterface.java）
java 代碼
package com.unmi;
import java.rmi.*;
//遠程介面必須擴展介面java.rmi.Remote
public interface HelloInterface extends Remote {
// 遠程介面方法必須拋出 java.rmi.RemoteException
public String say() throws RemoteException;
}
2. 實現遠程介面及遠程方法（繼承UnicastRemoteObject）Hello.java
java 代碼
package com.unmi;
import java.rmi.*;
import java.rmi.server.*;
/**
* 擴展了UnicastRemoteObject類，並實現遠程介面 HelloInterface
*/
public class Hello extends UnicastRemoteObject implements HelloInterface
{
private String message;
/**
必須定義構造方法，即使是默認構造方法，也必須把它明確地寫出來，因為它必須拋出出RemoteException異常
*/
public Hello(String msg) throws RemoteException
{
message = msg;
}
/**
* 遠程介面方法的實現
*/
public String say() throws RemoteException
{
System.out.println("Called by HelloClient");
return message;
}
}
3. 啟動RMI注冊服務，並注冊遠程對象（HelloServer.java）
java 代碼
package com.unmi;
import java.rmi.Naming;
import java.rmi.registry.LocateRegistry;
public class HelloServer
{
/**
* 啟動 RMI 注冊服務並進行對象注冊
*/
public static void main(String[] argv)
{
try
{
//啟動RMI注冊服務，指定埠為1099（1099為默認埠）
//也可以通過命令 ＄java_home/bin/rmiregistry 1099啟動
//這里用這種方式避免了再打開一個DOS窗口
//而且用命令rmiregistry啟動注冊服務還必須事先用RMIC生成一個stub類為它所用
LocateRegistry.createRegistry(1099);
//創建遠程對象的一個或多個實例，下面是hello對象
//可以用不同名字注冊不同的實例
HelloInterface hello = new Hello("Hello, world!");
//把hello注冊到RMI注冊伺服器上，命名為Hello
Naming.rebind("Hello", hello);
//如果要把hello實例注冊到另一台啟動了RMI注冊服務的機器上
//Naming.rebind("//192.168.1.105:1099/Hello",hello);
System.out.println("Hello Server is ready.");
}
catch (Exception e)
{
System.out.println("Hello Server failed: " + e);
}
}
}
4. 客戶端查找遠程對象，並調用遠程方法（HelloClient）
java 代碼
package com.unmi;
import java.rmi.Naming;
public class HelloClient
{
/**
* 查找遠程對象並調用遠程方法
*/
public static void main(String[] argv)
{
try
{
HelloInterface hello = (HelloInterface) Naming.lookup("Hello");
//如果要從另一台啟動了RMI注冊服務的機器上查找hello實例
//HelloInterface hello = (HelloInterface)Naming.lookup("//192.168.1.105:1099/Hello");
//調用遠程方法
System.out.println(hello.say());
}
catch (Exception e)
{
System.out.println("HelloClient exception: " + e);
}
}
}
5. 執行程序：啟動服務HelloServer；運行客戶端HelloClient進行調用
代碼如何編譯這里就不細講
(1)打開一個Dos窗口執行命令 java com.unmi.HelloServer 啟動服務HelloServer
E:workspaceTestRMIbin>java com.unmi.HelloServer
Hello Server is ready.
運行成功則可以看到 Hello Server is ready
(2)打開另一個Dos窗口執行命令 java com.unmi.HelloClient 運行客戶端程序
E:workspaceTestRMIbin>java com.unmi.HelloClient
Hello, world!
調用成功則可以看到Hello, world!
並且在啟動服務端的窗口中看到緊跟 Hello Server is ready. 列印出
Called by HelloClient
如果您能一路順暢的執行到這里，恭喜！您已度過了一個輕快的RMI之旅。
③ Java Rmi如何實現兩個客戶端之間的通信 求說的具體點
RMI的開發步驟
先創建遠程介面及聲明遠程方法，注意這是實現雙方通訊的介面，需要繼承Remote
開發一個類來實現遠程介面及遠程方法，值得注意的是實現類需要繼承UnicastRemoteObject
通過javac命令編譯文件，通過java -server 命令注冊服務，啟動遠程對象
最後客戶端查找遠程對象，並調用遠程方法
首先為服務建立一個Model層，注意因為此對象需要現實進行遠程傳輸，所以必須繼承Serializable
代碼
packagermi.model;
importjava.io.Serializable;
//注意對象必須繼承Serializable
{
privateintid;
privateStringname;
privateintage;
publicvoidsetId(intid){
this.id=id;
}
publicintgetId(){
returnid;
}
publicvoidsetName(Stringname){
this.name=name;
}
publicStringgetName(){
returnname;
}
publicvoidsetAge(intage){
this.age=age;
}
publicintgetAge(){
returnage;
}
}
創建遠程介面PersonService,注意遠程介面需要繼承Remote
代碼
packagermi.service;
importjava.rmi.Remote;
importjava.rmi.RemoteException;
importjava.util.List;
importrmi.model.*;
//此為遠程對象調用的介面，必須繼承Remote類
{
publicList<PersonEntity>GetList()throwsRemoteException;
}
建立PersonServiceImpl實現遠程介面，注意此為遠程對象實現類，需要繼承UnicastRemoteObject
代碼
packagermi.serviceImpl;
importjava.rmi.RemoteException;
importjava.rmi.server.UnicastRemoteObject;
importjava.util.LinkedList;
importjava.util.List;
importrmi.model.PersonEntity;
importrmi.service.*;
//此為遠程對象的實現類，須繼承UnicastRemoteObject
Service{
publicPersonServiceImpl()throwsRemoteException{
super();
//TODOAuto-generatedconstructorstub
}
@Override
publicList<PersonEntity>GetList()throwsRemoteException{
//TODOAuto-generatedmethodstub
System.out.println("GetPersonStart!");
List<PersonEntity>personList=newLinkedList<PersonEntity>();
PersonEntityperson1=newPersonEntity();
person1.setAge(25);
person1.setId(0);
person1.setName("Leslie");
personList.add(person1);
PersonEntityperson2=newPersonEntity();
person2.setAge(25);
person2.setId(1);
person2.setName("Rose");
personList.add(person2);
returnpersonList;
}
}
建立伺服器端，在伺服器端注冊RMI通訊埠與通訊路徑，然後通訊javac命令編譯文件，通過java -server 命令注冊服務。以下面代碼為例，如果閣下將項目建立於D:\RMIRemotingService文件夾上時，則先輸入D:\RMIRemotingServicesrc>javac rmi/remotingservice/Program.java獲取Program.class（如何閣下使用的MyEclipse等開發工具，可跳過此步，直接在*/bin文件夾中直接調用已經生成的Program.class），然後輸入D:\RMIRemotingServicesrc>java rmi/remotingservice/Program啟動服務。
代碼
packagermi.remotingservice;
importjava.rmi.Naming;
importjava.rmi.registry.LocateRegistry;
importrmi.service.*;
importrmi.serviceImpl.*;
publicclassProgram{
publicstaticvoidmain(String[]args){
try{
PersonServicepersonService=newPersonServiceImpl();
//注冊通訊埠
LocateRegistry.createRegistry(6600);
//注冊通訊路徑
Naming.rebind("rmi://127.0.0.1:6600/PersonService",personService);
System.out.println("ServiceStart!");
}catch(Exceptione){
//TODOAuto-generatedcatchblock
e.printStackTrace();
}
}
}
最後建立客戶端進行測試，注意客戶調用的RMI路徑必須伺服器配置一致
代碼
packagermi.remotingclient;
importjava.rmi.Naming;
importjava.util.List;
importrmi.model.PersonEntity;
importrmi.service.*;
publicclassProgram{
publicstaticvoidmain(String[]args){
try{
//調用遠程對象，注意RMI路徑與介面必須與伺服器配置一致
PersonServicepersonService=(PersonService)Naming.lookup("rmi://127.0.0.1:6600/PersonService");
List<PersonEntity>personList=personService.GetList();
for(PersonEntityperson:personList){
System.out.println("ID:"+person.getId()+"Age:"+person.getAge()+"Name:"+person.getName());
}
}catch(Exceptionex){
ex.printStackTrace();
}
}
}
常見錯誤
在命令提示符調用java命令時，顯示並無此命令。這是因為未在「環境變數」中綁定JAVA的JDK命令造成的，你首先單擊「計算機右鍵」->「屬性」->「高級」->「環境變數」。在系統變數Path設置中載入為JDK的路徑 .;D:Program FilesGenuitecCommoninarycom.sun.java.jdk.win32.x86_1.6.0.013in。然後在ClassPath載入伺服器端的Program.class地址 .;D:\RMIRemotingServicein
在調用javac命令時出現「javac 找不到文件 ..... 」此錯誤，可能是因為閣下輸入的文件路徑出現錯誤造成，注意不要把D:\RMIRemotingServicesrc>javac rmi/remotingservice/Program.java寫錯為D:\RMIRemotingServicesrc>javac rmi.remotingservice.Program.java
在調用D:\RMIRemotingServicein>java rmi/remotingservice/Program命令時出現「Exception in thread 'main' java.lang.NoClassEdfoundError」錯誤，第一這可能是閣下把Program錯寫為Program.class，注意java命令不需要加後綴名。第二可能是閣下把「java rmi/remotingservice/Program」錯寫為「java rmi emotingserviceProgram"。
④ java jdk Rmi遠程調用
加個埠試試！
然後啟動服務，telnet 一下。看看埠開放沒有
埠隨便。你啟動server後。telnet一下。看看你設置的那個埠響應不。
這是server
public class RMIServer {
public static void registRemoteObject() throws Exception {
IRemoteImp impl = new IRemoteImp();
Naming.rebind("rmi://127.0.0.1:1111/mytask", impl);
System.out.println("bound success!");
}
/**
* 創建一個Registry對象
*
* @return 返回一個Registry對象
*/
private static Registry createRegistry() {
Registry registry = null;
int port = 1111;
try {
registry = LocateRegistry.getRegistry(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 {
IRemoteImp impl = new IRemoteImp();
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();
}
}
}
這是客戶端
public class RMIClient {
public static void getRemoteObject() throws Exception{
IRemote obj = (IRemote)Naming.lookup("rmi://127.0.0.1:1111/mytask"); //得到遠程發布的服務
Task task = new Task();
task.doWork();
Object result = obj.invoke(task);
}
/**
* @param args
* @throws Exception
*/
public static void main(String[] args) throws Exception {
RMIClient.getRemoteObject();
}
}
⑤ java rmi連接遠程主機問題
你綁定的ip是什麼，好像只能訪問到那個IP，
你發布的RMI，應該是綁定對應網卡的
⑥ 那位大神幫忙 Java RMI 遠程訪問怎麼只能在局域進行訪問。要訪問外網應該怎麼弄
如果你們單位有外網的固定IP，可以在路由器上把伺服器的6672埠映射出去，外網客戶端直接訪問外網地址加6672的埠就行了
⑦ java rmi服務佔用哪個埠
默認本地 1099
⑧ java rmi怎樣實現伺服器間的通信
首先要選用技術，這很明顯做個socket就行，簡單通訊，還可以擴展為非區域網的主機。
1，編寫socket伺服器端 放在主伺服器上，利用開機啟動的方式啟動server
並保持監聽某埠
2，編寫socket客戶端放在 你需要的從屬伺服器上，同樣利用開機啟動的方式
運行client，然後程序中利用 經過包裝client.getOutputStream()的流，向伺服器發送消息，就是那個ip （當字元串發，轉換為byte[]）
(細節我就不介紹了…… )
3，匯總的實質就是 server 利用
client.getInputStream()的包裝流(假如叫in)
存放數據的數組，假如叫 bytep[] buf;
獲得數據 in.read(buf,0,buf.length);
然後：
File file = new File("D://log.txt");//假如是你要的log文件
FileInputStream fis =new FileInputStream(file);
fis.write(buf);
這樣就搞定了
細節注意點：由於log文件需要保留舊數據，所以寫文件的時候要注意選用Acess流進行插入。另外，當從屬伺服器關閉的時候，也要發個信息過來，把對應的ip刪除掉哦！
給我分唄
⑨ 哪些埠是通過java RMI連接使用
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
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
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編程。
一個簡單的RMI系統，一般可以分成4個文件，下面來介紹各個文件的創建和作用
第一步：創建一個遠程對象介面
import java.rmi.Remote;
import java.rmi.RemoteException;
/*
* 這個介面繼承自Remote，每一個定義的方法都必須拋出一個RemoteException異常對象
* 我們可供遠程調用的方法就是通過這里開公開
*/ public interface IRMI extends Remote{
public String invoke() throws RemoteException;
} 12345678910
第二步：創建介面的具體實現類
import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;
/*
* 遠程對象的實現
* 公開方法的具體實現就是這里定義的
*/ public class IRMIImpl extends UnicastRemoteObject implements IRMI {
protected IRMIImpl() throws RemoteException {
super(); // 這個實現必須有一個顯式的構造函數，並且要拋出一個RemoteException異常
}
private static final long serialVersionUID = 6131922116577454476L;
public String invoke() throws RemoteException { //該方法公開
return "hello,world!";
}
public String tryInvoke() throws RemoteException{ //該方法未公開，若要公開請在介面中定義
return "try to remote me";
}
}
第三步：創建RMI伺服器
import java.rmi.Naming;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
/*
* 遠程對象的注冊類 該類應該在伺服器端執行，執行之後
* 該機器將變為RMI伺服器 客戶端可以通過正確的url來訪問
* 伺服器上的遠程對象，執行對外報露的方法
*/ public class RMIServer {
static int port = 8888;
/*
* 創建一個Registry對象.
* LocateRegistry用於獲取名字服務或創建名字服務.
* 調用LocateRegistry.createRegistry(int port)方法可以在某一特定埠創建名字服務,從而用戶無需再手工啟動rmiregistry
* @return 返回一個Registry對象
*/
private static Registry createRegistry() {
Registry registry = null;
try {
registry = LocateRegistry.getRegistry(port); //如果該埠未被注冊，則拋異常
registry.list(); //拿到該埠注冊的rmi對象
} catch (final Exception e) {
try {
registry = LocateRegistry.createRegistry(port);//捕獲異常，埠注冊
} catch (final Exception ee) {
ee.printStackTrace();
}
}
return registry;
}
/**
* 將對象注冊到rmi伺服器上
*/
public static void bind() {
Registry registry = createRegistry();
try {
IRMIImpl impl = new IRMIImpl();
registry.rebind("mytask", impl); //這就是綁定,client里lookup必須和"mytast"一樣才能遠程調用impl
} catch (Exception e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
try {
bind();
} catch (Exception e) {
e.printStackTrace();
}
}
}
上面是一種比較好的寫法，如果只是要測試，可以直接在main()方法中寫:
ImplementClass ic = new ImplementClass(); //具體實現類
Registry r = LocateRegistry.createRegistry(8888);
r.bind("mytask", ic);
//Naming.rebind("rmi://localhost:8888/mytask", ic); 可替換上句 1234
1.注冊一個埠 2.在注冊埠綁定taskName和implementClass 3.客戶端就可以通過url和taskName來找到implementClass。
第四步：創建RMI客戶端
import java.rmi.Naming;
public class RMIClient {
/**
* 調用遠程對象中的方法
* @throws Exception
*/
public static void getRemoteObject() throws Exception{
/*得到遠程發布的服務
返回與指定 name 關聯的遠程對象的引用（一個stub）*/
IRMI obj = (IRMI)Naming.lookup("rmi://localhost:"+RMIServer.port+"/mytask"); //註：通過介面拿
System.out.println(obj.invoke()); //調用遠程服務的方法
}
public static void main(String[] args) {
try {
getRemoteObject();
} catch (Exception e) {
e.printStackTrace();
}
}
} 24
運行RMI系統：啟動RMI伺服器，啟動客戶端即可。
⑩ 請教一個關於java rmi遠程調用 傳遞自定義對象的問題
RMI(Remote Method Invocation)遠程方法調用是一種計算機之間利用遠程對象互相調用實現雙方通訊的一種通訊機制。使用這種機制，某一台計算機上的對象可以調用另外一台計算機上的對象來獲取遠程數據。RMI是Enterprise JavaBeans的支柱，是建立分布式Java應用程序的方便途徑。在過去，TCP/IP套接字通訊是遠程通訊的主要手段，但此開發方式沒有使用面向對象的方式實現開發，在開發一個如此的通訊機制時往往令程序員感覺到乏味，對此RPC(Remote Procere Call）應運而生，它使程序員更容易地調用遠程程序，但在面對復雜的信息傳訊時，RPC依然未能很好的支持，而且RPC未能做到面向對象調用的開發模式。針對RPC服務遺留的問題，RMI出現在世人面前，它被設計成一種面向對象的通訊方式，允許程序員使用遠程對象來實現通信，並且支持多線程的服務，這是一次遠程通訊的革命，為遠程通信開辟新的里程碑。
RMI的開發步驟
先創建遠程介面及聲明遠程方法，注意這是實現雙方通訊的介面，需要繼承Remote
開發一個類來實現遠程介面及遠程方法，值得注意的是實現類需要繼承UnicastRemoteObject
通過javac命令編譯文件，通過java -server 命令注冊服務，啟動遠程對象
最後客戶端查找遠程對象，並調用遠程方法
簡單實例
首先為服務建立一個Model層，注意因為此對象需要現實進行遠程傳輸，所以必須繼承Serializable
代碼
創建遠程介面PersonService,注意遠程介面需要繼承Remote
代碼
建立PersonServiceImpl實現遠程介面，注意此為遠程對象實現類，需要繼承UnicastRemoteObject
代碼
建立伺服器端，在伺服器端注冊RMI通訊埠與通訊路徑，然後通訊javac命令編譯文件，通過java -server 命令注冊服務。以下面代碼為例，如果閣下將項目建立於D:\\RMI\RemotingService文件夾上時，則先輸入D:\\RMI\RemotingService\src>javac rmi/remotingservice/Program.java獲取Program.class（如何閣下使用的MyEclipse等開發工具，可跳過此步，直接在*/bin文件夾中直接調用已經生成的Program.class），然後輸入D:\\RMI\RemotingService\src>java rmi/remotingservice/Program啟動服務。
代碼
最後建立客戶端進行測試，注意客戶調用的RMI路徑必須伺服器配置一致
代碼
常見錯誤
在命令提示符調用java命令時，顯示並無此命令。這是因為未在「環境變數」中綁定JAVA的JDK命令造成的，你首先單擊「計算機右鍵」->「屬性」->「高級」->「環境變數」。在系統變數Path設置中載入為JDK的路徑 .;D:\Program Files\Genuitec\Common\binary\com.sun.java.jdk.win32.x86_1.6.0.013\bin。然後在ClassPath載入伺服器端的Program.class地址 .;D:\\RMI\RemotingService\bin
在調用javac命令時出現「javac 找不到文件 ..... 」此錯誤，可能是因為閣下輸入的文件路徑出現錯誤造成，注意不要把D:\\RMI\RemotingService\src>javac rmi/remotingservice/Program.java寫錯為D:\\RMI\RemotingService\src>javac rmi.remotingservice.Program.java
在調用D:\\RMI\RemotingService\bin>java rmi/remotingservice/Program命令時出現「Exception in thread 'main' java.lang.NoClassEdfoundError」錯誤，第一這可能是閣下把Program錯寫為Program.class，注意java命令不需要加後綴名。第二可能是閣下把「java rmi/remotingservice/Program」錯寫為「java rmi\remotingservice\Program"。