corba接口开发详解（网络资料）

最新推荐文章于 2022-06-26 19:34:51 发布
最新推荐文章于 2022-06-26 19:34:51 发布
阅读量839 收藏 2
点赞数
文章标签： java 开发工具 操作系统
原文链接：http://www.cnblogs.com/jinzhengquan/archive/2011/04/23/2025717.html
版权

corba（公用对象请求代理体系）是基于对象技术的分布计算应用软件体系结构。corba标准主要分为三个部分：接口定义语言（IDL），对象请求代理（ORB），以及ORB之间的互操作协议IIOP，核心是对象请求代理。corba与平台和语言无关。

java IDL既是corba的一个实现，它是jdk1.3或更高版本的核心软件包之一，定义在org.omg.CORBA及其子包中，在java IDL的支持下，开发人员可以使用如下两种方法将java和corba集成在一起：

创建java对象并使之可在corba orb中展开；创建java类并作为http://www.cnblogs.com/jinzhengquan/admin/EditPosts.aspx?catid=295786和其它orb一起展开的corba对象的客户，这种方法提供了另外一种途径，通过它java可以被用于将你的新的应用和以前遗留的系统相集成。

采用java创建corba应用，corba对象服务的实现方式分为两种：对象的命名引用方式和字符串化对象引用方式，创建corba应用程序的过程大体如下：编写IDL接口定义文件；将接口定义文件编译为相应高级语言源代码，产生服务器框架与客户端存根；基于服务器框架，编写服务对象实现程序；基于客户端存根，编写客户对象调用程序；分别编译客户对象和服务对象程序；运行服务对象和客户对象程序。

第一步下载JacORB并配置jacORB

1，解压JacORB-2.3.0-bin，将jacORB拷贝到c:\jacORB;

2，修改c:\jacORB\bin下的文件，去掉idl.tpl,idl.bat.tpl,jaco.tpl和jaco.bat.tpl文件的后缀名".tpl"；

3，在jacORB目录下建立classes文件夹，将etc中的jacorb_properties.template文件拷贝到classes下，将文件中（*）ORBInitRef.NameService=file:/c:/NS_Ref修改为
（*）jacorb.naming.ior_filename=c:/NS_Ref，并将文件名改为jacorb.properties

4，在dos下输入ns即可。

但是在运行期间会出现 org.omg.CORBA.TRANSIENT: Retries exceeded, couldn't reconnect to 127.0.0.1:900  vmcid: 0x0  minor code: 0  completed: No” 

所以改用明命令

 tnameserv -ORBInitialPort 30000

源代码中用指定参数初始化 ORB 的代码形如：

                   Properties props = System.getProperties();

                   props.setProperty("org.omg.CORBA.ORBClass", "org.jacorb.orb.ORB");

                   props.setProperty("org.omg.CORBA.ORBSingletonClass", "org.jacorb.orb.ORBSingleton");

                   // 启动命名服务需要的参数 

                   props.setProperty("ORBInitRef.NameService", "corbaloc::192.168.0.5:30000/NameService"); 

              // 初始化ORB 

              org.omg.CORBA.ORB orb = org.omg.CORBA.ORB.init(args, props);

第二步下载ORBStudio

解压缩从ORBStudio/plugins/下面取得 ORBStudio_7.7.7.jar 的JAR包 放到Eclipse/plugins下面,果考入Jar包前以前Eclipse是运行的请关闭，重新运行。

windows/preferences/出现如下窗口选择ORB Studio/IDL Compiler/ 在右边选择JacORB 这里有5种编译器我们使用JacORB. 打开IDL Compiler 前面的加号选择,

JacORB 右边参数IDL Command： D:\Java\JacORB\bin\idl.bat

 Command Options: -d %D% %F% 这样就配置成功了Eclipse下面的Corba开发

第三步，编写idl文件

Hello.idl

module HelloApp
{
  interface Hello
  {
     string sayHello(in string message);
  };
};

右键ORB-->compile，会产生编译的源代码

_HelloStub.java：该类是客户机stub,可为客户机提供corba功能，它实现Hello.java接口。

也可以在idl文件所在的目录中使用命令：

 idlj -oldImplBase -fall Hello.idl

编译该hello.idl文件。

Hello.java：该接口含有IDL接口的java版本，Hello.java接口扩展org.omg.CORBA.Object并提供标准的CORBA对象功能。

HelloHelper.java：这是一个终态类，可以提供辅助功能，特别是提供将CORBA对象引用转换为适当类型所需的narrow()方法

HelloHolder.java：这是一个终态类，其中含有Helo类型的公有实例成员，它可为“out”和“inout”变量提供操作，CORBA有这些变量，但不容易映射为java的语义。

HelloOperations.java：这是一个接口类，其中含有方法sayHello()。

HelloImplBase.java：该抽象类是一个服务器skeleton，它可为服务器提供基本的CORBA功能，它实现Hello.java接口，服务器类HelloServant扩展HelloImplBase。

要完成该应用程序，只需在文件HelloServer.java和HelloClient.java中提供服务器和客户机的实现即可。

、启动ECLIPSE，新建JAVA项目，一切默认即可，新建文件
NEW->OTHERS->CORBA Wizard->IDL files->NEXT->设置IDL文件路径及文件名称（此处以默认值为例）->Finish
打开simple.idl,将看到已经有了默认内容
（大致意思是定义了一个模块，此模块对应到JAVA里面就是一个 PACKAGE，此模块（包）中定义了一个名为 MyService 的 interface，此interface定义了一个名为operation1的方法，此方法还接收一个string类型的传入参数，大致就是这么个意 思，至于IDM的协议规范，参见具体文档）

8、生成CORBA框架代码，右键simple.idl文件，ORB Menu->Compile，
此时会在src目录生成一个MyServer的包，此包里面将会生成
_MyServiceStub.java
MyService.java
MyServiceHelper.java
MyServiceHolder.java
MyServiceOperations.java
MyServicePOA.java
MyServicePOATie.java
这几个文件，至于具体各是什么意义，我也理太清楚，只知道
MyService变是IDL文件中定义的接口文件，后面 会经常用于与org.omg.CORBA.Object打交道
MyServiceHelper应该是个服务类，后面会经常用到，应该是 将对象的org.omg.CORBA.Object、interface（MyService）之间进行包装转换用
MyServiceHolder 看代码，觉得是个载体对象，具体如何用，目前还不太清楚
MyServiceOperations字面上看就是定义接口的操作的类，实际 是个接口，MyService就是继承自它（严格的说是接口继承，因为MyService也是接口）
MyServicePOA CORBA需要的类，我们实现接口（MyService）的类应该从它继承
MyServicePOATie就不太清楚其用处了

9、利用ORB插件为生成实现接口的类，新建文件
NEW->OTHER->CORBA Wizard->Server->Active object map->next->
IDL fieldname:选择/{项目名称}/simple.idl
interface: 选择MyServer.MyService
package:填写包名称（可以任意名称）
Server classname:MyServiceServerImpl（可以任意取名）
继续next,勾选 Create server class（勾了会自动生成SERVER端的默认代码，代码的内容形貌，取决于6的IDL Compiler选项值及具体的子COMMAND和COMMAND OPTIONS）

10、打开 MyServiceServerImpl，实现MyServiceOperations接口定义的方法

11、编写服务端代码，打开 Server_AOM文件，默认代码是使用IOR文件进行通信的，为了体现CORAB的跨平台特性，此处使用命名服务的方式运行，
注释掉 try{...}里面的代码，编写如下代码，其它代码保持不变，并 

import org.omg.CosNaming.*;

修改后的代码

            // 启动命名服务需要的参数 
            props.setProperty("ORBInitRef.NameService", "corbaloc::192.168.0.14:30000/NameService"); 

// 初始化ORB 
            org.omg.CORBA.ORB orb = org.omg.CORBA.ORB.init(args, props); 
// 获取根POA引用 
            POA poaRoot = POAHelper.narrow(orb.resolve_initial_references("RootPOA")); 
// 激活POA管理器 
            poaRoot.the_POAManager().activate(); 
// 实例化一个MyServiceServerImpl对象 
            MyServiceServerImpl serviceImpl = new MyServiceServerImpl(); 
// 从servant获得一个对象引用 
            org.omg.CORBA.Object refObj = poaRoot.servant_to_reference(serviceImpl); 
// 获得对象接口引用 
            MyServer.MyService service = MyServer.MyServiceHelper.narrow(refObj); 
// 命名上下文 
            org.omg.CORBA.Object ncObj = orb.resolve_initial_references("NameService"); 
            NamingContextExt nc = NamingContextExtHelper.narrow(ncObj); 
// 绑定一个服务引用,以便客户端可以调用 
            nc.rebind(nc.to_name("Simple.MyService"), service); 

            System.out.println("MyService is running and waiting......"); 
// 运行ORB 
            orb.run();

有必要说一下自己对CORBA启动整体流程的理解，
首先是设置参数，

设置ORB的服务端实现类 

props.setProperty("org.omg.CORBA.ORBClass", "org.jacorb.orb.ORB");

调协ORB的单例类 

props.setProperty("org.omg.CORBA.ORBSingletonClass", "org.jacorb.orb.ORBSingleton");

设置ORB命名服务的初始化参数，具体意思 corbaloc 协议名称 192.168.0.14 ORB服务器地址（也可以是主机名） 30000 ORB运行的端口 

props.setProperty("ORBInitRef.NameService", "corbaloc::192.168.0.14:30000/NameService");

设置了参数后，根据参数初始化一个org.omg.CORBA.ORB的实例
接着从ORB实例中获取一个根POA对象引用，通过调用POAHelper服务方法将POA根引用转换成POA对象，
紧接着调用POA管理器，将其激活
服务器端环境设置完成，

进而创建实现接口的对象的实例，
调用要根POA将其转换成一个org.omg.CORBA.Object对象，
再调用服务方法得到其接口定义对象

通过ORB对象获得一个命名服务器对象，
通过命名服务辅助类得到一个命名上下文
再通过命名上下文实与服务接口绑定（因为服务接口与实现接口的对象的已建立关系，所以此时命名上下文也与接口的实现对象建立了关系）
绑定完成之后，就可以进行ORB实例对象了

至此，服务端的运行完毕，只等待客户端的调用了。

12、编写客户端代码，还是通过ORB 控件生成客户端代码，新建文件
NEW->OTHER->CORBA Wizard->Client->Simple implementation，与9是基本一样，选择IDL文件，选择接口文件、填写包名称、客户端类名称

13、打开MyServiceClientImpl,找到initORB方法，注释默认添加的代码，
其代码如下： 

        Properties props = System.getProperties(); 
       props.setProperty("org.omg.CORBA.ORBClass", "org.jacorb.orb.ORB"); 
       props.setProperty("org.omg.CORBA.ORBSingletonClass", "org.jacorb.orb.ORBSingleton"); 

// 启动参数 
        props.setProperty("ORBInitRef.NameService", "corbaloc::192.168.0.14:30000/NameService"); 

       orb = org.omg.CORBA.ORB.init(args, props); 
// 获得命名服务上下文 
// 获得命名服务对象        
        org.omg.CORBA.Object nsObj = null; 
try { 
            nsObj = orb.resolve_initial_references("NameService"); 
        } catch (InvalidName e) { 
// TODO Auto-generated catch block 
            e.printStackTrace(); 
        } 
// 通过命名服务对象得到命名服务上下文 
        NamingContextExt nc = NamingContextExtHelper.narrow(nsObj); 
// 从命名服务上下文中获得特定的命名服务对象 
        org.omg.CORBA.Object svrObj = null; 
try { 
            svrObj = nc.resolve_str("Simple.MyService"); 
        } catch (NotFound e) { 
// TODO Auto-generated catch block 
            e.printStackTrace(); 
        } catch (CannotProceed e) { 
// TODO Auto-generated catch block 
            e.printStackTrace(); 
        } catch (org.omg.CosNaming.NamingContextPackage.InvalidName e) { 
// TODO Auto-generated catch block 
            e.printStackTrace(); 
        } 
// 从将特定命名服务对象中获得服务接口 
        MyServer.MyService service = MyServiceHelper.narrow(svrObj); 
        target =  service;


客户端代码就比较简单了，简单描述一下，
首先还是设置参数，初始化ORB，
从ORB实例对象中获取命名服务对象，
通过命名服务对象辅助类从命名服务对象中获取命名服务上下文对象，
从命名服务上下文对象中获取指定名称的服务的org.omg.CORBA.Object对象，
再通过接口服务对象辅助类从org.omg.CORBA.Object类型的接口服务对象中获取实现该接口服务的实例对象
获取了接口服务对象后，就可以使用该服务了，至于是谁实现了该接口，如何实现的，这里根本不关心，尽管使用就是了：）...

另外还需要修改main方法，取消默认的注释，这样才能调用服务接口定义的方法！

对于这个客户端文件，在原有已导入命名空间的基础上还得导入如下一些

import org.omg.CORBA.ORBPackage.InvalidName;
import org.omg.CosNaming.NamingContextPackage.CannotProceed;
import org.omg.CosNaming.NamingContextPackage.NotFound;
import MyServer.MyServiceHelper;

14、说了代码层面的，就该启动服务了，
首先启动CORBA， 

运行->cmd->ns D:/Java/JacORB/CTEST/NS_Ref -p 30000

再运行Server,
右键 Server_AOP->Run As->Java Application
发现了什么，一大堆的红色的错误信息，
大致如下：

org.omg.CORBA.INITIALIZE: can't instantiate default ORB implementation org.jacorb.orb.ORB  vmcid: 0x0  minor code: 0  completed: No 
    at org.omg.CORBA.ORB.create_impl(Unknown Source) 
    at org.omg.CORBA.ORB.init(Unknown Source) 
    at Server_AOM.main(Server_AOM.java:36) 
Caused by: java.lang.ClassNotFoundException: org.jacorb.orb.ORB 
    at java.net.URLClassLoader$1.run(Unknown Source) 
    at java.security.AccessController.doPrivileged(Native Method) 
    at java.net.URLClassLoader.findClass(Unknown Source) 
    at java.lang.ClassLoader.loadClass(Unknown Source) 
    at sun.misc.Launcher$AppClassLoader.loadClass(Unknown Source) 
    at java.lang.ClassLoader.loadClass(Unknown Source) 
    at java.lang.ClassLoader.loadClassInternal(Unknown Source) 
    at java.lang.Class.forName0(Native Method) 
    at java.lang.Class.forName(Unknown Source) 
    ... 3 more

一看大致是没有找到org.jacorb.orb.ORB这个类引起的问题，应该是没有引用相关的类引起的，

于是，项目－>Properties->Java Build Path->Libraries->Add Library->User Library->next->User Libraries->New->填写用户类库名称->选中刚新建的名称->Add JARs->浏览选择 D:\Java\JacORB\lib\jacorb.jar （注意：此处的D:\Java\JacORB视个人环境而定）
再次运行，可恶，又一在段红色错误提示信息，在此也列出来吧， 

org.omg.CORBA.INITIALIZE: can't instantiate default ORB implementation org.jacorb.orb.ORB  vmcid: 0x0  minor code: 0  completed: No 
    at org.omg.CORBA.ORB.create_impl(Unknown Source) 
    at org.omg.CORBA.ORB.init(Unknown Source) 
    at Server_AOM.main(Server_AOM.java:36) 
Caused by: java.lang.NoClassDefFoundError: org/apache/log/format/Formatter 
    at java.lang.Class.getDeclaredConstructors0(Native Method) 
    at java.lang.Class.privateGetDeclaredConstructors(Unknown Source) 
    at java.lang.Class.getConstructor0(Unknown Source) 
    at java.lang.Class.newInstance0(Unknown Source) 
    at java.lang.Class.newInstance(Unknown Source) 
    at org.jacorb.util.Environment.initLogging(Unknown Source) 
    at org.jacorb.util.Environment.init(Unknown Source) 
    at org.jacorb.util.Environment.<clinit>(Unknown Source) 
    at org.jacorb.orb.BufferManager.<clinit>(Unknown Source) 
    at org.jacorb.orb.ORB.<init>(Unknown Source) 
    at sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method) 
    at sun.reflect.NativeConstructorAccessorImpl.newInstance(Unknown Source) 
    at sun.reflect.DelegatingConstructorAccessorImpl.newInstance(Unknown Source) 
    at java.lang.reflect.Constructor.newInstance(Unknown Source) 
    at java.lang.Class.newInstance0(Unknown Source) 
    at java.lang.Class.newInstance(Unknown Source) 
    ... 3 more

看 Caused by: java.lang.NoClassDefFoundError: org/apache/log/format/Formatter 这 句，估计以是没有找到相关的引用类，于是，添加 D:\Java\JacORB\lib\logkit-1.2.jar 到用户类库，具体方法见上，

再次运行，还错误， 

org.omg.CORBA.INITIALIZE: can't instantiate default ORB implementation org.jacorb.orb.ORB  vmcid: 0x0  minor code: 0  completed: No 
    at org.omg.CORBA.ORB.create_impl(Unknown Source) 
    at org.omg.CORBA.ORB.init(Unknown Source) 
    at Server_AOM.main(Server_AOM.java:36) 
Caused by: java.lang.NoClassDefFoundError: org/apache/avalon/framework/logger/Logger 
    at java.lang.Class.getDeclaredConstructors0(Native Method) 
    at java.lang.Class.privateGetDeclaredConstructors(Unknown Source) 
    at java.lang.Class.getConstructor0(Unknown Source) 
    at java.lang.Class.newInstance0(Unknown Source) 
    at java.lang.Class.newInstance(Unknown Source) 
    at org.jacorb.util.Environment.initLogging(Unknown Source) 
    at org.jacorb.util.Environment.init(Unknown Source) 
    at org.jacorb.util.Environment.<clinit>(Unknown Source) 
    at org.jacorb.orb.BufferManager.<clinit>(Unknown Source) 
    at org.jacorb.orb.ORB.<init>(Unknown Source) 
    at sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method) 
    at sun.reflect.NativeConstructorAccessorImpl.newInstance(Unknown Source) 
    at sun.reflect.DelegatingConstructorAccessorImpl.newInstance(Unknown Source) 
    at java.lang.reflect.Constructor.newInstance(Unknown Source) 
    at java.lang.Class.newInstance0(Unknown Source) 
    at java.lang.Class.newInstance(Unknown Source) 
    ... 3 more


看 Caused by: java.lang.NoClassDefFoundError: org/apache/avalon/framework/logger/Logger 这名，估计还是缺少相关的引用类，于是， 添加 D:\Java\JacORB\lib\avalon-framework-4.1.5.jar 到用户类库，具体方法见上，

再次运行，终于不是红色的提示信息了，而是等待已久的
MyService is running and waiting......

终于成功了！

接下来，就是Client运行了，
右键MyServiceClientImpl->Run As->Java Application
OK, 又输出一条信息
A message in the bottle...

此时，Console窗口里面应该只有两条件信息，如
MyService is running and waiting......
A message in the bottle...

终于，这个JAVA下的CORRB应用就算完成了！

最后总结下CORBA应用的大体上的过程吧：
CORBA的配置、初始化参数就不说了，仅说说它如何应用的，
首先定义服务接口 IService ，
然后实现该接口 ServiceImpl，
创建实现该接口对象的实例 implInstance，
通过ORB得到一个与该实例相关联的org.omg.CORBA.Object对象 implInstanceOrbObj ，
通过 IServiceHelper 从 implInstanceOrbObj 中获取 IService 类型的 对象 service ，
通过命名服务上下文，将其绑定到 接口服务对象 service ， 同时提供一个服务名称，以便客户端定位到特定的服务，
绑定完毕，就可以运行ORB了，此时Server就处于运行状态（监听客户端的调用），只等待客户端调用，至此，服务端程序运行完毕！

说了这么多，感觉还是不如直接帖代码来的实在，下面就帖出主要文件全部代码

Server_AOM.java

import java.io.File;
import java.io.FileOutputStream;
import java.io.PrintWriter;
import java.util.Properties;

import org.omg.CosNaming.NamingContextExt;
import org.omg.CosNaming.NamingContextExtHelper;
import org.omg.PortableServer.IdAssignmentPolicyValue;
import org.omg.PortableServer.LifespanPolicyValue;
import org.omg.PortableServer.POA;
import org.omg.PortableServer.*;

public class Server_AOM {

public static void main(String[] args) {

		Properties props = System.getProperties();
		props.setProperty("org.omg.CORBA.ORBClass", "org.jacorb.orb.ORB");
		props.setProperty("org.omg.CORBA.ORBSingletonClass", "org.jacorb.orb.ORBSingleton");

try {
//			// Initialize the ORB.
//			org.omg.CORBA.ORB orb = org.omg.CORBA.ORB.init(args, props);
//
//			// get a reference to the root POA
//			org.omg.CORBA.Object obj = orb.resolve_initial_references("RootPOA");
//			POA poaRoot = POAHelper.narrow(obj);
//
//			// Create policies for our persistent POA
//			org.omg.CORBA.Policy[] policies = {
//					poaRoot.create_lifespan_policy(LifespanPolicyValue.PERSISTENT),
//					poaRoot.create_id_assignment_policy(IdAssignmentPolicyValue.USER_ID),
//					poaRoot.create_thread_policy(ThreadPolicyValue.ORB_CTRL_MODEL) 
//			};
//
//			// Create myPOA with the right policies
//			POA poa = poaRoot.create_POA("MyServiceServerImpl_poa",	poaRoot.the_POAManager(), policies);
//
//			// Create the servant
//			MyServiceServerImpl servant = new MyServiceServerImpl();
//
//			// Activate the servant with the ID on myPOA
//			byte[] objectId = "AnyObjectID".getBytes();
//			poa.activate_object_with_id(objectId, servant);
//			
//			// Activate the POA manager
//			poaRoot.the_POAManager().activate();
//
//			// Get a reference to the servant and write it down.
//			obj = poa.servant_to_reference(servant);
//
//			// ---- Uncomment below to enable Naming Service access. ----
//			// org.omg.CORBA.Object ncobj = orb.resolve_initial_references("NameService");
//			// NamingContextExt nc = NamingContextExtHelper.narrow(ncobj);
//			// nc.bind(nc.to_name("MyServerObject"), obj);
//
//			PrintWriter ps = new PrintWriter(new FileOutputStream(new File("server.ior")));
//			ps.println(orb.object_to_string(obj));
//			ps.close();
//
//			System.out.println("CORBA Server ready...");
//
//			// Wait for incoming requests
//			orb.run();

// 启动命名服务需要的参数 
            props.setProperty("ORBInitRef.NameService", "corbaloc::192.168.0.14:30000/NameService"); 

// 初始化ORB 
            org.omg.CORBA.ORB orb = org.omg.CORBA.ORB.init(args, props); 
// 获取根POA引用 
            POA poaRoot = POAHelper.narrow(orb.resolve_initial_references("RootPOA")); 
// 激活POA管理器 
            poaRoot.the_POAManager().activate(); 
// 实例化一个MyServiceServerImpl对象 
            MyServiceServerImpl serviceImpl = new MyServiceServerImpl(); 
// 从servant获得一个对象引用 
            org.omg.CORBA.Object refObj = poaRoot.servant_to_reference(serviceImpl); 
// 获得对象接口引用 
            MyServer.MyService service = MyServer.MyServiceHelper.narrow(refObj); 
// 命名上下文 
            org.omg.CORBA.Object ncObj = orb.resolve_initial_references("NameService"); 
            NamingContextExt nc = NamingContextExtHelper.narrow(ncObj); 
// 绑定一个服务引用,以便客户端可以调用 
            nc.rebind(nc.to_name("Simple.MyService"), service); 

            System.out.println("MyService is running and waiting......"); 
// 运行ORB 
            orb.run(); 
		}
catch(Exception ex) {
			ex.printStackTrace();
		}
	}
}

MyServiceClientImpl.java

/*
 * The client implementation is generated by the ORB Studio.
 */
import java.io.FileReader;
import java.io.IOException;
import java.io.LineNumberReader;
import java.util.Properties;

import org.omg.CosNaming.*;
import org.omg.CORBA.ORBPackage.InvalidName;
import org.omg.CosNaming.NamingContextPackage.CannotProceed;
import org.omg.CosNaming.NamingContextPackage.NotFound;
import MyServer.MyServiceHelper;

class MyServiceClientImpl {
private MyServer.MyService target = null;
private org.omg.CORBA.ORB orb = null;

/**
	 * Constructor for MyServiceClientImpl
	 * 
	 * @throws IOException
	 */
public MyServiceClientImpl() throws IOException {
		initORB(null);
	}

/**
	 * Constructor for MyServiceClientImpl
	 * 
	 * @throws IOException
	 * @see java.lang.Object#Object()
	 */
public MyServiceClientImpl(String[] args) throws IOException {
		initORB(args);
	}

/**
	 * Initialize ORB.
	 *  
	 * @param args
	 * @throws IOException
	 */
public void initORB(String[] args) throws IOException {

		Properties props = System.getProperties();
		props.setProperty("org.omg.CORBA.ORBClass", "org.jacorb.orb.ORB");
		props.setProperty("org.omg.CORBA.ORBSingletonClass", "org.jacorb.orb.ORBSingleton");

//		// Initialize the ORB
//		orb = org.omg.CORBA.ORB.init((String[])args, props);
//
//		// ---- Uncomment below to enable Naming Service access. ----
//		// org.omg.CORBA.Object ncobj = orb.resolve_initial_references("NameService");
//		// NamingContextExt nc = NamingContextExtHelper.narrow(ncobj);
//		// org.omg.CORBA.Object obj = nc.resolve_str("MyServerObject");
//
//		LineNumberReader input = new LineNumberReader(new FileReader("server.ior"));
//		String ior = input.readLine();
//		org.omg.CORBA.Object obj = orb.string_to_object(ior);
//
//		target = MyServer.MyServiceHelper.narrow(obj);		        

// 启动参数 
        props.setProperty("ORBInitRef.NameService", "corbaloc::192.168.0.14:30000/NameService"); 

        orb = org.omg.CORBA.ORB.init(args, props); 
// 获得命名服务上下文 
// 获得命名服务对象        
         org.omg.CORBA.Object nsObj = null; 
try { 
             nsObj = orb.resolve_initial_references("NameService"); 
         } catch (InvalidName e) { 
// TODO Auto-generated catch block 
             e.printStackTrace(); 
         } 

// 通过命名服务对象得到命名服务上下文 
         NamingContextExt nc = NamingContextExtHelper.narrow(nsObj); 
// 从命名服务上下文中获得特定的命名服务对象 
         org.omg.CORBA.Object svrObj = null; 
try { 
             svrObj = nc.resolve_str("Simple.MyService"); 
         } catch (NotFound e) { 
// TODO Auto-generated catch block 
             e.printStackTrace(); 
         } catch (CannotProceed e) { 
// TODO Auto-generated catch block 
             e.printStackTrace(); 
         } catch (org.omg.CosNaming.NamingContextPackage.InvalidName e) { 
// TODO Auto-generated catch block 
             e.printStackTrace(); 
         } 
// 从将特定命名服务对象中获得服务接口 
         MyServer.MyService service = MyServiceHelper.narrow(svrObj); 
         target =  service;
	}

/**
	 * Obtain ORB Interface.
	 * 
	 * @return
	 */
public MyServer.MyService getORBInterface() {
return target;
	}

/**
	 * Shutdown ORB.
	 */
public void shutdown() {
		orb.shutdown(true);
	}

/**
	 * Test driver for MyServiceClientImpl.
	 * 
	 * @param args
	 */
public static void main(String[] args) {
try {
			MyServiceClientImpl test = new MyServiceClientImpl();

			test.getORBInterface().operation1("A message in the bottle...");

			test.shutdown();
		}
catch(IOException ex) {
			ex.printStackTrace();
		}
	}
}

转载于:https://www.cnblogs.com/jinzhengquan/archive/2011/04/23/2025717.html

weixin_34111790
关注
CORBA接口开发详解
08-27
CORBA接口开发详解
CORBA
Ghost
07-05 1093
CORBA 是什么 公用对象请求代理（调度）程序体系结构（Common Object Request Broker Architecture），缩写为 CORBA，是对象管理组织（Object Management Group）对应当今快速增长的软硬件的协同工作能力的要求而提出的方案。简而言之，CORBA 允许应用程序和其他的应用程序通讯，而不论他们在什么
从Corba接口中取到的数据填充FastReport报表
清风
11-16 1171
从Corba接口中取到的数据填充FastReport报表设计过程  环境：编程工具：Borland C＋＋ Builder 6.0操作系统：windows 2000应用软件：FastReport5.2破解版 1．安装FastReport如安装到c:/program files/fastreports2．在bcb 6中使用FastReport（本过程从Rast
visibroker的corba接口
小y写程序
08-21 1006
<br />天终于接到客户那里打来的电话，我们corba接口的问题终于解决了，这个周末可以安心度过了。 <br />过程曲折复杂：<br />    今年上半年，客户提出需求，实现一个corba接口客户端，当时对corba一无所知。在网上查资料，原来就是EJB的爷爷，有自己的标准，开源产品也有几个。选了一个简单的，sun javaIDL，很快就做好，模拟了服务端，测试成功。<br />    拿到客户那里测试的时候，发现怎么也测试不通，与服务端开发人员联系，原来他们使用的是borland visibr
Corba开发总结(四)---华为CORBA接口开发
weixin_34150224的博客
03-27 2437
2019独角兽企业重金招聘Python工程师标准>>> ...
CORBA接口开发详解(网络资料).docx
07-31
此外，ORBStudio是一款用于CORBA开发的工具，它的IDL编译器支持包括JacORB在内的多种编译器。在Eclipse中集成ORBStudio的JAR包，可以方便地进行IDL到Java代码的转换。 总之，CORBA提供了一种标准的分布式计算模型，...
CORBA接口开发详解：从IDL到ORB集成
"CORBA接口开发详解文档详细介绍了CORBA技术，包括其体系结构、主要组成部分、Java IDL在CORBA中的应用，以及如何使用Java创建CORBA应用程序。文档特别提到了采用JacORB这一开源ORB的下载、配置及运行过程，但指出在...
电信行业CORBA接口开发详解与JavaIDL实践
"本文档深入解析了电信行业中使用CORBA接口进行开发的相关知识，包括CORBA的基本概念、架构、与RMI的对比，以及在Java环境下的实现方式。" 在电信行业中，CORBA（Common Object Request Broker Architecture，公用...
针对电信行业的CORBA接口开发详解
08-11
接口定义语言（IDL）是CORBA中的关键组件，它允许开发者用一种中立的方式来定义接口，这些接口可以在各种不同的编程语言中使用。IDL定义的接口会被编译成目标语言的代码，比如Java或C++，以便于在ORB中实现和调用。 ...
[转载]CORBA 连接: CORBA 3.0 的 IDL
congji3817的博客
03-06 263
CORBA 连接: CORBA 3.0 的 IDL扩展接口间的关系“对象管理组织（OMG）”的“接口定义语言”已经能使开发人员根据继承创建对象关系。然而，当处理复杂设计时，经常需要支持包含多个接口的对象，并且这些对象是通过组合而...
Corba开发总结(二)---中兴CORBA接口开发
weixin_34221073的博客
03-26 1392
2019独角兽企业重金招聘Python工程师标准>>> ...
python华为corba接口_CORBA接口用戶手册.doc
weixin_39875629的博客
01-15 519
CORBA接口用戶手册CORBA接口用户手册天元网络CORBA采集组手册目标描述如何安装、配置和启动SBIA，为开发维护人员和现场的工程人员提供参考阅读对象本手册适合以下人员阅读：SBIA开发维护人员；现场的工程人员；术语SBIA ： Sourth Bound Interface Agent即南向接口代理手册约定1、各类标志本手册采用各种醒目标志来表示在操作过程中应该特别注意的地方，这些标志的意义...
【中间件技术】第二部分 CORBA规范与中间件(4) 编写对象接口
memcpy0的博客
03-23 1174
第 4 章 编写对象接口 § 4.1 概 述 4.1.1 接口与实现的分离 将一个大型系统划分为若干模块，将一个模块的接口与实现相分离，并进一步能为一个 接口提供多个实现，这是大型程序设计追求的目标之一。这一设计目标直接带来的好处是有 可能在不同时间／空间效率的算法和数据结构之间作出折衷选择。接口与实现的分离要求将 模块的私有部分归属到实现一方，接口只提供模块对外公开的信息，并且接口与实现之间不 能再简单地通过相同的名字进行匹配。 将这种思想应用在面向对象的分布式软件系统中会带来更大的好处。客户程序仅仅依赖
CORBA的基本内容（下）
透明思考@CSDN
04-09 1754
CORBA的基本内容（下）（本文转载自软件工程专家网www.21cmm.com）苏洋接口仓库　　CORBA引入接口仓库(Interface Repository)的目的在于使服务对象能够提供持久的对象服务。将接口信息存入接口仓库后，如果客户端应用提交动态调用请求（Dynamic Invocation），ORB可以根据接口仓库中的接口信息及分布环境下数据对象的描述，获取请求调用所需的
CORBA中间件的开发过程
致力于顶级java全栈工程师
03-08 3690
上一篇博客我们介绍了CORBA规范和CORBA中间件中涉及的几个基本概念，例如OMG是什么。OMA参考模型怎么理解，其中的对象请求代理ORB又发挥了什么作用等。本篇博客我们分析CORBA中间件的开发过程。 一、开发前的准备：     虽然CORBA中间件对于异类环境下的可互操作性提高了很好的支持，但是对于不同平台之间的系统移植来说还是一个难题，所以在开发过程中我们还是要尽量避免使用与平台有关的
Corba实现步骤
exlink2012的专栏
08-04 694
1.写idl 2.生成Stub和Skeleton代码 用ide编译器生成http://www.codeproject.com/Articles/7166/HTML-editor-for-VC
CORBA 架构体系指南（通用对象请求代理体系架构）
AI天才研究院
06-26 9014
什么是 CORBA 架构？ 概述 通用对象请求代理体系架构 (CORBA) 是由对象管理组 (OMG) 定义的标准，它使以多种计算机语言编写并在多台计算机上运行的软件组件能够协同工作。 CORBA 是一种跨网络分发对象的标准，以便可以远程调用对这些对象的操作。CORBA 与特定的编程语言无关，任何具有 CORBA 绑定的语言都可以用来调用和实现 CORBA 对象。对象以称为接口定义语言 ...
CORBA规范和CORBA中间件&CORBA中间件的开发过程
BRAVE MAN的博客
09-05 2612
CORBA规范和CORBA中间件 本篇博客我们介绍一种流行的集成中间件：基于OMG的CORBA中间件以及CORBA规范。 一、OMG：对象管理组织，该组织发布了最有影响的两套规范，一个是UML统一建模语言，另一个就是CORBA规范。OMG的技术规范主要用来支持分布式、异构环境的软件开发项目。这些规范覆盖了从分析、设计到编码、部署、运行和管理的整个软件的开发过程。 二、OMA：对象体系结构，描...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值