OBTENCION DE UN VALOR DE LA SERIE DE FIBONACCI MEDIANTE RMI

RMI (Java Remote Method Invocation) es un mecanismo ofrecido por Java para
invocar un mtodo de manera remota, lo cual nos permite poder crear applets ms
livianos con capacidad de resolver problemas ms grandes, ya que en vez de contener
todo el cdigo necesario para resolver un problema, simplemente tiene un mtodo de
invocacin hacia un mtodo remoto, el cual se encargara de resolver el problema.
Forma parte del entorno estndar de ejecucin de Java y proporciona un mecanismo
simple para la comunicacin de servidores en aplicaciones distribuidas basadas
exclusivamente en Java. Si se requiere comunicacin entre otras tecnologas debe
utilizarse CORBA o SOAP en lugar de RMI.
RMI se caracteriza por la facilidad de su uso en la programacin por estar
especficamente diseado para Java; proporciona paso de objetos por referencia (no
permitido por SOAP), recoleccin de basura distribuida (Garbage Collector distribuido)
y paso de tipos arbitrarios (funcionalidad no provista por CORBA), mediante lo cual,
podremos resolver problemas de mayor envergadura, debido a la flexibilidad en los
datos que se pueden trasmitir.
A travs de RMI, un programa Java puede exportar un objeto, con lo que dicho objeto
estar accesible a travs de la red y el programa permanece a la espera de peticiones en
un puerto TCP. A partir de ese momento, un cliente puede conectarse e invocar los
mtodos proporcionados por el objeto, mediante esto, establecemos una comunicacin,
solicitando e invocando a los mtodos, para resolver los problemas y luego que
devuelvan el resultado, teniendo as una gran facilidad de clculo, con el nico
inconveniente de depender de las velocidades de transmisin.
La invocacin se compone de los siguientes pasos:

Encapsulado (marshalling) de los parmetros (utilizando la funcionalidad de

serializacin de Java), mediante esto, podemos abstraer el paso de los datos,
encapsulando estos, y convirtiendo en un solo objeto que ser transmitido.

Invocacin del mtodo (del cliente sobre el servidor). El invocador se queda

esperando una respuesta luego de enviar los datos que utilizara el mtodo
invocado, es as que obtendremos la respuesta del clculo realizado por el
mtodo remoto que se encuentra en el servidor.

Al terminar la ejecucin, el servidor serializa el valor de retorno (si lo hay) y lo

enva al cliente, donde nuevamente se realiza el encapsulado, para enviar los
datos.
El cdigo cliente recibe la respuesta y contina como si la invocacin hubiera
sido local, ya que en su ejecucin, es como si hubiera realizado una lnea de

cdigo que le devolva un valor, solo que el clculo o mtodo, fue realizado de
forma remota.
La serie de Fibonacci es un problema clsico en el mbito de la matemtica, el cual es
una sumatoria de nmeros, que se inician en 0 y 1, donde cada nmero consiguiente es
la suma de sus 2 predecesores, es as que por ejemplo, una serie de Fibonacci con 10
dgitos seria: 0 1 1 2 3 5 8 13 21 34, podemos apreciar el proceso y pasar a explicarlo de
las siguiente manera:
-

El proceso inicia con un 0 y un 1

0 se suma a 1 y el resultado es 1

Se suma el nuevo nmero obtenido al que esta anterior a l, es decir 1 ms 1 que

es 2

Se contina este proceso hasta obtener la cantidad de valores deseados.

El cdigo en Java para la serie de Fibonacci es el siguiente:

public void recibirMensaje(String texto) throws RemoteException

{
int numero1, numero2;
numero2 = Integer.parseInt(texto);
ventana.anadirEntradas(texto);
/* for(int e=0;e<numero2;e++)
{
ventana.anadirEntradas("t");
}*/
int n = 0;
int f = fibonacci(n); //Mando llamar al Metodo
for(n=0; n<=numero2; n++){
f = fibonacci(n);
ventana.anadirEntradas(f + "");
RmiCliente.recibir(f+ "");
}

/*

if ("fer".equals(texto))
{

correcto");
}*/
}
/**
* @param args
*/

ventana.anadirEntradas("texto

public static int fibonacci(int n)

{
if ( n == 0 ){ //Caso Base
return 0;
}
else if ( n == 1){ //Caso Base
return 1;
}
else{
return fibonacci(n - 1) + fibonacci(n - 2);
//Metodo Recursivo
}
}

Luego, la idea es crear un Applet que al ejecutarse en la maquina local, nos pida un
nmero, que ser el valor de la serie de Fibonacci que ocupe esa posicin, por ejemplo
si el numero fuera 10, el resultado seria 34 que es el valor de la serie de Fibonacci que
ocupa la posicin 10, al juntar el cdigo de una comunicacin mediante RMI y el de la
serie de Fibonacci obtenemos lo siguiente:
CLIENTE
//RmiCliente.java
import java.rmi.*;
import java.rmi.registry.*;
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
/**
* @author casidiablo
*
*/
public class RmiCliente extends JFrame implements ActionListener
{
private JTextField cajaEnviar;
private JButton botonEnviar;
private JLabel estado;
private static InterfazReceptorMensajes rmiServidor;
private static Registry registro;
private static String direccionServidor = "192.168.1.15";
private static String puertoServidor = "3232";
public RmiCliente() {

super("Cliente RMI");
getContentPane().setLayout(new BorderLayout());
cajaEnviar = new JTextField();
cajaEnviar.addActionListener(this);
botonEnviar = new JButton("Enviar");
botonEnviar.addActionListener(this);
estado = new JLabel("Estado...");
getContentPane().add(cajaEnviar);
getContentPane().add(botonEnviar, BorderLayout.EAST);
getContentPane().add(estado, BorderLayout.SOUTH);

setSize(300, 100);
setVisible(true);

public void actionPerformed(ActionEvent e) {

if (!cajaEnviar.getText().equals("")) {
enviarMensaje(cajaEnviar.getText());
cajaEnviar.setText("");
}
}
private static void conectarseAlServidor() {
try {
// obtener el registro
registro =
LocateRegistry.getRegistry(direccionServidor,
(new
Integer(puertoServidor)).intValue());
// creando el objeto remoto
rmiServidor = (InterfazReceptorMensajes)
(registro
.lookup("rmiServidor"));
} catch (RemoteException e) {
e.printStackTrace();
} catch (NotBoundException e) {
e.printStackTrace();
}
}
private void enviarMensaje(String mensaje) {
estado.setText("Enviando " + mensaje + " a " +
direccionServidor + ":"
+ puertoServidor);
try {
// llamando el metodo remoto
rmiServidor.recibirMensaje(mensaje);
estado.setText("El mensaje se ha enviado!!!");
} catch (RemoteException re) {
re.printStackTrace();
}
}
static public void main(String args[]) {
JFrame.setDefaultLookAndFeelDecorated(true);

conectarseAlServidor();
RmiCliente ventana = new RmiCliente();
ventana.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
}

SERVIDOR

import
import
import
import

java.net.InetAddress;
java.rmi.*;
java.rmi.registry.*;
java.rmi.server.*;

import javax.swing.JFrame;
public class RmiServidor extends UnicastRemoteObject implements
InterfazReceptorMensajes {
private static GUIServidor ventana;
private int estePuerto;
private String estaIP;
private Registry registro;
public RmiServidor() throws RemoteException {
try {
// obtener la direccion de este host.
estaIP =
(InetAddress.getLocalHost()).toString();
} catch (Exception e) {
throw new RemoteException("No se puede obtener
la direccion IP.");
}
estePuerto = 3232; // asignar el puerto que se
registra
ventana.anadirEntradas("Conexion establecida
por...\nEsta direccion="
+ estaIP + ", y puerto=" + estePuerto);
try {
// crear el registro y ligar el nombre y objeto.
registro =
LocateRegistry.createRegistry(estePuerto);
registro.rebind("rmiServidor", this);
} catch (RemoteException e) {
throw e;
}
}

/*
* (non-Javadoc)
*
* @see
InterfazReceptorMensajes#recibirMensaje(java.lang.String)
*/
public void recibirMensaje(String texto) throws
RemoteException {
int numero1, numero2;
numero2 = Integer.parseInt(texto);
ventana.anadirEntradas(texto);
/* for(int e=0;e<numero2;e++)
{
ventana.anadirEntradas("t");
}*/
int n = 0;
int f = fibonacci(n); //Mando llamar al Metodo
for(n=0; n<=numero2; n++){
f = fibonacci(n);
ventana.anadirEntradas(f + "");
RmiCliente.recibir(f+ "");
}

/*

if ("fer".equals(texto))
ventana.anadirEntradas("texto

correcto");
}*/
}
/**
* @param args
*/

public static int fibonacci(int n)

{
if ( n == 0 ){ //Caso Base
return 0;
}
else if ( n == 1){ //Caso Base
return 1;
}
else{
return fibonacci(n - 1) + fibonacci(n - 2);
//Metodo Recursivo
}
}

public static void main(String[] args) {

JFrame.setDefaultLookAndFeelDecorated(false);
ventana = new GUIServidor();
ventana.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
try {
new RmiServidor();
} catch (Exception e) {
e.printStackTrace();
System.exit(1);
}
}
}