JAVA PROGRAMMING WITH CORBA, 2E

Sample: Chapter 5

Chapter5
A First Java ORB Application

Figure 5.1

All code is presented in compact form in the Appendix and is also available in electronic form from www.wiley.com/compbooks/vogel. We used Visibroker for Java version 3.0 to develop and run our examples. As long as standard CORBA features are used the ORB you choose does not matter. Various ORB products which conform to the CORBA specification differentiate themselves with implementation details that have an impact on performance and scalability. Most also have extensions to the CORBA core.

This chapter starts with a summary of the development process for CORBA applications in Java (section 1). We give detailed explanations of the development of a simple example application (sections 2–8) and then extend this to include more features, including the use of the BOA (section 9). In Chapter 9 we will return to application development with a substantial example. Chapter 13 introduces a number of design patterns for scalability and performance.

1 Summary of the CORBA Development

• Write some IDL that describes the interfaces to the object or objects that will be used or implemented.
• Compile the IDL file. This produces the stub and skeleton code that implements location transparency. That is, it will convert an object reference into a network connection to a remote server and then marshal the arguments we provide to an operation on the object reference, convey them to the correct method in the object denoted by our object reference, execute the method, and return the results.
• Identify the IDL compiler-generated interfaces and classes that we need to use or specialize in order to invoke or implement operations.
• Write code to initialize the ORB and inform it of any CORBA objects that we have created.
• Compile all the generated code and our application code with a Java compiler.
• Run the distributed application.

Figure 5.2

When you execute the IDL compiler for the Java ORB you have installed, it will generate two sets of Java code files: stub code to create proxy objects which a client can use for making invocations on object references of the interface types defined in the IDL file, and skeleton code for access to objects that support those interfaces.

2 Environment Setup

We use JDK 1.1, assuming that the path is set appropriately and that the Java compiler javac and the Java run-time system java are installed. We also use Visigenic Software's Visibroker for Java version 3.0, assuming that the path and classpath are set appropriately. Visibroker's IDL compiler is called idl2java. To enable persistent CORBA objects we run Visibroker's directory agent:

unix> osagent &
dos> osagent-C

prompt> gatekeeper &.

3 Interface Specification

For any CORBA application we must write an IDL specification that defines data types and interfaces, including attributes and operations. For our example, we defined an IDL interface called HelloWorld which resembles the Java interface of the Hello World example from Chapter 3. We place the IDL file HelloWorld.idl, containing this definition, in a directory which represents its location in the book: com/wiley/compbooks/vogel/chapter5/simple.

//HelloWorld.idl
module com {
module wiley {
module compbooks {
module vogel {
module chapter 5 {
module simple {
module HelloWorld {
   interface GoodDay {
      string hello();
   };
};};};};};};};

Within the module HelloWorld we define one interface: GoodDay. The interface is not in any inheritance relationship. It provides one operation hello(). This operation does not have any parameters and returns a result of type string.

As we will see in the implementation, the object returns a string describing its locality as part of the result of the operation hello(). The operation returns a message saying: "Hello World, from location."

4 Compiling the IDL

classes> idl2java -portable
         com/wiley/compbooks/vogel/chapter5/simple/HelloWorld.idl

The following files are generated by the IDL compiler:

GoodDay.java
GoodDayHolder.java	GoodDayHelper.java
_portable_st_GoodDay.java	_GoodDayImplBase.java
GoodDayOperations.java	_tie_GoodDay.java

The remaining files that are generated by Visibroker's IDL compiler contain classes which have general functionality, but have ORB-specific names. The Java ORB Portability Interfaces, which we explain in Chapter 6, will ensure the portability of code from one ORB to another. The class _portable_st_GoodDay contains the stub code which forms a client-side proxy for the object implementation. The class _GoodDayImplBase contains the skeleton code which can be used without an explicit object adapter.

The interface GoodDayOperations and the class _tie_GoodDay are used for the Tie mechanism on the server side. This is explained in Chapter 6 and demonstrated by an example in Chapter 10.

5 A Client as a Java Application

• Initialize the CORBA environment; that is, obtain a reference to the ORB.
• Obtain an object reference for the object on which to invoke operations.
• Invoke operations and process the results.

5.1 Generated Java Interface

// generated Java - GoodDay.java
package com.wiley.compbooks.vogel.chapter5.simple.HelloWorld;
public interface GoodDay extends org.omg.CORBA.Object {
      public java.lang.String hello();
};

5.2 Initializing the ORB

package
com.wiley.compbooks.vogel.chapter5.simple.HelloWorldImpl;
import java.io.*;
import org.omg.CORBA.*;
import com.wiley.compbooks.vogel.chapter5.simple.HelloWorld.*;
public class Client {
   public static void main(String args[]) {
      try {
         // initialize the ORB
         ORB orb = ORB.init (args, null);

5.3 Obtaining an Object Reference

// get object reference from command-line argument
org.omg.CORBA.Object obj = orb.string_to_object( args[0] );

The narrow method is defined in the class GoodDayHelper.

GoodDay goodDay = GoodDayHelper.narrow( obj );
if( goodDay == null ) {
   System.err.println(
      "stringified object reference is of wrong type");
   System.exit( -1 );
}

5.4 Invoking the Operation

System.out.println( goodDay.hello() );

      catch(SystemException ex) {
         System.err.println(ex);
      }
   }
}

5.5 Compiling and Executing the Client

HelloWorldImpl> javac Client.java

… > java
com.wiley.compbooks.vogel.chapter5.HelloWorldImpl.Client
IOR:000000000000002149444c3a53696d706c6548656c6c6f576f726c642f4
76f6f644461793a312e300000000000000001000000000000004c0001000000
00000e3133302e3130322e3137362e3900fc7d0000003000504d43000000010
000001a53696d706c6548656c6c6f576f726c643a3a476f6f64446179000000
00000002febddb22
The client then prints the expected message.
Hello World, from Brisbane

6 A Client as an Applet

• Anchor the applet in an HTML page to make it addressable and loadable.
• Provide a GUI to enable interaction through a Web browser.
• Extend the Java applet class and override some of its methods.
• Use a different ORB initialization.

6.1 Anchoring the Applet into HTML

<html><header><title>
Hello World Example
</title>
<center><h1>
Hello World Example
</h1></center>
<center>
<applet code=com/wiley/compbooks/vogel/chapter5/simple/HelloWorldImpl/Applet.class
   width=400 height=80>
</applet>
</center>
</body></html>
</pre>

6.2 Initializing the Applet

• goodDay—to hold the object reference of the remote object
• helloWorldButton—a button to enable users to invoke the method
• textField—a text field to display the result of the method

package
   com.wiley.compbooks.vogel.chapter5.simple.HelloWorldImpl;
import java.awt.*;
import java.awt.event.*;
import java.io.*;
import org.omg.CORBA.*;
import com.wiley.compbooks.vogel.chapter5.simple.HelloWorld.*;
public class Applet
        extends java.applet.Applet
        implements ActionListener {
   private ORB orb;
   private GoodDay goodDay;
   private Button helloWorldButton;
   private TextField textField;
   public void init() {
      helloWorldButton = new Button("Invoke remote method");
      helloWorldButton.setFont(new Font("Helvetica",
           Font.BOLD, 20));
      helloWorldButton.setActionCommand("invoke");
      helloWorldButton.addActionListener( (ActionListener) this );
      textField = new TextField();
      textField.setEditable(false);
      textField.setFont(new Font("Helvetica", Font.BOLD, 14));
      setLayout( new GridLayout(2,1));
      add( helloWorldButton );
      add( textField );

6.3 Locating Objects

To initialize the Visibroker ORB we again call the method init(), this time with one argument, the applet object itself (using the Java keyword this to do so). This initialization changes the behavior of the stub. As part of its bootstrap code the stub will establish a connection to an instance of Visibroker's Gatekeeper, which it expects to be running on the machine where the applet has been downloaded from. The Gatekeeper is a CORBA object as well as an HTTP server. Besides the initial bootstrapping for a CORBA-enabled applet the GateKeeper performs the following tasks:

• reenables CORBA location transparency and callbacks to objects hosted by applets which are otherwise impossible due to applet sandboxing
• provides an HTTP tunneling mechanism to overcome client-side firewalls

To obtain a reference to the remote object we use Visibroker's OSAgent. The agent provides a proprietary directory service. The interface to this service is a method called bind(), which is generated for each IDL interface type and is located in its Helper class, for example, GoodDayHelper. The bind() method returns a reference to an object of the specified interface type, if one is available. If there are multiple objects of that interface type available, object references are returned in a round-robin fashion. Applet initialization is finished with the catching and processing of exceptions.

   try {
      // initialize the ORB (using this applet)
      orb = ORB.init( this );
      // bind to object
      goodDay = GoodDayHelper.bind( orb );
   }
   catch(SystemException ex) {
      System.err.println("ORB is not initialized");
      System.err.println(ex);
   }
}

6.4 Handling Applet Events

public void actionPerformed( ActionEvent e ) {
         if( e.getActionCommand().equals("invoke") ) {
         // invoke the operation
         try {
            textField.setText( goodDay.hello() );
         }
         // catch CORBA system exceptions
         catch(SystemException ex) {
            System.err.println(ex);
         }
      }
   }
}

6.5 Compiling and Executing the Applet

HelloWorldImpl> javac Applet.java

Figure 5.3

Once the button has been clicked, the result of the operation invocation is displayed in the text field as shown in Figure 5.4.

Figure 5.4

7 An Object Implementation

The inheritance approach involves a Java implementation class extending the servant base class. The servant base class is an abstract implementation of the Java interface which corresponds to the IDL interface. The object implementation is an extension of the base class and implements the methods.

The delegation approach is also known as the Tie method. This is done by providing the skeleton with a reference to an implementation object. This is explained in detail in Chapter 10.

In our example we have an implementation class GoodDayImpl which extends the servant base class _GoodDayImplBase. As in the implementation of the GoodDayImpl class shown in Chapter 3, we declare a private variable, location, which will hold a string identifying the location of the service. Here we mean the geographical location, as shown in the previous client examples. We also have to implement the constructor of the class. The constructor has one parameter which it assigns to the private variable location.

package
com.wiley.compbooks.vogel.chapter5.simple.HelloWorldImpl;
import org.omg.CORBA.*;
import com.wiley.compbooks.vogel.chapter5.simple.HelloWorld.*;
public class GoodDayImpl extends _GoodDayImplBase {
   private String location;
   // constructor
   GoodDayImpl( String location ) {
      // initialize location
      this.location = location;
   }
   // method
   public String hello() {
      return "Hello World, from " + location;
   }
}

HelloWorldImpl> javac GoodDayImpl.java

8 A Server

The server class for our example is called Server. We only implement the main() method in this class. We check for the right number of arguments, one of which indicates the location of the server. A server is responsible for initializing the ORB, creating the object, and making the object accessible.

We initialize the ORB in the same way we did on the client side calling ORB.init(), which returns a reference to the ORB pseudo-object. We then create an instance of the servant class goodDayImpl by calling Java's new operator and supply one argument to the constructor which we copy from the command-line argument.

package com.wiley.compbooks.vogel.chapter5.simple.HelloWorldImpl;
import java.io.*;
import org.omg.CORBA.*;
import com.wiley.compbooks.vogel.chapter5.simple.HelloWorld.*;
public class Server {
   public static void main(String[] args) {
      if( args.length != 1 ) {
         System.out.println(
            "Usage: java com.wiley.compbooks.vogel.chapter5.simple.HelloWorldImp
             ");
         System.exit( 1 );
      }
      try {
         //init ORB
         ORB orb = ORB.init (args, null);
         // create a GoodDay object
         GoodDayImpl goodDayImpl = new GoodDayImpl( args[0] );

         // export the object reference
         orb.connect( goodDayImpl );
         // print stringified object reference
         System.out.println( orb.object_to_string( goodDayImpl ) );
         // wait for requests
         java.lang.Object sync = new java.lang.Object();
         synchronized (sync) {
            sync.wait();
         }
      }
      catch(Exception e) {
         System.err.println(e);
      }
   }
}

8.1 Compiling and Starting the Server

HelloWorldImpl> javac Server.java

> java com.wiley.compbooks.vogel.chapter5.simple.HelloWorldImpl.Server
Brisbane
This prints out a stringified IOR which looks like this:
IOR:000000000000002149444c3a53696d706c6548656c6c6f576f726c642f476f6f644
461793a312e300000000000000001000000000000004c000100000000000e3133302e31
30322e3137362e3900fc7d0000003000504d43000000010000001a53696d706c6548656
c6c6f576f726c643a3a476f6f6444617900000000000002febddb22

simple> java com.wiley.compbooks.vogel.chapter5.simple.
HelloWorldImpl.Server Brisbane > shw.ior

simple> java com.wiley.compbooks.vogel.chapter5.simple.
HelloWorldImpl.Client 'cat shw.ior'

9 Extending the Hello World Example

• Further aspects of the specification of interfaces
• Parameter mapping and the semantics of parameter passing
• The development of a client
• Applet implementations
• The implementation of an object
• Using a Basic Object Adapter

9.1 Interface Specification

The signature of the operation is different. Its result is still a string, but this time the operation has parameters and it returns the description of the server's location. The parameters are tagged as out, meaning that their values will be supplied by the invoked object. They are both of type short and their intended meaning is that they hold the current time at the server's location: hour holds the hour and minute the minute.

module com {
module wiley {
…
module extended {
module HelloWorld {
   interface GoodDay {
      string hello(
         out short hour,
         out short minute );
   };
};…};

9.2 Parameter Mapping

The parameters in Java operations have pass-by-value semantics, meaning that a value is passed from the caller to the invoked object. There is a mismatch in the semantics of parameter passing between IDL and Java for IDL's out and inout parameters. The solution is provided by Holder objects. Instead of passing an argument itself, an object is used as an argument to the Java method. The Holder object contains a variable value of the type of the IDL parameter. This way the Java object's reference passed need not change, but contents may change as a result of the invocation (see Figure 5.5).

Figure 5.5

Holder classes for predefined IDL types are provided in the package org.omg.CORBA, as listed in Chapter 6. The IDL compiler generates Holder classes TypeNameHolder for user-defined types. In our examples we use the predefined Holder class org.omg.CORBA.ShortHolder.

9.3 A Client

package com.wiley.compbooks.vogel.chapter5.extended.HelloWorldImpl;
import java.io.*;
import org.omg.CORBA.*;
import com.wiley.compbooks.vogel.chapter5.extended.HelloWorld.*;
public class Client {
   public static void main(String args[]) {
      // create Holder objects for out parameters
      ShortHolder minute = new ShortHolder();
      ShortHolder hour = new ShortHolder();
      try {
         // initialize the ORB
         ORB orb = ORB.init(args, null);
         // get object reference from command-line argument
         org.omg.CORBA.Object obj = orb.string_to_object( args[0] );
         // and narrowed it to GoodDay
         GoodDay goodDay = GoodDayHelper.narrow( obj );
         if( goodDay == null ) {
            System.err.println(
               "stringified object reference is of wrong type");
            System.exit( -1 );
         }

9.3.1 Invoking the Operation

         // invoke the operation
         String location = goodDay.hello( hour, minute );
         // print results to stdout
         System.out.println("Hello World!");
         if( minute.value < 10 )
            System.out.println("The local time in " + location +
               " is " + hour.value + ":0" + minute.value + "." );
         else
            System.out.println("The local time in " + location +
               " is " + hour.value + ":" + minute.value + "." );
      }
      // catch exceptions
      catch(SystemException ex) {
         System.err.println(ex);
      }
   }
}

> java com.wiley.compbooks.vogel.chapter5.extended.HelloWorldImpl.Client
IOR:000000000000001b49444c3a48656c6c6f576f726c642f476f6f644461793
a312e30000000000001000000000000004c000100000000000e3133302e313032
2e3137362e390083840000003000504d43000000000000001448656c6c6f576f72
6c643a3a476f6f64446179000000000c476f6f64446179496d706c00
Hello World!
The local time in Brisbane is 16:42.

9.4 An Applet

import java.awt.*;
import java.awt.event.*;
import org.omg.CORBA.*;
import com.wiley.compbooks.vogel.chapter5.extended.HelloWorld.*;
public class Applet
   extends java.applet.Applet
   implements ActionListener {
   private ShortHolder minute;
   private ShortHolder hour;
   private GoodDay goodDay;
   private String text;
   private String locality;
   private Button helloWorldButton;
   private TextField textField;
   public void init() {
      minute = new ShortHolder();
      hour = new ShortHolder();
      helloWorldButton = new Button("Invoke remote method");
      helloWorldButton.setFont(new Font("Helvetica",
         Font.BOLD, 20));
      helloWorldButton.setActionCommand("invoke");
      helloWorldButton.addActionListener( (ActionListener) this );
      textField = new TextField();
      textField.setEditable(false);
      textField.setFont(new Font("Helvetica", Font.BOLD, 14));
      setLayout( new GridLayout(2,1);
      add( helloWorldButton );

9.4.1 Invoke the Operation

public void actionPerformed( ActionEvent e ) {
         if( e.getActionCommand().equals("invoke") ) {
         // invoke the operation
         try {
            locality = new String( goodDay.hello( hour, minute ) );
         }
         // catch exceptions
         catch(SystemException ex) {
            System.err.println(ex);
         }
         if( minute.value < 10 )
            text = new String("The local time in " + locality +
               " is " + hour.value + ":0" + minute.value + "." );
         else
            text = new String("The local time in " + locality +
               " is " + hour.value + ":" + minute.value + "." );
         textField.setText( text );
      }
   }
}

Hello World! The local time in Brisbane is 16:44.

9.5 Object Implementation

We create an object date which holds the time information of the system. The corresponding class is defined in java.util.Date. We retrieve the hour and the minute by invoking the methods getHours() and getMinutes() on the object. We assign the values to the corresponding value variables of the container objects. We return the locality as in the earlier example.

This time, however, we use the Visibroker skeleton class, which is generated by the IDL compiler in the class _sk_GoodDay, and the BOA. The BOA is defined in the CORBA specification, but is not complete. ORB vendors have filled in the gaps in different ways. As a consequence, BOA-based object implementations and servers are not portable. Given that the BOA was the only standard way to implement CORBA servers, until the recent introduction of the POA, it became quite popular. As the POA is not yet implemented, BOA implementations are the only way to get more sophisticated features on the server side other than the connect operations provided by the ORB. A more detailed overview of object adapters is given in Chapter 2.

package com.wiley.compbooks.vogel.chapter5.extended.HelloWorldImpl;
import java.util.Date;
import org.omg.CORBA.*;
import com.wiley.compbooks.vogel.chapter5.extended.HelloWorld.*;
public class GoodDayImpl extends _sk_GoodDay {
   private String location;
   // constructor
   GoodDayImpl( String location ) {
      super( location );
      this.location = location;
   }
   // method
   public String hello(
         ShortHolder hour,
         ShortHolder minute
      ) {
      // get local time of the server
      Date date = new Date();
      hour.value = (short) date.getHours();
      minute.value = (short) date.getMinutes();
      return location;
   }
}

package com.wiley.compbooks.vogel.chapter5.extended.HelloWorldImpl;
import org.omg.CORBA.*;
import com.wiley.compbooks.vogel.chapter5.extended.HelloWorld.*;
public class Server {
   public static void main(String[] args) {
      try {
         //init orb
         ORB orb = ORB.init (args, null);
         //init basic object adapter
         BOA boa = orb.BOA_init();
         // create a GoodDay object
         GoodDayImpl goodDayImpl = new GoodDayImpl( args[0] );
         // export the object reference
         boa.obj_is_ready( goodDayImpl );
         System.out.println( orb.object_to_string( goodDayImpl ) );
         // wait for requests
         boa.impl_is_ready();
      }
      catch(SystemException e) {
         System.err.println(e);
      }
   }
}

WCP Home Page