搭建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