Download I Objetivos.

UNIVERSIDAD AUTONOMA METROPOLITANA
UNIDAD IZTAPALAPA
División de Ciencias Básicas e Ingeniería
Departamento de Ingeniería Eléctrica
Licenciatura en Computación
“PROPUESTA DE UNA PLATAFORMA DE ESTUDIO DE LA
ARQUITECTURA CORBA UTILIZANDO JAVA”
Reporte de Proyecto Terminal
Alumno:
Christofer Bernardo Estebanez Ruiz
Matrícula:
205317917
Asesor:
Dra. Graciela Román Alonso
2010
1
• Índice.
I Objetivos ............................................................................................................. 3
II Introducción ...................................................................................................... 3
III CORBA .............................................................................................................5
III.I Arquitectura........................................................................................5
III.II Lenguaje Java-IDL...........................................................................6
IV Propuestas de ejercicios básicos usando CORBA..........................................7
IV.I Aplicación de acceso local.................................................................. 7
IV.II Aplicación de acceso remoto.......................................................... 19
V Conclusiones..................................................................................................... 21
VI Referencias..................................................................................................... 21
VII Anexo 1 ......................................................................................................... 22
2
I Objetivos.
1. Estudiar la arquitectura de manejo de objetos distribuidos CORBA.
2. Construir una plataforma basada en Java, que permita el manejo mediante
CORBA.
II Introducción.
Actualmente los sistemas distribuidos basados en objetos son una tecnología que es cada
vez más utilizada en el desarrollo de aplicaciones. El tener las bases para construir
aplicaciones que usan los recursos localizados en diversas computadoras abre el panorama
para abordar diferentes problemáticas de la vida diaria.
Modelos orientados a objetos.
En un modelo orientado a objetos (OO), una aplicación distribuida es considerada como
una colección de objetos autónomos especializados en diferentes funcionalidades, que
existen independientemente en un sistema distribuido.
Diversos objetos coordinan sus actividades y usan sus funcionalidades mediante rutinas
explícitas de comunicación.
Objetos comunicantes.
Un objeto reúne atributos y métodos y cada uno de ellos tiene un estado interno, descrito
por los valores de sus atributos.
Un objeto puede ser accesado mediante la llamada a sus métodos (mensaje), los cuales
pueden representar servicios para clientes o bien para modificar el estado interno del
objeto.
El modelo OO seguido se usa en el diseño de aplicaciones de granularidad gruesa de gran
escala.
Objetos distribuidos.
Los objetos distribuidos son un modelo para la realización de la arquitectura
Cliente/Servidor.
Los objetos distribuidos siguen el modelo de memoria distribuida, permiten el paralelismo
de tareas y una programación MPMD.
3
Cada interacción entre objetos sigue el patrón Cliente/Servidor. Sin embargo, la estructura
de los sistemas de objetos distribuidos es peer-to-peer: los papeles de Cliente y Servidor
pueden cambiar en el tiempo.
Objetos = Unidades de distribución.
Los objetos pueden ser de granularidad muy gruesa (productos vendidos por una empresa).
Los objetos poderosos de granularidad gruesa son comúnmente conocidos como
componentes.
•
Objeto.
◦ Término de lenguaje de programación.
◦ Enfatiza el encapsulamiento de datos y código.
◦ Se usa frecuentemente para entidades en un mismo programa.
•
Componente
◦ Término de ingeniería de software.
◦ Enfatiza la oportunidad de agrupar entidades en aplicaciones de gran escala.
◦ Existe independientemente, no existe un solo programa.
Arquitectura de objetos distribuidos.
Las aplicaciones a gran escala generalmente de organizan como sistemas de software
abiertos: los objetos pueden ser añadidos, modificados o retirados mientras el resto del
sistema sigue corriendo.
Sistemas como CORBA y DCOM proveen un conjunto de facilidades para el desarrollo de
aplicaciones de gran escala (frameworks, dessign patterns, business objects, beans, etc.)
4
III CORBA
III.I Arquitectura CORBA.
CORBA (Common Object Request Broker Architecture) es un estándar establecido
por la OMG (Object Management Group: http://www.omg.org/). CORBA se diseñó para
funcionar sobre ambientes heterogéneos y permite la interoperabilidad entre programas
escritos en diferentes lenguajes de programación y entre programas que corren en diferentes
máquinas. Existe una clara separación entre interfaz e implementación de servicio.
•
¿Qué es? CORBA es sólo una especificación para crear y usar objetos
distribuidos.
•
¿Qué no es? CORBA no es un lenguaje de programación.
Un sistema basado en CORBA es una colección de objetos que aislan a los solicitantes de
servicios (clientes) de los provedores de servicio (servidores) por una interfaz de
encapsulamiento bien definida.
•
•
•
Los objetos de CORBA pueden correr en cualquier plataforma.
Los objetos de CORBA pueden ser localizados en cualquier parte de la red.
Los objetos de CORBA pueden ser escritos en cualquier lenguaje que tenga
mapeo IDL.
La Object Management Architecture (OMA) de OMG define varios servicios de alto nivel
para el cómputo distribuido orientado a objetos.
El núcleo de OMA es el Object Request Broker (ORB) que es un mecanismo que provee
transparencia en la localización de objetos, comunicación y activación.
Cualquier programa existente puede ser transformado a un objeto CORBA al describir
su interfaz mediante un lenguaje de definición de interfaces (IDL).
Transparencia de localización. El propósito del ORB es mediar la comunicación entre los
objetos Cliente y Servidor de manera transparente.
Un objeto tiene asociado un identificador único (o referencia única de objeto), asignado
automática mente por el sistema.
Un Cliente no conoce la localización física del Servidor por lo que envía la petición al ORB
el cual busca la localización del Servidor y envía la petición del Cliente.
5
CORBA (Common Object Request Broker Architecture).
Servidor
Operación
Cliente
Implementación de objeto
Resultad
o
DII
Stubs
Interfaz
ORB
Interfaz
ORB
Skeletons
DSI
Adaptador
de
objeto
Deposito de
implement.
III.II Lenguaje Java-IDL.
Interface description language (también lenguaje de descripción de interfaces). Es un
lenguaje de informática utilizado para describir la interfaz de componentes software.
Describe una interfaz en un lenguaje neutral, lo cual permite la comunicación entre
componentes de software desarrollados en diferentes lenguajes como por ejemplo, entre las
componentes escritas Java.
Son utilizadas con frecuencia en el software de las llamadas a procedimiento remoto (RPC),
lo que permite a los sistemas de computadoras utilizar lenguajes y sistemas operativos
diferentes. IDL ofrece un puente entre dos sistemas diferentes.
El compilador IDL usa el mapeo del lenguaje IDL-a-Java para convertir las definiciones de
interfaz IDL a las correspondientes interfaces, clases y métodos de Java, los cuales pueden
ser usados para implementar el código cliente-servidor.
6
IV Propuestas de ejercicios básicos usando
CORBA: “Hola mundo” con tecnología JavaIDL.
IV.I Aplicación de acceso local.
Antes de empezar:
Para Windows: Se debe contar previamente con la versión 1.4 de J2SE (Java 2 Standard
Edition) que contiene la Interfaz de Programación de Aplicación (API por sus siglas en
inglés) y el Intermediario de Petición de Objetos (ORB por sus siglas en inglés) los cuales
son necesarios para habilitar la interacción de objetos distribuidos basados en CORBA, así
como el compilador IDL.
Para Linux: Para poder usar los comandos de conexión remota (orbd) basta con instalar la
máquina virtual de Java en el sistema operativo la cual ya cuenta con el compilador IDL y
con el protocolo correspondiente que permite habilitar la interacción de objetos
distribuidos.
Una vez visto esto procederemos a la creación y ejecución del programa.
7
• Escribiendo el archivo hello.idl.
1. Crear un nuevo directorio llamado Hello para esta aplicación.
2. En un archivo de texto escribir el código:
module HelloApp{
interface Hello{
string sayHello();
oneway void shutdown();
};
};
3. Guardar el archivo como Hello.idl.
• Entendiendo el archivo idl.
El idl para nuestro “hola mundo” es extremadamente sencillo ya que su interfaz tiene solo
dos operaciones. Solo se necesitan tres pasos a realizar:
1.
Declaración del modulo CORBA IDL.
Un módulo CORBA es un nombre-espacio que actúa como contendor para las interfaces y
declaraciones relacionadas. Se asemeja a un paquete Java. Cada declaración de módulo en
un archivo IDL es mapeado a un paquete Java.
La declaración del módulo luce así:
module HelloApp{
// Resto de las líneas del código
};
Cuando se compila el IDL, la declaración del módulo generará una declaración de paquete
en el código de Java.
2. Declaración de la interfaz.
Así como las interfaces Java, las interfaces CORBA declaran la relación que un objeto tiene
con otros objetos. Cada declaración de interfaz en IDL mapea la declaración de interfaz de
Java.
8
Para nuestro archivo Hello.idl, la declaración de interfaz luce así:
module HelloApp{
interface Hello{
};
};
Cuando se compila el IDL, esta declaración generará una declaración de interfaz en el
código de Java.
3. Declarando las operaciones.
Las operaciones de CORBA son el comportamiento que el servidor promete cumplir por los
clientes que lo invoquen. Cada declaración de operación en IDL genera una declaración de
método correspondiente en el que es generado en la interfaz Java.
En nuestro archivoHello.idl, la declaración de operaciones luce así:
module HelloApp{
interface Hello{
string sayHello();
oneway void shutdown();
};
};
La definición de interfaz para nuestra aplicación “hola mundo” ahora está completa.
• Mapeo del archivo Hello.idl a Java.
La herramienta idlj lee los archivos IDL y crea los archivos Java requeridos. El compilador
idlj genera por defecto solo las obligaciones del lado del cliente. Si se necesitan las
obligaciones del lado del cliente y los esqueletos del lado del servidor (como ocurre en este
caso), debes usar la opción –fall cuando ejecutes el compilador idlj.
Dentro del directorio de ubicación del archivo Hello.idl escribir en la línea de comandos:
idlj -fall Hello.idl
Esto crea un directorio llamado HelloApp que contiene seis archivos *.java.
9
• Entendiendo la salida del compilador idlj.
El compilador idlj genera un cierto número de archivos. Este número depende de las
opciones seleccionadas cuando el archivo IDL es compilado. Los archivos generados
proveen una funcionalidad estándar, así que pueden ser ignorados hasta el momento en que
hay que desplegar y ejecuta el programa. Los archivos generados son:
 HelloPOA.java. Esta clase abstracta es el esqueleto del servidor de conexión base la
cual provee al servidor de la funcionalidad CORBA básica.
 _HelloStub.java. Esta clase es el talón del cliente, el cual provee al cliente de la
funcionalidad CORBA.
 Hello.java. Esta interfaz contiene la versión Java de nuestra interfaz IDL.
 HelloHelper.java. Esta clase provee funcionalidad auxiliar, en particular el método
narrow() requerido para convertir las referencias de objeto CORBA a los tipos
apropiados.
 HelloHolder.java. Esta clase final posee un miembro de instancia pública del tipo
Hello. En el momento en que el tipo IDL es un parámetro out o inout, la clase
Poseedor es usada.
 HelloOperations.java. Esta interfaz contiene los métodos sayHello() y shutdown().
El mapeo IDL-a-Java pone todas las operaciones definidas en la interfaz en este
archivo.
Cuando se escribe la interfaz IDL, se hace toda la programación requerida para generar
todos estos archivos para la aplicación distribuida.
10
• Desarrollo del servidor.
Creación de HelloServer.java.
1. Abrir un editor de texto y crear un archivo llamado HelloServer.java dentro del directorio
Hello.
2. Escribe el siguiente código en el archivo:
import HelloApp.*;
import org.omg.CosNaming.*;
import org.omg.CosNaming.NamingContextPackage.*;
import org.omg.CORBA.*;
import org.omg.PortableServer.*;
import org.omg.PortableServer.POA;
import java.util.Properties;
class HelloImpl extends HelloPOA{
private ORB orb;
public void setORB(ORB orb_val){
orb = orb_val;
}
public String sayHello(){
return "\nHello world !!\n";
}
public void shutdown(){
orb.shutdown(false);
}
}
public class HelloServer{
public static void main(String args[]) {
try{
ORB orb = ORB.init(args, null);
POA rootpoa = POAHelper.narrow(orb.resolve_initial_references("RootPOA"));
rootpoa.the_POAManager().activate();
HelloImpl helloImpl = new HelloImpl();
helloImpl.setORB(orb);
org.omg.CORBA.Object ref = rootpoa.servant_to_reference(helloImpl);
Hello href = HelloHelper.narrow(ref);
org.omg.CORBA.Object objRef = orb.resolve_initial_references("NameService");
NamingContextExt ncRef = NamingContextExtHelper.narrow(objRef);
String name = "Hello";
11
NameComponent path[] = ncRef.to_name( name );
ncRef.rebind(path, href);
System.out.println("HelloServer ready and waiting ...");
orb.run();
}catch (Exception e) {
System.err.println("ERROR: " + e);
e.printStackTrace(System.out);
}
System.out.println("HelloServer Exiting ...");
}
}
3. Guarda y cierra HelloServer.java.
• Entendiendo HelloServer.java.
La estructura del programa servidor CORBA es el mismo que el de la mayoría de las
aplicaciones Java: se importan paquetes de librerías requeridos, se declara la clase del
servidor, se define main() y se manejan las excepciones.
Importando los paquetes requeridos:
import HelloApp.*;
import org.omg.CosNaming.*;
import org.omg.CosNaming.NamingContextPackage.*;
import org.omg.CORBA.*;
import org.omg.PortableServer.*;
import org.omg.PortableServer.POA;
Definiendo la clase servidor:
En este ejemplo estamos definiendo la clase para el objeto servidor dentro de
HelloServer.java pero fuera de la clase HelloServer.
class HelloImpl extends HelloPOA{
// Los métodos sayHello() y shutdown() van aquí
}
El servidor es una subclase de HelloPOA así que hereda la funcionalidad CORBA general
generada por el compilador.
Ahora, creamos una variable privada orb que es usada en el método setORB(ORB). Este en
un método privado definido por la aplicación desarrolladora para que el valor ORB pueda
ser fijado con el servidor. Este valor ORB es usado para invocar el método shutdown() en
respuesta a la invocación del método shutdown() del cliente.
12
private ORB orb;
public void setORB(ORB orb_val){
orb = orb_val;
}
Después declaramos e implementamos el método sayHello() requerido:
public String sayHello(){
return "\nHello world!!\n";
}
Por último, implementamos el método shutdown() de forma similar:
public void shutdown(){
orb.shutdown(false);
}
Declarando la clase del servidor:
public class HelloServer{
// El método mai() va aquí
}
Definiendo el método main():
Cada aplicación de Java necesita de un método main() y es declarado dentro de la clase
HellServer.
public static void main(String args[]{
// Aquí va el código try-catch
}
Manejando las excepciones del sistema CORBA.
Como todos los programa CORBA pueden arrojar excepciones de sistema CORBA en
tiempo de ejecución, toda la funcionalidad de main() es colocada dentro de un bloque trycatch. Los programa CORBA arrojan excepciones en tiempo de ejecución cuando ocurre un
problema durante algún proceso envuelto en una invocación. El manejador de excepciones
simplemente imprime la excepción y el rastro de su pila en una salida estándar para poder
ver que fue lo que ocurrió mal. El bloque try-catch se coloca dentro de main() como se
muestra:
try{
// El resto del código HelloServer va aquí.
}catch(Exception e){
System.err.println("ERROR: " + e);
e.printStackTrace(System.out);
}
13
• Compilando el servidor “hola mundo”.
Ahora ya podemos compilar HelloServer.java para corregir cualquier error antes de
continuar.
1. Posicionarse en el directorio Hello.
2. Ejecutar el compilador Java sobre HelloServer.java:
Javac HelloServer.java HelloApp/*.java
3. Corregir los errores y recompilar si es necesario.
4. Se generan los archivos HelloServer.class y HelloImp.class en el directorio
Hello.
14
• Desarrollo del cliente.
Creación de HelloClient.java.
1. Abrir un editor de texto y crear un archivo llamado HelloClient.java dentro del directorio
Hello.
2. Escribe el siguiente código en el archivo:
import HelloApp.*;
import org.omg.CosNaming.*;
import org.omg.CosNaming.NamingContextPackage.*;
import org.omg.CORBA.*;
public class HelloClient{
static Hello helloImpl;
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);
String name = "Hello";
helloImpl = HelloHelper.narrow(ncRef.resolve_str(name));
System.out.println("Obtained a handle on server object: " + helloImpl);
System.out.println(helloImpl.sayHello());
helloImpl.shutdown();
} catch (Exception e) {
System.out.println("ERROR : " + e) ;
e.printStackTrace(System.out);
}
}
}
3. Guarda y cierra HelloServer.java.
• Entendiendo HelloClient.java.
El caparazón básico de un cliente CORBA es el mismo que el de muchas de las
aplicaciones Java: se importan paquetes de librerías requeridos, se declara la clase del
servidor, se define main() y se manejan las excepciones.
15
Importando los paquetes requeridos:
import HelloApp.*;
import org.omg.CosNaming.*;
import org.omg.CosNaming.NamingContextPackage.*;
import org.omg.CORBA.*;
Definiendo la clase cliente:
Lo siguiente es declarar la clase del cliente:
public class HelloClient{
// El método main() va aquí
}
Creando el objeto ORB.
Un cliente CORBA necesita un objeto ORB local para desempeñar su cálculo de
referencias y su trabajo IIOP.
La variable ORB es declarada e inicializada dentro del bloque try-catch:
ORB orb = ORB.init(args,null);
La llamada al método init() de CORBA pasa los argumentos de la línea de comando en la
aplicación, permitiendo fijar ciertas propiedades en tiempo de ejecución.
Buscando el servidor Hello.
Ahora que la aplicación tiene un ORB, puede pedirle que localice el servicio que necesita,
en este caso el servidor Hello. Para ello, nuestra aplicación cliente usará el servicio de
nombramiento COS.
Obteniendo el contexto de nombramiento inicial.
El primer paso para usar el servicio de nombramiento es obtener el contexto de
nombramiento inicial:
org.omg.CORBA.Object objRef = orb.resolve_initial_references("NameService");
Estrechando la referencia del objeto.
Como en todas las referencias a objeto CORBA, objRef es un objeto CORBA genérico.
Para poder usarlo como un objeto NamingContextExt, se debe estrechar al tipo apropiado.
NamingContextExt ncRef = NamingContextExtHelper.narrow(objRef);
16
Aquí vemos el uso de una clase de ayuda generada por idlj, similar a la función
HelloHelper.
Resolver la referencia a objeto en el nombramiento.
Para publicar una referencia en el servicio de nombrado hacia el objeto Hello que
implementa la interfaz Hello, necesitas primero una cadena identificadora para el objeto
Hello:
String name = "Hello";
Finalmente pasamos name al método resolve_str() del servicio de nombrado para obtener
una referencia objeto para el servidorHello y estrecharlo al objeto Hello:
helloImpl = HelloHelper.narrow(ncRef.resolve-str(name));
System.out.println("Obtained a handle on server object: " + helloImpl);
Aquí se ve a la clase de ayuda HelloHelper trabajar. El método resolve_str() regresa un
objeto CORBA genérico. Por lo tanto, inmediatamente se estrecha el objeto Hello, el cual
es la referencia objeto que se necesita para realizar el resto del trabajo.
Invocando la operación sayHello().
Las invocaciones CORBA son una llamada a método sobre un objeto local.Finalmente,
imprimimos los resultados de la invocación a una salida estándar y se apaga el ORB:
System.out.println(helloImpl.sayHello());
helloImpl.shutdown();
• Compilando el servidor “hola mundo”.
Ahora ya podemos compilar HelloClient.java para corregir cualquier error antes de
continuar.
1. Posicionarse en el directorio Hello.
2. Ejecutar el compilador Java sobre HelloClient.java:
Javac HelloClient.java HelloApp/*.java
3. Corregir los errores y recompilar si es necesario.
4. Se genera el archivo HelloClient.class en el directorio Hello.
17
•
Ejecución de la aplicación “hola mundo”.
1. Iniciar el orbd.
Desde terminal Linux:
rbd -ORBInitialPort 1050 -ORBInitialHost localhost&
Desde terminal Windows:
start orbd -ORBInitialPort 1050 -ORBInitialHost localhost
NOTA: 1050 es el puerto en el cual se quiere ejecutar el servidor. Para poder ejecutar la
aplicación en un puerto en un puerto menor a 1024 se debe ser el administrador del sistema,
por eso es que se ejecuta en un puerto mayor a 1024.
2. Iniciar el servidor Hello:
Desde terminal Linux:
java HelloServer -ORBInitialPort 1050 -ORBInitialHost localhost&
Desde terminal Windows:
start java HelloServer -ORBInitialPort 1050 -ORBInitialHost localhost
3. Ejecutar la aplicación cliente
java HelloClient -ORBInitialPort 1050 -ORBInitialHost localhost
• El cliente imprime la cadena desde el servidor en la línea de
comandos.
Hello world !!
18
IV.II Aplicación de acceso remoto.
Cliente
Implementación del
objeto
Cliente
Implementación del
objeto
IDL
IDL
IDL
IDL
ORB
ORB
RED
Para poder ejecutar la aplicación “hola mundo” en dos máquinas se debe colocar al cliente,
los esbozos y los esqueletos en la máquina del cliente y el servidor en la máquina del
servidor.
1. Crear (como se muestro previamente) y compilar el archivo Hello.idl en la máquina
del cliente:
idlj -fall Hello.idl
2. Crear el archivo HelloClient.java en la máquina del cliente. Compilar los archivos
java, incluyendo los esbozos y los esqueletos (que se encuentran en el directorio
HelloApp):
javac *.java HellApp/*.java
3. Crear el archivo HelloServer.java en la máquina del servidor. Compila los archivos
*.java.
javac *.java
4. Inicia el demonio intermediario de petición de objets Java (orbd por sus siglas en
ingles), el cual incluye el servicio de nombramiento.
19
Para hacer esto en Linux:
orbd -ORBInitialPort 1050 -ORBInitialHost direcciónIP&
Para hacer esto en Windows:
start orbd -ORBInitialPort 1050 -ORBInitialHost direcciónIP
Los argumentos -ORBInitialPort y -ORBInitialHost son obligatorios para la línea de
comando orbd. En este ejemplo se usa el puerto 1050.
NOTA: La dirección IP del servidor fue generada por medio de un simulador de redes
virtuales, Hamachi en este caso, la cual es una es una aplicación configuradora de redes
privadas gratuita capaz de establecer vínculos directos entre computadoras que están bajo
firewalls de NAT sin requerir reconfiguración alguna (en la mayoría de los casos). En otras
palabras, establece una conexión a través de Internet y simula una red de área local formada
por ordenadores remotos.
5. Inicia el servidor Hello en la máquina del servidor como se muestra:
En la terminal de Linux:
java HelloServer -ORBInitialPort 1050&
En terminal de Windows:
start java HelloServer -ORBInitialPort 1050
Nota: No se necesita especificar el argumento -ORBInitialHost porque el servidor Hello
estará ejecutándose en el mismo anfitrión que el servidor en este ejemplo.
6. Ejecuta la aplicación Hello del cliente en la maquina donde se encuentra el cliente:
En terminal de Linux:
java HelloClient -ORBInitialHost direcciónIP -ORBInitialPort 1050&
En terminal de Windows:
java HelloClient -ORBInitialHost direcciónIP orbd -ORBInitialPort 1050
Nota: La direcciónIP es el anfitrión en el cual el servidor IDL está ejecutándose. En este
caso es la máquina del servidor.
7. Detener el orbd cuando se termine la aplicación, en caso contrario el servidor
seguirá esperando invocaciones del cliente.
20
V Conclusiones.
Java IDL es una tecnología para objetos distribuidos que permite la interacción de estos
sobre diferentes plataformas a través de la red. Esta interacción es posible porque Java-IDL
está basada en una arquitectura de intermediario de peticiones de objetos comunes
(CORBA), un modelo de objetos distribuidos estándar.
El compilador IDL es una herramienta poderosa y de gran ayuda para la creación de
aplicaciones de objetos distribuidos; una vez que se tiene definida la interface remota se
puede de forma relativamente sencilla crear aplicaciones, ya que la conexión entre clienteservidor se realiza de la misma forma en todas las aplicaciones, es decir, no cambia el
código de conexión en la aplicación de servidor.
Parte del poder de alcance de CORBA se debe al apoyo del compilador IDL, quien es el
encargado de la creación de todo el “esqueleto” de nuestras aplicaciones y al soporte que
proporciona Java, comenzando por las clases (que son compatibles con el lenguaje IDL),
pasando por los métodos de manipulación hasta el manejo de excepciones. Por ello se
propone utilizar esta plataforma para el desarrollo de aplicaciones Java-IDL ya que su
manejo es simple (como puede verse en este documento) para la creción de las mismas.
VI Referencias.
◦ ORBIX de IONA Technologies.
http://www.iona.com/products/orbix/
◦ VisiBroker de Borland.
http://www.borland.com/us/products/visibroker/
◦ JacORB is an object request broker written in Java, available under the LGPL.
http://www.jacorb.org/
◦ JavaIDL de JavaSoft.
http://java.sun.com/products/jdk/idl
◦ Información sobre el compilador IDL.
http://es.wikipedia.org/wiki/IDL
◦ Información sobre Hamachi.
http://es.wikipedia.org/wiki/Hamachi
21
VII Anexo 1. Otra aplicación para la
arquitectura CORBA usando tecnología JavaIDL.
◦ Implementador de fechas.
Código del archivo IDL:
module FechaApp {
interface Fecha{
string getFecha();
};
};
Código del servidor:
import FechaApp.*;
import org.omg.CORBA.*;
import org.omg.PortableServer.POAHelper;
import org.omg.PortableServer.POA;
import java.util.*;
import java.io.*;
import org.omg.CosNaming.*;
import org.omg.CosNaming.NamingContextPackage.*;
import org.omg.CORBA.*;
class FechaImpl extends FechaPOA {
public String getFecha() {
return (new Date()).toString();
}
}
public class FechaServer {
public static void main(String args[]) {
try {
ORB orb = ORB.init(args, null);
FechaImpl impl = new FechaImpl();
POA rootpoa=POAHelper.narrow(orb.resolve_initial_references("RootPOA"));
rootpoa.the_POAManager().activate();
org.omg.CORBA.Object ref = rootpoa.servant_to_reference(impl);
22
Fecha href = FechaHelper.narrow(ref);
org.omg.CORBA.Object objRef = orb.resolve_initial_references("NameService");
NamingContextExt ncRef = NamingContextExtHelper.narrow(objRef);
String nombre = "Fecha";
NameComponent path[] = ncRef.to_name(nombre);
ncRef.rebind(path, href);
orb.run();
}catch (Exception e) {
System.err.println("ERROR: " + e);
}
}
}
Código del cliente:
import FechaApp.*;
import org.omg.CORBA.*;
import org.omg.CosNaming.*;
import org.omg.CosNaming.NamingContextPackage.*;
public class FechaClient {
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);
String nombre = "Fecha";
Fecha impl = FechaHelper.narrow(ncRef.resolve_str(nombre));
System.out.println("Fecha: " + impl.getFecha());
}catch (Exception e) {
System.out.println("ERROR : " + e);
e.printStackTrace(System.out);
}
}
}
23