Ejercicio RMI (3) sdsds
-
Upload
renan-fabricio -
Category
Documents
-
view
9 -
download
0
description
Transcript of 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
Universidad ORT - Arquitectura de Software
Práctico 2009
Creación del proyecto Java para la Aplicación Servidor
• En la IDE de NetBeans, crear un proyecto seleccionando de la categoría Java la opción Java
Application.
• Asignarle el nombre AplicacionServidorRMI 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 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);
Universidad ORT - Arquitectura de Software
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:
• 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 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
• En la IDE de NetBeans, crear un proyecto seleccionando de la categoría Java la opción Java
Application.
• Asignarle el nombre AplicacionClienteRMI 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 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
Universidad ORT - Arquitectura de Software
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.
• 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 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í:
Universidad ORT - Arquitectura de Software
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:
Universidad ORT - Arquitectura de Software
Práctico 2009
Universidad ORT - Arquitectura de Software
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.
Universidad ORT - Arquitectura de Software
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
Universidad ORT - Arquitectura de Software
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.