⑴ 哪些埠是通過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客戶端也要實現服務端的介面嗎
兩邊是通過介面來交換信息的，當然都需要介面和它的 Stub。
你做實驗時可以考慮創建3個項目：
1、介面項目，只包括介面和介面編譯後的 Stub 類
2、服務端項目，只包括伺服器類，它依賴介面項目。
3、客戶端項目，只包括客戶端，它依賴介面項目。
如果是從命令行運行它們，那麼服務端需要服務端項目和介面項目兩個 jar，客戶端需要客戶端項目和介面項目兩個 jar，我們需要面向介面編程減少耦合程度，不要把所有類全部放在同一個項目中編譯，將來會碰到很多麻煩事，比如包名太多就可能不支持 OSGi 這種方式。
在遠程調用類的應用中，使用靜態方法調用時一般需要介面類對應的Stub，我們 lookup 得到的其實是 Stub （它只包括了連接到伺服器的參數，然後把你想調用的」服務「 + 」參數「 發送給伺服器並將從伺服器返回的結果返回給客戶端程序，因此，它其實並沒有什麼」針對你的程序和伺服器的特殊特性），使用動態的調用方式就完全可以做到不需要特定的 Stub 而用一個通用的方式 （也就是 RMI 編譯生成的那個 Stub 類的內容我們來自己寫成一個框架。
上面一段是廢話，來說說怎麼配置環境測試它們。
客戶端項目中只需要有介面 TestServer 和 TestServerStub 兩個類，如果你的參數本身也是一個 Remote 子類，那麼參數類也需要有相應的 Stub。
另外，我們客戶端也可以僅自帶介面類而不自帶Stub，在運行的時候可以」請求從伺服器上下載一份 Stub"，如下：
System.setSecurityManager(newRMISecurityManager());
然後在命令行添加額外參數:
-Djava.security.policy=$policy文件
-Djava.rmi.server.codebase=file:///C:/service-interface/classes/
這樣就可以啟用RMIClassLoader來自動從codebase對應的地方查找Stub類，這裡面codebase可以是一個Http或Ftp協議，注意這個codebaseURL後面一個/是必須的。那個$policy文件可以用JDKinpolicytool.exe來生成一個。
⑶ RMI是干什麼用的在JAVA裡面
RMI是J2EE的網路機制，允許你編寫分布式對象，使得對象的通信范圍能夠在內存中，跨Java虛擬機，跨物理設備
RMI-IIOP遵循了介面和實現的原則。你寫的所有網路代碼都是應用於介面，而不是實現。實際上，你必須使用RMI-IIOP中的範例，沒有其它的選擇。直接在你的對象實現上執行遠程調用是不可能的，你只能在對象類的介面上單獨進行這一操作。
所以我們在使用RMI-IIOP時，你必須建立一個客戶介面，叫做remote interface。這個遠程介面應該擴展java.rmi.Remote介面。
RMI應用程序通常包括兩個獨立的程序：伺服器程序和客戶機程序。典型的伺服器應用程序將創建多個遠程對象，使這些遠程對象能夠被引用，然後等待客戶機調用這些遠程對象的方法。而典型的客戶機程序則從伺服器中得到一個或多個遠程對象的引用，然後調用遠程對象的方法。RMI為伺服器和客戶機進行通信和信息傳遞提供了一種機制。
在與遠程對象的通信過程中，RMI使用標准機制：stub和skeleton。遠程對象的stub擔當遠程對象的客戶本地代表或代理人角色。調用程序將調用本地stub的方法，而本地stub將負責執行對遠程對象的方法調用。在RMI中，遠程對象的stub與該遠程對象所實現的遠程介面集相同。調用stub的方法時將執行下列操作：(1) 初始化與包含遠程對象的遠程虛擬機的連接；(2) 對遠程虛擬機的參數進行編組（寫入並傳輸）；(3) 等待方法調用結果；(4) 解編（讀取）返回值或返回的異常；(5) 將值返回給調用程序。為了向調用程序展示比較簡單的調用機制，stub將參數的序列化和網路級通信等細節隱藏了起來。在遠程虛擬機中，每個遠程對象都可以有相應的skeleton（在JDK1.2環境中無需使用skeleton）。Skeleton負責將調用分配給實際的遠程對象實現。它在接收方法調用時執行下列操作：(1) 解編（讀取）遠程方法的參數；(2) 調用實際遠程對象實現上的方法；(3) 將結果（返回值或異常）編組（寫入並傳輸）給調用程序。stub和skeleton由rmic編譯器生成。
⑷ Java RMI調用遠程程序拋出異常
背景要求：定時監控遠程主機上mongodb資料庫內存使用的情況，當內存使用過大時暫停邏輯處理線程後啟動內存空間的釋放處理線程，釋放完成後再啟動邏輯處理線程。
操作系統：CentOS 64bit (Linux)
步驟（代碼省略）：
1.創建Socket遠程伺服器
2.創建客戶端
配置：
#查找對象stub埠
RMI_PORT=9902
#服務埠
RMI_SERV_RMI_PORT=9903
#注冊服務地址埠要和查找對象stub埠一致
RMI_URL=rmi://192.168.0.118:9902/MongoServer
#綁定IP
RMI_IP=192.168.0.118
#檢查內存shell
RMI_MEMQUERY_COMMAND=sh /home/test/BI/smartshow14/MongoDBRMIServer/memquery.sh
#釋放內存shell
RMI_MEMFREE_COMMAND=sh /home/test/BI/smartshow14/MongoDBRMIServer/memclear.sh
#釋放內存容量閥值,單位M
RMI_MEM_CAPACITY_LIMIT=3000
3.啟動伺服器
客戶端線程通過 rmi://192.168.0.118:9902/MongoServer 訪問時出現異常：
--定時掃描MONGODB內存線程--：開始運行！
java.rmi.UnmarshalException: error unmarshalling return; nested exception is:
java.lang.ClassNotFoundException: com.linkage.iface.IMongoDBScan (no security manager: RMI class loader disabled)
at sun.rmi.registry.RegistryImpl_Stub.lookup(Unknown Source)
at java.rmi.Naming.lookup(Naming.java:84)
at com.linkage.querytool.QueryRMICaller.ramCapacityScan(QueryRMICaller.java:87)
at com.linkage.querytool.MongoDBARMScanThread$TimerWorkTask.run(MongoDBARMScanThread.java:94)
at java.util.TimerThread.mainLoop(Timer.java:512)
at java.util.TimerThread.run(Timer.java:462)
Caused by: java.lang.ClassNotFoundException: com.linkage.iface.IMongoDBScan (no security manager: RMI class loader disabled)
at sun.rmi.server.LoaderHandler.loadProxyClass(LoaderHandler.java:535)
at java.rmi.server.RMIClassLoader$2.loadProxyClass(RMIClassLoader.java:628)
at java.rmi.server.RMIClassLoader.loadProxyClass(RMIClassLoader.java:294)
at sun.rmi.server.MarshalInputStream.resolveProxyClass(MarshalInputStream.java:238)
at java.io.ObjectInputStream.readProxyDesc(ObjectInputStream.java:1530)
at java.io.ObjectInputStream.readClassDesc(ObjectInputStream.java:1492)
at java.io.ObjectInputStream.readOrdinaryObject(ObjectInputStream.java:1731)
at java.io.ObjectInputStream.readObject0(ObjectInputStream.java:1328)
at java.io.ObjectInputStream.readObject(ObjectInputStream.java:350)
... 6 more
--定時掃描MONGODB內存線程--：處理結束！
=======================================================================================================
--定時掃描MONGODB內存線程--：開始運行！
java.security.AccessControlException: access denied (java.net.SocketPermission 192.168.0.118:9902 connect,resolve)
at java.security.AccessControlContext.checkPermission(AccessControlContext.java:374)
at java.security.AccessController.checkPermission(AccessController.java:546)
at java.lang.SecurityManager.checkPermission(SecurityManager.java:532)
at java.lang.SecurityManager.checkConnect(SecurityManager.java:1034)
at java.net.Socket.connect(Socket.java:524)
at java.net.Socket.connect(Socket.java:478)
at java.net.Socket.<init>(Socket.java:375)
at java.net.Socket.<init>(Socket.java:189)
at sun.rmi.transport.proxy.RMIDirectSocketFactory.createSocket(RMIDirectSocketFactory.java:22)
at sun.rmi.transport.proxy.RMIMasterSocketFactory.createSocket(RMIMasterSocketFactory.java:128)
at sun.rmi.transport.tcp.TCPEndpoint.newSocket(TCPEndpoint.java:595)
at sun.rmi.transport.tcp.TCPChannel.createConnection(TCPChannel.java:198)
at sun.rmi.transport.tcp.TCPChannel.newConnection(TCPChannel.java:184)
at sun.rmi.server.UnicastRef.newCall(UnicastRef.java:322)
at sun.rmi.registry.RegistryImpl_Stub.lookup(Unknown Source)
at java.rmi.Naming.lookup(Naming.java:84)
at com.linkage.querytool.QueryRMICaller.ramCapacityScan(QueryRMICaller.java:89)
at com.linkage.querytool.MongoDBARMScanThread$TimerWorkTask.run(MongoDBARMScanThread.java:94)
at java.util.TimerThread.mainLoop(Timer.java:512)
at java.util.TimerThread.run(Timer.java:462)
--定時掃描MONGODB內存線程--：處理結束！
============================================================================================================
--定時掃描MONGODB內存線程--：開始運行！
java.security.AccessControlException: access denied (java.lang.RuntimePermission createSecurityManager)
at java.security.AccessControlContext.checkPermission(AccessControlContext.java:374)
at java.security.AccessController.checkPermission(AccessController.java:546)
at java.lang.SecurityManager.checkPermission(SecurityManager.java:532)
at java.lang.SecurityManager.<init>(SecurityManager.java:282)
at java.rmi.RMISecurityManager.<init>(RMISecurityManager.java:45)
at com.linkage.querytool.QueryRMICaller.ramCapacityScan(QueryRMICaller.java:88)
at com.linkage.querytool.MongoDBARMScanThread$TimerWorkTask.run(MongoDBARMScanThread.java:94)
at java.util.TimerThread.mainLoop(Timer.java:512)
at java.util.TimerThread.run(Timer.java:462)
--定時掃描MONGODB內存線程--：處理結束！
==========================================================================================================
以上異常都有可能出現，通過以下方式可解除問題：
1.在客戶端程序前打開安全管理器：
try {
System.setSecurityManager(new java.rmi.RMISecurityManager());
mds = (IMongoDBScan) Naming.lookup(urlStr);
} catch (MalformedURLException e) {
//..........
}
2.修改/usr/java/jdk1.6.0_21/jre/lib/security/java.policy後重啟
grant {
permission java.security.AllPermission;
}
⑸ android 怎麼使用java rmi
1、定義一個遠程介面
IHello.java代碼如下：
importjava.rmi.Remote;
{
publicStringsayHello(Stringname)throwsjava.rmi.RemoteException;
}
2、實現遠程的介面（服務端就在此遠程介面的實現類中）
HelloImpl.java代碼如下：
importjava.rmi.RemoteException;
importjava.rmi.server.UnicastRemoteObject;
{
//這個實現必須有一個顯式的構造函數，並且要拋出一個RemoteException異常
protectedHelloImpl()throwsRemoteException{
super();
}
/**
*說明清楚此屬性的業務含義
*/
=4077329331699640331L;
publicStringsayHello(Stringname)throwsRemoteException{
return"Hello"+name+"^_^";
}
publicstaticvoidmain(String[]args){
try{
IHellohello=newHelloImpl();
java.rmi.Naming.rebind("rmi://localhost:1099/hello",hello);
System.out.print("Ready");
}catch(Exceptione){
e.printStackTrace();
}
}
}
3、新建RMI客戶端調用程序
Hello_RMI_Client.java代碼如下：
importjava.rmi.Naming;
publicclassHello_RMI_Client{
publicstaticvoidmain(String[]args){
try{
IHellohello=(IHello)Naming.lookup("rmi://localhost:1099/hello");
System.out.println(hello.sayHello("zhangxianxin"));
}catch(Exceptione){
e.printStackTrace();
}
}
}
4、編譯並運行
4.1 用javac命令編譯IHello.java、HelloImpl.java、Hello_RMI_Client.java
>javac*.java
4.2用rmic命令生成樁和框架文件
>rmicHelloImpl
成功執行完上面的命令可以發現生成一個HelloImpl_stub.class文件，如果JDK是使用Java2SDK，那麼還可以發現多出一個HelloImpl_Skel.class文件。如果服務端程序與客戶端程序在同一台機器上並在同一目錄中，則可以省略掉介面實現類生成的樁和框架文件，但這就失去了使用RMI的意義，而如果要在不同的JVM上運行時，客戶端程序就必須得依靠服務端運程方法實現的樁和框架文件以及介面類。
4.3運行注冊程序RMIRegistry，必須在包含剛寫的類的目錄下運行這個注冊程序。
>rmiregistry
注冊程序開始運行了，不要管他，現在切換到另外一個控制台運行伺服器
4.4運行伺服器HelloImpl
>javaHelloImpl
當啟動成功出現Ready......這個伺服器就開始工作了，把介面的實現載入到內存等待客戶端的聯接。現在切換到第三個控制台，啟動我們的客戶端。
4.5啟動客戶端:為了在其他的機器運行客戶端程序你需要一個遠程介面(IHello.class)和一個stub(HelloImpl_Stub.class)。使用如下命令運行客戶端
>javaHello_RMI_Client
當運行成功會在控制台列印：Hellozhangxianxin（www.tiecou.com） ^_^
備註：如果不想在控制台上開啟RMI注冊程序RMIRegistry的話，可在RMI服務類程序中添加LocateRegistry.createRegistry(1099); 如下所示：
修改後的HelloImpl.java代碼如下：
importjava.rmi.RemoteException;
importjava.rmi.registry.LocateRegistry;
importjava.rmi.server.UnicastRemoteObject;
{
//這個實現必須有一個顯式的構造函數，並且要拋出一個RemoteException異常
protectedHelloImpl()throwsRemoteException{
super();
}
=4077329331699640331L;
publicStringsayHello(Stringname)throwsRemoteException{
return"Hello"+name+"^_^";
}
publicstaticvoidmain(String[]args){
try{
IHellohello=newHelloImpl();
LocateRegistry.createRegistry(1099);//加上此程序，就可以不要在控制台上開啟RMI的注冊程序，1099是RMI服務監視的默認埠
java.rmi.Naming.rebind("rmi://localhost:1099/hello",hello);
System.out.print("Ready");
}catch(Exceptione){
e.printStackTrace();
}
}
}
⑹ 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中rmi和corba的區別
java中rmi和corba的區別：
1、定義介面：
rmi自己定義介面（interface）
corba生成idl代碼，然後使用idlj -fall name.idl生成介面和幾個類文件
2、啟動服務：
rmi啟動的是rmiregistry (port)默認1099
corba啟動的是tnameserv
3、實現的繼承類：
rmi extends UnicastRemoteObject
corba extends 運行idlj時 生成的_NameImplBase
4、實現類的rebind
rmi可以直接rebind 如：Naming.rebind("rmi://localhost/meeting",meetingserver);
corba需要先調用init（）如：
ORB orb=ORB.init(avgs,null);
MOTDImpl impl=new MOTDImpl(motdFile);
orb.connect(impl);
org.omg.CORBA.Object objRef=
orb.resolve_initial_references("NameService");
NamingContext ncRef=NamingContextHelper.narrow(objRef);
NameComponent nc=new NameComponent(motdService,"");
NameComponent[] path=new NameComponent[]{nc};
ncRef.rebind(path,impl);
這里corba就要麻煩很多了
5、客戶端調用corba的調用跟實現類的綁定差不多如：
ORB orb=ORB.init(avgs,null);
org.omg.CORBA.Object objRef=
orb.resolve_initial_references("NameService");
NamingContext ncRef=NamingContextHelper.narrow(objRef);
NameComponent nc=new NameComponent("MessageOfTheDay","");
NameComponent path[]=new NameComponent[]{nc} ;
org.omg.CORBA.Object motdObj=ncRef.resolve(path);
MOTD motdRef=MOTDHelper.narrow(motdObj);
System.out.println(motdRef.getMOTD());
rmi只要lookup就可以了
總的來說其實rmi和corba都差不多，都是樁和框架，兩者相互競爭，但是在java中都可以相互調用。這歸功於rmi_iiop.
⑻ 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遠程調用 傳遞自定義對象的問題
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"。