Implementación de CORBA 2.2 en Java: JavaORB
JavaORB, desarrollado por el DOG, es una herramienta que nos permite desarrollar utilizando CORBA 2.2, por lo que tiene implementados sistemas como POA.
Lo primero que debemos tener en nuestra máquina GNU/Linux es tener instalada la versión de JDK 1.1.x, siendo recomendable la JDK 1.1.7.
El JDK para GNU/Linux se puede obtener de http://www.blackdown.org. Es importante no utilizar la versión JDK 1.2 ya que esta incluye su propio ORB y hay que configurar JavaORB de una forma especial para que no colisionen ambos ORBs. Esto es posible y se detalla dentro de la página web de JavaORB, pero no se va a cubrir en este artículo.
Una vez instalado el JDK 1.1 en nuestro sistema la instalación de JavaORB es muy sencilla. Lo primero que debemos hacer es ir al servidor de web del grupo que lo ha desarrollado (http://www.multimania.com/dogweb) y obtener el fichero "JavaORB_1.2.4.zip" que constituye la implementación de CORBA. Atención que cuando el lector acceda a este web pueden existir versiones nuevas, y su instalación aunque muy parecida a la que aquí se describe, puede diferir.
Tras ello ejecutamos la orden:
unzip JavaORB_1.2.4.zip
Una vez descomprimido el fichero nos vamos al directorio "Release/JavaORB" y dentro de él tenemos en el fichero "README.txt" las instrucciones de instalación. Básicamente, si no utilizamos JDK 1.2, en cuyo caso el lector debe leer dicho fichero, lo único que hay que hacer es añadir al CLASSPATH el fichero "JavaORBv1_2_4.jar". El CLASSPATH es una variable de entorno que utiliza el JDK para encontrar las clases.
Una vez hecho esto ya disponemos de todo lo necesario para desarrollar aplicaciones CORBA basadas en Java.
En nuestro caso lo único que vamos a hacer de momento es utilizar el compilador de IDL que proporciona la herramienta, para que el lector pueda empezar a trabajar con el lenguaje IDL y comprobar que utiliza de forma correcta el lenguaje.
Para utilizar dicho compilador encontramos dentro del directorio "Release/JavaORB/bin" el ejecutable "idl2java" (al ser una distribución para entornos MSDOS estos ficheros no tienen permiso de ejecución. El lector debe modificar esto con la orden "chmod 755 idl2java").
Este ejecutable lo que hace es lanzar un programa Java que es el que pasa del lenguaje IDL a Java. El compilador genera tanto los cabos (stubs) del cliente como los esqueletos (skeletons) del servidor. También genera las interfaces que debe implementar el servidor.
Pero de momento no vamos a entrar en estos detalles y nos vamos a centrar en el compilador "idl2java". Para su uso, definimos nuestras interfaces en un fichero ".idl", en nuestro caso "Mensajes.idl", y ejecutamos:
idl2java Mensajes.idl
Para ello puede el lector crearse un directorio "idl" dentro de su cuenta, copiar allí el fichero Mensajes.idl y poner en el PATH el directorio donde se encuentra el ejecutable "idl2java".
Si no utilizamos ningún parámetro del compilador, el resultado de dicha invocación es la creación de un directorio "corba_pkg" con todas las clases necesarias para los clientes y servidores CORBA.
Todas las opciones disponibles del compilador son:
bash-2.01$ idl2java
#################################################
# Java ORB #
# ----------------- #
# (c) 1997, 1998, 1999 #
#################################################
# Java IDL Compiler, Release 1.6 #
#################################################
Options
-------
-release
Show version number
-nopackage
Don't use corba_pkg directory as a package
-outdir:
Provide a way to specify the ouput dir. This option
will not use the corba_pkg directory.
For example :
idl demo.idl -outdir:/home/me/
-package: package_name
Generate files in package_name
Example:
idl demo.idl -package:exemple
-I
Allow specification of include directory
Example:
idl demo.idl -I/home/me/idl -I../autre
-D
Define a symbole. It is equivalent to #define
-nostub
Don't generate stub.
-noskeleton
Don't generate skeleton.
-tie
Generate TIE files to delegation mode.
-user
Generate code for user
-pidl
Consider the IDL file as PIDL description. It generates
mapping but no stub, no skeleton.
-native: native name = native mapping
Define native type mapping.
For example :
idl demo.idl -native:cookie=java.lang.Object
this command implies the mapping of
cookie in java.lang.Object.
-poa
Generate skeleton for POA
De ellas destacar el parametro "-poa" que generará los esqueletos necesarios para utilizar POA como adaptador de objetos de CORBA. Las demás opciones serán descritas a lo largo de las próximas entregas del curso.
Quizás el lector quiera comenzar a utilizar un interfaz más sencillo e ir poco a poco complicándolo. Un buen punto de partida es:
interface echo {
string repite (in string mensaje);
};
Para el lector avanzado podemos indicarle que consulte el fichero "corba_pkg/echoOperations.java" donde encontrará la interfaz Java que es traducción directa de la interfaz OMG/IDL.
Conclusiones
A lo largo de estos capítulos hemos podido ver la importancia del lenguaje OMG/IDL.
Todo proceso de diseño software orientado a objetos debe acabar definiendo de forma clara las interfaces de comunicación de los objetos de la aplicación. Y estas se describen en el mundo CORBA utilizando el leguaje OMG/IDL.
OMG/IDL es un lenguaje sencillo, basado fundamentalmente en Java, y con algunas extensiones para reflejar mecanismos de comunicación. A partir de él se obtiene de forma automática los cabos (stubs) y esqueletos (skeletons) que permitirán a nuestros clientes y servidores comunicarse a través del ORB.
Hemos visto por último la herramienta JavaORB, una implementación de CORBA 2.2 que incluye un compilador de IDL a Java con el que podemos empezar a trabajar.
Referencias
Tutoriales
