CORBA知识扫盲

CORBA（公用对象请求代理体系）是OMG（对象管理组织）于1991年提出的基于对象技术的分布计算应用软件体系结构。CORBA标准主要分为三个部分：接口定义语言（IDL）、对象请求代理（ORB），以及ORB之间的互操作协议IIOP，核心是对象请求代理。CORBA可以抽象系统平台、网络通讯及编程语言的差异。通过在CORBA技术规范中定义多种类型的服务，如名字服务（Naming  Service）、事务服务（Transaction Service）、对象生命期服务（LifeCycle Service）、并发控制服务（Concurrency Control Service）、时间服务（Time Service）等功能，为应用软件开发者提供一个全面、健壮、可扩展的分布对象计算平台，使面向对象的应用软件在分布异构环境下方便地实现可重用、易移植和互操作。

与RMI比较
  与RMI 不同，CORBA 不属于Java 平台本身。OMG（Object Management Group，对象管理组织）发明了CORBA 规范，CORBA 被设计成与平台和语言无关。因此，CORBA对象可以运行于任何平台之上，位于网络的任何位置，还可以用任何语言（包括 Java、C、C++和Smalltalk 等）编写，只要该语言具有IDL（Interface Definition Language，接口定义语言）的映射。

  与RMI 相比，CORBA 是为更大、可伸缩更强的系统准备的，在这些系统中可能有数千个对象；CORBA 的编程和部署比RMI 更复杂，但允程序员开发需要事务、安全性等支持的企业级系统；CORBA 的命名服务也比RMI 命名注册功能更强大和灵活。


  CORBA 的实现称为ORB（Object Request Broker，对象请求代理）。Java IDL 即是CORBA 的一个实现，它是JDK1.3 或更高版本的核心软件包之一，定义在org.omg.CORBA及其子包中。在Java IDL 的支持下，开发人员可以使用如下两种方法将Java 和CORBA 集成在一起：
·??创建Java 对象并使之可在CORBA ORB 中展开,
·??创建Java 类并作为和其它ORB 一起展开的CORBA 对象的客户。这种方法提供了另外一种途径，通过它Java 可以被用于将你的新的应用和以前遗留的系统相集。



采用Java创建CORBA应用

CORBA对象服务的实现方式分为两种：对象的命名引用方式和字符串化对象引用方式。不论采用何种高级语言，创建CORBA应用程序的过程大体如下：

● 编写IDL接口定义文件；

● 将接口定义文件编译为相应高级语言源代码，产生服务器框架与客户端存根；

● 基于服务器框架，编写服务对象实现程序；

● 基于客户端存根，编写客户对象调用程序；

● 分别编译客户对象和服务对象程序；

● 运行服务对象和客户对象程序；

CORBA实例分析

下面通过一个实例，描述如何通过Java创建CORBA应用程序。

1. 接口定义 (Hello.idl)
view plainprint?

   1. module HelloApp{     
   2.   interface Hello    {         
   3.     string sayHello(in string message);     
   4.   }; 
   5. }; 

module HelloApp{       interface Hello    {             string sayHello(in string message);       }; };
通过Sun提供的将IDL文件编译成Java源代码的工具idlj（jdk1.3.0_01以上版本），为接口定义文件生成客户端存根和服务器框架。具体操作如下：
   idlj -oldImplBase -fall Hello.idl

编译后将在 HelloApp 子目录中形成以下六个文件：

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

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

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

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

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

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

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


2. 接口实现
  HelloImpl.java是Hello IDL 接口的实现；每个Hello实例都由一个HelloImpl实例来实现。HelloImpl是_HelloImplBase的子类，_HelloImplBase是由 idlj编译器从示例 IDL 中生成的。

view plainprint?

   1. /* * @author javamxj （CSDN Blog) 创建日期 2004-12-27 */ 
   2. import HelloApp.*; 
   3. public class HelloImpl extends _HelloImplBase {     
   4.   /* 构造函数 */    
   5.   public HelloImpl() {         
   6.     super();     
   7.   }     
   8.   /* 实现接口声明方法sayHello */     
   9.   public String sayHello(String message) {         
  10.     System.out.println("我在CORBA的服务器端，客户端正在调用'sayHello'方法。 ");         
  11.     System.out.println("Hello  " + message);         
  12.     return message;     
  13.   } 
  14. } 

/* * @author javamxj （CSDN Blog) 创建日期 2004-12-27 */ import HelloApp.*; public class HelloImpl extends _HelloImplBase {       /* 构造函数 */     public HelloImpl() {             super();       }       /* 实现接口声明方法sayHello */       public String sayHello(String message) {             System.out.println("我在CORBA的服务器端，客户端正在调用'sayHello'方法。 ");             System.out.println("Hello  " + message);             return message;       } }
3. 服务器
服务器类含有服务器的main()方法，可完成以下任务：
· 创建一个 ORB 实例
· 创建一个HelloImpl实例（CORBA Hello对象的实现）并通知 ORB
· 获取一个命名上下文的 CORBA 对象引用，在该命名上下文中注册新 CORBA 对象
· 在命名上下文中将新对象注册在“Hello”名下
· 等待对新对象的调用

view plainprint?

   1. /* * @author javamxj （CSDN Blog) 创建日期 2004-12-27 */ 
   2. import org.omg.CosNaming.*; 
   3. import org.omg.CORBA.*; 
   4. public class HelloServer {     
   5.   public static void main(String args[]) {         
   6.     try {             
   7.       /* 创建和初始化 ORB */             
   8.       ORB orb = ORB.init(args, null);             
   9.       System.out.println("开始 ORB Server ...");             
  10.       /* 创建一个实例并将其向 ORB 注册 */             
  11.       HelloImpl helloImpl = new HelloImpl();             
  12.       orb.connect(helloImpl);             
  13.       System.out.println("将实例注册到ORB ");             
  14.       /* 获取根命名上下文 */             
  15.       org.omg.CORBA.Object objRef   =orb.resolve_initial_references("NameService");             
  16.       NamingContext ncRef = NamingContextHelper.narrow(objRef);             
  17.       /* 绑定命名中的对象引用 */             
  18.       NameComponent nc = new NameComponent("Hello", "");             
  19.       NameComponent path[] = { nc };             
  20.       ncRef.rebind(path, helloImpl);             
  21.       /* 等待来自客户机的调用 */             
  22.       java.lang.Object sync = new java.lang.Object();             
  23.       synchronized (sync) {                 
  24.         sync.wait();             
  25.       }             
  26.       System.out.println("等待CORBA客户端调用...");         
  27.     } catch (Exception e) {             
  28.       System.err.println("错误: " + e);             
  29.       e.printStackTrace(System.out);         
  30.     }     
  31.   } 
  32. } 

/* * @author javamxj （CSDN Blog) 创建日期 2004-12-27 */ import org.omg.CosNaming.*; import org.omg.CORBA.*; public class HelloServer {       public static void main(String args[]) {             try {                   /* 创建和初始化 ORB */                   ORB orb = ORB.init(args, null);                   System.out.println("开始 ORB Server ...");                   /* 创建一个实例并将其向 ORB 注册 */                   HelloImpl helloImpl = new HelloImpl();                   orb.connect(helloImpl);                   System.out.println("将实例注册到ORB ");                   /* 获取根命名上下文 */                   org.omg.CORBA.Object objRef =orb.resolve_initial_references("NameService");                   NamingContext ncRef = NamingContextHelper.narrow(objRef);                   /* 绑定命名中的对象引用 */                   NameComponent nc = new NameComponent("Hello", "");                   NameComponent path[] = { nc };                   ncRef.rebind(path, helloImpl);                   /* 等待来自客户机的调用 */                   java.lang.Object sync = new java.lang.Object();                   synchronized (sync) {                         sync.wait();                   }                   System.out.println("等待CORBA客户端调用...");             } catch (Exception e) {                   System.err.println("错误: " + e);                   e.printStackTrace(System.out);             }       } }
4. 客户端
下面的应用程序客户机将完成以下任务：
· 创建一个 ORB
· 获取一个指向命名上下文的引用
· 在命名上下文中查找 "Hello" 并获得指向该 CORBA 对象的引用
· 调用对象的 sayHello() 操作并打印结果

view plainprint?

   1. /* * @author javamxj （CSDN Blog) 创建日期 2004-12-27 */ 
   2. import HelloApp.*; 
   3. import org.omg.CosNaming.*; 
   4. import org.omg.CORBA.*; 
   5. public class HelloClient {     
   6.   public static void main(String args[]) {         
   7.     try {             
   8.       /* 创建和初始化 ORB */             
   9.       ORB orb = ORB.init(args, null);             
  10.       /* 获取根命名上下文 */             
  11.       org.omg.CORBA.Object objRef = orb.resolve_initial_references("NameService");             
  12.       NamingContext ncRef = NamingContextHelper.narrow(objRef);             
  13.       /* 解析命名中的对象引用 */             
  14.       NameComponent nc = new NameComponent("Hello", "");             
  15.       NameComponent path[] = { nc };             
  16.       Hello h = HelloHelper.narrow(ncRef.resolve(path));             
  17.       /* 调用 Hello 服务器对象并打印结果 */             
  18.       System.out.println("我在客户端，开始调用CORBA服务器端的'sayHello'方法");             
  19.       System.out.println("欢迎,  " +  h.sayHello("javamxj blog"));                       
  20.     } catch (Exception e) {             
  21.       System.out.println("错误 : " + e);             
  22.       e.printStackTrace(System.out);         
  23.     }     
  24.   } 
  25. } 

/* * @author javamxj （CSDN Blog) 创建日期 2004-12-27 */ import HelloApp.*; import org.omg.CosNaming.*; import org.omg.CORBA.*; public class HelloClient {       public static void main(String args[]) {             try {                   /* 创建和初始化 ORB */                   ORB orb = ORB.init(args, null);                   /* 获取根命名上下文 */                   org.omg.CORBA.Object objRef = orb.resolve_initial_references("NameService");                   NamingContext ncRef = NamingContextHelper.narrow(objRef);                   /* 解析命名中的对象引用 */                   NameComponent nc = new NameComponent("Hello", "");                   NameComponent path[] = { nc };                   Hello h = HelloHelper.narrow(ncRef.resolve(path));                   /* 调用 Hello 服务器对象并打印结果 */                   System.out.println("我在客户端，开始调用CORBA服务器端的'sayHello'方法");                   System.out.println("欢迎,  " +  h.sayHello("javamxj blog"));                           } catch (Exception e) {                   System.out.println("错误 : " + e);                   e.printStackTrace(System.out);             }       } }

CORBA Server/Client的编译与运行

· 把上面4个文件复制到D:\CorbaSample目录下，在此目录下建立Client和Server目录，假设它们分别为客户端和服务端。

· 编译Hello.idl
  D:\CorbaSample>idlj -oldImplBase -fall Hello.idl
这会生成一个HelloApp的目录

· 编译所有java文件：
  D:\CorbaSample>javac *.java HelloApp/*.java

· 分别在Client和Server目录下建立HelloApp子目录，将D:\CorbaSample\HelloApp目录中的 
    _HelloStub.class
    Hello.class
    HelloHelper.class
    HelloHolder.class
    HelloOperations.class
复制到D:\CorbaSample\Client\HelloApp目录下，再将D:\CorbaSample目录中的HelloClient.class复制到D:\CorbaSample\Client目录下。

  将D:\CorbaSample\HelloApp目录中的
    _HelloImplBase.class
    Hello.class
    HelloOperations.class
复制到D:\CorbaSample\Server\HelloApp目录下， 再将D:\CorbaSample目录中的HelloServer.class和 HelloImpl.class 复制到D:\CorbaSample\Server目录中
（注意：当然，你可以不必建立Server和Client目录及以上复制文件的操作，可以直接在D:\CorbaSample目录中进行操作,我这样做的目的主要是为了区分客户端和服务端）


· 确保名字服务器处于运行状态：
     D:\CorbaSample\Server>tnameserv -ORBInitialPort 1050


· 启动 Hello 服务器：
    D:\CorbaSample\Server>java HelloServer -ORBInitialPort 1050

· CORBA客户端调用CORBA服务：
    D:\CorbaSample\Client>java HelloClient -ORBInitialPort 1050
    （本地调用，不需要用-ORBInitialHost参数来指定远程的IP地址）

    D:\CorbaSample\Server>java HelloClient -ORBInitialHost localhost -ORBInitialPort 1050
   （远程调用CORBA服务，可以将localhost替换成远程的IP地址）