Desarrollo del cliente
El código para implementar el cliente tiene dos partes claramente diferenciadas. En una primera se realiza todo el proceso necesario para inicializar CORBA y contactar con el objeto servidor CORBA a través de un servidor de nombres. En una segunda fase se pasa a utilizar este objeto CORBA como si fuera un objeto local al cliente, momento en el que veremos la auténtica potencia de CORBA. A continuación presentamos el código fuente del cliente:
// ============================================================
// = Ejemplo de cliente CORBA =
// ============================================================
//
// Tutorial de JavaORB (Paso 2)
//
public class Client
{
public static void main( String args[] )
{
// 1.
// Inicializacion del ORB
org.omg.CORBA.ORB orb = org.omg.CORBA.ORB.init(args,null);
// 2.
// Localizacion del NamingService
org.omg.CORBA.Object obj = null;
org.omg.CosNaming.NamingContext naming = null;
try
{
obj = orb.resolve_initial_references("NamingService");
naming = org.omg.CosNaming.NamingContextHelper.narrow(obj);
}
catch ( org.omg.CORBA.ORBPackage.InvalidName name )
{
System.out.println("No se ha podido obtener el NamingService");
System.exit(0);
}
// 3.
// Construccion del nombre del objeto Calculator
org.omg.CosNaming.NameComponent [] name = new org.omg.CosNaming.NameComponent[1];
name[0] = new org.omg.CosNaming.NameComponent();
name[0].id = "Calculator";
name[0].kind = "Example";
// 4.
// Localizacion de la referencia al objeto Calculator
// dentro del NamingService
try
{
obj = naming.resolve(name);
}
catch ( org.omg.CosNaming.NamingContextPackage.NotFound ex )
{
System.out.println("Objeto no encontrado en el NamingService");
System.exit(0);
}
catch ( org.omg.CosNaming.NamingContextPackage.CannotProceed ex )
{
System.out.println("No se ha podido continuar");
System.exit(0);
}
catch ( org.omg.CosNaming.NamingContextPackage.InvalidName ex )
{
System.out.println("Nombre invalido");
System.exit(0);
}
// 5.
// Narrow de la referencia al objeto
Calculator calc = CalculatorHelper.narrow(obj);
// 6.
// Utilizamos el objeto Calculator somo si fuera local
try
{
System.out.println("5 + 3 = " + calc.add(5,3) );
System.out.println("5 / 0 = " + calc.div(5,0) );
}
catch ( DivisionPorCero ex )
{
System.out.println("Interceptada intento de divisón por cero");
System.out.println("La division era "+ex.op1+" / "+ex.op2);
}
catch ( org.omg.CORBA.SystemException ex )
{
System.out.println("Interceptada una excepcion CORBA System");
System.out.println(ex.getMessage());
}
}
}
En el primer paso del ejemplo lo que se hace es inicializar el ORB para indicarle que vamos a utilizarle. En este momento se le pueden pasar parámetros al ORB de inicialización como la localización del servidor de nombres, qué puerto debe de utilizar el ORB etc. En nuestro caso no vamos a utilizar esta via de configuracion del ORB.
Una vez inicializado el ORB lo siguiente que hacemos es contactar con el servidor de nombres. No es indispnesable tener un servidor de nombres CORBA disponible para la aplicación, pero si suele ser muy útil su uso para centralizar todas las referencias a objetos dentro de un servicio común. Por ello mostramos su uso en este ejemplo ya que en cualquier uso de CORBA real, el servidor de nombres suele ser indispensable.
JavaORB trae en la herramienta un servidor de nombres. Para arrancarlo basta con ir al directorio bin de JavaORB y ejecutar sh naming. Recordar al lector que dentro de la variable CLASSPATH debe estar la libreria JavaORBv1_2_4.jar.
Una vez arrancando el servidor de nombres con la configuración estandar el ORB de JavaORB sabe localizarlo. Para obtener una referencia a dicha objeto utilizamos el método de la API del ORB resolve_initial_references("NamingService"). En este caso utilizamos esta función para obtener una referencia al servicio de nombres, pero también se utiliza este método para obtener otros objetos del ORB como el adaptador de objetos. Este método nos devuelve un objeto CORBA genérico, pero en realidad nosotros sabemos que es un servidor de nombres (NamingContext) por lo que utilizamos la función narrow() del objeto Helper del servidor de nombres para transformar de forma segura este objeto genérico CORBA en un servidor de nombres.
Este procedimiento narrow() lo vamos a utilizar de forma constante. Cada objeto CORBA tiene definido una clase de ayuda Helper con esta función, que permite comprobar si un objeto genérico CORBA es realmente de su clase.
A lo largo del ejemplo se capturan muchas excepciones que pueden ocurrir a la hora de interactuar con CORBA. Es mucho más seguro programar de esta forma ya que en todo momento podemos estra informados de lo que ha podido ocurrir, siendo nuestro código mucho más robusto.
Una vez que tenemos dentro de naming la referencia al objeto CORBA del servidor de nombres, lo que hacemos en el paso 3 es construir el nombre que tiene el objeto CORBA Calculator dentro del servidor de nombres. Este nombre lo habrá puesto allí anteriormente el servidor CORBA que arranque dicho objeto CORBA. Los nombres dentro del servidor de nombres tienen dos campos, un identificador y una clase. De esta forma es más sencillo agrupar a los objetos comunes dentro de una clase.
En el paso 4 es donde realmente se contacta con el servidor de nombres y a través del método resolve() obtenemos la referencia al objeto CORBA Calculator. De nuevo en esta llamada se capturan varias excepciones. Hay que recordar al lector que esta llamada ya va a viajar por CORBA a través de los ORB del cliente y del servidor de nombres, ORBs que pueden estar separados por Internet p.e. por lo que pueden ocurrir muchas incidencias en esta llamada. Aunque para nosotros como desarrolladores el trabajo de invocar la función sea como la llamada sobre una función de un objeto local, el proceso es mucho más complejo.
De nuevo tenemos que utilizar la función narrow() en el paso 5, pero en este caso utilizando el Helper de Calculator, ya que es esta clase la que sabe si un objeto genérico CORBA es o no es un objeto Calculator. En el caso de lo que sea devuelve el objeto CORBA, pero ya como un Calculator. Y una vez que tenemos este objeto CORBA lo podemos utilizar exactamente igual que si fuera un objeto local, tal y como podemos ver en el paso 6 en las operaciones calc.add(5,3) y calc.div(5,0). Lo más interesante de este paso es como una excepción que se genera en el objeto remoto CORBA viaja a través de los ORBs y es entregada al cliente. De esta forma el uso de excepciones dentro de CORBA también es transparente para el desarrollador. En este caso la excepción capturada es la de "DivisionPorCero" que recordamos al lector que definimos dentro de la interfaz IDL Calculator.
En el siguiente esquema el lector puede observar la arquitectura del ejemplo y los pasos dados para contactar con el objeto servidor:
Tutoriales
