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:
