With the ORB you write your interfaces in Java and also benefit from the power of the Portable Object Adapter.
We will redo the Hello World application but this time we will use POA to create object references.
The Hello World interface defined using Java RMI.
package helloWorld2;
public interface Hello extends java.rmi.Remote
{
String sayHello() throws java.rmi.RemoteException;
}
To generate stubs and skeletons, run the rmi2iiop compiler. The rmi2iiop compiler works with compiled Java class files.
rmi2iiop -poa -keepgenerated -ds gensrc -d ../../lib helloWorld2.Hello
The following Java classes are genereted in the helloWorld2 package.
_Hello_Stub // the Stub HelloPOA // the inheritance based POA Skeleton HelloPOATie // the delegation based POA Skeleton
The HelloImpl class extends the Hello_Skel interface.
package poaHello2;
public class HelloImpl extends helloWorld2.HelloPOA
{
public String sayHello() throws java.rmi.RemoteException
{
| return "Hello World!\n";
}
}
The server creates the ORB, creates a POA servant, gets the root POA, creates an object reference, stringifies it, and writes it out, and then waits for invocations.
Notice, that sinceHelloImpl is not a CORBA object (does not implement
org.omg.CORBA.Object,) you need to first get its object reference using
the POA object creation APIs.
package poaHello2;
import util.Util;
import org.omg.CORBA.ORB;
import org.omg.PortableServer.POA;
import org.omg.PortableServer.Servant;
public class helloServer
{
public static void main(String[] args)
{
| try {
| |
| | // create the jBroker ORB
| | ORB orb = ORB.init(args, null);
| |
| | // create a servant
| | Servant hello = new HelloImpl();
| |
| | // get the root POA
| | POA rootPOA = (POA) orb.resolve_initial_references("RootPOA");
| |
| | // create a stringified object reference
| | String helloIOR = orb.object_to_string(rootPOA.
| | servant_to_reference(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();
| }
}
}
Since the RMI interface hasn't changed, we will use the client from Hello World using RMI-IIOP.
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();
| }
}
}
HelloImpl.java_Hello_Stub
The rmi2iiop compiler by default generates stubs that are enabled for local invocation. For locally running objects, a deep copy of serializable parameters is made to preserve RMI parameter passing semantics (pass by value of non-remote parameters, and pointer sharing) and then IIOP is bypassed to do a direct call on the servant object.
You can disable copying of parameters by specifying -localnocopy flag on the rmi2iiop compiler. You can skip generation of local stubs all together by using the -nolocal flag.
The _servant_preinvoke and _servant_postinvoke methods
give the ORB the opportunity to enfore the POA semantics of POA Manager, adapter
activation, object activation etc.
// Wed Jun 09 14:46:25 EDT 2004
package helloWorld2;
public class _Hello_Stub extends javax.rmi.CORBA.Stub
implements helloWorld2.Hello
{
private static final String[] __ids = {
| "RMI:helloWorld2.Hello:0000000000000000"
};
public String[] _ids() { return __ids; }
public java.lang.String sayHello()
throws java.rmi.RemoteException
{
| _local_stub:
|
| if (javax.rmi.CORBA.Util.isLocal(this)) {
| |
| | // get the Servant Object
| | org.omg.CORBA.portable.ServantObject _servObj =
| | _servant_preinvoke("sayHello", helloWorld2.Hello.class);
| | if (_servObj == null) break _local_stub;
| |
| | try {
| | | // invoke on the servant
| | | return ((helloWorld2.Hello) _servObj.servant).sayHello();
| | |
| | } catch (Throwable ex) {
| | | // copy the exception
| | | ex = (Throwable) javax.rmi.CORBA.Util.copyObject(ex, _orb());
| | |
| | | throw javax.rmi.CORBA.Util.wrapException(ex);
| | |
| | } finally {
| | | _servant_postinvoke(_servObj);
| | }
| }
|
| org.omg.CORBA_2_3.portable.InputStream in = null;
|
| try {
| | try {
| | | // create an output stream
| | | org.omg.CORBA_2_3.portable.OutputStream out =
| | | (org.omg.CORBA_2_3.portable.OutputStream)
| | | _request("sayHello", true);
| | |
| | | // do the invocation
| | | in = (org.omg.CORBA_2_3.portable.InputStream) _invoke(out);
| | | return (java.lang.String) in.read_value(java.lang.String.class);
| | |
| | } catch (org.omg.CORBA.portable.ApplicationException ex) {
| | |
| | | // get the input stream
| | | in = (org.omg.CORBA_2_3.portable.InputStream)
| | | ex.getInputStream();
| | |
| | | // read the exception id
| | | String id = ex.getId();
| | | in.read_string();
| | |
| | | // unexpected exception
| | | throw new java.rmi.UnexpectedException(id);
| | |
| | } catch (org.omg.CORBA.portable.RemarshalException rex) {
| | | return sayHello();
| | |
| | } finally {
| | | _releaseReply(in);
| | }
| |
| } catch (org.omg.CORBA.SystemException ex) {
| | throw javax.rmi.CORBA.Util.mapSystemException(ex);
| }
}
}
HelloPOA
// Wed Jun 09 14:46:25 EDT 2004
package helloWorld2;
public abstract class HelloPOA
extends org.omg.PortableServer.Servant
implements org.omg.CORBA.portable.InvokeHandler, helloWorld2.Hello
{
public org.omg.CORBA.ORB orb()
{
| return _orb();
}
public void orb(org.omg.CORBA.ORB orb)
{
| ((com.sssw.jbroker.POA.ServantDelegate)_get_delegate()).orb(this, orb);
}
public org.omg.CORBA.portable.OutputStream _invoke(String method,
org.omg.CORBA.portable.InputStream in1,
org.omg.CORBA.portable.ResponseHandler rh)
{
| org.omg.CORBA_2_3.portable.InputStream in =
| (org.omg.CORBA_2_3.portable.InputStream) in1;
| org.omg.CORBA_2_3.portable.OutputStream out = null;
|
| try {
| | if (method.equals("sayHello")) {
| | | java.lang.String result = sayHello();
| | | out = (org.omg.CORBA_2_3.portable.OutputStream)
| | | rh.createReply();
| | | out.write_value(result, java.lang.String.class);
| | }
| |
| | else throw new org.omg.CORBA.BAD_OPERATION(method);
| |
| } catch (org.omg.CORBA.SystemException ex) {
| | throw ex;
| |
| } catch (java.lang.Throwable ex) {
| | throw new org.omg.CORBA.portable.UnknownException(ex);
| }
|
| return out;
}
private static final String[] __ids = {
| "RMI:helloWorld2.Hello:0000000000000000"
};
public String[] _all_interfaces(org.omg.PortableServer.POA poa, byte[] oid)
{
| return __ids;
}
}
HelloPOATie
// Wed Jun 09 14:46:25 EDT 2004
package helloWorld2;
public class HelloPOATie
extends helloWorld2.HelloPOA
implements javax.rmi.CORBA.Tie, helloWorld2.Hello
{
public HelloPOATie() {}
public HelloPOATie(java.rmi.Remote target)
{
| setTarget(target);
}
public org.omg.CORBA.Object thisObject()
{
| return _this_object();
}
public synchronized void deactivate() {}
private helloWorld2.Hello _target;
public void setTarget(java.rmi.Remote target)
{
| _target = (helloWorld2.Hello) target;
}
public java.rmi.Remote getTarget()
{
| return _target;
}
public java.lang.String sayHello() throws java.rmi.RemoteException
{
| // delegate the invocation to target
| return _target.sayHello();
|
}
}
Copyright © 2003, 2004 Novell, Inc. All rights reserved. Copyright © 2001, 2002, 2003 SilverStream Software, LLC. All rights reserved.