您的位置: 首页  >  文章  >  CORBA的简单介绍及HelloWorld

CORBA的简单介绍及HelloWorld

分类: 文章 • 2025-02-23 17:26:17

CORBA概述

CORBA（Common Object Request Broker Architecture,公共对象请求代理体系结构）是由OMG组织制订的一种标准的面向对象应用程 序体系规范。或者说 CORBA体系结构是OMG为解决分布式处理环境(DCE)中，硬件和软件系统的互连而提出的一种解决方案。

OMG：Object Management Group，对象管理组织。是一个国际化的、开放成员的、非盈利性的计算机行业标准协会，该协会成立于1989年，其职责是为应用开发提供一个公共框架，制订工业指南和对象管理规范，加快对象技术的发展。。任何组织都可以加入OMG并且参与标准制定过程。OMG制定了统一建模语言UnifiedModeling Language™ (UML®)，模型驱动架构Model Driven Architecture® (MDA®)等建模标准。使强大的视觉设计，执行和维护软件等工序成为可能。并且，OMG还制定了广为人知的中间件标准Common Object Request Broker Architecture (CORBA®)。

通用对象代理体系结构CORBA（Common Object Request Broker Architecture）是OMG所定义的用来实现现今大量硬件、软件之间互操作的解决方案，CORBA也是迈向面向对象标准化和互操作的重要一步。 

简单地说，CORBA允许应用之间相互通信，而不管它们存在于哪里以及是谁设计的，即跨平台、跨语言。CORBA1.1于1991年由OMG发布，其中定义了接口定义语言（IDL）以及在对象请求代理（ORB）中实现客户对象与服务器对象之间交互的应用编程接口（API）。CORBA2.0于1994年发布，规定了各个供应商之间的ORB的通信规则。

CORBA标准主要分为三个部分：接口定义语言（IDL）、对象请求代理（ORB）以及ORB之间的互操作协议IIOP。 

IDL是CORBA定义的语言，CORBA还定义了IDL到各种语言的映射，标准映射的有Ada、C、C++、Smalltalk、Java、以及Python。有了这些映射，就可以将IDL翻译成各种语言，从而实现了跨语言。IDL语言是一种接口定义语言。IDL语言不同于所有已有的程序设计语言，它是一种描述性语言，也就是说，用它描述得到的接口是不能直接被编译执行。OMG IDL语言采用ISOLatin-1(8859.1)字符集。该字符集可以分为字母、数字、图形符号、空格符、和格式符号。其中字母包括英文26个字母的大小写，数字包括10个阿拉伯数字0到9。

ORB是CORBA的核心，是对象之间建立Client/Server关系的中间件。使用ORB，客户可以透明地调用一个服务对象上的方法，这个服务对象可以在本地，也可以在通过网络连接的其他机器上。ORB截获这一调用同时负责查找实现服务的对象并向其传递参数、调用方法返回最终结果。客户并不知道服务对象位于什么地方，它的编程语言和操作系统是什么，也不知道不属于对象接口的其他系统部分。这样，ORB在异构分布环境下为不同机器上的应用提供了互操作性，并无缝地集成了多种对象系统。

CORBA的基本结构如下：

         CORBA的简单介绍及HelloWorld

在client端去调用server端的代码时，ORB对于client端是不可见的，client感觉好像调用了自己对象的方法一样，但是网络传输的过程都被封装在了ORB中。

CORBA和Java都采用面向对象技术，因此，可以很容易地用Java语言开发CORBA应用，或将Java应用以及JavaBean对象集成到CORBA应用环境中；CORBA和Java都适用于开发分布式应用，所不同的是：CORBA偏重于通用的分布式应用开发，而Java注重于WWW环境中的分布式应用开发。

使用CORBA开发的小例子

如果想开发一个CORBA的Helloworld，基本上有以下几个步骤：

1.使用idl语言开发idl文件，这个文件中描述了接口的定义

[plain] view plain copy
  1. module helloworld{  
  2.    interface HelloWorld{  
  3.       string sayHello();  
  4.    };  
  5. };  
module：对应了java中的package

interface：对应了java中的interface，HelloWorld即接口名称

sayHello：对应了java中interface声明的方法

string：对应了java中方法的返回值

2.使用java中的idlj命令，将idl语言翻译成java语言，并生成java代码

将idl文件拷贝到%JAVA_HOME%\bin下，然后在命令行下切换到bin目录下执行：

[plain] view plain copy
  1. idlj -fall helloworld.idl  
idlj：java自带的工具

-fall：生成server和client端代码，也可以单独生成server或client

helloworld.idl：之前创建的idl文件

此时，在bin目录下就会生成helloworld文件夹，文件夹中会有6个文件，将这6个拷回eclipse工程中。注意：文件中的包名就是idl中生命的helloworld。如下图：

        CORBA的简单介绍及HelloWorld

这时_HelloWorldStub.java、HelloWorld.java、HelloWorldHelper.java、HelloWorldHolder.java、HelloWorldOperations.java是client需要的代码；HelloWorld.java、HelloWorldOperations.java、HelloWorldPOA.java是server需要的代码。

简单看一下自动生成的这几个文件：

HelloWorld.java，与idl中的接口名一模一样，但是实际上只是一个标识接口没有任何的实现

[java] view plain copy
  1. package helloworld;  
  2.   
  3.   
  4. /** 
  5. * helloworld/HelloWorld.java . 
  6. * Generated by the IDL-to-Java compiler (portable), version "3.2" 
  7. * from helloworld.idl 
  8. * Friday, May 16, 2014 2:13:26 PM CST 
  9. */  
  10.   
  11. public interface HelloWorld extends HelloWorldOperations, org.omg.CORBA.Object, org.omg.CORBA.portable.IDLEntity   
  12. {  
  13. } // interface HelloWorld  
HelloWorldOperations.java，是idl中声明的接口
[java] view plain copy
  1. package helloworld;  
  2.   
  3.   
  4. /** 
  5. * helloworld/HelloWorldOperations.java . 
  6. * Generated by the IDL-to-Java compiler (portable), version "3.2" 
  7. * from helloworld.idl 
  8. * Friday, May 16, 2014 2:13:26 PM CST 
  9. */  
  10.   
  11. public interface HelloWorldOperations   
  12. {  
  13.   String sayHello ();  
  14. } // interface HelloWorldOperations  
_HelloWorldStub.java、HelloWorldHelper.java、HelloWorldHolder.java是client的桩和工具类；HelloWorldPOA.java是server的实现接口的类（大概是这个意思吧，不太懂），看着比较晕，就不贴了。

3.开发server端的代码

既然开发了接口定义，也翻译成了java代码，那么就要写接口的实现了，实现是在server端的，需要继承自的HelloWorldPOA

[java] view plain copy
  1. package server;  
  2.   
  3. import helloworld.HelloWorldPOA;  
  4.   
  5.   
  6. /** 
  7.  * 服务器端的实现代码 
  8.  * 
  9.  */  
  10. public class HelloWorldImpl extends HelloWorldPOA {  
  11.   
  12.     @Override  
  13.     public String sayHello() {  
  14.           
  15.         return "Hello World!";  
  16.     }  
  17.   
  18. }  
server启动的代码，这段代码主要功能是将接口实现注册到ORB中，并启动监听，等待client来调用
[java] view plain copy
  1. package server;  
  2.   
  3. import helloworld.HelloWorld;  
  4. import helloworld.HelloWorldHelper;  
  5.   
  6. import org.omg.CORBA.ORB;  
  7. import org.omg.CORBA.ORBPackage.InvalidName;  
  8. import org.omg.CosNaming.NameComponent;  
  9. import org.omg.CosNaming.NamingContextExt;  
  10. import org.omg.CosNaming.NamingContextExtHelper;  
  11. import org.omg.CosNaming.NamingContextPackage.CannotProceed;  
  12. import org.omg.CosNaming.NamingContextPackage.NotFound;  
  13. import org.omg.PortableServer.POA;  
  14. import org.omg.PortableServer.POAHelper;  
  15. import org.omg.PortableServer.POAManagerPackage.AdapterInactive;  
  16. import org.omg.PortableServer.POAPackage.ServantNotActive;  
  17. import org.omg.PortableServer.POAPackage.WrongPolicy;  
  18.   
  19.   
  20. public class HelloServer {  
  21.     public static void main(String[] args) throws ServantNotActive, WrongPolicy, InvalidName, AdapterInactive, org.omg.CosNaming.NamingContextPackage.InvalidName, NotFound, CannotProceed {  
  22.         //指定ORB的端口号 -ORBInitialPort 1050  
  23.         args = new String[2];  
  24.         args[0] = "-ORBInitialPort";  
  25.         args[1] = "1050";  
  26.            
  27.         //创建一个ORB实例  
  28.         ORB orb = ORB.init(args, null);  
  29.            
  30.         //拿到RootPOA的引用，并**POAManager，相当于启动了server  
  31.         org.omg.CORBA.Object obj=orb.resolve_initial_references("RootPOA");  
  32.         POA rootpoa = POAHelper.narrow(obj);  
  33.         rootpoa.the_POAManager().activate();  
  34.            
  35.         //创建一个HelloWorldImpl实例  
  36.         HelloWorldImpl helloImpl = new HelloWorldImpl();  
  37.           
  38.         //从服务中得到对象的引用，并注册到服务中  
  39.         org.omg.CORBA.Object ref = rootpoa.servant_to_reference(helloImpl);  
  40.         HelloWorld href = HelloWorldHelper.narrow(ref);  
  41.            
  42.         //得到一个根名称的上下文  
  43.         org.omg.CORBA.Object objRef = orb.resolve_initial_references("NameService");  
  44.         NamingContextExt ncRef = NamingContextExtHelper.narrow(objRef);  
  45.           
  46.         //在命名上下文中绑定这个对象  
  47.         String name = "Hello";  
  48.         NameComponent path[] = ncRef.to_name(name);  
  49.         ncRef.rebind(path, href);  
  50.           
  51.         //启动线程服务，等待客户端调用  
  52.         orb.run();  
  53.           
  54.         System.out.println("server startup...");  
  55.     }  
  56. }  
4.开发client端的代码

server端的实现与服务监听都已经做完，现在需要写一个client来调用server的方法

[java] view plain copy
  1. package client;  
  2.   
  3. import helloworld.HelloWorld;  
  4. import helloworld.HelloWorldHelper;  
  5.   
  6. import org.omg.CORBA.ORB;  
  7. import org.omg.CORBA.ORBPackage.InvalidName;  
  8. import org.omg.CosNaming.NamingContextExt;  
  9. import org.omg.CosNaming.NamingContextExtHelper;  
  10. import org.omg.CosNaming.NamingContextPackage.CannotProceed;  
  11. import org.omg.CosNaming.NamingContextPackage.NotFound;  
  12.   
  13.   
  14. public class HelloClient {  
  15.     static HelloWorld helloWorldImpl;  
  16.        
  17.     static {  
  18.         System.out.println("client开始连接server.......");  
  19.            
  20.         //初始化ip和端口号，-ORBInitialHost 127.0.0.1 -ORBInitialPort 1050  
  21.         String args[] = new String[4];  
  22.         args[0] = "-ORBInitialHost";  
  23.         //server端的IP地址，在HelloServer中定义的  
  24.         args[1] = "127.0.0.1";  
  25.         args[2] = "-ORBInitialPort";  
  26.         //server端的端口，在HelloServer中定义的  
  27.         args[3] = "1050";  
  28.            
  29.         //创建一个ORB实例  
  30.         ORB orb = ORB.init(args, null);  
  31.            
  32.         // 获取根名称上下文  
  33.         org.omg.CORBA.Object objRef = null;  
  34.         try {  
  35.         objRef = orb.resolve_initial_references("NameService");  
  36.         } catch (InvalidName e) {  
  37.             e.printStackTrace();  
  38.         }  
  39.         NamingContextExt neRef = NamingContextExtHelper.narrow(objRef);  
  40.            
  41.         String name = "Hello";  
  42.         try {  
  43.               
  44.             //通过ORB拿到了server实例化好的实现类  
  45.             helloWorldImpl = HelloWorldHelper.narrow(neRef.resolve_str(name));  
  46.         } catch (NotFound e) {  
  47.             e.printStackTrace();  
  48.         } catch (CannotProceed e) {  
  49.             e.printStackTrace();  
  50.         } catch (org.omg.CosNaming.NamingContextPackage.InvalidName e) {  
  51.             e.printStackTrace();  
  52.         }  
  53.            
  54.         System.out.println("client connected server.......");  
  55.     }  
  56.        
  57.     public static void main(String args[]) throws Exception {  
  58.         sayHello();  
  59.     }  
  60.        
  61.     //调用实现类的方法  
  62.     public static void sayHello() {  
  63.         String str = helloWorldImpl.sayHello();  
  64.         System.out.println(str);  
  65.     }  
  66. }  
我们可以看到在server和client个创建了一个ORB的实例，这时因为在server和client都需要有支持通信（见上面的CORBA基本结构图）。

5.启动orbd服务

仅仅创建了server和client的代码还不足以跑起来一个HelloWorld，还需要启动一个orbd服务，这个服务在%JAVA_HOME%\jre\bin下。orbd包含自启动服务、透明的命名服务、持久化命名服务和命名管理器的后台处理进程。应该是上面的HelloWorld用到了nameService所以才会需要这个服务，使用其他方式拿server的实例是不是就不需要这个服务了，又或者是所有的CORBA都要与这个服务通信，不太明白？

在命令行下输入启动orbd：

[html] view plain copy
  1. cd /d  %JAVA_HOME%\bin  
  2. orbd -ORBInitialPort 1050 -ORBInitialHost 127.0.0.1  

6.启动server服务

7.启动client

可以看到输出结果：

[plain] view plain copy
  1. client开始连接server.......  
  2. client connected server.......  
  3. Hello World!  

现在CORBA用的已经很少了，基本上只有一些大的电信项目还在用，现在同类的解决方案中WebService是比较流行的。

相关推荐