RMI-IIOP

De Wikipedia, la enciclopedia libre
Saltar a: navegación, búsqueda

RMI-IIOP (leído RMI sobre IIOP) denota la interfaz RMI de Java sobre el sistema CORBA.

Este estándar fue creado intentando simplificar el desarrollo de las aplicaciones CORBA, mientras preservaba todos los beneficios principales. RMI-IIOP está ampliamente basado en el concepto Objeto por Valor (descrito en la página CORBA) que sirve como un contenedor o un reemplazo directo para estructuras CORBA, uniones, secuencias, arrays y strings. La IDL no se usa. En cambio, las definiciones de la estructura de datos "supuestas" automáticamente, recolectan los datos necesarios a través de mecanismos de reflexión. Cuando CORBA normalmente necesita una clase generada suplementaria para cada estructura de datos no trivial que está siendo transferida, RMI-IIOP solo usa el código generado para los objetos remotos. Menos código generado resulta en menos huella.

Ambas CORBA y RMI-IIOP usan el mismo estándar de comunicación GIOP. Si se necesitara, es posible generar las definiciones de IDL para las estructuras de datos RMI-IIOP involucradas y usar esas definiciones para alcanzar la interoperabilidad entre las aplicaciones RMI-IIOP y CORBA planas.

Las versiones recientes de RMI-IIOP derivan sus servants desde la clase estándar Servant (CORBA). Por lo tanto es posible conectarlos al CORBA ORB manualmente, involucrando, si es necesario, el Adaptador de Objeto Portable, Interceptores Portables, servicio de nombrado CORBA y todas las demás características estándar CORBA.

Ejemplo Hola Mundo (java)[editar]

El nombre estándar para el paquete de implementación Java RMI-IIOP es javax.rmi.CORBA.

Las interfaces[editar]

 public interface MyServer extends Remote
 {
   // El cliente se pasa a sí mismo como primer parámetro. El servidor puede llamar a un 
   // método remoto en el cliente. Esto es útil cuando el procesamiento de peticiones toma mucho tiempo.
   void receiveRequest(MyClient client, String message) throws RemoteException;
 }
 
 public interface MyClient extends Remote
 {
   // Este método remoto es llamado por el servidor.
   void receiveReply(String message) throws RemoteException;
 }

Las implementaciones cliente y servidor, suministrando la funcionalidad.[editar]

 public class MyServerImpl implements MyServer
 {
    void receiveRequest(MyClient client, String message) throws RemoteException
    {
      System.out.println("The client says: "+message);
      client.receiveReply("Yes, "+message+", "+message+", "+message+"...");
    }
 }
 
 public class MyClientImpl implements MyClient
 {
    MyServer server;
    public MyClientImpl(String Server_IOR, ORB orb)
      throws Exception
    {
      server = (MyServer) PortableRemoteObject.narrow(
                  orb.string_to_object(Server_IOR), MyServer.class);
    }
    // Esto es un método remoto.
    void receiveReply(String message) throws RemoteException
    {
      System.out.println("And the answer is: "+message);
    }
    // Esto no es un método remoto, esto es un método local.
    public void talk(String conversation)
    {
       server.receiveRequest(this, conversation);
    }
 }

La herramienta de desarrollo RMI-IIOP, usualmente llamada rmic, utilizará las dos clases anteriores y creará dos stubs (para uso en el lado remoto) y los dos lazos (para uso en la parte servidora), un par para el servidor y otro par para el cliente.

El código, necesario para iniciar el servidor[editar]

new Thread()
{
    public void run()
    {
        try
        {
            // Crea el [[CORBA]] ORB.
            MyServerImpl.orb = ORB.init(args, properties);
 
            // Obtiene el [[Adaptador de Objeto Portable]] raíz:
            POA rootPOA = POAHelper.narrow(MyServerImpl.orb.resolve_initial_references("RootPOA"));              
            // MyServerImpl contiene la implementación de 
            // los métodos que nuestro servidor debe soportar.
            MyServerImpl impl = new MyServerImpl();
            PortableRemoteObject.exportObject(impl);
 
            // Construye el lazo que es también el [[Servant (CORBA)|Servant]].
            // La clase _MyServerImpl_Tie se genera automáticamente desde MyServerImpl.
            Tie tie = new _MyServerImpl_Tie();    
            // Asigna el objetivo de la invocación para este lazo.
            tie.setTarget(impl);
 
            // Obtiene la referencia al correspondiente objeto CORBA:
            org.omg.CORBA.Object object = rootPOA.servant_to_reference((Servant) tie);
 
            // Activa el POA raíz.
            rootPOA.the_POAManager().activate();
            // Obtiene el IOR URL que debe ser pasado a los clientes.
            String Server_IOR = MyServerImpl.orb.object_to_string(object);
            MyServerImpl.orb.run();
 
            // El contenido el string variable Server_IOR debe ser transferido 
            // a nuestro cliente.
        }
        catch (Exception exc)
        {
            exc.printStackTrace();
        }
    }
}.start();

El código, requerido para iniciar el cliente[editar]

MyClient the_client;
 
new Thread()
{
    public void run()
    {
        try
        {
            ORB orb = ORB.init(args, parameters);
            the_client = new MyClientImpl(Server_IOR, orb);
            POA rootPOA = POAHelper.narrow(desk.orb.resolve_initial_references("RootPOA"));
            rootPOA.the_POAManager().activate();
            // Construye el lazo.
            Tie tie = new _MyClientImpl_Tie();
            // Asigna la clase implementadora (objetivo de la invocación).
            tie.setTarget(the_client);
            // Conecta el lazo como POA servant.
            org.omg.CORBA.Object object = rootPOA.servant_to_reference((Servant) tie);
            // El valor del string [[Interoperable Object Reference|IOR]] puede usarse para encontrar este objeto en la web
            String IOR = desk.orb.object_to_string(object);
            orb.run();
        }
        catch (Exception exc)
        {
            exc.printStackTrace();
        }
    }
}.start();

Ahora, en cualquier momento desde el código, después de que el hilo ORB ha sido iniciado, podemos llamar:

the_client.talk("it is raining");

Ejecutando[editar]

El servidor (primero) y el cliente (segundo) son iniciados en dos máquinas diferentes (o como dos procesos separados en la misma máquina). El servidor imprime The client says: it is raining. El cliente imprime And the answer is: Yes, it is raining, it is raining, it is raining...

El código de ejemplo sugerido Hello world debe funcionar con Sun Microsystems java 1.5 y GNU Classpath 0.19 (usa la pestaña discusión para informar si no fuera así). Debido a posteriores bugs solucionados los ejemplos no funcionarán con los releases más antiguos de las dos plataformas.

Estado legal del acrónimo[editar]

IIOP es la marca resgistrada OMG y debe usarse con cuidado. Dado que este protocolo es puesto en la parte superior de GIOP, en algunos casos puede ser recomendable decir que la application usa o implementa GIOP.

Bibliografía[editar]