CORBA desde Java

CORBA desde Java
Diego Sevilla Ruiz
Sistemas Distribuidos
Índice
1. Introducción
1
2. Primeros pasos
2.1. Fichero IDL . .
2.2. Cliente . . . . .
2.3. Implementación
2.4. El servidor . .
1
1
2
3
5
. .
. .
del
. .
. . . . .
. . . . .
servant
. . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
3. Ejecución
1.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
6
Introducción
Este documento explica los primeros pasos para usar CORBA desde Java. Primero se
describe un ejemplo sencillo y luego se ofrece un cliente Java para el servidor visto en
C++. Con cualquier JDK se pueden realizar los ejemplos propuestos.
2.
Primeros pasos
Para comprender el funcionamiento de CORBA desde Java, introduciremos un ejemplo
sencillo de una aplicación que define un IDL, un cliente y un servidor.
2.1.
Fichero IDL
El fichero IDL, Calculadora.idl es el siguiente:
1
3
5
7
module prueba
{
interface Calculadora
{
double add ( in double x , in double y ) ;
double substract ( in double x , in double y ) ;
double multiply ( in double x , in double y ) ;
1
double divide ( in double x , in double y ) ;
void storeMemory ( in double x ) ;
double readMemory () ;
9
};
11
};
Las funciones son las normales de una calculadora, como se puede ver.
Para generar los stubs y skeletons, hay que ejecutar el compilador de IDL. Lo ejecutamos con la opción ((-fall)), para que genere tanto los stubs como los skeletons:
$ idlj -fall Calculadora.idl
Esto genera los ficheros de stub y skeleton dentro del subdirectorio ((prueba)):
$ ls prueba -C1
CalculadoraHelper.java
CalculadoraHolder.java
Calculadora.java
CalculadoraOperations.java
CalculadoraPOA.java
_CalculadoraStub.java
2.2.
Cliente
A continuación se muestra el cliente (Cliente.java): Es un programa que es capaz
de utilizar el objeto Calculadora:
package prueba ;
2
4
import prueba .*;
import org . omg . CORBA .*;
import java . io .*;
6
8
10
12
14
public class Cliente
{
public static void main ( String args [])
{
try {
// Iniciar el ORB
org . omg . CORBA . ORB orb = org . omg . CORBA . ORB . init ( args , null ) ;
16
18
20
// Leer el IOR del fichero
File IORFile = new File ( " IOR " ) ;
FileReader reader = new FileReader ( IORFile ) ;
BufferedReader buf = new BufferedReader ( reader ) ;
String IOR = buf . readLine () ;
22
24
// Convertir el IOR en un objeto
org . omg . CORBA . Object o = orb . string_to_object ( IOR ) ;
2
Calculadora calc = CalculadoraHelper . narrow ( o ) ;
26
// Usar la calculadora
System . out . println ( calc . add (2.0 ,3.0) ) ;
28
} catch ( Exception e ) {
e . printStackTrace () ;
}
30
32
}
}
34
El cliente realiza las siguientes labores:
Lı́nea 3: Incluye el paquete con el stub para el tipo de objeto Calculadora.
Lı́nea 15: Se inicia el ORB. Normalmente, el ORB se implementa como una función
de librerı́a. Esta llamada realiza todas las funciones de inicialización para el ORB.
Lı́nea 24: Se utiliza la operación del ORB string to object para convertir el
IOR dado en la lı́nea de comando como primer parámetro en una referencia a un
objeto CORBA. Todos los objetos CORBA heredan de la interfaz CORBA::Object
(org.omg.CORBA.Object).
Lı́nea 25: El método narrow de la clase CalculadoraHelper (generado automáticamente) se utiliza para especializar la referencia obtenida a un objeto del tipo
especı́fico. En este caso Calculadora. La función devolverá en calc la referencia
especializada a un objeto de tipo Calculadora, o ((null)) si la conversión no se
puede realizar
Lı́nea 28: Se realiza la llamada propiamente dicha. La abstracción proporcionada
por CORBA permite hacer una llamada al objeto remoto como si fuera un objeto
local. El resultado se imprime por la pantalla.
2.3.
Implementación del servant
Para implementar un objeto CORBA, esto es, para ofrecer sus servicios al mundo, se
tienen que implementar dos cosas:
El servant que contiene la implementación de los métodos del interfaz que se ofrece
al exterior,
y un servidor, que quedará esperando conexiones en un puerto IP.
El servant es simplemente un objeto del lenguaje de programación (en este caso Java)
que implementa la funcionalidad de los métodos del objeto CORBA. Este servant es
llamado por el skeleton cuando un cliente llama a un método del objeto CORBA implementado por ese servant. El código del servant es el que se muestra a continuación. Se
ha implementado las funciones de la calculadora en el fichero CalculadoraImpl.java:
3
package prueba ;
2
4
class CalculadoraImpl extends CalculadoraPOA
{
private double memory_ ;
6
public CalculadoraImpl ()
{
memory_ = 0;
}
8
10
public double add ( double x , double y )
{
return x + y ;
}
12
14
16
public double substract ( double x , double y )
{
return x - y ;
}
18
20
public double multiply ( double x , double y )
{
return x * y ;
}
22
24
26
public double divide ( double x , double y )
{
double result = 0;
28
30
try {
result = x / y ;
} catch ( Exception e )
{
}
32
34
36
return result ;
38
}
40
public void storeMemory ( double x )
{
memory_ = x ;
}
42
44
public double readMemory ()
{
return memory_ ;
}
46
48
}
De destacar en este fichero es:
El servant se implementa en una clase CalculadoraImpl. Todas las clases servant
4
heredan de la clase ((<interfaz>POA)).
El interfaz de ese objeto, salvo algunos métodos adicionales que se explican en la
teorı́a de la asignatura, sigue el definido en el IDL.
2.4.
El servidor
En cualquier aplicación CORBA debe existir un servidor que quede esperando las
peticiones sobre los objetos CORBA implementados por él (servants). El servidor es un
programa Java normal que dejará activado un servant para el objeto CORBA.
1
package prueba ;
3
import org . omg . CORBA .*;
import org . omg . PortableServer .*;
5
7
9
public class Servidor
{
public static void main ( String [] args )
{
try {
11
13
15
// Iniciar el ORB
org . omg . CORBA . ORB orb = org . omg . CORBA . ORB . init ( args , null ) ;
// Objeto auxiliar
org . omg . CORBA . Object o ;
17
19
21
23
// Encontrar el POA raı́z
POA rootPOA ;
o = orb . r e s o l v e _ i n i t i a l _ r e f e r e n c e s ( " RootPOA " ) ;
rootPOA = POAHelper . narrow ( o ) ;
// Activar el POA
rootPOA . the_POAManager () . activate () ;
25
// Crear el objeto implmentación
27
29
31
prueba . CalculadoraImpl calcImpl =
new prueba . CalculadoraImpl () ;
// Registrarlo en el POA
o = rootPOA . servant_to_reference ( calcImpl ) ;
33
35
37
39
41
prueba . Calculadora calc =
prueba . CalculadoraHelper . narrow ( o ) ;
// Producir la dirección del objeto
String ior = orb . object_to_string ( calc ) ;
System . out . println ( ior ) ;
// Esperar llamadas
orb . run () ;
5
43
} catch ( Exception e )
{
e . printStackTrace () ;
}
45
47
}
}
49
El servidor contiene casi toda la carga de la dificultad de la programación con CORBA.
Las tareas que implementa el servidor son las siguientes:
Lı́nea 13: El ORB se inicia como en el cliente.
Lı́neas 19–24: Se obtiene el POA raı́z. El objeto servidor se tiene que registrar en
un adaptador de objetos (OA). En CORBA, el POA es el adaptador de objetos,
que se puede configurar como una jerarquı́a. En este caso, registraremos el objeto
en el POA raı́z (RootPOA). Para la mayorı́a de los usos, este adaptador de objetos
es suficiente. Se obtiene el POA Manager. Este manager controla a un conjunto
de adaptadores de objetos, permitiéndoles funcionar, o bien encolar las peticiones
o rechazarlas. Finalmente, se activa el POAManager.
Lı́nea 29: Se crea un objeto servant CalculadoraImpl.
Lı́nea 32: Se utiliza el método servant to reference del POA para obtener una
referencia CORBA a partir de un servant.
Lı́nea 35: La referencia se convierte a una referencia de un interfaz Calculadora.
Este paso no es necesario, se muestra por completitud.
Lı́nea 38: La referencia se convierte en una cadena de caracteres con la función del
ORB object to string.
Lı́neas 43–52: La referencia en formato cadena de caracteres se imprime por pantalla.
Lı́nea 42: El ORB se pone a funcionar (esperar peticiones). con la función run del
ORB. El servidor queda ası́ esperando las peticiones de los clientes.
3.
Ejecución
Una tı́pica ejecución del programa podrı́a ser la siguiente:
$ java prueba.Servidor | tee IOR
IOR:000...
$ cat IOR
IOR:000...
6
$ java prueba.Cliente
5.0
7