RMI - Ejemplo

Ejemplo 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.
  
  
  
  

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)
   {
   }
 }
}

• Como se puede observar, la clase MiClaseRemota implementa el interfaz MiInterfazRemoto que hemos definido previamente. Además, hereda de UnicastRemoteObject, que es una clase de Java que podemos utilizar como superclase para implementar objetos remotos.


• Luego, dentro de la clase, definimos un constructor (que lanza la excepción RemoteException porque también la lanza la superclase UnicastRemoteObject), y los métodos de la/las interfaz/interfaces que implemente.


• Finalmente, en el método main, definimos el código para crear el objeto remoto que se quiere compartir y hacer el objeto remoto visible para los clientes, mediante la clase Naming y su método rebind(...).

Nota: Hemos puesto el método main() dentro de la misma clase por comodidad. Podría definirse otra clase aparte que fuera la encargada de registrar el objeto remoto.

• Compilar y ejecutar el servidor

Ya tenemos definido el servidor. Ahora tenemos que compilar sus clases mediante los siguientes pasos:

• 
  
  
  
  • Compilamos el interfaz remoto. Además lo agrupamos en un fichero JAR para tenerlo presente tanto en el cliente como en el servidor:
  
  
  
  

javac MiInterfazRemoto.java
jar cvf objRemotos.jar MiInterfazRemoto.class

• 
  
  
  
  • Luego, compilamos las clases que implementen los interfaces. Y para cada una de ellas generamos los ficheros Stub y Skeleton para mantener la referencia con el objeto remoto, mediante el comando rmic:
  
  
  
  

set CLASSPATH=%CLASSPATH%;.\objRemotos.jar;.
javac MiClaseRemota.java
rmic -d . MiClaseRemota

Observamos en nuestro directorio de trabajo que se han generado automáticamente dos ficheros .class (MiClaseRemota_Skel.class y MiClaseRemota_Stub.class) correspondientes a la capa stub-skeleton de la arquitectura RMI.

• 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).
  
  
  
  

En el caso de Windows, se debe ejecutar:

start rmiregistry 1234

Y en el caso de Linux:

rmiregistry &

• 
  
  
  
  • Por último, se lanza el servidor:
  
  
  
  

java -Djava.rmi.server.hostname=127.0.0.1 MiClaseRemota 1234

• 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();
     }
   }
 }
}

Como se puede observar, simplemente consiste en buscar el objeto remoto en el registro RMI de la máquina remota. Para ello usamos la clase Naming y su método lookup(...).

• 
  
  
  
  • Compilar y ejecutar el cliente
  
  
  
  

Una vez que ya tenemos definido el cliente, para compilarlo hacemos:

set CLASSPATH=%CLASSPATH%;.\objRemotos.jar;.
javac MiClienteRMI.java

Luego, para ejecutar el cliente hacemos:

java MiClienteRMI 127.0.0.1 1234

Se debe poder acceder al fichero Stub de la clase remota. Para ello, o bien lo copiamos al cliente y lo incluimos en su CLASSPATH, o lo eliminamos del CLASSPATH del servidor e incluimos su ruta en el java.rmi.codebase del servidor (si no se elimina del CLASSPATH del servidor, se ignorará la opción java.rmi.codebase, y el cliente no podrá acceder al Stub).. Si echamos un vistazo a la ventana donde está ejecutándose el servidor RMI, veremos como se ha encontrado el objeto remoto y ejecutado sus métodos