IMPLEMENTACION DE

CORBA EN JAVA
Integrantes:
Arancibia Zurita Angela Nataly
Barrientos Salazar Abel
Camacho Dorado Francisco Javier
Choque Polo Alexander
Diaz Valda Edward
Construcción de una aplicación CORBA
Descripción de la aplicación

 Se trata de implementar un programa cliente/servidor muy sencillo: un

Contador distribuido.
 Los clientes pueden consultar y modificar el valor del contador. También hay
operaciones para incrementar y decrementar en una unidad el valor del contador.
 La aplicación muestra el modo de invocación estático (stubs y skeletons generados
por el compilador IDL)
 El programa cliente invoca 1000 veces la operación incrementar sobre el contador
y al final muestra el tiempo medio de respuesta
Arquitectura de la aplicación
Especificación de la interfaz con IDL

// ClienteRemoto.idl
module ClienteRemoto{
interface ClienteRem
{
string Saludar(in string nombre);
};
};
Compilación de la interfaz

ClienteRemoto.idl

ClienteRem >idlj –fall ClienteRemoto.idl

_ClienteRemStub
ClienteRemPOA
ClienteRemHolder ClienteRem

ClienteRemHelper ClienteRemOperations
Código generado por el compilador IDL:
ClienteRem.java y ClienteRemOperations.java

package ClienteRemoto;

public interface ClienteRem extends ClienteRemOperations,

org.omg.CORBA.Object, org.omg.CORBA.portable.IDLEntity
{
} // interface ClienteRem

package ClienteRemoto;

public interface ClienteRemOperations

{
String Saludar (String nombre);
}
// interface ClienteRemOperations
 Código generado por el compilador IDL:
_ClienteRemStub.java (1)
package ClienteRemoto;

public class _ClienteRemStub extends org.omg.CORBA.portable.ObjectImpl implements

ClienteRemoto.ClienteRem

{
public String Saludar (String nombre) {
// ..
} // Saludar
// Type-specific CORBA::Object operations
private static String[] __ids = {
"IDL:ClienteRemoto/ClienteRem:1.0«
};
Código generado por el compilador IDL:
_ClienteRemStub.java (2)
public String[] _ids () {
return (String[])__ids.clone ();
}

private void readObject (java.io.ObjectInputStream s) throws java.io.IOException{

// …
}
private void writeObject (java.io.ObjectOutputStream s) throws java.io.IOException {
//..
}
} // class _ClienteRemStub
Código generado por el compilador IDL:
ClienteRemHelper.java (1)
package ClienteRemoto;

abstract public class ClienteRemHelper

{
private static String _id = "IDL:ClienteRemoto/ClienteRem:1.0";
public static void insert (org.omg.CORBA.Any a, ClienteRemoto.ClienteRem that)
{
//..
}
public static ClienteRemoto.ClienteRem extract (org.omg.CORBA.Any a) {
return read (a.create_input_stream ());
}
synchronized public static org.omg.CORBA.TypeCode type () {
//..
}
Código generado por el compilador IDL:
ClienteRemHelper.java (2)
public static ClienteRemoto.ClienteRem read (org.omg.CORBA.portable.InputStream
istream)
{
return narrow (istream.read_Object (_ClienteRemStub.class));
}
public static ClienteRemoto.ClienteRem narrow (org.omg.CORBA.Object obj) {
// ...
}
// ...
public static ClienteRemoto.ClienteRem unchecked_narrow (org.omg.CORBA.Object obj) {
//...
}
}
Código generado por el compilador IDL:
ClienteRemHolder.java (1)
package ClienteRemoto;

final class ClienteRemHolder implements org.omg.CORBA.portable.Streamable

{
public ClienteRemoto.ClienteRem value = null;
public ClienteRemHolder () {
}
public ClienteRemHolder (ClienteRemoto.ClienteRem initialValue)
{
value = initialValue;
}
Código generado por el compilador IDL:
ClienteRemHolder.java (2)
public void _read (org.omg.CORBA.portable.InputStream i)
{
value = ClienteRemoto.ClienteRemHelper.read (i);
}
public void _write (org.omg.CORBA.portable.OutputStream o)
{
ClienteRemoto.ClienteRemHelper.write (o, value);
}
public org.omg.CORBA.TypeCode _type ()
{
return ClienteRemoto.ClienteRemHelper.type ();
}
}
Código generado por el compilador IDL:
ClienteRemPOA.java (1)
package ClienteRemoto;
public abstract class ClienteRemPOA extends org.omg.PortableServer.Servant
implements ClienteRemoto.ClienteRemOperations, org.omg.CORBA.portable.InvokeHandler{
// Constructors
private static java.util.Hashtable _methods = new java.util.Hashtable ();
static
{
_methods.put ("Saludar", new java.lang.Integer (0));
}
public org.omg.CORBA.portable.OutputStream _invoke (String $method,
org.omg.CORBA.portable.InputStream in,
org.omg.CORBA.portable.ResponseHandler $rh){
//..
}
Código generado por el compilador IDL:
ClienteRemPOA.java (2)
// Type-specific CORBA::Object operations

private static String[] __ids = {

"IDL:ClienteRemoto/ClienteRem:1.0"};

public String[] _all_interfaces (org.omg.PortableServer.POA poa, byte[] objectId) {

return (String[])__ids.clone ();
}

public ClienteRem _this() {

//..
}
public ClienteRem _this(org.omg.CORBA.ORB orb) {
// ..
}
} // class ClienteRemPOA
Programación del Cliente

 El Cliente puede ser una clase Java con método main() o un applet.
 En general un Cliente realiza las siguientes funciones:
1) Inicializar el ORB
2) Obtener la referencia a un objeto CORBA que implemente la
interfaz deseada (en este ejemplo, ClienteRem)
 Usando el método string_to_object()

 Usando el servicio de Nombres (solución estándar)

3) Utilizar el objeto CORBA
Cliente.java (1)

import org.omg.CORBA.*;
import org.omg.CosNaming.*;
import org.omg.CosNaming.NamingContextPackage.*;
public class Cliente {
public static void main(String args[]) {
try{
ORB orb = ORB.init(args,null);
// obtener una referencia a NameService
org.omg.CORBA.Object objRef = orb.resolve_initial_references("NameService");
// las siguientes lineas nos permiten obtener una ref a un objeto remoto
NamingContextExt ncRef = NamingContextExtHelper.narrow(objRef);
Cliente.java (2)

// nombre del obj remoto

String nombre = "ClienteRemoto";
ClienteRemoto.ClienteRem impl =
ClienteRemoto.ClienteRemHelper.narrow(ncRef.resolve_str(nombre));
System.out.println(impl.Saludar(′′ Estudiante de Sistemas Distribuidos ′′));
}
catch (Exception e) {
System.out.println("ERROR : " + e);
e.printStackTrace(System.out);
}
}
}
Compilación del cliente

Para compilar el cliente el CLASSPATH tiene que indicar dónde encontrar las
clases del ORB y las generadas por el compilador de IDL
> javac Cliente.java
Implementación del servidor

El servidor consta de dos partes:

1) La implementación de una o varias interfaces IDL
 Clases que implementan las operaciones de las interfaces y que se
corresponden a objetos CORBA
 Hay dos maneras de implementar una interfaz:
• Por herencia de la clase interfacePOA
• Por delegación, usando una clase _tie_
2) El programa principal (main)
• Inicializa el ORB y POA
• Crea objetos que implementan interfaces
Implementación de la interfaz

 En este ejemplo se utiliza la herencia

 La implementación se realiza definiendo una clase de implementación que
tiene que hacer 2 cosas:
1) Heredar de la clase <interfazIDL>POA
• Esta clase la genera el compilador de IDL y proporciona el
skeleton
2) Implementar cada método de la interfaz
• Se pueden usar métodos auxiliares en la clase de
implementación de la interfaz
ClienteRemImpl.java

public class ClienteRemImpl extends ClienteRemoto.ClienteRemPOA

{
public ClienteRemImpl(){}
public String Saludar(String nombre){
return " Bienvenido "+nombre;
}
}
Implementación del servidor
Programa principal (main)
El programa principal (main) realiza las siguientes funciones:
1) Inicializar el ORB y el POA
2) Crear los objetos CORBA
• Al menos los que sean necesarios inicialmente (se pueden crear otros
dinámicamente)
3) Pasar el control al ORB
• Bucle de eventos
Servidor.java (1)
import org.omg.CORBA.ORB;
import org.omg.CosNaming.NameComponent;
import org.omg.CosNaming.NamingContextExt;
import org.omg.CosNaming.NamingContextExtHelper;
import org.omg.PortableServer.POA;
import org.omg.PortableServer.POAHelper;
public class Servidor{
public static void main(String[] args){
//inicializa orb
System.out.println("Iniciando");
try {
// crear e inicializar ORB
ORB orb = ORB.init(args, null);
// crear un objeto remoto
ClienteRemImpl impl = new ClienteRemImpl();
Servidor.java (2)

// obtener referencia rootpoa y activar el POAManager

POA rootpoa = POAHelper.narrow(orb.resolve_initial_references("RootPOA"));
rootpoa.the_POAManager().activate();

// obtener una referencia al objeto remoto

org.omg.CORBA.Object ref = rootpoa.servant_to_reference(impl);
ClienteRemoto.ClienteRem href =ClienteRemoto.ClienteRemHelper.narrow(ref);

// las siguientes lineas me permiten publicar un obj remoto

org.omg.CORBA.Object objRef = orb.resolve_initial_references("NameService");
NamingContextExt ncRef = NamingContextExtHelper.narrow(objRef);
Servidor.java (3)

// nombre con el cual voy a publicar mi objeto

String nombre = "ClienteRemoto";
NameComponent path[] = ncRef.to_name(nombre);
// publicar el objeto
ncRef.rebind(path, href);
// ejecutar el orb
orb.run();
} catch (Exception e) {
System.err.println("ERROR: " + e);
}
}
}
Prueba de la aplicación
1)Compilar todo
> javac *.java
-Esta operación se hace a las clases creadas por IDL y tambien a nuestras clases creadas
2) Arrancar el Corba
>orbd -ORBInitialPort 2500
-Donde 2500 es el puerto
3) Arrancar el servidor:
>java Servidor -ORBInitialPort 2500
4) Y ejecutar el cliente:
>java Cliente -ORBInitialPort 2500
Inicializa el ORB...
Consigue la referencia al objeto ClienteRem
> Que mandara un mensaje
 Puede ser interesante probar varios clientes a la vez.
 Algunos pueden ser aplicaciones y otros applets.
Resumen

La realización de una aplicación cliente/servidor con Java y CORBA requiere:

 Definir con IDL las interfaces que exporta el servidor
 Desarrollar el cliente usando los stubs generados por el compilador de IDL
 Implementar las interfaces y desarrollar el servidor utilizando los skeletons
generados por el compilador de IDL