## Desarrollar el Servidor Hello World

Esta lección presenta lo básico para escribir un servidor CORBA. Aquí está la versión completa de HelloServer.java.

### Realizar la Configuración Básica

> La estructura de un programa servidor CORBA es la misma que la mayoría de las aplicaciones Java. Importamos los paquetes necesarios, declaramos la clase servidor, definimos el método main, y recordamos manejar cualquier excepción.

> ### Importar los Paquetes Necesarios

> Arrancamos nuestro editor de texto y grabamos un nuevo fichero llamado HelloServer.java. Luego, importamos los paquetes que necesita la clase cliente:

> >     // The package containing our stubs.
> >     import HelloApp.*;
> >     // HelloServer will use the naming service.
> >     import org.omg.CosNaming.*;
> >     // The package containing special exceptions
> >     // thrown by the name service.
> >     import org.omg.CosNaming.NamingContextPackage.*;
> >     // All CORBA applications need these classes.
> >     import org.omg.CORBA.*;

> ### Declarar la Clases Servidor

> Declaramos la clase servidor:

> >     public class HelloServer {
> >         // Add the main method here in the next step.
> >     }

> ### Definir el método main

> Declaramos un método main estándard:

> >     public static void main(String args[]) {
> >         // Add the try-catch block here in the next step.
> >     }

> ### Manejar las Excepciones del Sistema de CORBA

> Como todos los programas CORBA pueden lanzar excepciones del sistema en el momento de la ejecución, situaremos toda la funcionalidad del método main dentro de un bloque try-catch. El manejador de excepciones sólo impleme la excepción y su pila en la slaida estándard para que podamos ver qué tipo de problema a ocurrido.

> Dentro de main, configuramos un bloque try-catch:

> >     try {
> >         // Add the rest of the HelloServer code here.
> >     } catch(Exception e) {
> >         System.err.println("ERROR: " + e);
> >         e.printStackTrace(System.out);
> >     }

> ### Crear un Objeto ORB

> Al igual que el cliente, un servidor CORBA necesita un objeto ORB local. Cada servidor ejemplariza un ORB y registra sus objetos sirvientes para que el ORB puede encontrar el servidor cuando recibe las invoaciones para él.

> Dentro del bloque try-catch de HelloServer.java, declaramos e inicializamos una variable ORB:

> >     ORB orb = ORB.init(args, null);

> La llamada al método init del objeto ORB pasa los argumentos de la línea de comandos del servidor, permitiéndonos configurar ciertas propiedades durante la ejecución.

### Manejar el Objeto Sirviente

> Un servidor es un proceso que ejemplariza uno o más objetos sirvientes. El sirviente implementa el interface generado por idltojava y realmente realiza el trabajo de las operaciones sobre el interface. Nuestro HelloServer necesita un HelloServant.

> ### Ejemplarizar el Objeto Sirviente

> Dentro del bloque try-catch, justo debajo de la llamada a init, ejemplarizamos el objeto sirviente:

> >     HelloServant helloRef = new HelloServant();

> Esta clase sirviente no está definida todavía; lo harmeos en un paso posterior. Luego conectamos el sirviente al ORB, para que el ORB pueda reconocer las invocaciones sobre él y pasarlas al sirviente correcto:

> >     orb.connect(helloRef);

> ### Definir la Clase Sirviente

> Al final del fichero HelloServer.java, y fuera de la clase HelloServer , definimos la clase para el objeto sirviente.
> 1. Declaramos la clase sirviente:

>    >     class HelloServant extends _HelloImplBase {
>    >         // Add the sayHello method here in the next step.
>    >     }

> 2. La clase sirviente es una subclase de _HelloImplBase por lo que hereda toda la funcionalidad CORBA generada por el compilador.
> 3. Declara el método sayHello:

>    >     public String sayHello() {
>    >         // Add the method implementation here in the next step.
>    >     }

> 4. Escribir la implementación del método sayHello:

>    >     return "\nHello World!!\n";

### Trabajar con el Nombrado COS

> El HelloServer funciona con el servicio de nombrado para hacer que las operaciones del objeto sirviente estén disponibles para los clientes. El servidor necesita un objeto referencia hacia el nombre del sevicio, para que pueda registrarse a sí mismo y asegurarse de que las llamadas al interface Hello se enrutan hacia su objeto sirviente.

> ### Obtener el Contexto de Nombrado Inicial

> En el bloque try-catch, debajo de la ejemplarización del sirviente, llamamos a orb.resolve_initial_references para obtener un objeto referencia hacia el nombre del servidor:

> >     org.omg.CORBA.Object objRef =
> >         orb.resolve_initial_references("NameService");

> El string NameService está dfinido para todos los ORBs de CORBA. Cuando pasamos este string, el ORB retorna un objeto de contexto de nombrado que es un objeto referencia para el nombre del servicio.

> ### Apuntar el Objeto Referencia

> Al igual que los objetos referencia CORBA, objRef es un objeto CORBA genérico. Para usarlo como un objeto NamingContext, debemos aputarle hacia su propio tipo. Añadimos la llamada a narrow justo debajo de la sentencia anterior:

> >     NamingContext ncRef = NamingContextHelper.narrow(objRef);

> Aquí podmeos ver el uso de una clase ayuda generada por idltojava, similar en función a HelloHelper. El objeto ncRef es ahora un org.omg.CosNaming.NamingContext y podemos usarlo para acceder al servicio de nombrado y registrar el servidor.

> ### Registrar el Sirviente con el Nombre del Servidor

> 1. Debajo de la llamada a narrow, creamos un nuevo miembro NameComponent:

>    >     NameComponent nc = new NameComponent("Hello", "");

> 2. Esta sentencia sonfigura el campo id de nc, del nuevo NameComponent, a "Hello" y el componten kind a un string vacío. Como el path de Hello tiene un sólo elemento, creamos el array de un elemento que NamingContext.resolve necesita para su trabajo:

>    >     NameComponent path[] = {nc};

> 3. Finalmente, pasamos el path y el objeto sirviente al servicio de nombrado, ocultando el objeto sirviente la identidad de "Hello":

>    >     ncRef.rebind(path, helloRef);

> Ahora, cuando el cliente llame a resolve("Hello") sobre el contexto de nombrado inicial, el servicio de nombrado devolverá un objeto referencia hacia el sirviente Hello .

### Esperar Llamadas

> El servidor está listo; sólo necesita esperar peticiones de los clientes. Para consegui esto, introducimos el siguiente código al final (pero dentro) del bloque try-catch:

> >     java.lang.Object sync = new java.lang.Object();
> >     synchronized(sync) {
> >         sync.wait();
> >     }

> Esta forma de Object.wait requiere que HelloServer permanezca vivo (aunque incosciente) hasta que vengan las llamadas desde el ORB. Como está dentro de main, después de que se complete una llamada y sayHello retorne, el servidor espera de nuevo.

Ozito