搭建rmi伺服器

1. 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刪除掉哦！

給我分唄

2. 如何讓 RMI 程序同時支持 IPv4 和 IPv6

實踐證明它是健壯，易於實現，並具有很好的互操作性。但是 IPv4 協議的初始設計仍有一些未考慮到的地方，隨著 Internet 的飛速發展和新型應用的不斷涌現，這些不足逐漸顯露出來。首先，近年來 Internet 成指數級數增長，而只有 32 位地址的 IPv4 引起了迫在眉睫的 IP 地址空間耗盡的問題；第二，IPv4 路由結構較為扁平，使得 Internet 上骨幹路由器需要維護龐大的路由表；第三，目前 IPv4 實現方案中，多數情況需要手工配置或者使用 DHCP 有狀態方式配置協議，隨著越來越多的節點要求接入網路，需要一種簡便的配置方式；第四，在 IP 級的安全方面，IPv4 並不強制使用 IPSec ；最後，IPv4 協議中使用服務類型 TOS 欄位來支持實時通信流傳送，而 TOS 功能有限，因此對實時數據傳輸 Qos 的支持不是很理想。為解決上述問題及其它相關問題，互聯網工程任務組織 IETF 開發了一套新的協議和標准即 IP 版本 6（IPv6）。它吸納了很多用於更新 IPv4 的新思想，在設計時力求對上下層協議造成最小的影響。與 IPv4 相比，IPv6 協議具有以下一些新的特性：IPv6 協議頭採用了固定長度的頭部，路由器在處理 IPv6 報頭時，效率會更高。IPv6 具有 128 位的巨大地址空間，既便為當前所有主機都分配一個 IPv6 地址，IPv6 仍然有充足的地址供以後使用。IPv6 具有即插即用特性。 IPv6 引入了無狀態地址自動配置方式，鏈路上的主機根據路由公告和自身的鏈路地址可以自動生產一個 IPv6 地址，從而簡化了入網主機的配置過程，實現了 IPv6 的即插即用。提供網路層的認證和加密。 IPv6 支持 IPSec，這為網路安全提供了一種基於標準的解決方案。IPv6 更好地支持 QoS 。 IPv6 協議頭部包含流標簽欄位，使得路由器可以對屬於一個流的數據包進行識別和提供特殊處理；用業務流分類欄位來區分通信流的優先順序。因此 IPv6 對 QoS 提供了更好的支持。IPv6 更好地支持移動性。雖然 IPv4 也有移動特性，但是作為 IPv4 的擴展實現，受到體系結構和連通性的限制。而 IPv6 的移動特性是內置的，具有較少的局限性並具有更強的可伸縮性和健壯性，可滿足將來 Internet 的通信需求。IPv6 具有很好的可擴展性，這可通過在 IPv6 協議頭之後添加新的擴展協議頭實現。回頁首Java 對 IPv6 的支持Java 從 1.4 開始，已經提供了對 IPv6 的支持。 Java APIs 遵循了如下 IPv6 標准：RFC2373: IPv6 Addressing ArchitectureRFC2553: Basic Socket Interface Extensions for IPv6RFC2732: Format for Literal IPv6 Address in URL但是由於安全等因素，Java 並沒有支持原始套接字。除此之外，一些 IPv6 特性，諸如隧道，自動配置，移動 IP 等，Java 都沒有提供支持。與 C/C++ 對 IPv6 的支持不同，Java 對 IPv6 的支持是自動和透明的，也就是說現有的 Java 程序不需要經過修改就可以直接支持 IPv6 。以下面代碼為例，這段代碼在 IPv4 上可以正常運行，同樣也可以工作在 IPv6 上。InetAddress ip = InetAddress.getByName("java.sun.com"); Socket s = new Socket(ip, 80);Java 對 IPv6 的支持體現在其 JDK 對 IPv6 的支持上，當然前提條件是操作系統需要提供對 IPv6 的支持。以下操作系統已經提供了對 IPv6 的支持，表1. OS 對 IPv6 的支持Windows:Windows 2000Windows XPWindows NTWindows 2003 serverlinux:Linux kernel 2.2 及以上版本Unix:AIX 4.3 及以上版本Solaris 8 及以上版本HP-UX 11i 及以上版本BSD/OS 4.0 及以上版本True64 Unix 4.0D 及以上版本FreeBSD 4.0 及以上版本NetBSDOpenBSD 2.7 及以上版本Other OS:OS/390, Z/OS V1R4 及以上版本OS400 V5R2 及以上版本Mac OS X下面列出了各個版本 JDK 對 IPv6 的支持情況。表2. JDK 對 IPv6 的支持JDK/ JDK 1.4NOYESYESNOIBM JDK 1.5YESYESYESYESSUN JDK 1.4NOYESYESSUN JDK 1.5YESYESYESJRockit JDK 1.4NOYESJRockit JDK 1.5YESYESHP-UX JDK 1.4YESHP-UX JDK 1.5YES回頁首RMI 對 IPv6 的支持既然Java 對 IPv6 的支持是透明的，那麼 RMI 程序理論上就應該同時支持 IPv4 和 IPv6，但測試結果告訴我們只有在 RMI 伺服器端套接字不綁定 IP 地址的情況下這種結論才成立。考慮下面這樣一個例子，一個支持雙棧的伺服器，同時配置了 IPv4 地址和 IPv6 地址。伺服器應用程序用如下代碼創建了一個伺服器套接字，等待客戶端的連接。由於 Java 對 IPv6 的透明支持，IPv4 和 IPv6 的客戶端都可以正常連接到這台伺服器上。清單1. 無 IP 綁定的伺服器套接字程序 try { int port = 2000; ServerSocket srv = new ServerSocket(port); Socket socket = srv.accept(); } catch (IOException e) { e.printStackTrace(); }通過natestat – na可以看出，伺服器監聽在 0.0.0.0:2000 上，這樣任何客戶端都可以連接到伺服器上，其中包括 IPv6 客戶端用伺服器的 IPv6 地址也能順利連接。Proto Local Address Foreign Address State TCP 0.0.0.0:2000 0.0.0.0:0 LISTENING但是很多時候，應用程序從安全等角度考慮，常常需要將伺服器套接字綁定在某個具體的 IP 上。現在我們假設把伺服器套接字綁定在一個 IPv4 地址上，如下程序所示：清單2. 綁定 IP 的伺服器套接字程序 try { int port = 2000; ServerSocket srv = new ServerSocket(port); srv.bind(new InetSocketAddress( 「 9.181.27.34 」 , port) Socket socket = srv.accept(); } catch (IOException e) { e.printStackTrace(); }通過natestat – na，我們可以發現監聽方式已改變： Proto Local Address Foreign Address State TCP 9.181.27.34:2000 0.0.0.0:0 LISTENING從套接字的定義看出，它由 IP 和埠組成，它們唯一確定了一個套接字，同時也限定了訪問套接字的方式。在訪問由固定 IP 和埠組成的套接字時，客戶端必須指定伺服器的 IP 和埠才能正常連接。在伺服器綁定 IPv4 地址的情況下，IPv6 客戶端就無法用伺服器的 IPv6 地址進行訪問，當然 IPv4 客戶端能通過伺服器的 IPv4 地址 9.181.27.34 進行連接訪問。上面分析了 Java 對 IPv6 的支持以及伺服器套接字如何影響客戶端的連接，接下來我們用實例分析 RMI 對 IPv6 的支持。我們搭建了如下的實驗環境：圖1. 實驗環境接下來，我們設計了一個基本的 RMI 應用程序，下面這段是 RMI 伺服器程序：清單3. RMI 伺服器程序 import java.rmi.*; import java.rmi.server.*; import java.rmi.registry.*; public class SampleServerImpl extends UnicastRemoteObject implements SampleServer { SampleServerImpl() throws RemoteException { super(); } public int sum(int a,int b) throws RemoteException { return a + b; } public static void main(String args[]) { try { //create a local instance of the object SampleServerImpl Server = new SampleServerImpl(); //put the local instance in the registry Naming.rebind("rmi://9.181.27.34/SAMPLE-SERVER" , Server); System.out.println("Server waiting....."); } catch (java.net.MalformedURLException me) { System.out.println("Malformed URL: " + me.toString()); } catch (RemoteException re) { System.out.println("Remote exception: " + re.toString()); } } }編譯源程序，啟動rmiregistry，然後運行 RMI 伺服器程序。通過netstat – na我們可以看見，RMI 監聽方式如下，盡管我們在程序中用了」Naming.rebind("rmi://9.181.27.34/SAMPLE-SERVER" , Server)」:Proto Local Address Foreign Address State TCP 0.0.0.0:1099 0.0.0.0:0 LISTENING那麼，根據我們上面關於套接字對客戶端連接的影響的分析，我們可以看出在這種情況下，IPv4 RMI 客戶端和 IPv6 RMI 客戶端都應該能夠順利連接 RMI 伺服器。下面我們就看一下 IPv4 客戶端的連接程序：清單4. RMI 客戶端程序 import java.rmi.*; import java.rmi.server.*; public class SampleClient { public static void main(String[] args) { //get the remote object from the registry try { //using RMI server 』 s IPv4 address to connect String url = "//9.181.27.34/SAMPLE-SERVER"; SampleServer remoteObject = (SampleServer)Naming.lookup(url); System.out.println("Got remote object"); System.out.println(" 1 + 2 = " + remoteObject.sum(1,2) ); } catch (RemoteException exc) { System.out.println("Error in lookup: " + exc.toString()); } catch (java.net.MalformedURLException exc) { System.out.println("Malformed URL: " + exc.toString()); } catch (java.rmi.NotBoundException exc) { System.out.println("NotBound: " + exc.toString()); } } }編譯並運行該程序，可以看到正常連接到 RMI 伺服器，運行結果如下：Got remote object 1 + 2 = 3下面我們在 IPv4 RMI 客戶端程序的基礎上作一下改動，用 RMI 伺服器的 IPv6 地址進行連接，修改如下：String url = "//2001:251:1a05::6/SAMPLE-SERVER"; SampleServer remoteObject = (SampleServer)Naming.lookup(url);編譯修改之後的程序，在 IPv6 RMI 客戶端上運行，同樣可以正常連接 RMI 伺服器，運行結果如下：Got remote object 1 + 2 = 3通過這個例子，我們可以看出基本的 RMI 程序對 IPv6 的支持是透明的，它可以同時支持 IPv4 和 IPv6 。通過這個例子，我們也可以看出，它實際上不能綁定 IP 地址，這在安全性要求比較高的企業級應用程序中並不是很合適，它們通常採用UnicastRemoteObject類的exportObject(Remote obj, int port, RMIClientSocketFactory csf, RMIServerSocketFactory ssf)方法來綁定 RMI IP 地址。在RMIServerSocketFactory實例中，創建 RMI 伺服器套接字並綁定 IP 地址，在RMIClientSocketFactory實例中通過伺服器綁定的 IP 地址進行訪問。在RMI 伺服器綁定 IP 地址的情況，如果讓 RMI 同時支持 IPv4 和 IPv6 呢？下面給出了一個解決方案。既然要讓 RMI 同時支持 IPv4 和 IPv6，那麼在伺服器端，我們就要同時創建兩個套接字，一個綁定在 IPv4 地址上，一個綁定在 IPv6 地址上。首先，我們應該創建兩個類IPv4RMIServerSocket和IPv6RMIServerSocket，他們都實現RMIServerSocketFactory介面。IPv4RMIServerSocket創建一個伺服器套接字並綁定在 RMI 伺服器的 IPv4 地址上；IPv6RMIServerSocket創建一個伺服器套接字並綁定在 RMI 伺服器的 IPv6 地址上。其次，在創建兩個類IPv4RMIClientSocket和IPv6RMIClientSocket，他們都實現RMIClientSocketFactory介面。IPv4RMIClientSocket創建一個客戶端套接字並通過 RMI 伺服器的 IPv4 地址進行連接；IPv6RMIClientSocket創建一個客戶端套接字並通過 RMI 伺服器的 IPv6 地址進行連接。然後，在創建好我們需要的伺服器和客戶端類之後，伺服器應用程序需要兩次調用exportObject方法將遠程對象導出。但是有一個問題出現了，同一個遠程對象不能同時導出兩次。如何解決這個問題呢？辦法就是我們需要對遠程對象作一個wrapper。現在假設有一個遠程對象Kernel的類定義如下：清單5. Kernel 類定義 public class Kernel extends Remote{ public void addWebServer(String hostName, int port) throws RemoteException { //Function implementation code } public void changeLogLevel(int level) throws RemoteException { //Function implementation code } }Kernel 的 Wrapper 定義如下：清單6. Kernel 的 Wrapper 類定義 public class KernelWrapper extends Remote { transient Kernel kernel_; public KernelWrapper (Kernel kernel) throws RemoteException, IOException { super(); kernel_ = kernel; } public void addWebServer(String hostName, int port) throws RemoteException { kernel_.addWebServer(hostName, port); } public void changeLogLevel(int level) throws RemoteException { kernel_.changeLogLevel(level); } }在應用程序初始化的時候，實例化一個 Kernel 實例，並將它作為參數實例化兩個 KernelWrapper 實例，如下所示：清單7. KernelWrapper 實例化 kernelObj = new Kernel(); //remote kernel object for IPv4 clients ipv4kernelObj = new KernelWrapper (kernelObj); //remote kernel object for IPv6 clients ipv6kernelObj = new KernelWrapper (kernelObj);最後應用程序需要將 ipv4kernelObj 和 ipv6kernelObj 遠程對象導出，如下所示：清單8. 遠程對象導出 //export remote object for IPv4 client UnicastRemoteObject.exportObject( ipv4kernelObj, 1099, IPv4RMIClientSocket, IPv4RMIServerSocket ) //export remote object for IPv6 client UnicastRemoteObject.exportObject( ipv6kernelObj, 1099, IPv6RMIClientSocket, IPv6RMIServerSocket )這樣IPv4 客戶端通過伺服器的 IPv4 地址進行訪問，而 IPv6 客戶端通過伺服器的 IPv6 地址進行訪問，從而成功的使得 RMI 伺服器在綁定 IP 地址的情況下同時支持 IPv4 和 IPv6 。回頁首結束語本文在分析伺服器套接字對 IPv4 和 IPv6 客戶端的影響的基礎上，介紹了兩種不同的 RMI 應用對 IPv6 的支持情況，同時給出了一種 RMI 伺服器在需要綁定 IP 地址的情況下如何同時支持 IPv4 和 IPv6 客戶端的解決方案。參考資料 IPv6 主頁：IPv6 官方網站。
Networking IPv6 User Guide for J2SDK/JRE 1.4：JDK 1.4 對 IPv6 的支持。
An example of RMI programming：RMI 的簡單例子。
「探索Internet Protocol, version 6 (IPv6)」（developerWorks，2006 年 7 月）：了解 IPv6 的地址格式、主要優點和符合新標準的 IT 產品。
「配置FTP 伺服器以支持 IPv6」（developerWorks，2006 年 8 月）：在本文中，學習配置 File Transfer Protocol (FTP) 伺服器以支持 IPv6，然後通過一個簡單的使用 IPv6 地址的 Java 程序來與 FTP 伺服器通信。
「結合使用 WebSphere Application Server V7 和 IPv6」（developerWorks，2008 年 11 月）：本文將介紹用於驗證 IBM WebSphere Application Server V7 的過程，以驗證其對 IPv6 以及對 IPv4/IPv6 混合模式基礎結構的支持。
developerWorks Java 技術專區：這里有數百篇關於 Java 編程的文章。
關於作者沈剛目前在 IBM Tivoli 部門從事 ITM for Applications 產品開發工作。關閉[x]關於報告濫用的幫助報告濫用謝謝! 此內容已經標識給管理員注意。關閉[x]關於報告濫用的幫助報告濫用報告濫用提交失敗。 請稍後重試。關閉[x]developerWorks：登錄IBM ID：需要一個 IBM ID？忘記IBM ID？密碼：忘記密碼？更改您的密碼 保持登錄。單擊提交則表示您同意developerWorks 的條款和條件。 使用條款 當您初次登錄到 developerWorks 時，將會為您創建一份概要信息。您在developerWorks 概要信息中選擇公開的信息將公開顯示給其他人，但您可以隨時修改這些信息的顯示狀態。您的姓名（除非選擇隱藏）和昵稱將和您在 developerWorks 發布的內容一同顯示。所有提交的信息確保安全。關閉[x]請選擇您的昵稱：當您初次登錄到 developerWorks 時，將會為您創建一份概要信息，您需要指定一個昵稱。您的昵稱將和您在 developerWorks 發布的內容顯示在一起。昵稱長度在 3 至 31 個字元之間。 您的昵稱在 developerWorks 社區中必須是唯一的，並且出於隱私保護的原因，不能是您的電子郵件地址。昵稱：（長度在 3 至 31 個字元之間）單擊提交則表示您同意developerWorks 的條款和條件。 使用條款. 所有提交的信息確保安全。為本文評分評論回頁首

3. RMI建立分布式系統

客戶機可以象調用本地對象的方法一樣用相同的語法調用遠程對象。RMI API提供的類和方法可以處理所有訪問遠程方法的基礎通信和參數引用要求的串列化。

遠程方法調用類似於Sun公司1985年提出的遠程過程調用（RPC）特徵。RPC也要求串列化參數和返回數值數據，但由於沒有涉及對象，情況比較簡單。Sun開發了外部數據表示（XDR）系統，支持數據串列化。RPC和RMI之間的一個重要差別是RPC用快速而不夠可靠的UDP協議，RMI用低速而可靠的TCP/IP協議。

遠程方法調用（RMI）和CORBA都是分布式計算技術，在進行分布式時各有其優缺點，為了有助於了解RMI的特點和用途，有必要討論一下CORBA和RMI的區別。

CORBA（Common Object Request Broker Architecture）是OMG的Object Management Architecture（對象管理結構），它是面向對象的分布式系統建立所依據的標准。CORBA被設計成一個能供所有編程語言使用的一個開放性說明，就是說一個機器上的Java客戶可以要求另一個用SmallTalk或C++的機器服務。正是由於這種語言的獨立性使得CORBA這么靈活和吸引人。為了適應語言獨立性，CORBA採用了非常通用的標准作為其介面。在不同的語言中，遠程調用、簽名和對象的引入有各自不同的定義，所以CORBA必須盡可能的中立和開放。正是這種通用性是CORBA的一個弱點。當開發人員都採用CORBA時，他們要用一種新的標準定義語言介面，它要求開發者學習新的編程介面，從而減小了遠程模型的透明性。

RMI是為僅在Java對Java的分布式計算中而開發的。遠程調用的標準是為了Java和應用Java的自然Java簽名和調用而開發的，這使得RMI對Java的開發者相當透明而且易於實現。RMI用Java語言緊密集成從而同CORBA相比能夠提供非常好的容錯能力及對異常的處理。盡管Java的RMI標准不像CORBA那樣語言獨立，但Java本身是一個獨立的平台，這就使RMI在跨平台的分布軟體開發中是一個很好的選擇。

IIOP
它是一個用於CORBA 2.0及兼容平台上的協議。這個協議的最初階段是要建立以下幾個組件部分：一個IIOP到HTTP的網關，使用這個網關可以讓CORBA客戶訪問WWW資源；一個HTTP到IIOP的網關，通過這個網關可以訪問CORBA資源；一個為IIOP和HTTP提供資源的伺服器，一個能夠將IIOP作為可識別協議的瀏覽器。

4. rmi的角色rmi的運行原理在rmi編程應用中要引入哪些個包

簡介

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 extends UnicastRemoteObject implements AddServer {
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.Java
然後，我們就會發現多了2個新建的類文件，它們分別是AddServerImpl_Stub.class 和AddServerImpl_Skel.class 。

The Coding (Contd.)

我們已經編譯了所有的源代碼，下面我們來創建客戶端和伺服器端，將下面的代碼保存為名字為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 RemoteException, MalformedURLException {
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這個輸出，說明我們已經成功地執行了一個遠程方法。當然，在這里，我們並沒有執行真正意義上的遠程方法，因為我們的計算機既是伺服器，又是客戶機。如果有計算機網路，我們就可以方便地進行執行遠程方法的試驗了。

5. JAVA RMI 請問RMI的伺服器端和客戶端可以分成兩個項目來寫（工具是netbeans)

可以分開寫, 但是你定義那個方法的介面(Interface), 必須要兩邊都有.

這樣才能交流.

6. 如何實現 WebLogic RMI

可以擴展此「標記」介面（即，它作為標識遠程類的標記），以便使用創建遠程對象結構的方法存根控制項創建自己的遠程介面。隨後，可使用遠程類實現自己的遠程介面。此實現會綁定到注冊表中的一個名稱，客戶端或伺服器可在注冊表中查找對象並遠程使用該對象。 如果已經編寫了 RMI 類，則可以通過更改遠程介面以及擴展此介面的類上的導入語句，將其置於 WebLogic RMI 中。要添加對客戶端應用程序的遠程調用，請按名稱在注冊表中查找對象。WebLogic RMI 異常與 java.rmi 異常完全相同，並對其進行了擴展，因此現有介面和實現不必更改異常處理。 實現WebLogic RMI 的步驟 以下部分描述如何實現 WebLogic Server RMI： 創建可以遠程調用的類步驟1. 編寫遠程介面步驟2. 實現遠程介面步驟3. 編譯 Java 類步驟4. 使用 RMI 編譯器編譯實現類步驟5. 編寫調用遠程方法的代碼Hello 代碼示例 創建可以遠程調用的類 只需幾個步驟，即可編寫自己的 WebLogic RMI 類。下面是一個簡單示例。 步驟1. 編寫遠程介面 可被遠程調用的每個類都實現一個遠程介面。使用一種 Java 代碼文本編輯器，編寫符合下列准則的遠程介面。 遠程介面必須擴展介面 java.rmi.Remote（其中不包含任何方法簽名）。在實現介面的每個遠程類中包含將實現的方法簽名。有關如何編寫介面的詳細信息，請參閱 Sun Microsystems JavaSoft 教程中的「Creating Interfaces」。遠程介面必須是公共的。否則，客戶端在嘗試載入實現它的遠程對象時將出現錯誤。與JavaSoft RMI 不同，沒有必要讓介面中的每個方法都在其 throws 塊中聲明 java.rmi.RemoteException。應用程序引發的異常可以特定於應用程序，並且可以擴展 RuntimeException。WebLogic RMI 為 java.rmi.RemoteException 設置了子類，因此如果已存在 RMI 類，將不必更改異常處理。遠程介面不會包含很多代碼。您所需要的只是要在遠程類中實現的方法的方法簽名。 下面是遠程介面的示例，方法簽名為 sayHello()。 package examples.rmi.multihello;import java.rmi.*;public interface Hello extends java.rmi.Remote { String sayHello() throws RemoteException;} 對於JavaSoft 的 RMI，每個實現遠程介面的類必須有附帶的、預先編譯的代理。WebLogic RMI 支持更靈活的運行時代碼生成；WebLogic RMI 支持動態代理和動態創建的位元組代碼（類型正確，但又獨立於實現介面的類）。如果類實現單一的遠程介面，則編譯器生成的代理和位元組代碼將與遠程介面具有相同的名稱。如果類實現多個遠程介面，則編譯生成的代理和位元組代碼的名稱將取決於編譯器使用的名稱重整。 步驟2. 實現遠程介面 仍使用 Java 代碼文本編輯器，編寫用於遠程調用的類。此類應實現在步驟1 中編寫的遠程介面，這意味著需要實現介面中包含的方法簽名。目前，WebLogic RMI 中出現的所有代碼的生成都取決於這個類文件。 對於WebLogic RMI，類不需要擴展 UnicastRemoteObject，而 JavaSoft RMI 則要求擴展它。（可以擴展 UnicastRemoteObject，但這不是必需的。）這樣便能夠保持一個對您的應用程序有意義的類層次。 注意：在Weblogic Server 中，Weblogic RMI 和標准 JDK RMI 均可使用。如果使用 Weblogic RMI，則必須將「java weblogic.rmic ...」作為 rmic 編譯器使用，並且不得將 RMI 實現作為「java.rmi.server.UnicastRemoteObject」的子類創建。如果使用標准 JDK RMI，則必須將「%JAVA_HOME%\bin\rmic」作為 rmic 編譯器使用，並且必須將 RMI 實現類作為「java.rmi.server.UnicastRemoteObject」的子類創建。 類可以實現多個遠程介面。類也可以定義非遠程介面中的方法，但是不能遠程調用這些方法。 此示例將實現一個類，此類創建多個 HelloImpl 並將每個 HelloImpl 都綁定到注冊表中的一個唯一的名稱。方法 sayHello() 問候用戶，並標識已遠程調用的對象。 package examples.rmi.multihello;import java.rmi.*;public class HelloImpl implements Hello { private String name; public HelloImpl(String s) throws RemoteException { name = s; } public String sayHello() throws RemoteException { return "Hello!From " + name; } 接下來，編寫一個 main() 方法，以創建遠程對象的實例，並通過將其綁定到一個名稱（指向對象的實現的 URL）將其注冊到 WebLogic RMI 注冊表中。需要獲取代理以遠程使用對象的客戶端將能夠按名稱查找此對象。 下面是 HelloImpl 類的 main() 方法的示例。它將 HelloImpl 對象注冊到 WebLogic Server 注冊表中的名稱 HelloRemoteWorld 下。 public static void main(String[] argv) { // WebLogic RMI 中不需要 // System.setSecurityManager(new RmiSecurityManager()); // 但是如果包含此行代碼，就應該 // 使它成為有條件的，如這里所顯示： // if (System.getSecurityManager() == null) // System.setSecurityManager(new RmiSecurityManager()); int i = 0; try { for (i = 0; i < 10; i++) { HelloImpl obj = new HelloImpl("MultiHelloServer" + i); Context.rebind("//localhost/MultiHelloServer" + i, obj); System.out.println("MultiHelloServer" + i + " created."); } System.out.println("Created and registered " + i + " MultiHelloImpls."); } catch (Exception e) { System.out.println("HelloImpl error: " + e.getMessage()); e.printStackTrace(); } } WebLogic RMI 並不要求您設置安全管理器以將安全性集成到應用程序中。安全是由 WebLogic Server 對 SSL 和 ACL 的支持處理的。如果必須設置安全管理器，則可以使用自己的安全管理器，但不要將其安裝在 WebLogic Server 中。 步驟3. 編譯 Java 類 使用javac 或某些其他 Java 編譯器編譯 .java 文件，以便生成遠程介面的 .class 文件以及實現它的類。 步驟4. 使用 RMI 編譯器編譯實現類 對遠程類運行 WebLogic RMI 編譯器 (weblogic.rmic)，以便在運行過程中生成動態代理和位元組代碼。代理是遠程對象的客戶端代理，它將每個 WebLogic RMI 調用轉發到與其匹配的伺服器端位元組代碼，而此位元組代碼又依次將此調用轉發到實際遠程對象實現。要運行 weblogic.rmic，請使用命令模式： $ java weblogic.rmic nameOfRemoteClass 其中，nameOfRemoteClass 是實現遠程介面的類的完整包名。對於前面使用的示例，命令將為： $ java weblogic.rmic examples.rmi.hello.HelloImpl 如果在創建存根控制項或骨架類時需要保留生成的源代碼，請在運行 weblogic.rmic 時設置標志 –keepgenerated。有關可用的命令行選項列表，請參閱 WebLogic RMI 編譯器選項。 步驟5. 編寫調用遠程方法的代碼 使用一種 Java 代碼文本編輯器，在 WebLogic Server 上編譯和安裝了遠程類、它實現的介面以及其代理和位元組代碼後，即可為 WebLogic 客戶端應用程序添加代碼，以便調用遠程類中的方法。 通常，只需一行代碼：獲得對遠程對象的引用。使用 Naming.lookup() 方法來完成此任務。下面是一個簡短的 WebLogic 客戶端應用程序，它使用上一示例中創建的對象。 package mypackage.myclient;import java.rmi.*;public class HelloWorld throws Exception { // 查找 WebLogic 注冊表中的 // 遠程對象 Hello hi = (Hello)Naming.lookup("HelloRemoteWorld"); // 遠程調用方法 String message = hi.sayHello(); System.out.println(message);} 此示例演示將 Java 應用程序作為客戶端使用。 Hello 代碼示例 下面是 Hello 介面的完整代碼。

7. 哪些埠是通過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伺服器，啟動客戶端即可。

8. 如何啟動rmi注冊服務

jb7+weblogic6.x配置方法如下：
Win 2000 Temp、Tmp 的配置

因為我們生成的 ejb 相關代碼要進行一系列的編譯，那麼所生成的臨時文件就要有個地方放啊，但 Win2000中的 Temp、Tmp 目錄卻偏偏有空格 如%USERPROFILE%\Local Settings\Temp，接下來我們來配置一下：

1） 右擊 《我的電腦》 選屬性，在彈出的對話框中選 《高級》 ，再選 《環境變數》 按鈕，

2) 修改 《Administrator 的用戶變數》和《系統變數》中的 TEMP、TEMP、TMPDIR 選項，單擊每一個選項，然後點《編輯》(右圖)，把每個 變數名為 TEMP、TEMP、TMPDIR 的值都改為 c:\WINNT\temp ，當然這不是必須的，只是我建議你這么做。

其實也沒什麼難的，若改完，則Win2000環境這么應該沒什麼問題了。
WebLogic 6.X 部分

一、JDBC Connection Pool 的配置 以Mysql 小型資料庫為例

在進行此項配置之前，先將欲使用的 資料庫JDBC 驅動 Jar 文件放到D:\bea\wlserver6.1\lib\jdbc 目錄下(建議這樣做,沒有jdbc目錄就建一個唄)，然後編輯D:\bea\wlserver6.1\config\mydomain 下的 startWebLogic.cmd 文件,在 classpath 中加入資料庫的JDBC驅動文件，如紅字部分：

:runWebLogic
echo on
set PATH=.\bin;.\bin\oci817_8;d:\oracle\ora81\bin;%PATH%
set CLASSPATH=.\lib\cr_wls60f.jar;.\lib\weblogic_sp.jar;.\lib\weblogic.jar;.\lib\jdbc\mysql.jar

這樣 Weblogic 啟動時才會載入欲使用的資料庫JDBC驅動，配置也才會正常，否則會報錯。
1)在Weblogic控制台中依次展開Services \ JDBC \ Connection Pools
2)單擊 Configure a new JDBC Connection Pool...

3)填入每一項參數，結果如下：
url: jdbc:mysql://127.0.0.1:3306/test
driver classname:org.gjt.mm.mysql.Driver
properties(key=value):user=root
4) 別忘了點一下 Apply 即應用一下：）
5) Connections 簽下的 初始容量、最大容量、容量增長等可根據自已需要配置
6) 還有至關重要的最後一步，我們做的以上配置工作還沒有真正的應用到 Weblogic 上，所以還差一步，
選 Targets 簽，選 Servers 簽，選 Available (可用)中的 myserver ，然後點"-->" ，再點 Apply 應用一下。
這樣我們所做的工作才會真正有效， Weblogic 也才會認識我們配置的 JDBC Connection Pool
二、配置數據源

1)在Weblogic控制台中依次展開Services \ JDBC \ Tx Data Sources
2)單擊 Configure a new JDBC Tx Data Source...
3)填入每一項參數，結果如下：

jndi name: MysqlDataSoruce
PoolName:MysqlPool
row prefetch size :48
stream chunk size: 2564) 別忘了點一下 Apply 即應用一下：）
5) 同樣，選 Targets 簽，選 Servers 簽，選 Available (可用)中的 myserver ，然後點"-->" ，再點 Apply 應用一下。
這樣我們所做的工作才會真正有效， Weblogic 也才會認識我們配置的 DataSource。

JBuilder 7 的相關配置

一、資料庫驅動的載入

同 weblogic 一樣，在進行此項配置之前，先將欲使用的 資料庫JDBC 驅動 Jar 文件放到 D:\JBuilder7\lib\jdbc 目錄下(建議這樣做,沒有jdbc目錄就建一個唄)

1) 開啟 JBuilder 7,單擊 Tools \ EnterPrise Setup .......

2) 在彈出窗口中選擇 Database Drivers 簽
3) 再點 Add 按鈕，彈出新窗口(可能你的與圖上的略有不同)
4) 再單擊 New ... 按鈕，彈出新窗口，並改變 Name： 的默認值為 mysql (只要有意義，起個什麼名都成)
5) 單擊 Add... 按鈕來查找並添加資料庫的 JDBC 驅動，當然了，我們到 D:\JBuilder7\lib\jdbc 下去找，選 mysql.jar ，注意，不要把mysql.jar 展開，象圖那樣選中再按 OK 就行了。
提示：可以配合 Shift 和 Ctrl 鍵同時選多個 .jar 文件。
6) 結果如下圖，如果有多個需要添加的 .jar 文件，還可點 Add... 按鈕繼續添加。
7) OK 退出.
8) 再OK ，則 mysql JDBC 驅動就已經加入了。
9) 再一次的 Ok ，JBuilder 提示要重起後上述配置才會生效，確定並重啟 JBuilder。
二、EJB 2.0 和 應用伺服器的配置，以 WebLogic 6.X為例

在進行此項配置之前要安裝 Borland Enterprise Servler 5.02 ，IAS 4.5 也成，它倆是一回事，當然了我是有新的不用舊的，安裝過程略，因為安裝它很 easy ! 基本是一路回車，我把我的安裝在 D:\BorlandEnterpriseServer 下了。

1) 開啟 JBuilder 7,單擊 Tools \ EnterPrise Setup .......

2) 選擇 CORBA 簽，在 Configuration 下的下拉列表框，選擇 VisiBroker

3) 選擇 Edit... ,彈出 Edit Confiuration 窗口
點擊path for orb tools
4) 單擊 Path for ORB tools: 旁邊的 ... 瀏覽按鈕,彈出 Select Directory 窗口，選擇 D:\BorlandEnterpriseServer5\bin 並 OK。

5) 再 兩遍 OK ，JBuilder 又要求你重啟，沒辦法，照它說的做，重啟 JBuilder 。

6) 重啟後，還要到 Tools \ EnterPrise Setup ....... ，選 CORBA 項，選 Edit ，在彈出窗口中選 Library for projects: 旁邊的 ... 按鈕
7) 在彈出的新窗口的 User Home 中你會發現多了一個選項 Borland Enterprise Server 5.0.2+ Client
即 選擇圖中所示 黑亮的選項,然後 三遍 OK 退出。
8) 再選擇 Project \ Default Project Properties 項
9) 在彈了對話框中選 Server 簽，如圖，點擊 ... 按鈕，
10) 在彈出的新對話框中，選擇 WebLogic Application Server 6.x +，然後復選 Enable server ，見圖中紅框。
11) 復選 Enable server 後，其它各項可選或可填，點擊 ... 按鈕，
選擇 Home directory ；
選擇 Working directory ；
為你機器所裝 Weblogic 的位置。
12) 點擊 Class 簽內的Add 按鈕，如上圖，將 D:\bea\wlserver6.1\lib\cr_wls60f.jar 文件添加進來。如上圖紅線。
再用 Move Up 按鈕，將 D:\bea\wlserver6.1\lib\cr_wls60f.jar 文件移至最項端，因為一般後加的 .jar 文件在最下邊。
這一步也比較重要，因為在JBuilder 環境下可以直接啟動 Weblogic ，那它就要首先檢測 license 是否合法，即 cr_wls60f.jar文件
是否存在。

13) 再選擇 Custom 簽，按如下紅線所示配置，可能您裝的 Weblogic 目錄位置與我的有不同，但大概意思是一樣的。
配置完後，點擊 OK 按鈕退出
domain name :mydomain
server name: myserver
version:6.1 Service Pack1(d:/bea/wlserver6.1)
14) 再在如圖窗口中的 Single server for all services in project 下拉列表框中選擇 WebLogic Application Server 6.x+ 如圖所示，然後 OK 退出。

--駱駝祥子整理的

9. linux中怎麼配置rmi安全策略文件

問題一：RMI服務提供程序運行在Windows操作系統下，RMI服務可以正常訪問，但將RMI服務提供程序部署到Linux操作系統下後，RMI服務無法訪問，提示

org.springframework.remoting.RemoteConnectFailureException:

Cannot connect to remote service
[rmi://192.168.0.106:1199/ItemRetag]; nested exception is
java.rmi.ConnectException: Connection refused to host: 127.0.0.1; ……
解
決辦法：在載入RMI服務之前將當前伺服器的IP指定給hostName，如
System.setProperty("java.rmi.server.hostname",
"192.168.100.7");或者修改/etc/hosts文件，在這個文件中加 192.168.100.54 testlinux1
localhost.localdomain localhost
就行，或者將/etc/hosts文件中默認的127.0.0.1改成當前機器的IP即可！

問題二：java.rmi.server.ExportException: internal error: ObjID already in
use Caused by: java.rmi.server.ExportException: internal error: ObjID
already in use……

出現這種問題及有可能是/etc/hosts文件中指定的IP並不是當前伺服器的真實IP，RMI在初始化時注冊服務失敗。

通過System.out.println(InetAddress.getLocalHost().toString());查看當前主機的IP
是否為真實IP，如顯示為SIMBANK/220.250.64.24，而真實IP為192.168.1.2

解決辦法：修改/etc/hosts文件中錯誤的IP即可，將：

220.250.64.24 SIMBANK
修改為

192.168.1.2 SIMBANK