Invocación Remota de Métodos (RMI)

• Compilar el Ejemplo
• Construir un Fichero JAR con las Clases de Interfaces
• Construir las Clases del Servidor
• Construir las clases del Cliente

Compilar el Ejemplo

En un escenario del mundo real donde se desarrollara un servicio como el del motor de cálculo, un desarrollador querría crear un fichero JAR que contenga los interfaces Compute y Task para que los implementan las clases servidor y para que los utilicen los programas clientes.

Luego, un desarrollador (quizás el mismo que creo el fichero JAR con los interfaces) escribiría una implementación del interface Compute y desarrollaría ese servicio en una máquina disponible para los clientes.

Los desarrolladores de los programas clientes pueden utilizar los interfaces Compute y Task (contenidos en el fichero JAR) e independientemente desarrollar una tarea y un programa cliente que utilice un servicio Compute.

En esta página, aprenderemos cómo crear un fichero JAR, las clases del servidor, y las clases del cliente. Veremos como la clase Pi será descargada al servidor durante la ejecución. También veremos como el stub remoto ComputeEngine será descargado desde el servidor hasta el cliente durante la ejecución.

El ejemplo separa los interfaces, la implementación de los objetos remotos y el código del cliente en tres paquetes diferentes.

• compute (Los interfaces Compute y Task)
• engine (Implementación de la clase, el interface y el stub de ComputeEngine)
• client (la implementación del cliente ComputePi y de la tarea Pi)

Primero construiremos el fichero JAR para proporcionar los interfaces del servidor y del cliente a los desarrolladores.

 Construir un Fichero JAR con las Clases de Interfaces

Primero necesitamos compilar los ficheros fuente de los interfaces del paquete compute que construir un fichero JAR que contenga los ficheros class. Supongamos que el usuario waldo ha escrito estos interfaces particulares y ha situado los ficheros fuente en c:\home\waldo\src\compute (en UNIX sería, /home/waldo/src/compute). Con estos paths podemos utilizar los siguientes comandos para compilar los intefaces y crear el fichero JAR.

cd c:\home\waldo\src
javac compute\Compute.java 
javac compute\Task.java
jar cvf compute.jar compute\*.class

cd /home/waldo/src
javac compute/Compute.java 
javac compute/Task.java
jar cvf compute.jar compute/*.class

added manifest
adding: compute/Compute.class (in=281) (out=196) 
    	(deflated 30%)
adding: compute/Task.class (in=200) (out=164) 
    	(deflated 18%)

Ahora podemos distribuir el fichero compute.jar a los desarrolladores de las aplicaciones del cliente y del servidor para que puedan hacer uso de los interfaces.

En general, cuando cosntruimos las clases del servidor o del cliente con los compiladores javac y rmic, necesitaremos especificar donde deberían residir los ficheros de clase resultantes para que sean accesibles a la red. En este ejemplo, esta localización es, para Unix, /home/user/public_html/classes porque algunos servidores web permiten el acceso a public_html mediante una URL HTTP construida como http://host/~user/. Si nuestro servidor web no soporta esta convención, podríamos utilizar un fichero URL en su lugar. El fichero de URL toma la forma file:/home/user/public_html/classes/ en UNIX, o file:/c:\home\user\public_html\classes/ en Windows. También se puede seleccionar otro tipo de URL apropiado.

La accesibilidad en la red de los ficheros de clases permite al sistema RMI descargar código cuando sea necesario. En vez de definir su propio protocolo para descargar código, RMI utiliza un protocolo URL soportado por Java (por ejemplo, HTTP) para descargar el código. Observa que un servidor web completo y poderoso no necesita realizar esta descarga de fichero class. De hecho, un sencillo servidor HTTP proporciona toda la funcionalidad necesaria para hacer que las clases estén disponibles para su descarga en RMI mediante HTTP, puedes encontrar uno en.

ftp://java.sun.com/pub/jdk1.1/rmi/class-server.zip

 Construir las Clases del Servidor

El paquete engine sólo contiene la implementación de la clase del lado del servidor, ComputeEngine, la implementación del objeto remoto del interface Compute. Como ComputeEngine es una implementación de un interface remoto, necesitamos generar un stub para el objeto remoto para que los clientes puedan contactar con él.

Digamos que, ana, la desarrolladora de la clase ComputeEngine, ha situado ComputeEngine.java en el directorio c:\home\ana\src\engine, y ha colocado el fichero class para que lo usen los clientes en un subdirectorio de su directorio public_html, c:\home\ana\public_html\classes (en UNIX podría ser /home/ana/public_html/classes, accesible mendiante algún servidor web como http://host/~ana/classes/).

Asumamos que el fichero compute.jar esta localizado en el directorio c:\home\ana\public_html\classes. Para compilar la clase ComputeEngine, nuestro path de clases debe incluir el fichero compute.jar y el propio directorio fuente.

Aquí podemos ver cómo seleccionar la variable de entorno CLASSPATH.

set CLASSPATH=c:\home\ana\src;c:\home\ana\public_html\classes\compute.jar

setenv CLASSPATH /home/ana/src:/home/ana/public_html/classes/compute.jar

Ahora compilamos el fichero fuente ComputeEngine.java y generamos un stub para la clase ComputeEngine y coloca el stub accesible a la red. Para crear el stub (y opcionalmente los ficheros esqueleto) ejecutamos el compilador rmic sobre los nombres totalmente cualificados de las clases de implementación de los objetos remotos que deberían encontrarse en el path de clases. El comando rmic toma uno o más nombres de clase como entrada y produce, como salida, ficheros de clases con la forma ClassName_Stub.class (y opcionalmente ClassName_Skel.class). El fichero esqueleto no será generado si llamamos a rmic con la opción -v1.2. Esta opción sólo debería utilizarse si todos nuestros clientes van a utilizar el JDK 1.2 o posterior.

cd c:\home\ana\src
javac engine\ComputeEngine.java
rmic -d . engine.ComputeEngine
mkdir c:\home\ana\public_html\classes\engine
cp engine\ComputeEngine_*.class
    c:\home\ana\public_html\classes\engine

cd /home/ana/src
javac engine/ComputeEngine.java
rmic -d . engine.ComputeEngine
mkdir /home/ana/public_html/classes/engine
cp engine/ComputeEngine_*.class
    /home/ana/public_html/classes/engine

La opción -d le dice al compilador rmic que situe los ficheros de clases generados, ComputeEngine_Stub y ComputeEngine_Skel, en el directorio c:\home\ana\src\engine. También necesitamos poner estos ficheros accesibles en la red, por eso debemos copiarlos en el área public_html\classes.

Como el stub de ComputeEngine implementa el interface Compute, que referencia al interface Task, también necesitamos poner estas clases disponibles en la red. Por eso, el paso final es desempaquetar el fichero compute.jar en el directorio c:\home\ann\public_html\classes para hacer que los interfaces Compute y Task estén disponibles para su descarga.

cd c:\home\ana\public_html\classes
jar xvf compute.jar

cd /home/ana/public_html/classes
jar xvf compute.jar

created: META-INF/
extracted: META-INF/MANIFEST.MF
extracted: compute/Compute.class
extracted: compute/Task.class

 Construir las clases del Cliente

Asumamos que el usuario jones ha creado el código del cliente en el directorio c:\home\jones\src\client y colocará la clase Pi (para que sea descargada por el motor de cálculo) en el directorio accesible a la red c:\home\jones\public_html\classes (también disponible mediante algunos servidores como http://host/~jones/classes/). Las dos clases del lado del cliente están contenidas en los ficheros Pi.java y ComputePi.java en el subdirectorio client.

Para construir el código del cliente, necesitamos el fichero compute.jar que contiene los interfaces Compute y Task que utiliza el cliente. Digamos que el fichero compute.jar está situado en c:\home\jones\public_html\classes. Las clases del cliente se pueden construir así.

set CLASSPATH=c:\home\jones\src;c:\home\jones\public_html\classes\compute.jar
cd c:\home\jones\src
javac client\ComputePi.java
javac -d c:\home\jones\public_html\classes client\Pi.java

setenv CLASSPATH /home/jones/src:/home/jones/public_html/classes/compute.jar
cd /home/jones/src
javac client/ComputePi.java
javac -d /home/jones/public_html/classes client/Pi.java

Sólo necesitamos situar la clase Pi en el directorio public_html\classes\client (el directorio client lo crea el javac si no existe). Esto es así por esta clase es la única que necesita ser desacargada por la máquina virtual del motor de cálculo.

Ahora podemos ejecutar el servidor y luego el cliente.