Hello World using Java RMI-IIOP

The ORB supports writing CORBA interfaces using Java RMI. With this feature, you can work just with Java and never have to worry about learning and using IDL.

This is a simple example to get you started with Java CORBA programming using simple transient object support in the ORB. Java RMI will be used to define Object interfaces.

1 Hello RMI Interface

The Hello World interface defined using Java RMI. 
package helloWorld2;
                                                                           
public interface Hello extends java.rmi.Remote
{
    String sayHello() throws java.rmi.RemoteException;
}

2 Hello Implementation

 The HelloImpl implements the Hello interface. 
package helloWorld2;
                                                                           
import java.rmi.RemoteException;
import javax.rmi.PortableRemoteObject;
                                                                           
public class HelloImpl extends PortableRemoteObject implements Hello
{
    public HelloImpl() throws RemoteException {}
                                                                           
    public String sayHello() throws RemoteException
    {
    |   return "Hello World!\n";
    }
}

3 Hello World Server

 The server creates the ORB, creates a Java RMI servant, writes out it's stringified object reference, and then waits for invocations. Notice, that since HelloImpl is not a CORBA object (does not implement org.omg.CORBA.Object,) you need to first get its stub/object reference befor using the object_to_string method. 
package helloWorld2;
                                                                           
import util.Util;
                                                                           
import org.omg.CORBA.ORB;
import org.omg.CORBA.Object;
                                                                           
import javax.rmi.PortableRemoteObject;
                                                                           
public class helloServer
{
    public static void main(String[] args)
    {
    |   try {
    |   |                                                                  
    |   |   // create the jBroker ORB
    |   |   ORB orb = ORB.init(args, null);
    |   |                                                                  
    |   |   // create a servant
    |   |   Hello hello = new HelloImpl();
    |   |                                                                  
    |   |   // create a stringified object reference
    |   |   String helloIOR = orb.object_to_string((Object) 
    |   |       PortableRemoteObject.toStub(hello));
    |   |                                                                  
    |   |   // write the stringified object reference
    |   |   Util.writeIOR(helloIOR, "ior", true);
    |   |                                                                  
    |   |   // wait for invocations
    |   |   System.out.println("waiting for invocations ...");
    |   |   orb.run();
    |   |                                                                  
    |   } catch (Exception ex) {
    |   |   ex.printStackTrace();
    |   }
    }
}

4 Hello World Client

 The client creates the ORB, reads the stringified object reference of the Hello object, casts it to the Hello type, and then invokes the sayHello method on it. 
package helloWorld2;
                                                                           
import util.Util;
import org.omg.CORBA.ORB;
                                                                           
public class helloClient
{
    public static void main(String[] args)
    {
    |   try {
    |   |                                                                  
    |   |   // create the jBroker ORB
    |   |   ORB orb = ORB.init(args, null);
    |   |                                                                  
    |   |   // read the stringified object reference
    |   |   String helloIOR = Util.readIOR("ior");
    |   |                                                                  
    |   |   // narrow the stringified object
    |   |   Hello hello = (Hello) orb.string_to_object(helloIOR);
    |   |                                                                  
    |   |   // invoke method on the object
    |   |   System.out.println(hello.sayHello());
    |   |                                                                  
    |   } catch (Exception ex) {
    |   |   ex.printStackTrace();
    |   }
    }
}

Note: When an object is unmarshaled or destringified, the ORB automatically finds the right stub for it. This makes it possible to use Java casts instead of using the narrow method on javax.rmi.PortableRemoteObject. The use of narrow method is ofcourse the standard thing to do. For example, 

Hello hello = (Hello) orb.string_to_object(helloIOR);
above can be replaced by 

Hello hello = (Hello) PortableRemoteObject.narrow(orb.string_to_object(
    helloIOR), Hello.class);
if desired.

5 Generating Stub and Skeleton

 Notice that none of the above code had any dependency on generated code. The ORB still needs the stubs and skeletons to do marshaling and request brokering.

To generate stubs and skeletons, run the rmi2iiop compiler. The rmi2iiop compiler works with compiled Java class files. It is customary to run the compiler against the remote implementation instead of the remote interface.

rmi2iiop -keepgenerated -ds gensrc -d ../../lib helloWorld2.HelloImpl
The following Java classes are genereted in the helloWorld2 package. 
_Hello_Stub     // the Stub
_HelloImpl_Tie  // the delegation based Skeleton
Copyright © 2000-2003, Novell, Inc. All rights reserved.