Ejercicio RMI (3) sdsds

Universidad ORT - Arquitectura de Software

Práctico 2009

Requisitos

• Versión 1.5.x de la JDK de Java (o superior)

• NetBeans como IDE de desarrollo

• Variable de entorno JAVA_HOME definida en el path apuntando al directorio de instalación

de Java.

Ejercicio de RMI

El objetivo es simular un ambiente de ejecución distribuido donde una aplicación instalada en una

“máquina” que actúa como cliente puede invocar funcionalidad de otra aplicación que reside en otra

“máquina” que actúa como servidor.

Se construirán 3 componentes:

• Interfaces distribuidas: contiene la interfaz Java remota con el método que será invocado por la aplicación cliente usando RMI.

• Aplicación cliente: contiene una clase Java que será la que consuma el método de la

interfaz remota

• Aplicación servidor: contiene una clase Java que implementa el método invocado por el

cliente y otra clase Java que “publica” la interfaz remota al cliente por RMI

Para cada componente se creará un proyecto en Netbeans con las clases Java correspondientes y se

generará un archivo JAR que se utilizará para ejecutar el ejercicio.

Creación del proyecto Java para Interfaces Distribuidas

• En la IDE de NetBeans, crear un proyecto seleccionando de la categoría Java la opción Java

Application.

• Asignarle el nombre InterfacesDistribuidas y definir la ubicación del proyecto en la carpeta D:\ArqSoft\Practico2009.

• Asegurarse de DESMARCAR las opciones Set as Main Project y Create Main Class y

finalizar.

• Dentro del proyecto creado, posicionarse en la carpeta Source Packages y crear un nuevo

Java Package con el nombre rmi

• Crear la interface Java con nombre Saludo en el package rmi y declarar un método getSaludo:

public interface Saludo extends Remote {

String getSaludo() throws RemoteException;

}

• Posicionarse en el proyecto y seleccionar la opción Clean and build del menú contextual. Luego pasar a la vista Files y verificar que en la estructura del proyecto se ha creado un

directorio dist que contiene el componente InterfacesDistribuidas.jar


Práctico 2009

Creación del proyecto Java para la Aplicación Servidor


Application.

• Asignarle el nombre AplicacionServidorRMI y definir la ubicación del proyecto en la carpeta D:\ArqSoft\Practico2009.


finalizar.

• Dentro del proyecto creado, posicionarse en la carpeta Libraries y seleccionar la opción add

project del menú contextual. Se abrirá un diálogo de Windows donde se mostrarán los

proyectos del workspace. Seleccionar el proyecto InterfacesDistribuidas y confirmar la

selección. Verificar que se haya agregado a la lista de librerías el archivo JAR que contiene

la interfaz remota Saludo.

• Posicionarse en la carpeta Source Packages y crear un nuevo Java Package con el nombre

com.negocio.servidor

• En el package anterior crear la siguiente clase SaludoImpl que implementa la interface

Saludo:

public class SaludoImpl implements Saludo {

/** Creates a new instance of SaludoImpl */

public SaludoImpl() {

}

public String getSaludo() throws RemoteException {

return "HOLA VERANOOOOOOO!!!!!!!!";

}

}

• Crear en el mismo package la clase ServidorSaludos que publicará la interfaz remota a

través de RMI y actuará de servidor de llamados del cliente:

public class ServidorSaludos {

/** Creates a new instance of ServidorSaludos */

public ServidorSaludos() {

}

public static void main(String args[]) {

try {

// Exporto el objeto remoto y obtengo un "stub" de la interface

SaludoImpl saludoImpl = new SaludoImpl();

Saludo stub = (Saludo) UnicastRemoteObject.exportObject(saludoImpl, 0);

// Creo una entrada en el Registry asociada al puerto 8885.

// Por omision se asume que el servidor es localhost.

Registry registry = LocateRegistry.createRegistry(8885);

// Asocio el stub del objeto remoto con un "key"

registry.bind("objetoSaludador", stub);


Práctico 2009

System.err.println("Server ready");

} catch (Exception e) {

System.err.println("Server exception: " + e.toString());

e.printStackTrace();

}

}

}

• Posicionarse en el proyecto y seleccionar la opción Properties del menú contextual. Se

abrirá un diálogo de Windows que muestra sobre la izquierda la lista de propiedades

configurables en el proyecto. Seleccionar de la lista la propiedad Run y definir como Main

Class del proyecto la clase ServidorSaludos:


directorio dist que contiene el componente AplicacionServidorRMI.jar. Nótese que también se generó un subdirectorio lib con el archivo JAR de interfaces remotas que

habíamos declarado en la librería del proyecto.

Creación del proyecto Java para la Aplicación Cliente


Application.

• Asignarle el nombre AplicacionClienteRMI y definir la ubicación del proyecto en la carpeta D:\ArqSoft\Practico2009.


finalizar.

• Dentro del proyecto creado, posicionarse en la carpeta Libraries y seleccionar la opción add

project del menú contextual. Se abrirá un diálogo de Windows donde se mostrarán los

proyectos del workspace. Seleccionar el proyecto InterfacesDistribuidas y confirmar la selección. Verificar que se haya agregado a la lista de librerías el archivo JAR que contiene

la interfaz remota Saludo.

• Posicionarse en la carpeta Source Packages y crear un nuevo Java Package con el nombre

com.negocio.cliente


Práctico 2009

• En el package anterior crear la clase PedidorSaludos que invocará el método de la interfaz

remota Saludo:

public class PedidorSaludos {

/** Creates a new instance of PedidorSaludos */

public PedidorSaludos() {

}

public static void main(String[] args) {

// Por parametro se especifica el host que oficia de server del objeto

// remoto. Si no se especifica, se asume localhost como server.

String host = (args.length < 1) ? null : args[0];

try {

// Obtengo una instancia de Registry que "apunta" al puerto 8885

// del host indicado como server

Registry registry = LocateRegistry.getRegistry(host, 8885);

// Solicito al registry que me retorne el stub del objeto remoto

// que esta mapeado con el key indicado.

Saludo saludo = (Saludo) registry.lookup("objetoSaludador");

// Invoco el metodo del objeto remoto a traves de su stub

String response = saludo.getSaludo();

System.out.println("Respuesta del saludador en " + host + ": " +

response);

} catch (Exception e) {

System.err.println("Client exception: " + e.toString());

e.printStackTrace();

}

}

}

• Posicionarse en el proyecto y seleccionar la opción Properties del menú contextual. Configurar la propiedad Run de igual forma que en la aplicación servidor, pero en este caso

la clase main será PedidorSaludos.


directorio dist que contiene el componente AplicacionClienteRMI.jar. Nótese que también se generó un subdirectorio lib con el archivo JAR de interfaces remotas que habíamos

declarado en la librería del proyecto.

Compilación y distribución

Verificar que la estructura del workspace haya quedado así:


Práctico 2009

Si bien se puede realizar la prueba con ambas aplicaciones Servidor y Cliente en la misma

máquina, es interesante comprobar el comportamiento de RMI distribuyendo el Cliente a otra máquina. Para ello alcanza con copiar el contenido del directorio dist del proyecto

AplicacionClienteRMI a una máquina y el contenido del directorio dist del proyecto AplicacionServidorRMI a otra.

Ejecución y prueba

• En la máquina que actúa de servidor:

o Abrir una línea de comandos DOS y posicionarse en el directorio donde se copió la

distribución de la aplicación servidor o Ejecutar el archivo JAR:

• En la máquina que actúa de cliente:

o Abrir una línea de comandos DOS y posicionarse en el directorio donde se copió la

distribución de la aplicación servidor

o Ejecutar el archivo JAR:


Práctico 2009


Práctico 2009

Ejercicio de Serializable

Extensión del Ejercicio anterior

El objetivo es mostrar el envío de parámetros en una invocación desde un cliente remoto a una clase

en el servidor.

• En el proyecto InterfacesDistribuidas crear la clase Parametro en el package rmi:

public class Parametro implements Serializable {

private String value;

public Parametro() {}

public String getValue() {

return value;

}

public void setValue(String value) {

this.value = value;

}

}

• Agregar a la interface remota Saludo el siguiente método:

void mostrarParametro(Parametro parametro) throws RemoteException;

• En el proyecto AplicacionServidorRMI implementar este método en la clase SaludoImpl:

public void mostrarParametro(Parametro parametro) throws RemoteException {

System.out.println("Soy el servidor que saluda!. Valor parámetro=" +

parametro.getValue());

}

• En el proyecto AplicacionClienteRMI modificar la clase PedidorSaludos para que llame al

nuevo método enviando como parámetro una instancia de Parametro:

Parametro param = new Parametro();

param.setValue("ORT");

saludo.mostrarParametro(param);

• Compilar los proyectos nuevamente y distribuir los JARs a las máquinas correspondientes.

• Repetir la ejecución de la prueba.


Práctico 2009

Ejercicio de Externalizable

El objetivo es mostrar de qué forma se puede realizar la serialización manual de los parámetros en

una invocación desde un cliente remoto a una clase en el servidor. Para esto, la clase que se serializa

debe implementar los métodos writeExternal(…) y readExternal(…).

Extensión del Ejercicio anterior

• En el proyecto InterfacesDistribuidas crear la clase ParametroExternalizado en el package

rmi:

public class ParametroExternalizado implements Externalizable {

Parametro param;

int entero = 0;

boolean bool = false;

// Constructor vacío de la clase

public ParametroExternalizado() {

this.param = null;

}

// Constructor de la clase

public ParametroExternalizado(Parametro param) {

this.param = param;

}

public boolean isBool() {

return bool;

}

public void setBool(boolean bool) {

this.bool = bool;

}

public int getEntero() {

return entero;

}

public void setEntero(int entero) {

this.entero = entero;

}

public Parametro getParam() {

return param;

}

public void setParam(Parametro param) {

this.param = param;

}

// Método que escribe la serialización public void writeExternal(ObjectOutput output) throws IOException {

output.writeBoolean(this.bool);

output.writeInt(this.entero);

if (this.param != null) {

output.writeBoolean(true);

output.writeObject(this.param);

} else {

output.writeBoolean(false);

}

}

// Método que permite leer el stream serializado


Práctico 2009

public void readExternal(ObjectInput input) throws IOException,

ClassNotFoundException {

this.bool = input.readBoolean();

this.entero = input.readInt();

if (input.readBoolean()) {

this.param = (Parametro) input.readObject();

} else {

this.param = null;

}

}

}

• Agregar a la interface remota Saludo el método que procesará el nuevo parámetro:

void mostrarParametroEx(ParametroExernalizado param) throws RemoteException;

• En el proyecto AplicacionServidorRMI implementar este método en la clase SaludoImpl:

public void mostrarParametroEx(ParametroExernalizado param) throws RemoteException {

System.out.println("Booleano: " + param.isBool());

System.out.println("Entero: " + param.getEntero());

if (param.getParam() != null) {

System.out.println("Value: " + param.getParam().getValue());

} else {

System.out.println("Value: null");

}

}

• En el proyecto AplicacionClienteRMI modificar la clase PedidorSaludos para que llame al nuevo método enviando como parámetro una instancia de ParametroExternalizado:

ParametroExernalizado ex = new ParametroExernalizado();

ex.setBool(false);

ex.setEntero(123);

ex.setParam(param);

saludo.mostrarParametroEx(ex);

• Compilar los proyectos nuevamente y distribuir los JARs a las máquinas correspondientes.

• Repetir la ejecución de la prueba.

Ejercicio RMI (3) sdsds

Documents

Transcript of Ejercicio RMI (3) sdsds