精华内容
下载资源
问答
  • CORBA

    2021-06-10 13:26:26
    百度百科中的corba

    百度百科中的corba

    《计算机网络管理与实现》中CORBA相关内容

    IDL文件-IDL(Interface Definition Language)即接口定义语言,是CORBA规范的一部分,是跨平台开发的基础。

    类似于一个注册发现的中间组件,存储服务与IP:port之间的对应关系,对于请求的名字服务给出对应的IP:port,从而实现

    调度的一个作用.

    展开全文
  • corba

    2013-07-13 14:07:47
    CORBA(Common Object Request Broker Architecture, 公共对象请求代理体系结构)是由OMG(对象管理组织,Object Management Group)提出的应用软件体系结构和对象技术规范,其核心是一套标准的语言、接口和协议,以...
    CORBA(Common Object Request Broker Architecture, 公共对象请求代理体系结构)是由OMG(对象管理组织,Object Management Group)提出的应用软件体系结构和对象技术规范,其核心是一套标准的语言、接口和协议,以支持异构分布应用程序间的互操作性及独立于平台和编程语言的对象重用。
    
      CORBA经过近十年的发展,已逐步走向成熟,并成功地应用在我国许多大型的软件系统中,由此产生了对掌握CORBA技术的软件开发人员的大量需求。在此,我们应广大读者的要求组织了本次讲座。 本系列讲座分别介绍了CORBA的基本思想、体系结构以及CORBA应用程序的设计与开发,希望借此能帮助广大软件开发、设计人员,开阔思路,加深对CORBA的理解,进而真正掌握这门技术,并能在实际工作中加以灵活运用,更高效、迅速地开发出更强壮的软件系统,最终促进我国软件事业的蓬勃发展。 


    CORBA产生的背景 


      近年来,随着互联网技术的日益成熟,公众及商业企业正享受着高速、低价网络信息传输所带来的高品质数字生活。但是,由于网络规模的不断扩大以及计算机软硬件技术水平的飞速提高,给传统的应用软件系统的实现方式带来了巨大挑战。 


      首先,在企业级应用中,硬件系统集成商基于性能、价格、服务等方面的考虑,通常在同一系统中集成来自不同厂商的硬件设备、操作系统、数据库平台和网络协议等,由此带来的异构性给应用软件的互操作性、兼容性以及平滑升级能力带来了严重问题。 


      另外,随着基于网络的业务不断增多,传统的客户/服务器(C/S)模式的分布式应用方式越来越显示出在运行效率、系统网络安全性和系统升级能力等方面的局限性。 


      为了解决分布式计算环境(DCE,Distributed Computing Environment)中不同硬件设备和软件系统的互联,增强网络间软件的互操作性,解决传统分布式计算模式中的不足等问题,对象管理组织(OMG)提出了公共对象请求代理体系结构(CORBA),以增强软件系统间的互操作能力,使构造灵活的分布式应用系统成为可能。


      正是基于面向对象技术的发展和成熟、客户/服务器软件系统模式的普遍应用以及集成已有系统等方面的需求,推动了CORBA技术的成熟与发展。作为面向对象系统的对象通信的核心,CORBA为当今网络计算环境带来了真正意义上的互联。 


    CORBA的发展历程 


    1. 对象管理组织(OMG)简介 


      OMG成立于1989年,作为一个非营利性组织,集中致力于开发在技术上具有先进性、在商业上具有可行性并且独立于厂商的软件互联规范,推广面向对象模型技术,增强软件的可移植性(Portability)、可重用性(Reusability)和互操作性(Interoperability)。 


      该组织成立之初,成员包括Unisys、Sun、Cannon、Hewlett-Packard、Philips等在业界享有声誉的软硬件厂商,目前该组织拥有800多家成员。 


    2. CORBA主要版本的发展历程 


      ● 1990年11月,OMG发表《对象管理体系指南》,初步阐明了CORBA的思想; 
      ● 1991年10月,OMG推出1.0版,其中定义了接口定义语言(IDL)、对象管理模型以及基于动态请求的API和接口仓库等内容; 
      ● 1991年12月,OMG推出了CORBA 1.1版,在澄清了1.0版中存在的二义性的基础上,引入了对象适配器的概念; 
      ● 1996年8月,OMG基于以前的升级版本,完成了2.0版的开发,该版本中重要的内容是对象请求代理间协议(IIOP,Internet Inter-ORB Protocol)的引入,用以实现不同厂商的ORB真正意义上的互通; 
      ● 1998年9月,OMG发表了CORBA 2.3版,增加了支持CORBA对象的异步实时传输、服务质量规范等内容。目前,宣布支持CORBA 2.3规范的中间件厂商包括Inprise(Borland)、Iona、BEA System等著名的CORBA产品生产商。 


    CORBA体系结构概述 


      CORBA规范充分利用了现今软件技术发展的最新成果,在基于网络的分布式应用环境下实现应用软件的集成,使得面向对象的软件在分布、异构环境下实现可重用、可移植和互操作。其特点可以总结为如下几个方面: 


      1. 引入中间件(MiddleWare)作为事务代理,完成客户机(Client)向服务对象方(Server)提出的业务请求(引入中间件概念后分布计算模式如图1所示); 




    图1 引入中间件后客户机与服务器之间的关系




      2. 实现客户与服务对象的完全分开,客户不需要了解服务对象的实现过程以及具体位置(参见图2所示的CORBA系统体系结构图); 


      3. 提供软总线机制,使得在任何环境下、采用任何语言开发的软件只要符合接口规范的定义,均能够集成到分布式系统中; 


      4. CORBA规范软件系统采用面向对象的软件实现方法开发应用系统,实现对象内部细节的完整封装,保留对象方法的对外接口定义。 


      在以上特点中,最突出的是中间件的引入, 在CORBA系统中称为对象请求代理(ORB,Object Request Broker)和采用面向对象的开发模式。 


      对象模型是应用开发人员对客观事物属性和功能的具体抽象。由于CORBA使用了对象模型,将CORBA系统中所有的应用看成是对象及相关操作的集合,因此通过对象请求代理(ORB),使CORBA系统中分布在网络中应用对象的获取只取决于网络的畅通性和服务对象特征获取的准确程度,而与对象的位置以及对象所处的设备环境无关。








    图2 CORBA系统体系结构图


    CORBA的主要应用方向及中间件产品介绍 


      CORBA规范的推出,重新调整了客户机与服务器之间的关系。客户机可以向服务器提出事务请求,同时也可以为下一个请求充当服务器角色。 


      由于CORBA系统引入了中间件的概念,即事务代理,由中间件完成客户机与服务器之间的通信,使得服务器对于客户机的位置相对透明,取消了原有分布式计算模型中客户机、服务器之间的一一对应关系。CORBA客户机可以在运行时动态获得服务对象的位置,并且可以对多个服务对象提交事务请求,因此,极大推动了分布计算的发展。 


      分布计算是指网络中两个或两个以上的软件相互共享信息资源。这些软件可以位于同一台计算机中,也可以部署在网络节点的任意位置。基于分布式模型的软件系统具有均衡运行系统负载、共享网络资源的技术优势。 


      另外,CORBA规范约束采用面向对象的分布式软件的构造方法,以接口定义语言的形式实现对象内部细节的完整封装,从而降低了软件系统的复杂程度,增加了软件功能的可重用性。CORBA提供到C/C++、Java、SmallTalk等高级语言的映射,很大程度地减小了对程序设计语言的依赖性,使软件开发人员可以在较大范围内共享已有成果。 


      正是以上特点推动了分布式多层软件体系结构的发展。目前,CORBA技术在银行、电信、保险、电力和电子商务领域都有广泛的应用。 


      软件市场中能够见到的CORBA中间件产品很多,但基于不同公司的产品战略以及研发方向,各个产品在服务性能、对高级语言的支持和所依赖的系统平台方面有很大区别。根据整理的资料,笔者对主要产品在上述几方面进行了分析(参见表1),供读者在选择时参考。 用JAVA开发CORBA应用实例




      通用对象代理体系结构CORBA(Common Object Request Broker Architecture)是对象管理组织所定义的用来实现现今大量硬件、软件之间互操作的解决方案,CORBA也是迈向面向对象标准化和互操作的重要一步。 
    ■ CORBA技术简介 
    简单地说,CORBA允许应用之间相互通信,而不管它们存在于哪里以及是谁设计的。CORBA1.1于1991年由OMG发布,其中定义了接口定义语言(IDL)以及在对象请求代理(ORB)中实现客户对象与服务器对象之间交互的应用编程接口(API)。CORBA2.0于1994年发布,规定了各个供应商之间的ORB的通信规则。
      CORBA标准主要分为三个部分:接口定义语言(IDL)、对象请求代理(ORB)以及ORB之间的互操作协议IIOP。 
      ORB是对象之间建立Client/Server关系的中间件。使用ORB,客户可以透明地调用一个服务对象上的方法,这个服务对象可以在本地,也可以在通过网络连接的其他机器上。ORB截获这一调用同时负责查找实现服务的对象并向其传递参数、调用方法返回最终结果。客户并不知道服务对象位于什么地方,它的编程语言和操作系统是什么,也不知道不属于对象接口的其他系统部分。这样,ORB在异构分布环境下为不同机器上的应用提供了互操作性,并无缝地集成了多种对象系统。 
      在开发传统的Client/Server应用时,开发者使用他们自己设计的或一个公认的标准来定义用于设备之间通信的协议。协议的定义依赖于实现语言、网络传输和许多其他因素,而ORB的出现简化了这一过程。使用ORB时,协议是使用接口定义语言(IDL)定义的,而IDL是独立于语言的。并且ORB提供很强的灵活性,它使程序员选择最适合的操作系统、执行环境,甚至系统各个组件也可以采用不同的编程语言实现。更重要的是,它允许现有组件的集成。在一个基于ORB的解决方案中,开发者可以使用与创建新对象一样的IDL对遗留系统进行建模,他们创建"包装"代码以在标准化的软件总线与遗留系统接口之间传递信息。 
      使用CORBA,用户可以透明地访问信息,并不需要知道信息存在于什么软件中、使用什么硬件平台,以及位于企业网络的什么地方。作为面向对象系统的通信核心,CORBA为今天的计算环境带来了真正的互操作性。
    ■ CORBA与JAVA的相互关系 
     CORBA不只意味着对象请求代理(ORB),它还是非常全面的分布式对象平台。CORBA使JAVA应用可以跨越网络、语言以及操作系统,并为JAVA提供了一组分布服务,如分布式自我观察、动态发现、事务、关系、安全和命名等。
    JAVA不仅是一种语言,它还是一个动态代码系统,它对运行对象来说是一个可移植的虚拟机(JVM)。JAVA为开发、管理、发布Client/Server应用提供了更简单的方式。人们可以通过将应用放在一个Web服务器上将这一应用发布给成千上万个用户,而不必关心它的安装和升级。JAVA还非常适合服务器的开发,它可以动态地将服务代码移向最需要它们的地方。 
    JAVA将会使CORBA对象能够运行在从主机、网络计算机到蜂窝电话等可编程的各种机器上,并简化了大型CORBA系统的代码发布。对客户和服务对象来说JAVA是很理想的编程语言,JAVA内置的多线程、垃圾收集和错误处理使编写健壮的网络对象变得很容易。
      这两种对象模型可以很好地相互补充,CORBA处理网络的透明性,JAVA处理实现的透明性,CORBA为JAVA可移植应用环境提供了一个分布式的结构。 
    ■ 使用JAVA开发CORBA应用 
     下面让我简要介绍一下开发CORBA的步骤。
    使用JAVA开发CORBA应用需要如下五个步骤:
    1. 使用IDL创建接口 (About.idl) 
    2.   下面的OMG IDL描述一个CORBA对象。
    module About 
      { 
       interface Show 
       { 
       string ShowName();
      }; 
      }; 
      将其存为Show.idl。 
    3. 编译接口并生成CORBA支持文件 
    我们用以下命令编译这个 IDL 接口: 
       idltojava Show.idl 
      idltojava是SUN公司的IDL编译器,可以免费从SUN公司站点上下载。 
      因为idltojava在编译IDL文件之前,需要进行预编译,而如果你的机器上没有预编译器,可以使用以下命令: 
      idltojava -fno-cpp Show.idl 
      编译后将在当前目录下生成About子目录,其中会包括一些支持文件,如有兴趣可以看一下,但一定不要修改。 
    4. 实现服务器 (ShowServer.java) 
    ShowServer的main() 方法,可完成以下任务: 
    (1) 创建一个 ORB 实例 
    (2) 创建一个服务对象实例(CORBA About 对象的实现)并通知 ORB 
    (3)获取一个命名上下文的CORBA对象引用,在该命名上下文中注册新的CORBA对象 
    (4)在命名上下文中将新对象注册在"About"名下 
    (5)等待对新对象的调用 
    实现服务器源程序如下: 
    import About.; 
      import org.omg.CosNaming.; 
      import org.omg.CosNaming.NamingContextPackage.; 
      import org.omg.CORBA.; 
      class ShowObject extends _ShowImplBase 
      { 
       public String ShowName() 
       { 
       return "/nMy name is Seymour!!/n"; 
       } 
      } 
      public class ShowServer { 
       public static void main(String args[]) 
       { 
       try{ 
      // 创建和初始化 ORB 
       ORB orb = ORB.init(args, null); 
       // 创建服务对象并将其向 ORB 注册 
       ShowObject ShowRef = new ShowObject(); 
       orb.connect(ShowRef); 
       // 获取根命名上下文 
       org.omg.CORBA.Object objRef = orb.resolve_initial_references("NameService"); 
       NamingContext ncRef = NamingContextHelper.narrow(objRef); 
       // 绑定命名中的对象引用 
      NameComponent nc = new NameComponent("About", ""); 
       NameComponent path[] = {nc}; 
       ncRef.rebind(path, ShowRef); 
       // 等待来自客户机的调用 
       java.lang.Object sync = new java.lang.Object(); 
       synchronized (sync) { 
      sync.wait(); 
       } 
       } catch (Exception e) { 
       System.err.println("ERROR: " + e); 
       e.printStackTrace(System.out); 
       } 
       } 
      } 
      4.实现客户机 (ShowClient.java) 
      下面的应用程序客户机将完成以下任务: 
      (1)创建一个ORB; 
     (2)获取一个指向命名上下文的引用; 
      (3)在命名上下文中查找"Show"并获得指向该 CORBA 对象的引用; 
      (4)调用对象的 ShowName() 操作并打印结果。 
      import About.; 
      import org.omg.CosNaming.; 
      import org.omg.CORBA.; 
      public class ShowClient 
      { 
       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("About", ""); 
      NameComponent path[] = {nc}; 
      About.Show ShowRef = ShowHelper.narrow(ncRef.resolve(path)); 
      // 调用 Show 服务对象并打印结果 
       String show = ShowRef.ShowName(); 
       System.out.println(show); 
       } catch (Exception e) { 
       System.out.println("ERROR : " + e) ; 
       e.printStackTrace(System.out); 
       } 
       } 
      } 
      5.构建和运行ShowName程序 
      (1)编译 .java 文件,包括 stub 和 skeleton(在About目录中): 
       javac .java About/.java 
      (2)启动一个MS-DOS命令解释器,输入以下命令,确保名字服务器处于运行状态: 
       tnameserv -ORBInitialPort 1050 
      (3)启动另一个MS-Dos命令解释器,输入以下命令,启动Show服务器: 
      java ShowServer -ORBInitialPort 1050 
      (4)再启动一个MS-Dos命令解释器Show应用程序客户机:
      java ShowClient -ORBInitialPort 1050 
      这时屏幕上会出现"My name is Seymour!"的字样,说明实验已经成功了。
    展开全文
  • Corba

    2010-07-04 15:53:00
     《Corba 介绍》  CORBA(Common Object Request Broker Architecture公共对象请求代理体系结构)是由OMG组织制订的一种标准的面向对象应用程序体系规范。或者说 CORBA体系结构是对象管理组织(OMG)为...

                                      《Corba 介绍》

     CORBA(Common Object Request Broker Architecture公共对象请求代理体系结构)是由OMG组织制订的一种标准的面向对象应用程序体系规范。或者说 CORBA体系结构是对象管理组织(OMG)为解决分布式处理环境(DCE)中,硬件和软件系统的互连而提出的一种解决方案;OMG组织是一个国际性的非盈利组织,其职责是为应用开发提供一个公共框架,制订工业指南和对象管理规范,加快对象技术的发展。

    OMG组织成立后不久就制订了OMA(Object Management Architecture,对象管理体系结构)参考模型,该模型描述了OMG规范所遵循的概念化的基础结构。OMA由对象请求代理ORB、对象服务、公共设施、域接口和应用接口这几个部分组成,其核心部分是对象请求代理ORB(Object Request Broker)。对象服务是为使用和实现对象而提供的基本服务集合;公共设施是向终端用户应用程序提供的一组共享服务接口;域接口是为应用领域服务而提供的接口;应用接口是由开发商提供的产品,用于它们的接口,不属于OMG标准的内容。ORB提供了一种机制,通过这种机制,对象可以透明的发出请求和接收响应。分布的、可以互操作的对象可以利用ORB构造可以互操作的应用。

      CORBA标准由对象管理组织(OMG)设立并进行控制,CORBA定议了一系列API,通信协议,和物件/服务信息模型用于使得异质应用程序能够互相操作,这些应用程序用不同的程序语言编写,运行在不同的平台上。CORBA因此为定义明确的物件提供了平台和位置的透明性,这些物件是分布式计算平台的基础。

      CORBA分布计算技术,是由绝大多数分布计算平台厂商所支持和遵循的系统规范技术,具有模型完整、先进,独立于系统平台和开发语言,被支持程度广泛的特点,已逐渐成为分布计算技术的标准。COBRA标准主要分为3个层次:对象请求代理、公共对象服务和公共设施。最底层是对象请求代理ORB,规定了分布对象的定义(接口)和语言映射,实现对象间的通讯和互操作,是分布对象系统中的"软总线";在ORB之上定义了很多公共服务,可以提供诸如并发服务、名字服务、事务(交易)服务、安全服务等各种各样的服务;最上层的公共设施则定义了组件框架,提供可直接为业务对象使用的服务,规定业务对象有效协作所需的协定规则。

    展开全文
  • CORBA

    2008-11-11 10:14:29
    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 ...
    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
    展开全文

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 43,340
精华内容 17,336
关键字:

corba