Remote Method Invocation
2da. Clase del 19 de Junio
Programación Paralela y Distribuida
Pedro Chacín ([email protected])
Unidad Curricular
Programación paralela y distribuida
 Vinculación
con el Proyecto Nacional
Simón Bolívar (PPNS)
 Vinculación con el eje proyecto
Tecnologías de software
libre
El pueblo se apodera de
las tecnologías
Mejorando la plataforma
Software del gobierno
Incorporar la tecnología a la
Producción socialista
Incorporar a los venezolanos
Al sistema educativo, económico
Y social. (evitar exclusión)
Independencia tecnológica
Cooperación tecnológica sin
interdependencia
Objetivo
 Comprender
la tecnología de aplicaciones
distribuidas usando Java RMI
 Diseñar, compilar y programar una
aplicación simple usando tecnología Java
RMI
Definición.
•Remote Method Invocation.
•Exclusivo de Java *.
•Mecanismo/sistema que permite que un objeto ejecutándose en
un JVM llame a métodos de otro objeto que esta en una JVM
diferente.
•Para plataformas diferentes se necesitaría SOAP o CORBA.
•RMI proporciona el mecanismo para transferir información entre
procesos de diferentes máquinas.
Estructura.
• Formado básicamente por 2 programas remotos:
 Servidor. Crea objetos remotos. Referencia a ellos. Espera
por la solicitud de los clientes.
 Cliente. Obtiene referencia a los objetos remotos. Ejecuta
sus métodos.
• Mecanismo general de comunicación:
 Localización de objetos: rmiregitry
 Comunicación con objetos remotos. Control por parte de
RMI. Transparencia para el programador del cliente.
Una aplicación...
•
Pasos en los que se observa el desarrollo de una aplicación
distribuida RMI:
1. Se inicia el servidor y registra sus objetos y métodos a invocarse
en un servicio de nombramiento. Asocia un nombre con el objeto
remoto.
2. Se inicia el cliente y localiza los objetos y/o métodos a invocar de
manera remota en el directorio de nombres del servidor
obteniendo la referencia al objeto.
3. El cliente invoca a los métodos remotos mediante la referencia al
objeto obtenida. Espera por respuesta.
• Serialización de los datos para ser enviados.
• Invocación del método en el servidor.
4. Termina la ejecución del método en el servidor y se regresa el
valor de retorno serializado al cliente.
Esquema de
funcionamiento.
Especificación de RMI (en
Java).
• Interfaces, objetos y métodos remotos.
 Interfaces remotas:
 Heredan de java.rmi.Remote
 Lanzan excepción java.rmi.RemoteException.
 Objetos y métodos remotos.
Heredan de java.rmi.server.UnicastRemoteObject ó
 Heredan de java.rmi.server.Activatable.
 Paso de parámetros en RMI.
 Paso de objetos remotos.
 Paso de objetos locales.
 Transmisión de datos.
RMI Stub y Skeleton.
•
STUB: Es una representación local EN EL CLIENTE del objeto remoto.
o
El objeto que realiza una llamada remota invoca el método en el stub
“local”.
o
Implementa exactamente el mismo conjunto de interfaces remotas que
el objeto remoto.
o
Los pasos que realiza son:
1. Inicia una conexión con la JVM remota que contiene el objeto
remoto.
2. Escribe (serializa) y transmite los parámetros a la JVM remota.
3. Espera los resultados de la invocación remota.
4. Lee (deserializa) los valores de retorno o excepciones devueltas.
5. Devuelve el valor al objeto que inicio la llamada.
•
Skeleton: Es una representación local EN EL SERVIDOR del objeto remoto.
o
o
Es responsable de enviar la llamada a la implementación del objeto
remoto.
Pasos que realiza son:
1. Lee (deserializa) los parámetros del método remoto.
2. Invoca al método en la implementación del objeto remoto.
3. Escribe (serializa) y transmite el resultado.
A partir del JDK 1.2 (versión de Java 2) se ha introducido un protocolo
stub adicional que elimina la necesidad del uso de los “esqueletos”.
Registro de objetos remotos.
•
RMIRegistry: Se ejecuta en el servidor y es un objeto remoto
con un puerto conocido. Relaciona el objeto remoto con un
nombre.
o
El contacto directo se tiene con el stub proporcionado por
el objeto remoto.
o
Almacena internamente la etiqueta y el objeto stub en un
hashmap.
o
Devuelve el stub al cliente que solicito el objeto remoto.
o
En caso de no hacer uso de este ejecutable de Java se
encuentran la interfaz Registry y la clase LocateRegistry
(con sus métodos createRegustry y getRegistry).
Localización de objetos
remotos.
• Se realiza utilizando la clase java.rmi.Naming.
• Esta clase “construye” un objeto stub y lo asocia al objeto remoto del registro.
• Maneja principalmente dos parámetros para la mayoría de sus métodos
primordiales:

cadena que nombra al objeto (URL):
//host:puerto/nombre.
Stub
del objeto remoto.
• Hace uso de los siguientes métodos:

bind y rebind.

lookup.

unbind.

list.
Creación de una aplicación
distribuida.
1. Diseño e implementación de las componentes
(interfaz, servidor, cliente).
2. Compilar las fuentes y generar los stubs.
3. Hacer accesibles las clases a la red.
4. Iniciar la aplicación (registro y cliente - servidor).
Metas del sistema RMI de
Java.
• Proporcionar invocación remota de objetos que se encuentran
en JVM’s diferentes.
• Integrar el modelo de objetos distribuidos en Java de forma
natural.
• Intentar simplificar al máximo la escritura de aplicaciones
distribuidas.
• Preservar la seguridad proporcionada por Java.
• Proporcionar varias semánticas para las referencias de los
objetos remotos (persistentes, no persistentes y de "activación
retardada" ).
Bibliografía
recomendada
Java RMI
William Grosso
Editorial: O'Reilly
Primera Editición Octubre 2001
ISBN: 1-56592-452-5, 572 páginas
Disponible en http://www.iutllado.edu.ve/descargas/libro_java_rmi.pdf
Práctica
 Diseño
de una aplicación sencilla que usa
Java RMI para comunicar un cliente con
un servidor remoto.
 Procedimiento
inicial:
 Crear dos carpetas en c:\ llamadas


Cliente
Servidor
Crear un servidor RMI


Un servidor RMI consiste en definir un objeto remoto que va a ser
utilizado por los clientes. Para crear un objeto remoto, se define
una interfaz, y el objeto remoto será una clase que implemente
dicha interfaz. Veamos como crear un servidor de ejemplo mediante
3 pasos:
Definir el interfaz remoto
Cuando se crea un interfaz remoto:




El interfaz debe ser público.
Debe extender (heredar de) el interfaz java.rmi.Remote, para indicar
que puede llamarse desde cualquier máquina virtual Java.
Cada método remoto debe lanzar la
excepción java.rmi.RemoteException en su claúsula throws, además de
las excepciones que pueda manejar.
Veamos un ejemplo de interfaz remoto:
public interface MiInterfazRemoto extends java.rmi.Remote
{
public void miMetodo1() throws java.rmi.RemoteException;
public int miMetodo2() throws java.rmi.RemoteException;
}
Implementar el interfaz remoto
public class MiClaseRemota
extends java.rmi.server.UnicastRemoteObject
implements MiInterfazRemoto
{
public MiClaseRemota() throws java.rmi.RemoteException
{
// Código del constructor
}
public void miMetodo1() throws java.rmi.RemoteException
{
// Aquí ponemos el código que queramos
System.out.println("Estoy en miMetodo1()");
}
public int miMetodo2() throws java.rmi.RemoteException
{
return 5; // Aquí ponemos el código que queramos
}
public void otroMetodo()
{
// Si definimos otro método, éste no podría llamarse
// remotamente al no ser del interfaz remoto
}
public static void main(String[] args)
{
try
{
MiInterfazRemoto mir = new MiClaseRemota();
java.rmi.Naming.rebind("//" + java.net.InetAddress.getLocalHost().getHostAddress() +
":" + args[0] + "/PruebaRMI", mir);
}
catch (Exception e)
{
}
}
}
Crear un cliente RMI

Vamos ahora a definir un cliente que accederá a el/los objeto/s remoto/s
que creemos. Para ello seguimos los siguientes pasos:
Definir la clase para obtener los objetos remotos necesarios
La siguiente clase obtiene un objeto de tipo MiInterfazRemoto,
implementado en nuestro servidor:


public class MiClienteRMI
{
public static void main(String[] args)
{
try
{
MiInterfazRemoto mir = (MiInterfazRemoto)java.rmi.Naming.lookup("//" +
args[0] + “:" + args[1] + "/PruebaRMI");
// Imprimimos miMetodo1() tantas veces como devuelva miMetodo2()
for (int i=1;i<=mir.miMetodo2();i++) mir.miMetodo1();
}
catch (Exception e)
{
e.printStackTrace();
}
}
}
}
Compilar y ejecutar el servidor



Ya tenemos definido el servidor. Ahora tenemos que compilar sus
clases mediante los siguientes pasos:
Compilamos el interfaz remoto.
javac MiInterfazRemoto.java

Luego, compilamos las clases que implementen los interfaces. Y
para cada una de ellas generamos los ficheros Stub para mantener
la referencia con el objeto remoto, mediante el comando rmic:

javac MiClaseRemota.java
rmic -d . MiClaseRemota

No olvide copiar el objeto stub generado en la carpeta cliente


Para ejecutar el servidor, seguimos los siguientes pasos:
Se arranca el registro de RMI para permitir registrar y buscar
objetos remotos. El registro se encarga de gestionar un conjunto de
objetos remotos a compartir, y buscarlos ante las peticiones de los
clientes. Se ejecuta con la aplicación rmiregistry distribuida con
Java, a la que podemos pasarle opcionalmente el puerto por el que
conectar (por defecto, el 1099):

start rmiregistry 1234

Nota:Aparecerá una ventana vacía, no la cierre

Por último, se lanza el servidor:
java -Djava.rmi.server.hostname=127.0.0.1 MiClaseRemota 1234

 Compilar
y ejecutar el cliente
 Una vez que ya tenemos definido el
cliente, para compilarlo hacemos:
 javac
MiClienteRMI.java
 Luego,
para ejecutar el cliente hacemos:
 java MiClienteRMI 127.0.0.1 1234
Resultado
 Veremos
como al ejecutar el cliente, se
imprime en el servidor:
Descargar

Diapositiva 1