CORBA en java .:. Ejemplo completo

Common Object Request Broker Architecture (CORBA) es un estándar que permite que diversos componentes de software escritos en múltiples lenguajes de programación y que corren en diferentes computadoras, puedan trabajar juntos; es decir, facilita el desarrollo de aplicaciones distribuidas en entornos heterogéneos. [wikipedia]

Corba y la tecnología Java

La plataforma Java ofrece Object Request Broker (ORB) y dos modelos de programación CORBA que puede utilizar Java CORBA ORB y el Protocolo de Internet InterORB (IIOP).

La tecnología CORBA es una parte integral de la plataforma Java. Consiste en:

• Object Request Broker (ORB): presente desde la versión 1.3 de java, ORB es el nombre que recibe una capa de software (también llamada middleware) que permite a los objetos realizar llamadas a métodos situados en máquinas remotas, a través de una red, para ello utiliza un estándar para convertir las estructuras de datos en un flujo de bytes, conservando el orden de los bytes entre distintas arquitecturas. Este proceso se denomina marshalling,  es decir permite a objetos distribuidos interactuar entre sí de manera transparente como si estuviesen en la misma máquina.
• APIs para el modelo de programación RMI: es un mecanismo ofrecido por Java para invocar un método de manera remota. Proporciona un mecanismo simple para la comunicación de servidores en aplicaciones distribuidas basadas exclusivamente en Java.
• APIs para el modelo de programación IDL o Java ID:  esta compuesto por el compilador IDLJ asi como un conjunto de APIs que pueden explorarse con el prefijo org.omg.

Desarrollo Cliente/servidor

En este post se desarrollara un sistema cliente/servidor bajo la arquitectura CORBA.

¿Que necesitamos?

• IDE Netbeans 8.x
• Java 7 o superior
• Sistema Operativo Windows 7 o superior

Nivel: Intermedio – Avanzado

Tiempo: 30 minutos

Paso 1. Proyectos

El sistema estará conformado por tres proyectos, los que crearemos con Netbeans, estos son:

• CorbaFiboCliente. Aplicación Cliente
• CorbaFiboInterface. Proyecto que contiene las clases usadas tanto por el cliente como el servidor (El Servant)
• CorbaFiboServidor. Aplicación servidor

estos proyectos irán dentro de una carpeta que se llamara «corba» la cual estará dentro de tu carpeta de proyectos java, por ejemplo: «X:\carpeta_de_tu_proyecto\corba\»

Paso 2. La capa de Interface/IDL

Debido a que CORBA es independiente del lenguaje de programación, la interfaz se define por medio de un lenguaje conocido como Interface Definition Language (IDL) o Lenguaje de Definición de Interfaces, es un lenguaje puramente declarativo diseñado para especificar interfaces para aplicaciones distribuidas.

IDL es muy parecido a Java o C++ sin embargo IDL puede implementarse en un gran número de lenguajes, incluyendo C, Cobol, Java, Ada, Smalltalk, List, Python,  IDLScript. Es decir cuando se mapea un IDL este se traduce al lenguaje de su elección, osea si se usa el compilador idlj se crean archivos java, pero si se usa el compilador idl de c++, este se traduce en este idioma.

Creando IDL en Netbeans

Netbeans no tiene soporte para archivos IDL por lo que para crear un archivo *.idl debemos:

Click derecho sobre el proyecto CorbaFiboInterfaz <default package>, new → otros → en categoría seleccionamos «otros» → en Tipo de Archivo, seleccionamos Archivo Vacio → presionamos el botón siguiente → en nombre de archivo, escribimos «fibonacci.idl»

module example{ 
    
    interface fibonacci{ 
        
        /*
         * Para generar 
         * in: el valor del parametro se lo envia el cliente al servidor
         * long: -231..231-1 (32 bits)
         * numero: nombre de la variable
        */
        string generar(in long numero);
        
    }; 
};

• module.Permite agrupar varias definiciones IDL que comparten un mismo propósito, se traduce en java como package
• interface. Las interfaces definen servicios IDL. Son una colección de atributos, excepciones y
  operaciones

Nuestro archivo IDL, donde se encuentra declarada nuestra interfaz «fibonacci«, esta compuesto por un solo método llamado «generar«, el cual tiene un parámetro de entrada (indicado con in) de tipo long y retorna un resultado de tipo string.

Compilación de IDL con java

Para compilar el IDL utilizaremos el compilador IDLJ del SDK que viene con java. Este se encuentra en: «C:\Program Files\Java\jdk1.8.0_65\bin» y el comando para compilar desde consola es:

idlj -fall nombre_de_archivo.idl

Donde el comando -fall genera infraestructura para el servidor y el cliente

Si bien el comando es sencillo y fácil de recordar, si desarrollamos Interfaces más complejas, lo ideal es automatizar esta tarea (el tiempo es oro) y no estar escribiendo lo mismo una y otra vez, entonces para automatizar esta tarea, lo haremos utilizando un archivo por lotes (*.BAT)

Para crear el archivo BAT realizamos los mismos pasos utilizados para crear el archivo IDL, pero en nombre de archivo, colocaremos «compile.bat«.

El código del archivo por lotes es el siguiente:

:: Directorio de java SDK
SET JAVA_HOME="C:\Program Files\Java\jdk1.8.0_65"

:: direccion de las fuentes SRC de proyecto netbeans IDL "CorbaFiboInterface"
SET PATH_IDL="X:\carpeta_de_tu_proyecto\corba\CorbaFiboInterface\src"

:: nombre del archivo IDL
SET IDL_NAME=fibonacci.idl

:: comando para compilar
%JAVA_HOME%\bin\idlj -fall -td %PATH_IDL% %PATH_IDL%\%IDL_NAME%

IMPORTANTE: en PATH_IDL debes colocar la ruta de tu proyecto java

Nuestro proyecto «CorbaFiboInterface«, debe lucir de la siguiente forma:

Ejecución del archivo compile.bat:

Para ejecutar un archivo por lotes desde Netbeans, debemos hacer clic derecho sobre el archivo, y seleccionar la opción RUN

El proceso de compilado aparecerá en la consola de Netbeans, si hicimos todo bien, podremos observa en nuestro proyecto «CorbaFiboInterface» que se crearon nuevos archivos.

Archivos generados:

• _Operations.java: Intefaz Java resultante de aplicar las reglas de mapping IDL a Java a la interfaz traducida, es decir, encapsula las operaciones que se han declarado en la interfaz IDL
• _Stub,java: Sólo necesaria para compilar
• _Holder.java: Se genera una clase Holder para cada tipo definido por el usuario en el IDL,  se utilizan cuando se pretende utilizar un <InterfazRemota> como parámetro out o inout de otra llamada remota.
• _Helper.java: Clase abstracta que se genera en mismas circunstancias que clase Holder.  Proporciona métodos auxiliares para objetos de tipo <InterfazRemota>, tales como los que permiten leer un objeto de un stream o escribirlo, hacer un cast de objetos
• _POA.java: Clase abstracta  para conexión con el Adaptador de Objetos (que a su vez conecta a éstos con el ORB)

Paso 3. El servidor

Como primer paso en el proyecto del servidor, debemos importar las clases del proyecto CorbaFiboInterface, para poder usar las mismas.

Importar proyecto CorbaFiboInterface

Clic derecho sobre «bibliotecas» del proyecto «CorbaFiboServidor» → Agregar poyecto… Seleccionar el proyecto «CorbaFiboInterface» y presionar botón «Agregar al proyecto archivos JAR»

A continuacion, en el paquete example agregamos 2 clases:

• FiboImpl. Clase para implementar los metodos de la interfaz fibonacci
• FiboServer. Nuestro servidor

El proyecto Servidor tiene la siguiente forma:

El código de las clases creadas son:

FiboImpl.java

package example;
/**
 * @see https://www.jc-mouse.net/
 * @author mouse
 */
public class FiboImpl extends fibonacciPOA {

    @Override
    public String generar(int numero) {
	String cadena = "";
        for (int i = 1; i <= numero; i++) {
            double raiz = Math.sqrt(5);
            int rta = (int) ((1 / raiz) * (Math.pow((1 + raiz) / 2, i)) - (1 / raiz) * (Math.pow((1 - raiz) / 2, i)));            
            cadena += Math.round(rta) + " ";
        }
        return cadena;
    }

}

FiboServer.java

package example;
import org.omg.CosNaming.*;
import org.omg.CORBA.*;
import org.omg.CORBA.ORBPackage.InvalidName;
import org.omg.CosNaming.NamingContextPackage.CannotProceed;
import org.omg.CosNaming.NamingContextPackage.NotFound;
import org.omg.PortableServer.*;
import org.omg.PortableServer.POA;
import org.omg.PortableServer.POAManagerPackage.AdapterInactive;
import org.omg.PortableServer.POAPackage.ServantNotActive;
import org.omg.PortableServer.POAPackage.WrongPolicy;
/**
 * @see https://www.jc-mouse.net/
 * @author mouse
 */
public class FiboServer {

    public static void main(String args[]) {
        try {
            //crea instancua al ORB
            ORB orb = ORB.init(args, null);            
            //crea instancia a POA 
            POA rootpoa = POAHelper.narrow(orb.resolve_initial_references("RootPOA"));       
            //activa POA Manager
            rootpoa.the_POAManager().activate();       
            //instancia de clase Fibonacci
            FiboImpl fiboImpl = new FiboImpl();             
            //obtiene la referencia de la clase FiboImpl (servant)
            org.omg.CORBA.Object ref = rootpoa.servant_to_reference(fiboImpl);
            fibonacci href = fibonacciHelper.narrow(ref);
            
            //obtiene referencia
            org.omg.CORBA.Object objRef = orb.resolve_initial_references("NameService");
            NamingContextExt rootContext = NamingContextExtHelper.narrow(objRef);
             
            NameComponent nameComponent[] = rootContext.to_name("Fibonacci");
            rootContext.rebind(nameComponent, href);
            
            //listo para recibir peticiones
            System.out.println("Servidor> listo y en espera");
            orb.run();            
        } catch (AdapterInactive | InvalidName | ServantNotActive | WrongPolicy | org.omg.CosNaming.NamingContextPackage.InvalidName | NotFound | CannotProceed e) {
            System.err.println("Error: " + e.getMessage());
            e.printStackTrace(System.out);
        }
    }
}

Paso 4. El Cliente

En este proyecto también debemos importar las clases del «CorbaFiboServidor» y para ello, realizamos los mismos pasos que en el servidor

Tambien debemos crear una clase Main, con el nombre de «FiboClient«, nuestro proyecto Cliente, tiene la siguiente forma:

El código de la clase FiboClient, es:

package example;
import java.util.Scanner;
import org.omg.CosNaming.*;
import org.omg.CORBA.*;
import org.omg.CORBA.ORBPackage.InvalidName;
import org.omg.CosNaming.NamingContextPackage.CannotProceed;
import org.omg.CosNaming.NamingContextPackage.NotFound;
/**
 * @see https://www.jc-mouse.net/
 * @author mouse
 */
public class FiboClient {
    
    public static void main(String args[]) {
        try {
            ORB orb = ORB.init(args, null);
            org.omg.CORBA.Object objRef = orb.resolve_initial_references("NameService");
            NamingContextExt ncRef = NamingContextExtHelper.narrow(objRef);
            //
            fibonacci fiboImpl = fibonacciHelper.narrow(ncRef.resolve_str("Fibonacci"));
            //para capturar lo que escriba el usuario
            Scanner c = new Scanner(System.in);
            System.out.println("PC> - Generador de Fibonacci - ");
            for (;;) {//ciclo infinito
                System.out.println("PC> Ingrese numero [x:salir]:");
                String input = c.nextLine();       
                if(input.equals("x"))break;
                int numero = Integer.parseInt(input);
                String response = fiboImpl.generar(numero);
                System.out.println("Fibonacci de " + numero + " es " + response);
                System.out.println("----------------------------------------------------------------------------");
            }            
        } catch (InvalidName | NotFound | CannotProceed | org.omg.CosNaming.NamingContextPackage.InvalidName e) {
            System.out.println("Error: " + e);
            e.printStackTrace(System.out);
        }
    }
}

Paso 5. Configuración

Clic derecho sobre proyecto «CorbaFiboServidor» → propiedades (properties) → en «categorias» seleccionar «ejecutar». A continuación en Main Class, presionar el boton «examinar…» y seleccionar la clase «FiboServer». En el apartado de «argumentos», escribir «-ORBInitialPort 3700 -ORBInitialHost localhost» tal como se ve en la siguiente imagen:

Para el proyecto «CorbaFiboCliente«, realizar los mismos pasos, pero en Main Class, seleccionar «FiboClient»

Paso 6. ORB (Object Request Broker Daemon)

Antes de iniciar nuestros proyectos, debemos levantar el ORB de java, orbd se utiliza para permitir a los clientes localizar e invocar objetos persistentes en servidores en el entorno CORBA.

Abrir una consola en modo administrador, ubicarse en en el bin de java, es decir: «C:\Program Files\Java\jdk1.8.0_65\bin», escribir el comando:

start orbd -ORBInitialPort 3700

y presionar enter

se abrira una nueva ventana que corresponde al orbd de java. No la cierres.

paso 7. Ejecutar Cliente/Servidor

Ejecuta primero el Servidor, podrás apreciar en consola lo siguiente:

Ahora ejecuta el cliente

Se presenta una interfaz, también en consola donde puedes introducir un numero y generar la serie fibonacci.

FIN

enjoy!!!