⑴ 哪些端口是通过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"。