`
ekumen
  • 浏览: 108197 次
  • 性别: Icon_minigender_1
  • 来自: 上海
社区版块
存档分类
最新评论

CORBA

    博客分类:
  • java
阅读更多
Programming   Example:   Array   Adder  
  Now   let's   see   how   to   use   the   POA   to   develop   a   CORBA   application.   The   application   that   we   will   develop   here   is   an   array   adder:   the   client   provides   two   arrays   and   the   server   adds   them   together   and   sends   the   result   back   to   the   client.   We   will   develop   two   versions   of   the   application:   a   transient   server   and   a   persistent   server.    
   
  Array   Adder:   Transient   Server  
  The   first   step   in   developing   any   CORBA   application   is   to   define   the   interface   in   the   OMG   Interface   Definition   Language   (IDL).   The   IDL   interface   for   the   array   adder   is   shown   in   Code   Sample   1.   Here   I   define   a   module   ArithApp   (which   is   equivalent   to   a   Java   package),   an   interface   Add   that   contains   a   constant,   a   new   data   type   array   (which   is   a   synonym   for   an   array   of   longs   and   an   operation   addArrays   that   takes   in   two   arrays   as   input   (specified   using   the   in)   and   another   array   as   the   output   holder   (specified   using   the   out).    
   
  Code   Sample   1:   Add.idl    
   
  module   ArithApp   {  
        interface   Add   {  
              const   unsigned   short   SIZE=10;  
              typedef   long   array[SIZE];  
              void   addArrays(in   array   a,   in   array   b,    
                  out   array   result);  
        };  
  };  
   
  You   can   now   compile   this   IDL   interface   to   map   it   to   Java   and   generate   stubs   and   skeletons.   This   can   be   done   using   the   idlj   compiler.   When   you   run   this   tool   you   can   request   it   to   generate   client   stubs   only,   server   side   skeletons   only,   or   both.   Here   you   want   to   generate   both,   client   stubs   and   server   skeletons.   To   do   so   use   the   following   command:    
   
  prompt>   idlj   -fall   Add.idl  
  This   command   will   generate   several   files.   Check   the   local   directory   where   you   run   the   command   from   to   see   the   files.   You   will   notice   that   a   new   subdirectory   with   the   name   ArithApp   has   been   created.   This   is   because   an   OMG   IDL   module   is   mapped   to   a   Java   package.   For   more   information   on   the   idlj   compiler   and   the   options   you   can   use,   please   see   the   IDL-to-Java   Compiler.    
   
   
  --------------------------------------------------------------------------------  
  Note:   The   new   idlj   compiler   in   J2SE   1.4   generates   server-side   mappings   for   the   Portable   Object   Adapter   (POA).   The   new   compiler   is,   however,   backward   compatible   with   earlier   releases   since   it   provides   the   -ImplBase   flag   that   can   be   used   to   generate   server-side   mappings   for   existing   applications   that   have   been   created   using   J2SE   1.3   or   earlier   versions.   Therefore,   in   order   to   talk   to   existing   applications   that   have   been   created   using   J2SE   1.3   or   earlier,   you   need   to   use   the   -ImplBase   flag   to   generate   server-side   mappings.   New   applications   do   not   need   to   generate   these   deprecated   server-side   mappings.    
  --------------------------------------------------------------------------------  
   
  The   next   step   is   to   implement   the   IDL   interface   in   Code   Sample   1.   An   implementation   is   shown   in   Code   Sample   2.   The   AddImpl   class   is   a   subclass   of   AddPOA,   which   is   generated   by   the   idlj   compiler   from   the   IDL   interface.   Note   the   third   parameter   to   the   addArrays   operation.   Here   I   am   using   an   array   holder   simply   because   I   am   using   the   out   parameter   as   a   holder   for   the   output   array.    
   
  Code   Sample   2:   AddImpl.java    
   
  import   ArithApp.*;  
  import   org.omg.CORBA.*;  
   
  class   AddImpl   extends   AddPOA   {  
      private   ORB   orb;  
     
      public   AddImpl(ORB   orb)   {  
          this.orb   =   orb;  
      }  
   
      //   implement   the   addArrays()   method  
      public   void   addArrays(int   a[],   int   b[],    
          ArithApp.AddPackage.arrayHolder   result)   {  
   
          result.value   =   new   int[ArithApp.Add.SIZE];  
   
          for(int   i=0;   i<ArithApp.Add.SIZE;   i++)   {  
              result.value[i]   =   a[i]   +   b[i];  
          }  
      }        
  }  
   
  The   next   step   is   to   develop   the   server.   A   sample   server   is   shown   in   Code   Sample   3.   The   server   performs   the   following   tasks:    
   
  Creates   and   initializes   the   ORB.    
  Creates   an   instance   of   the   interface   implementation   and   registers   it   with   the   ORB.    
  Gets   a   reference   to   the   RootPOA   and   activates   the   POAManager.    
  Gets   an   object   reference   from   the   servant.    
  Gets   the   root   naming   context   from   the   naming   service   and   registers   the   new   object   under   the   name   "Add".    
  Waits   for   invocations   from   clients.
Code   Sample   3:   AddServer.java    
   
  import   ArithApp.*;  
  import   org.omg.CORBA.*;  
  import   org.omg.CosNaming.*;  
  import   org.omg.PortableServer.*;  
  import   org.omg.PortableServer.POA;  
  import   org.omg.CosNaming.NamingContextPackage.*;  
   
  public   class   AddServer   {  
   
      public   static   void   main(String   args[])   {  
          try{  
              //   create   and   initialize   the   ORB  
              ORB   orb   =   ORB.init(args,   null);  
   
              //   create   an   implementation   and   register   it   with   the ORB  
              AddImpl   impl   =   new   AddImpl(orb);  
   
              //   get   reference   to   rootpoa   &   activate   the   POAManager  
              POA   rootpoa   =   POAHelper.narrow(  
                  orb.resolve_initial_references("RootPOA"));  
              rootpoa.the_POAManager().activate();  
   
              //   get   object   reference   from   the   servant  
              org.omg.CORBA.Object   ref   =    
                  rootpoa.servant_to_reference(impl);  
              Add   href   =   AddHelper.narrow(ref);  
       
              //   get   the   root   naming   context  
              //   NameService   invokes   the   name   service  
              org.omg.CORBA.Object   objRef   =    
                  orb.resolve_initial_references("NameService");  
              //   Use   NamingContextExt   which   is   part   of   the   Interoperable  
              //   Naming   Service   (INS)   specification.  
              NamingContextExt   ncRef   =    
                  NamingContextExtHelper.narrow(objRef);  
   
              //   bind   the   Object   Reference   in   Naming  
              String   name   =   "Add";  
              NameComponent   path[]   =   ncRef.to_name(   name   );  
              ncRef.rebind(path,   href);  
   
              System.out.println("AddServer    
                  ready   to   add   up   your   arrays   ....");  
   
              //   wait   for   invocations   from   clients  
              orb.run();  
          }   catch   (Exception   e)   {  
                  System.err.println("ERROR:   "   +   e);  
                  e.printStackTrace(System.out);  
          }  
          System.out.println("AddServer   Exiting   ....");  
      }  
  }  
   
  Now,   implement   the   client.   A   sample   client   is   shown   in   Code   Sample   4.   The   client   code   performs   the   following   tasks:    
   
  Creates   and   initializes   the   ORB.    
  Obtains   a   reference   to   the   root   naming   context.    
  Looks   up   the   "Add"   object   in   the   naming   context   and   obtains   a   reference   to   it.    
  Invokes   the   addArrays   method   and   prints   the   results.    
  Code   Sample   4:   AddClient.java    
   
  import   ArithApp.*;  
  import   org.omg.CORBA.*;  
  import   org.omg.CosNaming.*;  
  import   org.omg.CosNaming.NamingContextPackage.*;  
   
  public   class   AddClient   {  
   
      public   static   void   main(String   args[])   {  
          try   {  
              //   create   and   initialize   the   ORB  
              ORB   orb   =   ORB.init(args,   null);  
   
              //   get   the   root   naming   context  
              org.omg.CORBA.Object   objRef   =    
                  orb.resolve_initial_references("NameService");  
   
              //   Use   NamingContextExt   instead   of   NamingContext.   This   is    
              //   part   of   the   Interoperable   Naming   Service.      
              NamingContextExt   ncRef   =    
                  NamingContextExtHelper.narrow(objRef);  
     
              //   resolve   the   Object   Reference   in   Naming  
              String   name   =   "Add";  
              Add   impl   =   AddHelper.narrow(ncRef.resolve_str(name));  
   
              System.out.println("Handle    
                  obtained   on   server   object:   "   +   impl);  
   
              //   the   arrays   to   be   added  
              int   a[]   =   {6,   6,   6,   6,   6,   6,   6,   6,   6,   6};  
              int   b[]   =   {7,   7,   7,   7,   7,   7,   7,   7,   7,   7};  
                   
              //   the   result   will   be   saved   in   this   new   array  
              ArithApp.AddPackage.arrayHolder   c   =    
                  new   ArithApp.AddPackage.arrayHolder();  
   
              //   invoke   the   method   addArrays()  
              impl.addArrays(a,   b,   c);  
              //   print   the   new   array  
              System.out.println("The   sum   of   the   two   arrays   is:   ");  
              for(int   i=0;i<ArithApp.Add.SIZE;i++)   {  
                  System.out.println(c.value[i]);  
              }  
   
          }   catch   (Exception   e)   {  
                  System.out.println("ERROR   :   "   +   e)   ;  
                  e.printStackTrace(System.out);  
          }  
      }  
  }  
   
  Now   you   can   compile   the   classes   AddImpl,   AddServer,   AddClient,   and   the   stubs   and   skeletons   that   were   generated   by   the   idlj   compiler.   This   is   done   using   the   javac   compiler   as   follows:    
   
  prompt>   javac   *.java   ArithApp/*.java  
  To   run   the   application:    
   
  Start   the   orbd,   which   is   a   name   server:    
   
   
  prompt>   orbd   -ORBInitialPort   2500  
  The   number   2500   is   the   port   number   where   you   want   the   orbd   to   run.   Note   that   the   -ORBInitialPort   is   a   require   command-line   argument.    
   
   
  Start   the   AddServer:    
   
   
  prompt>   java   AddServer   -ORBInitialPort   2500  
  This   command   starts   the   server   as   shown   in   Figure   2.    
   
   
   
  Figure   2:   Starting   the   AddServer      
   
   
  Here   we   are   assuming   that   both   the   AddServer   and   orbd   are   running   on   the   same   host.   If   the   orbd   is   running   on   a   different   host,   use   the   -ORBInitialHost   argument   to   inform   the   server   where   to   find   the   orbd.    
   
   
  Start   the   AddClient:    
   
   
  prompt>   java   AddClient   -ORBInitialPort   2500  
  You   should   see   the   sum   of   the   two   arrays   as   shown   in    
   
   
   
  Figure   3:   Starting   the   AddClient  
 
分享到:
评论

相关推荐

    corba测试工具(Telcopro)

    CORBA(Common Object Request Broker Architecture,公共对象请求代理体系结构)是一种标准的中间件技术,它允许不同系统上的软件对象相互通信,就像它们在同一个进程中一样。这种跨平台、跨语言的通信能力使得...

    CORBA基础_C++corba开发_corba_

    CORBA(Common Object Request Broker Architecture,公共对象请求代理体系结构)是用于分布式计算的一种标准,它允许不同系统间的软件对象进行交互,就像它们在同一个进程内一样。在C++环境中进行CORBA开发可以帮助...

    java_CORBA.rar_CORBA java_Java CORBA_corba

    Java CORBA,全称为Java Common Object Request Broker Architecture(Java通用对象请求代理架构),是一种用于分布式计算的技术,允许不同网络上的对象或服务之间进行交互。它实现了对象请求代理(ORB)的概念,...

    iManager U2000 V100R006C02 北向CORBA接口 用户指南

    《iManager U2000 V100R006C02 北向CORBA接口 用户指南》是华为公司为网络管理平台iManager U2000提供的一份详细的技术文档,主要针对该系统如何通过CORBA(Common Object Request Broker Architecture,公共对象...

    com 与corba 本质与互用

    CORBA支持多种传输协议和编码格式,如IIOP(Internet Inter-ORB Protocol)和GIOP(General Inter-ORB Protocol),确保了跨网络和系统的互操作性。 当涉及到COM与CORBA的互用时,由于它们的设计理念和实现机制不同...

    corba实例(java版)

    CORBA(Common Object Request Broker Architecture,公共对象请求代理体系结构)是用于分布式计算的一个标准,它允许不同系统间的对象进行交互,仿佛它们都在同一进程中。Java版的CORBA利用Java平台的强大功能,...

    Ultra Corba Simulator (Corba 模拟器)1.3.6

    ** Ultra Corba Simulator 1.3.6:深入理解与应用** Ultra Corba Simulator是一款针对Corba技术的专业模拟工具,版本为1.3.6。Corba,全称为Common Object Request Broker Architecture(通用对象请求代理架构),...

    《Advanced CORBA Programming with C》(英文原版)高清pdf

    《Advanced CORBA Programming with C》是一本面向有C++基础的程序员的专业书籍,旨在深入探讨CORBA(Common Object Request Broker Architecture)技术在C++中的高级编程应用。这本书以英文原版的形式提供,确保了...

    CORBA技术及实例

    ### CORBA技术详解与实践案例 #### 一、CORBA技术概述 CORBA(Common Object Request Broker Architecture,通用对象请求代理系统)是一种分布式计算环境下的软件架构标准,它由OMG(Object Management Group,...

    Java 编写通用 Corba Client 是测试Corba服务的好工具

    Java 编写的通用Corba Client是一种强大的工具,用于测试和交互与Corba(Common Object Request Broker Architecture)服务。Corba是一种标准的中间件技术,它允许不同操作系统、编程语言和网络环境中的对象相互通信...

    CORBA标准 part 2 CORBA互操作 - 版本 3.2 (2011)

    CORBA(Common Object Request Broker Architecture)标准,即通用对象请求代理体系结构,是由OMG(Object Management Group)定义的分布式计算的关键技术之一。CORBA标准旨在提供一种机制,允许不同的软件组件...

    CORBA 原理及应用

    ### CORBA原理及应用知识点详解 #### 一、CORBA简介 - **CORBA**(Common Object Request Broker Architecture,通用对象请求代理体系结构)是一种分布式计算标准,旨在提供跨网络和平台之间的对象交互能力。 - **...

    corba程序源代码

    【标题】:CORBA程序源代码 【描述】:这些源代码示例涵盖了多个使用CORBA(Common Object Request Broker Architecture)技术的程序,包括Java RMI(Remote Method Invocation)、Inprocess通信、简单的HELLO世界...

    UCS (Ultra Corba Simulator)  中文使用说明书

    UCS Ultra Corba Simulator 中文使用说明书 UCS Ultra Corba Simulator 是一个模拟器工具,旨在帮助用户快速学习和掌握 Corba 技术。下面是对 UCS 用户手册的详细解释和知识点总结: 项目背景 UCS Ultra Corba ...

    corba核心规范-- 一个简单的CORBA/Java示例

    **CORBA核心规范——一个简单的CORBA/Java示例** **一、CORBA基础** **CORBA(Common Object Request Broker Architecture)**,即公共对象请求代理架构,是一种跨平台、跨语言的分布式计算模型,旨在解决不同系统...

    基于C++的CORBA实现

    **基于C++的CORBA实现** CORBA(Common Object Request Broker Architecture)是一种开放的、标准的中间件技术,用于构建跨平台、跨网络、跨语言的分布式计算环境。它允许不同计算机上的对象相互通信,仿佛它们都在...

    CORBA技术系列丛书之-CORBA服务

    CORBA(Common Object Request Broker Architecture,公共对象请求代理体系结构)是一种分布式计算技术,它允许在不同的操作系统、网络环境和编程语言之间进行无缝通信。CORBA技术系列丛书之"CORBA服务"着重于深入...

    corba的ppt文档

    【CORBA概述】 CORBA(Common Object Request Broker Architecture,公用对象请求代理体系结构)是一种分布式计算框架,旨在解决不同计算平台上的对象之间的交互问题。它由Object Management Group(OMG)组织提出...

Global site tag (gtag.js) - Google Analytics