Download Java RMI - Programación Distribuida y Tiempo Real

Programación Distribuida y Tiempo Real
RMI
1. RMI: Remote Method Invocation
1.1. RMI: programación con objetos/Java para sistemas distribuidos, extensión
del modelo de programación de Java para/en sistemas distribuidos
1.2. Es propio de Java (Sun-Oracle, RPC…)
1.3. Idea general de un sistema/arquitectura de objetos distribuidos
1.4. Cliente/Servidor (¡!)
1.5. Es muy similar en varios aspectos a RPC
1.6. Iniciaremos con lo mismo que hicimos con RPC
1.6.1. Todo en una JVM (no distribuido)
1.6.2. Un objeto sobre el que invocaremos un método en otra JVM
Programación Distribuida y Tiempo Real – Notas de Clase
2. Una clase “normal”
/*
* NoRemoteClass.java
*
Just one method: sendThisBack
*
*/
/* This class implements the interface with remote methods */
public class NoRemoteClass
{
protected NoRemoteClass()
{
super();
}
/* Remote method implementation */
public byte[] sendThisBack(byte[] data)
{
System.out.println("Data back to client");
return data;
}
}
Que es utilizada desde o es parte de una aplicación…
/*
* StartAndInvoke.java
*
a) Creates a NoRemoteClass object
*
b) Invokes the only one method
*/
public class StartAndInvoke
{
public static void main(String[] args)
{
NoRemoteClass noRemoteObj = new NoRemoteClass();
int bufferlength
byte[] buffer
= 100;
= new byte[bufferlength];
noRemoteObj.sendThisBack(buffer);
System.out.println("Done");
}
}
Programación Distribuida y Tiempo Real – Notas de Clase
2.1. RMI: Esquema general:
Comp. con servidor
Comp. con cliente
registry
3
Aplic. con obj. que invoca
remoto
2
Aplic. con obj. remoto
1
Interf. remoto
4
Objeto remoto
Llam. remoto
2.2. Interfaces, Clases, Exceptions, …
2.3. Ejemplo
2.3.1. IfaceRemoteClass: def. de los métodos a llamar de forma remota
2.3.2. RemoteClass: implementación de la clase con los remotos
2.3.3. StartRemoteObject: creación y registro del objeto invocable
2.3.4. AskRemote: búsqueda e invocación del objeto con métodos remotos
3. Abrir una terminal, a partir de aquí se considera que se está en $HOME, el signo
“>” identifica la línea de comandos de la terminal
4. El contenido de todos los .java se puede extraer directamente de esta guía
Programación Distribuida y Tiempo Real – Notas de Clase
5. Para que una clase tenga definidos métodos a ser invocados de manera remota
5.1. Se utiliza interface (solamente define, no implementa) ¿Por qué?
5.2. Se utiliza lo provisto por Java para RMI, Java RMI
5.3. La interface en IfaceRemoteClass.java define un sólo “método remoto”:
/*
* IfaceRemoteClass.java
* Interface defining only one method which can be invoked remotely
*
*/
/* Needed for defining remote method/s */
import java.rmi.Remote;
import java.rmi.RemoteException;
/* This interface will need an implementing class */
public interface IfaceRemoteClass extends Remote
{
/* It will be possible to invoke this method from an application in other JVM */
public byte[] sendThisBack(byte[] data) throws RemoteException;
}
5.3.1. Es una interface de Java: no tiene código ejecutable, solamente
declaraciones. Como lo indican los comentarios:
5.3.2. Los “import” son necesarios para definir métodos remotos
5.3.3. La “interface” necesitará una clase que la implemente
5.3.4. El método sendThisBack se podrá invocar de manera remota: desde
otra aplicación que se ejecuta en otra máquina virtual
5.4. Como “reglas generales” de cada interface con métodos remotos:
5.4.1. Debe extender Remote: extends Remote
5.4.2. Todos los métodos deben tener throws RemoteException
Programación Distribuida y Tiempo Real – Notas de Clase
5.5. Implementación de la interface:
/*
* RemoteClass.java
*
Just implements the RemoteMethod interface as an extension to
*
UnicastRemoteObject
*
*/
/* Needed for implementing remote method/s */
import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;
/* This class implements the interface with remote methods */
public class RemoteClass extends UnicastRemoteObject implements IfaceRemoteClass
{
protected RemoteClass() throws RemoteException
{
super();
}
/* Remote method implementation */
public byte[] sendThisBack(byte[] data) throws RemoteException
{
System.out.println("Data back to client");
return data;
}
}
5.5.1. Como en el caso anterior, hay un conjunto de declaraciones necesarias,
en este caso para una implementación con métodos remotos
5.5.2. Lo único que es propio de la implementación es el código del método:
{
System.out.println("Data back to client");
return data;
}
Muestra un mensaje en pantalla y retorna lo recibido como parámetro
Programación Distribuida y Tiempo Real – Notas de Clase
6. Hasta ahora no hay un objeto sobre el cual invocar un método, se necesita
6.1. Una aplicación que tenga la creación de un objeto de esta clase
6.2. Indicar (registrar) el objeto explícitamente como objeto remoto
La clase StartRemoteObject hace exactamente estas dos cosas:
/*
* StartRemoteObject.java
* Starts the remote object. More specifically:
*
1) Creates the object which has the remote methods to be invoked
*
2) Registers the object so that it becomes avaliable
*/
import java.rmi.registry.Registry;
import java.rmi.Naming;
/* REGISTRY_PORT
/* rebind
*/
*/
public class StartRemoteObject
{
public static void main (String args[])
{
try{
/* Create ("start") the object which has the remote method */
RemoteClass robject = new RemoteClass();
/* Register the object using Naming.rebind(...) */
String rname = "//localhost:" + Registry.REGISTRY_PORT + "/remote";
Naming.rebind(rname, robject);
} catch (Exception e) {
System.out.println("Hey, an error occurred at Naming.rebind");
e.printStackTrace();
System.out.println(e.getMessage());
}
}
}
La creación del objeto es estándar:
RemoteClass robject = new RemoteClass();
Registrar un objeto en realidad es asociar el objeto a una URL:
String rname = "//localhost:" + Registry.REGISTRY_PORT
Naming.rebind(rname, robject);
+ "/remote";
rname es un String que debería tener el formato de URL:
//host:port/dir
Y el número de puerto es provisto (estándar) por Registry
7. Con la interface y las dos clases de Java anteriores se tiene el “lado del servidor”
Programación Distribuida y Tiempo Real – Notas de Clase
8. Para el “lado del cliente”, se necesita una aplicación que:
8.1. Obtenga una referencia al objeto sobre el cual hacer RMI
8.2. Efectivamente haga la invocación
La clase AskRemote hace exactamente estas dos cosas:
/*
* AskRemote.java
*
a) Looks up for the remote object
*
b) "Makes" the RMI
*/
import java.rmi.Naming;
import java.rmi.registry.Registry;
/* lookup
/* REGISTRY_PORT
*/
*/
public class AskRemote
{
public static void main(String[] args)
{
/* Look for hostname and msg length in the command line */
if (args.length != 1)
{
System.out.println("1 argument needed: (remote) hostname");
System.exit(1);
}
try {
String rname = "//" + args[0] + ":" + Registry.REGISTRY_PORT + "/remote";
IfaceRemoteClass remote = (IfaceRemoteClass) Naming.lookup(rname);
int bufferlength
byte[] buffer
= 100;
= new byte[bufferlength];
remote.sendThisBack(buffer);
System.out.println("Done");
} catch (Exception e) {
e.printStackTrace();
}
}
}
Más específicamente: la obtención de la referencia se efectiviza con
RemoteMethod remote = (RemoteMethod) Naming.lookup(rname);
(notar el uso del String-URL, no creación de obj.). Y luego, la llamada remota es
remote.sendThisBack(buffer);
9. Para compilar todo
> javac *.java
Programación Distribuida y Tiempo Real – Notas de Clase
10. Para ejecutar el servidor
> rmiregistry &
> java StartRemoteObject
10.1. rmiregistry es el proceso que efectivamente realiza el registro, es decir:
10.1.1. El que contiene la referencia a partir de que en el servidor se ejecuta
Naming.rebind(rname, robject);
10.1.2. El que “responde” al requerimiento de búsqueda de la referencia al
objeto cuando se ejecuta en el cliente
Naming.lookup(rname);
11. Para ejecutar el cliente (en otra terminal)
> java AskRemote localhost
12. Preguntas inmediatas
12.1. ¿Qué tiene que ser necesariamente conocido en cada lado?
12.2. ¿Podrían haber clases que se desconozcan?
13. Otras preguntas: Transparencia
13.1. ¿Qué pasa con los parámetros?
14. Otras preguntas: Concurrencia
14.1. ¿Pueden existir invocaciones concurrentes?
14.2. ¿Pueden existir dos métodos concurrentes?
14.3. ¿Se puede controlar la concurrencia?
15. Otras preguntas: clases involucradas
15.1. Descarga dinámica de clases
15.2. Sin llegar a reflection o creación dinámica de clases
Programación Distribuida y Tiempo Real – Notas de Clase