ESCUELA SUPERIOR POLITECNICA DE CHIMBORAZO

FACULTAD DE INFORMTICA Y ELECTRNICA ESCUELA DE INGENIERA EN SISTEMAS

APLICACIONES EMPRESARIALES EN JAVA

TEMA: CORBA EN JAVA DOCENTE: Ing. Jorge Huilca

INTEGRANTES:

Andrea Moncayo

4059

RIOBAMBA ECUADOR 2011

INTRODUCCIN

CORBA es una tecnologa que oculta la programacin a bajo nivel de aplicaciones distribuidas, de tal forma que el programador no se tiene que ocupar de tratar con sockets, flujos de datos, paquetes, sesiones etc. CORBA oculta todos estos detalles de bajo nivel. No obstante CORBA tambin brinda al programador una tecnologa orientada objetos, las funciones y los datos se agrupan en objetos, estos objetos pueden estar en diferentes mquinas, pero el programador acceder a ellos a travs de funciones normales dentro de su programa. CORBA proporciona un entorno de desarrollo y ejecucin de aplicaciones distribuidas. La distribucin de aplicaciones introduce un nuevo conjunto de dificultades. Sin embargo, algunas veces no hay eleccin, algunas aplicaciones por su naturaleza deben estar distribuidas a travs de mltiples computadoras por alguno de estos motivos: y y y La aplicacin utiliza datos distribuidos La computacin est distribuida Los usuarios de la aplicacin estn distribuidos

OBJETIVOS OBJETIVO GENERAL  Conocer las caractersticas, y el desarrollo de una aplicacin en CORBA OBJETIVOS ESPECFICOS  Conocer los conceptos relaciones con CORBA  Analizar las caractersticas, ventajas de CORBA  Desarrollar una aplicacin usando CORBA

SISTEMA DISTRIBUIDO Un sistema distribuido es la coleccin de elementos de cmputo autnomo que se encuentran fsicamente separados y no comparten una memoria comn, se comunican entre s a travs del intercambio de mensajes utilizando un medio de comunicacin. Los sistemas autnomos pueden tener caractersticas no homogneas. Un sistema distribuido puede verse como un sistema formado por varios ordenadores haciendo algo conjuntamente, de los que se desprenden tres caractersticas: y Compuesto por mltiples ordenadores: un sistema distribuido est compuesto de ms de un sistema independiente, cada uno con una o ms CPUs, memoria local, memoria secundaria, en genera conexiones con perifricos de acceso inmediato Hay interconexin entre ellos: varios ordenadores distintos van a colaborar en la realizacin de tareas, deben comunicarse y sincronizarse entre ellos, por lo que debe haber alguna lnea o red de interconexin Tienen un estado compartido: si los ordenadores realizan un trabajo conjuntamente, deben mantener un estado compartido, es decir, todos los ordenadores tienen la misma visin del estado del sistema distribuido (tablas, bases de datos del sistema, de servidores)

Ventajas: Procesadores ms poderosos y a menos costos y Desarrollo de Estaciones con ms capacidades y Las estaciones satisfacen las necesidades de los usuarios. y Uso de nuevas interfaces. Avances en la Tecnologa de Comunicaciones. y Disponibilidad de elementos de Comunicacin. y Desarrollo de nuevas tcnicas. Comparticin de Recursos. y Dispositivos (Hardware). y Programas (Software). Eficiencia y Flexibilidad. y Respuesta Rpida. y Ejecucin Concurrente de procesos (En varias computadoras). y Empleo de tcnicas de procesamiento distribuido. Disponibilidad y Confiabilidad. y Sistema poco propenso a fallas (Si un componente no afecta a la disponibilidad del sistema). y Mayores servicios que elevan la funcionalidad (Monitoreo, Telecontrol, Correo Elctrico, Etc.).

Crecimiento Modular. y Es inherente al crecimiento. y Inclusin rpida de nuevos recursos. y Los recursos actuales no afectan. Desventajas: Requerimientos de mayores controles de procesamiento. Velocidad de propagacin de informacin (Muy lenta a veces). Servicios de replicacin de datos y servicios con posibilidades de fallas. Mayores controles de acceso y proceso (Commit ). Administracin ms compleja. Costos.

CORBA
CORBA (Common Object Request Broker Architecture) es una arquitectura estndar para sistemas de objetos distribuidos. Permite una coleccin distribuida y heterognea de objetos que interoperan entre s. CORBA utiliza el lenguaje de definicin de interfaces (IDL) para especificar las interfaces con los servicios que os objetos ofrecern. Al compilar una interfaz en idl se genera cdigo para el cliente y el servidor  El cdigo del cliente sirve para poder realizar llamadas a mtodos remotos, conocido como stub, que incluye un proxy del objeto remoto  El cdigo generado para el servidor consiste en skeletons que tiene para implementar los mtodos del objeto El OMG (Object Management Group) es el responsable de la definicin de CORBA. El OMG es un conjunto de ms de 700 compaas y organizaciones, incluyendo casi todos los mayores vendedores y desarrolladores de tecnologas de objetos distribuidos. Slo emite especificaciones (no existe implementacin de referencia) Las especificaciones se desarrollan por consenso y son pblicas y gratuitas Existen muchos fabricantes que implementan las especificaciones ms importantes para las plataformas ms usuales Tambin estandariza UML (Unified Modeling Language) Ventajas Estandarizado, mltiples implementaciones (no se depende de un fabricante) Las especificaciones se adoptan por consenso Buena infraestructura para construir aplicaciones distribuidas Permite integrar aplicaciones heterogneas

Desventajas No es la tecnologa ms sencilla de utilizar Las especificaciones tardan en desarrollarse, y en consecuencia las implementaciones tardan en salir al mercado La arquitectura CORBA CORBA define una arquitectura para objetos distribuidos. El paradigma bsico de CORBA es que se hace una peticin para obtener un servicio de un objeto distribuido. Todo lo dems definido por el OMG est descrito en trminos de este paradigma bsico. Los servicios que proporciona un objeto son dados por su interfaz. Los interfaces se definen en el IDL (Interface Definition Language) del OMG. Los objetos distribuidos estn identificados por referencias a objetos, las cuales se describen mediante los interfaces IDL. Un cliente tiene una referencia a un objeto distribuido. La referencia al objeto est descrita por un interface. En la figura, la referencia est simbolizada por el interface Rabbit. El ORB (Object Request Broker), entrega la peticin al objeto y devuelve el resultado al cliente.

ORB El ORB es el servicio distribuido que implementa la peticin al objeto remoto. Localiza el objeto remoto en la red, le comunica la peticin, espera a los resultados y cuando estn disponibles se los devuelve al cliente. El ORB implementa transparencia de localizacin. Se usa exactamente el mismo mecanismo de peticiones tanto por el cliente como por el objeto CORBA, sin importar donde est localizado. Podra tratarse de un proceso en el mismo ordenador que el cliente o estar situado a unos metros o incluso al otro lado del planeta. El cliente no notar la diferencia. El ORB implementa independencia del lenguaje de programacin para las peticiones. El cliente que lanza la peticin se puede escribir en uno de los diferentes lenguajes que aceptan objetos CORBA. El ORB hace las conversiones necesarias entre lenguajes de programacin. Estos enlaces con CORBA estn definidos para los lenguajes ms populares.

CORBA como un Estndar para Objetos Distribuidos Uno de los objetivos de la especificacin CORBA es que las implementaciones de los clientes y servidores sean portables. La especificacin CORBA define un API (Application Programmer's Interface) para los clientes de objetos distribuidos as como un API para la implementacin de un objeto CORBA. Esto significa que el cdigo escrito por un desarollador CORBA puede, con un esfuerzo mnimo, reescribirse para trabajar con el producto de otro desarrollador. Sin embargo, la realidad de los productos CORBA del mercado de hoy es que los clientes CORBA son portables, pero las implementaciones de los objetos necesitan un poco de esfuerzo para portarse de un producto CORBA a otro. CORBA 2.0 aadi la interoperabilidad como un objetivo en la especificacin. En particular, CORBA 2.0 define un protocolo de red llamado IIOP (Internet Inter-ORB Protocol), que permite a los clientes usar productos CORBA de cualquier desarrollador que se comuniquen con objetos CORBA de cualquier otro desarrollador. IIOP trabaja sobre Internet, o ms exactamente, sobre cualquier implementacin de TCP/IP. La interoperabilidad es ms importante en un sistema distribuido que la portabilidad. IIOP se usa en otros sistema que incluso no intentan proporcionar el API de CORBA. En particular, IIOP se usar como protocolo de transporte en una versin de Java RMI (llamada "RMI over IIOP"). Dado que EJB est definido en trminos de RMI, tambin puede usar IIOP. Varios servidores de aplicaciones disponibles en el mercado usan IIOP, pero no implementan el API completo de CORBA. Dado que todos ellos usan IIOP, estos los programas pueden interoperar con cualquier otro que est escrito para el API de CORBA. Servicios CORBA Otra parte importante del estndar CORBA es la definicin de un conjunto de servicios distribuidos para soportar la integracin e interoperabilidad de los objetos distribuidos. Como se muestra en el grfico de abajo, los servicios (conocidos como CORBA Services o COS) se encuentran definidos en la parte superior del ORB. Esto es, estn definidos como objetos CORBA estandar con interfaces IDL, algunas veces llamados "Object Services."

Existen varios servicios que proporciona CORBA. Los ms populares se describen brevemente a continuacin:

Servicio

Descripcin Define como los objetos CORBA se crean, eliminan, Ciclo de vida del objeto mueven y copian. Nominacin Eventos Relaciones Externalizacin Transacciones Control de concurrencia Propiedad Negociacin Consultas Productos CORBA CORBA es una especificacin; es una guia para imprementar productos. Varios comerciantes proporcionan productos CORBA para varios lenguajes de programacin. Los productos CORBA que admite el lenguaje Java incluyen: Define como los objetos CORBA pueden tener nombres simblicos amigables. Desacopla la comunicacin entre objetos distribuidos. Proporciona una red arbitraria de relaciones entre objetos CORBA. Coordina la transformacin entre objetos CORBA a y desde el medio extremo. Coordina accesos atmicos a objetos CORBA. Proporciona un servicio de bloqueo para objetos CORBA que asegura accesos serializables. Soporta la asociacin de pares nombre-valor con objetos CORBA. Soporta la bsqueda de objetos CORBA basados en propiedades que describen el servicio ofrecido por el objeto. Soporta las consultas a objetos.

ORB Java 2 ORB VisiBroker for Java OrbixWeb WebSphere Netscape Communicator

Descripcin Viene con el Java 2 SDK de Sun. No implementa algunas funcionalidades. Un ORB para Java muy popular de Inprise Corporation. VisiBroker tambin lo podemos encontrar empotrado en otros productos, como en el Netscape Communicator. Un ORB para Java de Iona Technologies. Un servidor de aplicaciones con un ORB de IBM El Netscape tiene una versin de VisiBroker incrustada. Los Applets pueden hacer peticiones a objetos CORBA sin descargar clases ORB en el nevegador. Ya estn ah.

Varias ORBs shareware

libres

Existen implementaciones de CORBA para varios lenguajes que se pueden descargar de algunos servidores.

Proceso de desarrollo en Java IDL Definir el Interfaz Remoto Usted define la interfaz para el objeto remoto usando el lenguaje para la definicin de interfaces del OMG. Se usa IDL en lugar de Java porque el compilador idl2java automticamente genera los ficheros de stub y skeleton en Java a partir de la definicin IDL, as como toda la infraestructura para conectar con el ORB. Tambin usando IDL hace posible a los desarrolladores implementar clientes y servidores en cualquier otro lenguaje compatible con CORBA. Si se ha implementando un cliente para un servicio existente de CORBA, o un servidor para un cliente ya existente, se coge los interfaces IDL del implementador. Deber ejecutar el compilador idl2java pasando como parmetro esos interfaces e implementar los mtodos que necesite. Compilar el Interfaz Remoto Al compilador IDL de a Java (idl2java) se genera una versin en Java del interface, as como el cdigo de las clases de los ficheros de stub y skeleton que le permiten enganchar su aplicacin al ORB. Estas son los mapeos que se hacen entre constructores de IDL, Java y C++:

IDL Module

Java Package

C++ namespace abstract class member function

interface Interface operation Method

Attribute pair of methods pair of methods exception Exception exception

Y este es el mapeo para los tipos de datos entre IDL y Java: IDL Boolean char / wchar Octet short / unsigned short long / unsigned long Java boolean char byte short int

long long / unsigned long long long Float Doubl string / wstring float double String

Implementar el Servidor Luego de ser ejecutado el compilador idl2java, se puede usar el esqueleto (skeleton) generado para implementar la aplicacin servidora. Adems de implementar los mtodos del interface remoto, su cdigo del servidor incluye un mecanismo para inicar el ORB y esperar una peticin de un cliente remoto. Implementar el Cliente Se usar los stubs generados por el compilador idl2java como base para la aplicacin cliente. El cdigo del cliente inicia su ORB, busca el servidor usando el servicio de nombrado proporcionado con Java IDL, obtiene una referencia al objeto remoto y llama a su mtodo. Iniciar las aplicaciones Luego de haber implementado el cliente y el servidor, se puede iniciar el servicio de nombrado, iniciar el servidor y por ltimo arrancar el cliente.

Aplicacin Ejemplo "Hello world" en Cliente/Servidor Para el ejercicio se realizar "Hello world!!", pero en versin cliente/servidor con CORBA. Se tratar de una aplicacin distribuida usando el Java IDL. El programa tiene una slo operacin que devuelve una cadena, la cual imprimir. Este diagrama muestra el proceso de comunicacin entre el cliente y el servidor

Estos son los pasos que se lleva a cabo: 1. El cliente invoca la operacin sayHello del servidor HelloServer. 2. El ORB transfiere dicha invocacin al objeto servidor registrado para el interface IDL. 3. El mtodo sayHello del servidor se ejecuta, devolviendo un String. 4. El ORB transfiere ese String de vuelta al cliente. 5. El cliente imprime el valor del String obtenido. Requisitos: Se necesita dos cosas: la versin 1.2 del JDK y el compilador idl2java (de VisiBroker for Java). El JDK proporciona el API y el ORB necesarios para habilitar la interaccin entre los objetos distribuidos basado en CORBA. El compilador idl2java usa el mapeo IDL Java para convertir las definiciones de interfaces escritas en IDL a los interfaces, clases y mtodos correspondientes en Java, que usaremos para implementar el cdigo del cliente y del servidor. Desarrollo: Estos son los pasos
y y y y

Escribir el interfaz IDL Escribir el Cliente Escribir el Servidor Compilar y Ejecutar la aplicacin

Escribir el interfaz IDL En esta seccin escribiremos un interfaz IDL simple para el programa Hello World. El interface IDL define el contrato entre las partes cliente y servidor de su aplicacin, especificando qu operaciones y atributos estn disponibles. OMG IDL es independiente del lenguaje de programacin. Escribiendo Hello.idl OMG IDL es un lenguaje puramente declarativo diseado para especificar interfaces para aplicaciones distribuidas de una forma independiente del lenguaje. OMG especifica un mapeo de IDL a varios lenguajes de programacin, incluyendo C, C++, Smalltalk, COBOL, Ada y Java. Cuando se mapea, cada orden en OMG IDL se traduce a su correspondiente orden en el lenguaje de programacin elegido. La herramienta idl2java se usa para mapear un interfaz en IDL a Java e implementar la clase del cliente. Cuando usted mapea el mismo IDL sobre C++ e implementa el servidor en ese lenguaje, el cliente en Java y el servidor en C++ pueden comunicarse a travs del ORB como si estuvieran escritos en el mismo lenguaje.  Declarar el Mdulo IDL de CORBA Un mdulo de CORBA es un espacio de nombre que acta como un contenedor para los interfaces y declaraciones asociados. Se corresponde a un paquete de Java. Cada mdulo en un fichero IDL se mapea a un paquete de Java. La declaracin del mdulo HelloApp se hace as: module HelloApp { // Las dems lneas van aqu. }; Declarar la Interface As como los interfaces en Java, los interfaces de CORBA declaran el API que usan los objetos para llamarse unos a otros. Cada interface en IDL se mapea con un interface en Java. Escribiremos en el fichero Hello.idl el interface Hello: module HelloApp { interface Hello { // Aqu irn las operaciones. }; };

Declarando las Operaciones Las operaciones de CORBA tienen el comportamiento que prometen los servidores realizar cuando los clientes los invocan. Este compromiso viene indicado en el IDL. Cada sentencia de operacin en IDL genera su correspondiente sentencia de mtodo en el interfaz generado de Java. Introducimos la operacin en el fichero Hello.idl: module HelloApp { interface Hello { string sayHello(); // Aadimos esta lnea. }; };

Mapeando Hello.idl de IDL a Java La herramienta idl2java lee los ficheros OMG IDL y crea los ficheros Java necesarios. Por defecto, el comportamiento de la herramienta es generar tanto el cliente como el servidor, simplemente le pasamos como parmetro el fichero IDL que hemos creado antes: $ idl2java Hello.idl Si se lista el contenido del directorio se ver que se ha creado un directorio llamado HelloApp, el cual contiene cinco ficheros. /* Hello.java as generated by idltojava */ package HelloApp; public interface Hello extends org.omg.CORBA.Object { String sayHello(); } Sentencia IDL Sentencia Java

module HelloApp package HelloApp; interface Hello public interface Hello

string sayHello(); String sayHello();

Todos los objetos CORBA derivan de org.omg.CORBA.Object para asegurarse que se tiene toda la funcionalidad CORBA. La salida de idl2java El compilador idl2java genera una serie de ficheros, basndose en las opciones que le pasamos en la lnea de comandos. Los cinco ficheros generados son: 1. HelloImplBase.java Esta clase abstracta es el skeleton del servidor, proporcionando una funcionalidad CORBA bsica para el servidor. Implementa el interface Hello.java. La clase del servidor HelloServant hereda de _HelloImplBase. /* * File: ./HelloApp/_HelloImplBase.java * From: Hello.idl * Date: Thu Jul 3 09:46:22 2000 * By: idltojava Java IDL 1.2 Jul 12 1997 12:23:47 */ package HelloApp; public abstract class _HelloImplBase extends org.omg.CORBA.DynamicImplementation implements HelloApp.Hello { // Constructor public _HelloImplBase() { super(); } // Type strings for this class and its superclases private static final String _type_ids[] = { "IDL:HelloApp/Hello:1.0" }; public String[] _ids() { return (String[]) _type_ids.clone(); } private static java.util.Dictionary _methods = new java.util.Hashtable(); static { _methods.put("sayHello", new java.lang.Integer(0)); } // DSI Dispatch call public void invoke(org.omg.CORBA.ServerRequest r) {

switch (((java.lang.Integer) _methods.get(r.op_name())).intValue()) { case 0: // HelloApp.Hello.sayHello { org.omg.CORBA.NVList _list = _orb().create_list(0); r.params(_list); String ___result; ___result = this.sayHello(); org.omg.CORBA.Any __result = _orb().create_any(); __result.insert_string(___result); r.result(__result); } break; default: throw new org.omg.CORBA.BAD_OPERATION(0, org.omg.CORBA.CompletionStatus.COMPLETED_MAYBE); } } } 2. HelloStub.java Esta clase es el stub del cliente, proporcionando funcionalidad CORBA al cliente. Implementa el interface Hello.java. /* * File: ./HelloApp/_HelloStub.java * From: Hello.idl * Date: Thu Jul 3 09:46:22 2000 * By: idltojava Java IDL 1.2 Nov 12 1997 12:23:47 */ package HelloApp; public class _HelloStub extends org.omg.CORBA.portable.ObjectImpl implements HelloApp.Hello { public _HelloStub(org.omg.CORBA.portable.Delegate d) { super(); _set_delegate(d); } private static final String _type_ids[] = { "IDL:HelloApp/Hello:1.0" }; public String[] _ids() { return (String[]) _type_ids.clone(); }

// IDL operations // Implementation of ::HelloApp::Hello::sayHello public String sayHello() { org.omg.CORBA.Request r = _request("sayHello"); r.set_return_type(org.omg.CORBA.ORB.init().get_primitive_tc( org.omg.CORBA.TCKind.tk_string)); r.invoke(); String __result; __result = r.return_value().extract_string(); return __result; } }; 3. Hello.java Este interface contiene la versin en Java del interface en IDL. Contiene un slo mtodo llamado sayHello. El interface Hello.java hereda de org.omg.CORBA.Object, proporcionando tambin una funcionalidad CORBA estndar. /* * File: ./HelloApp/Hello.java * From: Hello.idl * Date: Thu Jul 3 09:46:22 2000 * By: idltojava Java IDL 1.2 Nov 12 1997 12:23:47 */ package HelloApp; public interface Hello extends org.omg.CORBA.Object { String sayHello(); } 4. HelloHelper.java Esta clase proporciona una funcionalidad auxiliar, mtodo necesario para hacer la conversin de la referencia al objeto CORBA a sus tipos adecuados. /* * File: ./HelloApp/HelloHelper.java * From: Hello.idl * Date: Thu Jul 3 09:46:22 2000 * By: idltojava Java IDL 1.2 Nov 12 1997 12:23:47 */

package HelloApp; public class HelloHelper { // It is useless to have instances of this class private HelloHelper() { } public static void write(org.omg.CORBA.portable.OutputStream out, HelloApp.Hello that) { out.write_Object(that); } public static HelloApp.Hello read(org.omg.CORBA.portable.InputStream in) { return HelloApp.HelloHelper.narrow(in.read_Object()); } public static HelloApp.Hello extract(org.omg.CORBA.Any a) { org.omg.CORBA.portable.InputStream in = a.create_input_stream(); return read(in); } public static void insert(org.omg.CORBA.Any a, HelloApp.Hello that) { org.omg.CORBA.portable.OutputStream out = a.create_output_stream(); write(out, that); a.read_value(out.create_input_stream(), type()); } private static org.omg.CORBA.TypeCode _tc; synchronized public static org.omg.CORBA.TypeCode type() { if (_tc == null) _tc = org.omg.CORBA.ORB.init().create_interface_tc(id(), "Hello"); return _tc; } public static String id() { return "IDL:HelloApp/Hello:1.0"; } public static HelloApp.Hello narrow(org.omg.CORBA.Object that) throws org.omg.CORBA.BAD_PARAM { if (that == null) return null; if (that instanceof HelloApp.Hello) return (HelloApp.Hello) that; if (!that._is_a(id())) { throw new org.omg.CORBA.BAD_PARAM(); } org.omg.CORBA.portable.Delegate dup = ((org.omg.CORBA.portable.ObjectImpl)that)._get_delegate(); HelloApp.Hello result = new HelloApp._HelloStub(dup); return result; } }

5. HelloHolder.java Esta clase contiene un miembro de instancia pblica del tipo Hello. Proporciona las operaciones para trabajar con los argumentos que tiene CORBA pare no se pueden mapear fcilmente en la semntica de Java: /* * File: ./HelloApp/HelloHolder.java * From: Hello.idl * Date: Thu Jul 3 09:46:22 2000 * By: idltojava Java IDL 1.2 Nov 12 1997 12:23:47 */ package HelloApp; public final class HelloHolder implements org.omg.CORBA.portable.Streamable{ // instance variable public HelloApp.Hello value; // constructors public HelloHolder() { this(null); } public HelloHolder(HelloApp.Hello __arg) { value = __arg; } public void _write(org.omg.CORBA.portable.OutputStream out) { HelloApp.HelloHelper.write(out, value); } public void _read(org.omg.CORBA.portable.InputStream in) { value = HelloApp.HelloHelper.read(in); } public org.omg.CORBA.TypeCode _type() { return HelloApp.HelloHelper.type(); } }  Desarrollo del Cliente Configuracin

El cliente CORBA es el mismo que muchas aplicaciones Java, se importan los paquetes requeridos, declaramos la clase de la aplicacin, definimos el mtodo main y procuramos manejar cualquier excepcin. Paquetes requeridos Se necesita crear un nuevo fichero llamado HelloClient.java en el directorio del proyecto. Importaremos los paquetes necesarios: import HelloApp.*; // El paquete que contienes nuestros stubs. import org.omg.CosNaming.*; // HelloClient usar el servicio de nombrado. import org.omg.CORBA.*; // Necesario para todas las aplicaciones CORBA. La clase del cliente En el fichero HelloClient.java, declaramos la clase del cliente: public class HelloClient { // Aqu ir el mtodo main. } Mtodo main Cada aplicacin Java necesita un mtodo main, declarado dentro de la clase HelloClient: public static void main(String args[]) { // Ponga aqu el bloque try-catch. } Manejando las excepciones CORBA Todos los programas CORBA pueden lanzar excepciones del sistema CORBA en tiempo de ejecucin, se debe englobar toda la funcionalidad principal dentro de un bloque trycatch. Los programas CORBA lanzan excepciones siempre que ocurre un problema durante alguno de los procesos involucrados en la invocacin del servidor por parte del cliente. Nuestro manejador de excepciones simplemente imprime el nombre de la excepcin y la traza de la pila por la salida estndar, para ver qu cosas han ido mal. Dentro del main, pondremos el bloque try-catch: try { // Aada el resto del cdigo del cliente aqu. } catch(Exception e) {

System.out.println("ERROR : " + e); e.printStackTrace(System.out); } Crear un objeto ORB Un cliente CORBA necesita un objeto ORB local para realizar todo el trabajo de conversin de datos y comunicacin. Cada cliente instancia un objeto org.omg.CORBA.ORB y lo inicializa pasndole cierta informacin sobre s mismo. En el fichero HelloClient.java, dentro del bloque try-catch, declaramos e inicializamos una variable ORB: ORB orb = ORB.init(args, null); La llamada al mtodo init del ORB le pasa los argumentos de la lnea de comando, permitindole establecer ciertas propiedades en tiempo de ejecucin. Encontrar el Servidor Hello Una vez que la aplicacin tiene un ORB, puede preguntar al ORB para localizar el servicio que necesita. Un cliente CORBA tiene varias formas de obtener una referencia inicial; nuestra aplicacin cliente usar el COS Naming Service especificado por OMG y proporcionado por Java IDL. Obtener el Contexto Inicial de Nombrado Para usar el Servicio de Nombrado (Naming Service) se obtiene el contexto inicial de nombrado. En el bloque try-catch, bajo la inicializacin del ORB, se llamar a orb.resolve_initial_references para obtener una referencia a un objeto del servidor de nombres: org.omg.CORBA.Object objRef = orb.resolve_initial_references("NameService"); La cadena "NameService" est definida para todos los ORBs de CORBA. Cuando pasa esa cadena, el ORB devuelve el contexto inicial de nombrado, una referencia a un objeto del servidor de nombres. Ajustar la Referencia a Objeto Como con todas las referencias a objetos CORBA, objRef es un objeto CORBA genrico. Para usarlo como un objeto NamingContext (Contexto de Nombrado), se debe ajustarlo a su tipo adecuado. Aada la llamada para ajustarlo debajo de la sentencia anterior:

NamingContext ncRef = NamingContextHelper.narrow(objRef); El objeto ncRef es ahora del tipo org.omg.CosNaming.NamingContext y puede usarlo para acceder al servicio de nombrado y encontrar otros servicios. Encontrar un Servicio de Nombrado Los nombres pueden tener diferentes estructuras dependiendo de la implementacin del servicio de nombrado. CORBA maneja nombres complejos en forma de objetos NameComponent. Cada NameComponent tiene una sola parte, o elemento, del nombre. Un vector de objetos NameComponent pueden albergar un camino a un objeto completamente especificado, ya sea en un fichero o en un disco del sistema. Para encontrar el servidor Hello, se necesita un NameComponent para almacenar una cadena identificativa para el servidor Hello. Aada este cdigo directamente debajo de la llamada de ajuste: NameComponent nc = new NameComponent("Hello", ""); Esta instruccin establece el campo de identificacin de nc, el nuevo NameComponent, a "Hello" y el campo de tipo a una cadena vaca. Dado que el camino al objeto Hello tiene slo un elemento, crearemos un vector de un slo elemento de nc. El mtodo NamingContext.resolve necesita este vector para su trabajo: NameComponent path[] = {nc}; Pasamos el camino al mtodo de resolucin del servicio de nombres para obtener una referencia al servidor Hello y ajustarlo a un objeto Hello: Hello helloRef = HelloHelper.narrow(ncRef.resolve(path)); El mtodo de resolucin devuelve un objeto CORBA genrico cuando localizbamos el servicio de nombrado. Invocando la Operacin sayHello Las invocaciones en CORBA se parece a una llamada a un objeto local. Las complicaciones de ajuste de tipos de datos (marshaling y unmarshaling), ruteo y dems son completamente transparentes al programador del cliente. Dado que ya hay mucho hecho por el cdigo generado, la invocacin es realmente la parte ms fcil de la programacin en CORBA. Continuando en el cloque try-catch del fichero HelloClient.java, introduzca la siguiente invocacin debajo de la resolucin del nombre del servicio:

String hello = helloRef.sayHello(); Aada cdigo para imprimir el resultado de la invocacin a la salida estndar: System.out.println(hello); El fichero HelloClient.java completo es el siguiente: import HelloApp.*; // El paquete que contienes nuestros stubs. import org.omg.CosNaming.*; // HelloClient usar el servicio de nombrado. import org.omg.CORBA.*; // HelloClient usar el servicio de nombrado.

public class HelloClient { public static void main(String args[]) { try{ // Crea e inicializa el ORB ORB orb = ORB.init(args, null); // Obtiene el contexto de nombrado raiz org.omg.CORBA.Object objRef = orb.resolve_initial_references("NameService"); NamingContext ncRef = NamingContextHelper.narrow(objRef); // Resuelve la referencia al objeto en el nombrado NameComponent nc = new NameComponent("Hello", ""); NameComponent path[] = {nc}; Hello helloRef = HelloHelper.narrow(ncRef.resolve(path)); // Llama al objeto servidor Hello e imprime el resultado String hello = helloRef.sayHello(); System.out.println(hello); } catch(Exception e) { System.out.println("ERROR : " + e); e.printStackTrace(System.out); } } }  Desarrollo del Servidor Configuracin

La estructura de un programa servidor en CORBA es la misma que la de muchas aplicaciones en Java, importar los paquetes necesarios, declara la clase servidora, define el mtodo main y maneja cualquier excepcin que ocurra. Importando los paquetes requeridos Crearemos un fichero llamado HelloServer.java. Luego importaremos los paquetes necesarios para esta clase: import HelloApp.*; // El paquete que contienes nuestros stubs. import org.omg.CosNaming.*; // HelloServer usar el servicio de nombrado. import org.omg.CosNaming.NamingContextPackage.*; // Excepciones especiales. import org.omg.CORBA.*; // Necesario para todas las aplicaciones CORBA. Declarando la clase del servidor Declaramos la clase del servidor: public class HelloServer { // Aqu ir el mtodo main. }

Mtodo main Declaramos un mtodo main estndar: public static void main(String args[]) { // Ponga aqu el bloque try-catch. } Excepciones CORBA Los programas CORBA lanzan excepciones en tiempo de ejecucin cuando ocurre algn problema durante alguno de los procesos que se llevan a cabo durante la invocacin de servicio remoto (marshaling, unmarshaling, upcall). El manejador de excepciones simplemente imprime la excepcin y la traza de la pila. De esta forma podremos saber qu cosa ha ido mal. Dentro del bloque try-catch escribiremos: try { // Aada el resto del cdigo del servidor aqu.

} catch(Exception e) { System.err.println("ERROR: " + e); e.printStackTrace(System.out); } Crear un objeto ORB Como un cliente, un servidor CORBA tambin necesita un objeto ORB local. Cada servidor instancia un ORB y registra sus objetos sirvientes para que el ORB pueda encontrar el servidor cuando recibe una peticin para l. En el fichero HelloServer.java, dentro del bloque try-catch, declaramos e inicializamos la variable ORB: ORB orb = ORB.init(args, null); La llamada al mtodo init del ORB pasa los argumentos de la lnea de comando, permitindole establecer ciertas propiedades en tiempo de ejecucin. Administrando el Objeto Sirviente Un servidor es un proceso que instancia uno o varios objetos sirvientes. El sirviente implementa la interface generada por el programa idl2java y realiza el trabajo del interface. Nuestro HelloServer necesita un HelloServant.

Instanciando el Objeto Sirviente Dentro del bloque try-catch, justo debajo de la llamada a init, instanciaremos el objeto sirviente: HelloServant helloRef = new HelloServant(); Esta clase sirviente no est definida an, conectaremos el sirviente al ORB, para que el ORB pueda reconocer las llamadas a ste y enviarlas al sirviente correcto: orb.connect(helloRef); Definiendo la Clase Sirviente Al final de HelloServer.java, fuera de la clase HelloServer, defina la clase para el objeto sirviente. Para ello declaramos la clase:

class HelloServant extends _HelloImplBase { // Aada aqu el mtodo sayHello. } El sirviente es una subclase de _HelloImplBase as que hereda la funcionalidad general CORBA generada por el compilador. Declare el mtodo sayHello: public String sayHello() { // Aada aqu la implementacin del mtodo. } Y escribimos la implementacin del mtodo: return "\nHello World!!\n"; El fichero HelloServer.java completo es el siguiente: import HelloApp.*; // El paquete que contienes nuestros stubs. import org.omg.CosNaming.*; // HelloServer usar el servicio de nombrado. import org.omg.CosNaming.NamingContextPackage.*; // Excepciones especiales. import org.omg.CORBA.*; // Necesario para todas las aplicaciones CORBA. public class HelloServer { public static void main(String args[]) { try{ // Crea e inicializa el ORB ORB orb = ORB.init(args, null); // Crea al sriviente y lo registra con el ORB HelloServant helloRef = new HelloServant(); orb.connect(helloRef); // Obtiene el contexto de nombrado raiz org.omg.CORBA.Object objRef = orb.resolve_initial_references("NameService"); NamingContext ncRef = NamingContextHelper.narrow(objRef); // Liga el objeto al nombrado NameComponent nc = new NameComponent("Hello", ""); NameComponent path[] = {nc}; ncRef.rebind(path, helloRef); // Espera a peticiones de los clientes java.lang.Object sync = new java.lang.Object(); synchronized(sync){ sync.wait(); }

} catch(Exception e) { System.err.println("ERROR: " + e); e.printStackTrace(System.out); } } } class HelloServant extends _HelloImplBase { public String sayHello() { return "\nHello world!!\n"; } } Trabajando con el Nombramiento COS El servidor HelloServer trabaja con el servicio de nombramiento para hacer disponibles las operaciones del sirviente a los clientes. El servidor necesita una referencia al nombre del servicio, de manera que pueda registrarlo y asegurarse que las peticiones del interface Hello son dirigidas a su objeto sirviente. Obteniendo el Contexto Inicial de Nombramiento En el bloque try-catch, bajo la instanciacin del sirviente, llamaremos orb.resolve_initial_references para obtener una referencia al servicio de nombres: org.omg.CORBA.Object objRef = orb.resolve_initial_references("NameService"); La cadena NameService est definida para todos los ORBs de CORBA. Cuando usted pasa esa cadena, el ORB devuelve un contexto de nombramiento que es una referencia al servicio de nombres. a

Ajustando la Referencia a Objeto Como con todas las referencias a objetos CORBA, objRef es un objeto CORBA genrico. Para usarlo como un objeto NamingContext (Contexto de Nombrado), usted debe ajustarlo a su tipo adecuado. Aada la llamada para ajustarlo justamente debajo de la sentencia anterior: NamingContext ncRef = NamingContextHelper.narrow(objRef);

Registrar el Sirviente en el Servidor de Nombres Justo debajo de llamada al ajuste, cree un nuevo miembro NameComponent: NameComponent nc = new NameComponent("Hello", ""); Esta instruccin establece el campo de identificacin de nc, el nuevo NameComponent, a "Hello" y el campo de tipo a una cadena vaca. Dado que el camino al objeto Hello tiene slo un elemento, crearemos un vector de un slo elemento de nc. El mtodo NamingContext.resolve necesita este vector para su trabajo: NameComponent path[] = {nc}; Pasamos el camino y el objeto sirviente al servicio de nombramiento, ligando el objeto sirviente al identificador "Hello": ncRef.rebind(path, helloRef); Ahora, cuando el cliente llama a resolve("Hello") en el contexto inicial de nombramiento, el servicio de nombramiento devuelve un referencia al objeto sirviente Hello. Esperando a la peticin El servidor est preparado; simplemente necesita esperar a una peticin del cliente. Para hacer esto, introduzca el siguiente cdigo al final del bloque try-catch: java.lang.Object sync = new java.lang.Object(); synchronized(sync) { sync.wait(); } Esta forma de Object.wait hace que HelloServer permanezca (inactivo) hasta que venga una peticin del ORB. Como esto est en el main, despus de que se complete y sayHello termine, el servidor esperar otra vez.  Compilando y ejecutando la aplicacin "Hello World" Compilando el Cliente Compilamos el fichero HelloClient.java: $ javac HelloClient.java HelloApp/*.java Debera aparecer el fichero HelloClient.class en el directorio del proyecto.

Compilando el Servidor Compilamos el fichero HelloServer.java: $ javac HelloServer.java HelloApp/*.java Deberan aparecer los ficheros HelloServer.class y HelloServant.class. Ejecutando la Aplicacin Cliente/Servidor Desde una terminal, iniciamos el servidor de nombres de Java IDL: $ tnameserv -ORBInitialPort nameserverport Ntese que nameserverport es el puerto donde correr el servidor de nombres. Si usted no especifica este puerto, por defecto se elegir el 900. Si estamos en Unix hay que tener en cuenta que slo root puede ejecutar un proceso en un puerto menor que 1024. Por esta razn, recomendamos que se elija un puerto superior a 1024. Desde una seguna terminal iniciamos el servidor de Hello: $ java HelloServer -ORBInitialPort nameserverport -ORBInitialHost nameserverhost

Ntese que nameserverhost es el host donde el servidor de nombres IDL est ejecutndose. Usted puede omitir -ORBInitialHost nameserverhost si el servidor de nombres est ejecutndose en la misma mquina que el servidor de Hello. Tambin puede omitir ORBInitialPort nameserverport si el servidor de nombres se est ejecutando en el puerto asignado por defecto. Desde una tercera terminal ejecutamos el cliente de Hello: $ java HelloClient -ORBInitialHost nameserverhost -ORBInitialPort nameserverport nameserverhost es el host donde el servidor de nombres IDL est ejecutndose. Puede omitir -ORBInitialHost nameserverhost si el servidor de nombres est ejecutndose en la misma mquina que el cliente de Hello. Tambin puede omitir -ORBInitialPort nameserverport si el servidor de nombres se est ejecutando en el puerto asignado por defecto. El cliente imprime la cadena que le enva el servidor: Hello world!!

Recuerde parar tanto el proceso tnameserv como HelloServer despus de que el cliente termine satisfactoriamente.