Sistemas distribuidos usando RMI

Los sistemas distribuidos se utilizan generalmente para distribuir carga en diferentes equipos. No es lo mismo que un cluster (existen varios tipos, cada uno con fines distintos), un cluster puede ser solo un caso de un sistema distribuido. En este contexto, uno puede, literalmente, dividir un sistema en partes que se pueden distribuir en distintas máquinas, máquinas reales o virtuales, o dentro de la misma máquina.

Pero y de qué sirve ? para qué dividir un sistema en varias partes ?. Las razones pueden ser variadas, pero seguramente todas tienen que ver con aumentar la velocidad de procesamiento, el agilizar la atención de clientes, disminuir la carga en el servidor principal, etc.

La idea general es que, por un lado se tienen clientes que esperan una atención y por otra un servidor que responde las peticiones, pero antes de responder, las peticiones se distribuyen a distintas máquinas de manera tal que cada una procesa una parte (o todo lo que pide un cliente) mientras que otro procesa otra parte (o a otro cliente). Esto impacta directamente en la velocidad de respuesta ya que no es un servidor el que se encarga de manejar todas las peticiones, sino que en realidad son varios.

Pero y cómo se desarrolla un sistema distribuido ? bueno, depende de la tecnología que utilizemos, pero en general es lo mismo. Un servidor implementa métodos que proveen servicios y se registran en el servidor como un servicio público el cuál puede ser accesado por los clientes.

Las tecnologías mas populares son Remoting de .NET y RMI de Java. También existe CORBA.

En esta instancia les quiero dar un ejemplo de RMI, mostrando los pasos o la "receta" a seguir. Hace un tiempo atrás, en este mismo blog, hice una guía de cómo hacer un sistema de pago online (nada real, solo virtual) al servicio de impuestos internos (SII) utilizando web services. Este ejemplo trata de lo mismo pero utilizando RMI en vez de web services. La base de datos la cambié de Derby a MySQL y el servidor de aplicaciones Glassfish no fue necesario.

En el link de RMI se explica cómo se utiliza pero la verdad para mi no fué tal cual sale explicado ahi, no se explica bien el tema del Stub que es parte escencial para generar un sistema distribuido con Java.

Lo primero que se debe hacer al momento de querer desarrollar un sistema distribuido (o cualquier tipo de sistema, despues de el desarrollo de requerimientos) es definir la arquitectura a utilizar. A continuación les mostraré un ejemplo de ésto:

Como se puede ver, al lado izquierdo se tienen dos clientes y al lado derecho un servidor. Este servidor posee una Interfaz que define los servicios a publicar y al lado se ve un Servicio Remoto, que en éste caso es una clase que implementa los métodos de la Interfaz.

La interfaz debe heredar de la clase Remote de java.rmi, mientras que la clase que implementa debe heredar de la clase UnicastRemoteObject de java.rmi.server.

A continuación se puede ver la interfaz InterfaceRemota:

package org.remoto;

import java.rmi.Remote;
import org.cliente.UsuarioBean;

/**
*
* @author metalklesk
*/
public interface InterfaceRemota extends Remote{

public String obtenerDeuda(String rut) throws java.rmi.RemoteException;

public String pagarDeuda(String rut, String monto) throws java.rmi.RemoteException;

public UsuarioBean obtenerUsuario(String rut) throws java.rmi.RemoteException;
}

y a continuación pueden ver la implementación de los métodos de la interfaz en la clase ServicioRemoto:

package org.remoto;

import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;
import org.cliente.UsuarioBean;
import org.logica.LogicaNegocio;

/**
*
* @author metalklesk
*/
public class ServicioRemoto extends UnicastRemoteObject implements InterfaceRemota{

private LogicaNegocio ln;

public ServicioRemoto() throws RemoteException{
ln = new LogicaNegocio();
}

public String obtenerDeuda(String rut) throws RemoteException {
String respuesta = ln.obtenerDeuda(rut);
return respuesta;
}

public String pagarDeuda(String rut, String monto) throws RemoteException {
String respuesta = ln.pagarDeuda(rut, monto);
return respuesta;
}

public UsuarioBean obtenerUsuario(String rut) throws RemoteException {
UsuarioBean usuario = ln.obtenerUsuario(rut);
return usuario;
}
}

La verdad, lo mas sano es separar en multicapas, de manera tal de que cuando se quiera modificar algo, solo afecte a la capa que corresponda siendo transparente para las demás en el sistema.

Lo siguiente es levantar el servicio, para ésto se necesita utilizar el método rebind de la clase Naming del package java.rmi. A continuación pueden ver el código de la clase Servicio que se encarga de ésto:

package org.principal;

import java.net.MalformedURLException;
import java.rmi.Naming;
import java.rmi.NotBoundException;
import java.rmi.RemoteException;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.configuracion.AccesoConfiguracion;
import org.remoto.ServicioRemoto;

/**
*
* @author metalklesk
*/
public class Servicio {

private ServicioRemoto servicio;

public Servicio() {
try {
servicio = new ServicioRemoto();
} catch (RemoteException ex) {
Logger.getLogger(Servicio.class.getName()).log(Level.SEVERE, null, ex);
System.exit(1);
}
}

public boolean iniciarServicio(){
try {
Naming.rebind((AccesoConfiguracion.getInstance()).getServicioRMI(), servicio);
return true;
} catch (RemoteException ex) {
Logger.getLogger(Servicio.class.getName()).log(Level.SEVERE, null, ex);
return false;
} catch (MalformedURLException ex) {
Logger.getLogger(Servicio.class.getName()).log(Level.SEVERE, null, ex);
return false;
}
}

public boolean pararServicio(){
try {
Naming.unbind((AccesoConfiguracion.getInstance()).getServicioRMI());
return true;
} catch (RemoteException ex) {
Logger.getLogger(Servicio.class.getName()).log(Level.SEVERE, null, ex);
return false;
} catch (NotBoundException ex) {
Logger.getLogger(Servicio.class.getName()).log(Level.SEVERE, null, ex);
return false;
} catch (MalformedURLException ex) {
Logger.getLogger(Servicio.class.getName()).log(Level.SEVERE, null, ex);
return false;
}
}

@Override
public void finalize(){
pararServicio();
}
}

El método rebind recibe dos parámetros, un String con el nombre del servicio (puede ser cualquier cosa) y el objeto que implementa los métodos a publicar.

Ya con eso estamos casi listos por el lado del servidor. Lo siguiente es crear un Stub, que es un archivo .class que se encarga de entablar la comunicación en la red con el cliente. Este Stub se crea usando el comando rmic, en éste caso es:

rmic org.remoto.ServicioRemoto

lo cuál crea el archivo ServicioRemoto_Stub.class. Es importante decir que el comando anterior se hace con los archivos .class, no los .java, no se confundan con eso. Lo otro que es importante es que se fijen en los packages. No vale entrar a la carpeta org/remoto y ejecutar ahí el comando, se debe respetar el package.

Ahora debemos ejecutar:

rmiregistry

y el servicio rmi ya está registrado en el servidor, por default en el puerto 1099 (se puede cambiar pasando el puerto como parámetro al comando anterior).

Ahora solo resta crear el cliente. Lo importante por el lado del cliente son dos cosas.
Primero se debe tener la interfaz InterfaceRemota ya que es el puente de comunicación con el servidor y además se necesita el Stub (el mismo que se creó en el lado del cliente).

Para comunicarnos con el servidor se tiene el siguiente código:

package org.datos;

import org.cliente.*;
import java.net.MalformedURLException;
import java.rmi.Naming;
import java.rmi.NotBoundException;
import java.rmi.RemoteException;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.configuracion.AccesoConfiguracion;
import org.remoto.InterfaceRemota;

/**
*
* @author metalklesk
*/
public class AccesoDatos {

private static AccesoDatos acceso = new AccesoDatos();
private static boolean instanciado = false;

private InterfaceRemota servicio;

public static synchronized AccesoDatos getInstance(){
if(!instanciado){
instanciado = true;
return acceso;
} else{
System.out.println("No se puede instanciar el acceso a datos mas de una vez");
return null;
}
}

public boolean conectar(){
try {
servicio = (InterfaceRemota)
Naming.lookup("rmi://" + (AccesoConfiguracion.getInstance()).getHost() + "/" + (AccesoConfiguracion.getInstance()).getService());
return true;

} catch (NotBoundException ex) {
Logger.getLogger(AccesoDatos.class.getName()).log(Level.SEVERE, null, ex);
return false;
} catch (MalformedURLException ex) {
Logger.getLogger(AccesoDatos.class.getName()).log(Level.SEVERE, null, ex);
return false;
} catch (RemoteException ex) {
Logger.getLogger(AccesoDatos.class.getName()).log(Level.SEVERE, null, ex);
return false;
}
}

public String obtenerNombreUsuario(String rut){
if(servicio != null){
try {
UsuarioBean ub = servicio.obtenerUsuario(rut);
String nombreCompleto = ub.getNombre() + " " + ub.getApellidoPaterno() + " " + ub.getApellidoMaterno();

return nombreCompleto;
} catch (RemoteException ex) {
Logger.getLogger(AccesoDatos.class.getName()).log(Level.SEVERE, null, ex);
return null;
}

} else {
return null;
}
}

public String obtenerDeuda(String rut){
if(servicio != null){
try {
return servicio.obtenerDeuda(rut);
} catch (RemoteException ex) {
Logger.getLogger(AccesoDatos.class.getName()).log(Level.SEVERE, null, ex);
return null;
}

} else {
return null;
}
}

public String pagarDeuda(String rut, String monto){
if(servicio != null){
try {
return servicio.pagarDeuda(rut, monto);
} catch (RemoteException ex) {
Logger.getLogger(AccesoDatos.class.getName()).log(Level.SEVERE, null, ex);
return null;
}

} else {
return null;
}
}
}

Como pueden ver, para conectarnos utilizamos el método lookup de la clase Naming. Se recibe como parámetro, el host del servidor seguido del nombre del servicio.

Ya con ésto tenemos un objeto para instanciar los métodos remotos como si fuera de forma local.
El último paso importante es copiar el Stub al cliente. Recuerden que el Stub creado en el servidor pertenece al package org.remoto, el cuál, en el caso del servidor contiene 3 archivos .class (InterfazRemota, ServicioRemoto, ServicioRemoto_Stub) mientras que en el caso del cliente solo debe contener 2 (InterfazRemota, ServicioRemoto_Stub). No tiene ningún sentido que, en el cliente, exista ServicioRemoto.class ya que ésta clase implementa los métodos de la interfaz y utiliza recursos del servidor para proveer los servicios a los clientes.

De esa forma creamos un servicio con RMI en un servidor y creamos un cliente que consume ese servicio.

A continuación pueden ver el diagrama de clases del servidor:



y el diagrama de clases del cliente:



Qué ventajas existen ? aparte de las ya mencionadas (velocidad, agilidad, etc.) se tiene que es muchísimo mas rápido que web services. Sin embargo no es mejor que web services. Cada uno tiene su utilidad.

RMI sirve para desarrollar distemas distribuidos, pero solo de la misma tecnología RMI a java, Remoting a .NET, no permiten integración pero es rápido.

Web Services sirve para integrar sistemas distribuidos de distintas tecnologías, facilmente se pueden unir sistemas .NET con sistemas Java, pero es mas lento.

Acá les dejo unas capturas del sistema funcionando correctamente.



Como siempre, me pueden pedir el código dejándome sus correos y con gusto les enviaré el ejemplo de vuelta, es llegar y ejecutar. Además incluye el código fuente (desarrollado en NetBeans 6.0) y un informe sobre el trabajo.

saludos!!!!


EDITADO!!!

Subí el código a un servidor para que puedan hacer la descarga sin necesidad de enviarme sus correos (así no tienen que esperar a que yo lea el correo para rebotarlo a ustedes), si tienen problemas para la descarga seguimos con el método tradicional del correo electrónico.

Descarga

saludos !!!