&yPSXWR'LVWULEXLGR0HGLDQWH

50,
5HPRWH0HWKRG,QYRFDWLRQ
5HPRWH0HWKRG,QYRFDWLRQ

0RGHORGH REMHWRV
 0RGHORGHREMHWRVHQVLVWHPDVGLVWULEXLGRV

Máquina A Máquina B Máquina C

(OVXHxRGHWRGRVLVWHPDGLVWULEXLGR

Lo ideal sería tener un sistema distribuido orientado

a objetos que permita:

1)Invocar un método de un objeto que se localiza

en otra máquina exactamente de la misma
manera que si se encontrará en la misma
máquina

objetoDistante.metodo()

Tomado de “Java et les objets distribués”, Patrick Itey, INRIA-Sophia, France

 (OVXHxRGHWRGRVLVWHPDGLVWULEXLGR

‡  8WLOL]DUXQREMHWRGLVWDQWH2'VLQVDEHUGRQGH

VHHQFXHQWUDVLPSOHPHQWHVROLFLWDQGRVXGLUHFFLyQD
XQVHUYLFLRGHGLFDGR

REMHWR'LVWDQWH
6HUYLFLR'H1RPEUHVEXVFDPL2EMHWR

Tomado de “Java et les objets distribués”, Patrick Itey, INRIA-Sophia, France

(OVXHxRGHWRGRVLVWHPDGLVWULEXLGR

‡ 3RGHUSDVDUXQ2'FRPRSDUiPHWURGH
OODPDGDDXQPpWRGRORFDOyUHPRWR

UHVXOWDGR
REMHWR/RFDOPHWRGRREMHWR'LVWDQWH

UHVXOWDGR
REMHWR'LVWDQWHPHWRGRRWUR2EMHW'LVWDQWH

Tomado de “Java et les objets distribués”, Patrick Itey, INRIA-Sophia, France

 (OVXHxRGHWRGRVLVWHPDGLVWULEXLGR

‡ 3RGHUUHFLELUFRPRUHVXOWDGRGHXQDLQYRFDFLyQXQ
REMHWRTXHKDVLGRFUHDGRHQXQDPiTXLQDGLVWDQWH

2EMHWR'LVWDQWH 2EMHWR'LVWDQWHPHWRGR

Tomado de “Java et les objets distribués”, Patrick Itey, INRIA-Sophia, France

&RPXQLFDFLyQHQWUHREMHWRVUHPRWRV

-DYD9LUWXDO0DFKLQH -DYD9LUWXDO0DFKLQH

&OLHQW 5HPRWH
2EMHFW 7&3 2EMHFW
 /DVFDSDVGH50,

-DYD9LUWXDO0DFKLQH -DYD9LUWXDO0DFKLQH
&OLHQW 5HPRWH
2EMHFW 2EMHFW

6WXE 6NHOHWRQ

5HPRWH5HIHUHQFH/D\HU 5HPRWH5HIHUHQFH/D\HU
7&3
7UDQVSRUW/D\HU 7UDQVSRUW/D\HU

&RS\ULJKW‹$OH[&KDIIHH

$UTXLWHFWXUDGH-DYD50,
Capa de Aplicación
2EMHWR&OLHQWH 2EMHWR6HUYLGRU

Capa de Representantes
6WXE 6NHOHWRQ
Proxy

5HIHUHQFLD Capa de RMI 5HIHUHQFLD

5HPRWD 5HPRWD

Capa de Protocolo de
7UDQVSRUWH 7UDQVSRUWH
Comunicación (TCP/IP)

3URWRFRORVGH%DMR1LYHO
 &RPXQLFDFLyQHQWUHHO&OLHQWH\HO6HUYLGRU

2EMHWR&OLHQWH 2EMHWR6HUYLGRU

6WXE 6NHOHWRQ
Solicitud Cliente

5HIHUHQFLD 5HIHUHQFLD
Respuesta Servidor
5HPRWD 5HPRWD

7UDQVSRUWH 7UDQVSRUWH

3URWRFRORVGH%DMR1LYHO

$UTXLWHFWXUDGH-DYD50,
Capa de Aplicación . Objetos que implementan la aplicación. En general en este nivel
se distinguen dos tipos de agentes: los clientes, que son objetos que invocan métodos o
hacen peticiones a otros objetos remotos y los servidores, que son objetos que reciben
peticiones de otros objetos remotos.

Capa de Representantes (Proxy) . En esta capa se encuentran los objetos que

actúan como representantes locales de objetos remotos. Se encargan del empaquetado y
desempaquetado (marshalling y desmarshalling) de las invocaciones, argumentos y
resultados de métodos remotos. En RMI existen dos tipos de representantes: los stubs
del lado cliente y los skeletons del lado servidor.

Capa de Referencias Remotas . En esta capa se realiza la interpretación de las

referencias a objetos remotos, las referencias locales a stubs o skeletons se resuelven a
sus contrapartes remotas y estos datos, junto con los datos "empaquetados" (marshalled)
que contienen las invocaciones o los resultados de invocaciones, se pasan a la Capa de
Transporte.

Capa de Transporte . En esta capa se encuentra el protocolo de comunicación, que se

encarga de transportar los mensajes que intercambian los distintos objetos. RMI utiliza por
omisión el protocolo TCP/IP.
 7HFQRORJtDGH2EMHWRV

‡ +HUHQFLDGHWLSR9V+HUHQFLDGHFODVH

&ODVH 7LSR

-DYDH[WHQGV -DYDLPSOHPHQWV

6XE&ODVH 6XE7LSR

7HFQRORJtDGH2EMHWRV
‡ 3ROLPRUILVPR

&OLHQWH ,QWHUIDFH

-DYDLPSOHPHQWV

&ODVH &ODVH &ODVH

2EMHWRV
 ,QWHUIDFHVWXEVNHOHWRQ

5HPRWH,QWHUIDFH

LPSOHPHQWV LPSOHPHQWV

5HPRWH2EMHFW
&OLHQW 6WXE 6NHOHWRQ
6HUYHU

&RS\ULJKW‹$OH[&KDIIHH

3DWUyQ*HQHUDOSDUDOD,QYRFDFLyQ5HPRWD

&OLHQWH 6HUYLGRU

6WXE 6NHOHWRQ

,QIUDVWUXFWXUD

‡ /ODPDGD ‡ 6HUYLFLR
± (PSDFDUDUJXPHQWRV ± 5HFLELUGDWRV
± FRQYHUWLUDIRUPDWRGH ± 'HVHPSDFDU
UHG ± ,QYRFDUPpWRGR
± /RFDOL]DUHOVHUYLGRU ± (PSDFDUODUHVSXHVWD
± WUDQVPLWLUGDWRV ± WUDQVPLWLUGDWRV
 50,5HJLVWU\
‡ 50,UHJLVWU\HVXQVHUYLFLRGHQRPEUHVXELFDGRHQHOVHUYLGRU
TXHSHUPLWHTXHORVFOLHQWHVUHPRWRVREWHQHUXQDUHIHUHQFLDGH
XQREMHWRUHPRWR

‡ 3DUDHMHFXWDUHOUHJLVWU\HMHFXWHHOFRPDQGR
± UPLUHJLVWU\

‡ (OUHJLVWURXWLOL]DHOSXHUWRSRUGHIDXOW

(O6HUYLFLRGH1RPEUHVHQ50,

1DPLQJ HVXQDFODVHGHOSDTXHWHGH50,TXH
SURSRUFLRQDHOVHUYLFLRGHUHJLVWURGHREMHWRVUHPRWRV

‡ 3HUPLWHUHODFLRQDUXQQRPEUHWLSR85/FRPRSRUHMHPSOR
³UPLKRVWREMHFWQDPH´
FRQXQREMHWRUHPRWRKRVWHVHOQRPEUHR,3GHOD
PiTXLQDGRQGHVHXELFDHOREMHWR\REMHFWQDPH HVXQVWULQJ
6LVHRPLWHHOKRVWVHDVXPHTXHHVXQREMHWRORFDO
‡ 6HGHEHDJUHJDUXQQ~PHURGHSXHUWRVLHOVHUYLFLRGH
QRPEUHVQRIXHLQVWDODGRHQHOSXHUWR
³UPLKRVWREMHFWQDPH´
 /DVPDQHUDVGHXVDU1DPLQJ
(QHOVHUYLGRU
(OVHUYLGRUUHJLVWUDHOREMHWRUHPRWR
HelloImp obj = new HelloImpl();
Naming.rebind(“//myhost/HelloServer”, obj);

(QHOFOLHQWH

(OFOLHQWHREWLHQHXQDUHIHUHQFLDGHOREMHWRUHPRWRPHGLDQWHVXQRPEUH
+HOORREM +HOOR1DPLQJORRNXS´P\KRVW+HOOR6HUYHU´
1DPLQJORRNXSUHJUHVDXQWLSR2EMHFWSRUORTXHHOREMHWRREWHQLGRGHEH
FRQYHUWLUVHDODFODVH

7DEODGHQRPEUHV

2EMHWR
1DPLQJ 5HPRWR
³EDQFR´ $ 2EMHWR
5HPRWR
³FXHQWD´
2EMHWR &
³FXHQWD´ 5HPRWR
%
+RVWFVPW\LWHVPP[
 8VRGHODWDEOD

ORRNXS³UPLFVPW\LWHVPP[FXHQWD´

1DPLQJ
2EMHWR ³EDQFR´ 2EMHWR
&OLHQWH 5HPRWR
³FXHQWD´ 6HUYLGRU
5HIHUHQFLD ³FXHQWD´
UHPRWD
WHFFRP +RVWFVPW\LWHVPP[

0HWRGRVHVWiWLFRVGHODFODVH1DPLQJ
YRLG ELQG6WULQJ5HPRWH
%LQGVWKHQDPHWRWKHVSHFLILHGUHPRWHREMHFW
()*%+,-. OLVW6WULQJ
!"#$%&'()*%+,
!"#$%&'()*%+,-.
5HWXUQVDQDUUD\RIVWULQJVRIWKH85/VLQWKHUHJLVWU\
SXEOLF5HPRWH ORRNXS6WULQJ
5HWXUQVWKHUHPRWHREMHFWIRUWKH85/
SXEOLFYRLG UHELQG6WULQJ5HPRWH
5HELQGWKHQDPHWRDQHZREMHFWUHSODFHVDQ\H[LVWLQJ
ELQGLQJ
SXEOLFYRLG XQELQG6WULQJ
8QELQGWKHQDPH
 $UTXLWHFWXUD50,
&OLHQW9LUWXDO0DFKLQH 6HUYHU9LUWXDO0DFKLQH
&OLHQW 5HPRWH
2EMHFW

6NHOHWRQ
6WXE 6HUYHU

³)UHG´

5HJLVWU\9LUWXDO0DFKLQH

)OXMR50,
1. El servidor crea el objeto remoto
&OLHQW9LUWXDO0DFKLQH 6HUYHU9LUWXDO0DFKLQH
2. El servidor registra el objeto remoto
&OLHQW 5HPRWH
2EMHFW


6NHOHWRQ
6WXE 6HUYHU

³)UHG´

5HJLVWU\9LUWXDO0DFKLQH
 )OXMR50,

&OLHQW9LUWXDO0DFKLQH 6HUYHU9LUWXDO0DFKLQH
&OLHQW 5HPRWH
3. El cliente solicita el objeto al Registry
2EMHFW
4. El Registry regresa la referencia
remota
6NHOHWRQ
6WXE 6HUYHU
 

³)UHG´

5HJLVWU\9LUWXDO0DFKLQH

)OXMR50,

&OLHQW9LUWXDO0DFKLQH 6HUYHU9LUWXDO0DFKLQH
&OLHQW 5HPRWH
2EMHFW
 


6NHOHWRQ
6WXE 6HUYHU

5. El Cliente invoca el método del stub

6. El Stub se comunica con el skeleton
7. El Skeleton invoca el método del objeto remoto
³)UHG´

5HJLVWU\9LUWXDO0DFKLQH
 ,QWHUIDFHV2EMHWRV\0pWRGRV5HPRWRV

• RMI permite la comunicación entre objetos situados en

máquinas diferentes.
• Un objeto remoto vive en un Servidor.
• Cada objeto remoto implementa un interfaz remoto que
especifica cuales métodos pueden ser invocados por los
clientes.
• Los clientes pueden invocar métodos remotos casi
exactamente igual que se invocan métodos locales.

&UHDU$SOLFDFLRQHV'LVWULEXLGDVXWLOL]DQGR50,
Cuando se utiliza RMI para desarrollar una aplicación distribuida,
debemos seguir estos pasos generales:

• Diseñar e implementar los componentes de nuestra aplicación

distribuida.

• Compilar los Fuentes y generar stubs.

• Arrancar la Aplicación.
'LVHxDUHLPSOHPHQWDUORVFRPSRQHQWHVGHQXHVWUD
DSOLFDFLyQGLVWULEXLGD
• Definir los Interfaces Remotos.
Remotos Una interfaz remota especifica
los métodos que pueden ser llamados remotamente por un
cliente.

• Implementar los Objetos Remotos.

Remotos Los objetos remotos deben
implementar uno o varios interfaces remotos. La clase del objeto
remoto podría incluir implementaciones de otras interfaces locales
o remotas que sólo estarán disponibles localmente).

• Implementar los Clientes. Los clientes que utilizan objetos

remotos pueden ser implementados después de haber definido
las interfaces remotas.

&RPSLODU ORV )XHQWHV \ *HQHUDU VWXEV

VWXEV
Este es un proceso de dos pasos:

En el primer paso, se utiliza el compilador javac para

compilar los archivos fuentes de Java.

En el segundo paso es utilizar el compilador rmic para crear

los stubs de los objetos remotos.
$UUDQFDU OD $SOLFDFLyQ

Arrancar la aplicación incluye ejecutar 3 programas:

1) el registro de objetos remotos de RMI,
2) el servidor y
3) el cliente.

Look, a remote object.

No, Sire, it is but a local stub.

 (-(03/2

'LVHxDU XQD ,QWHUID] 5HPRWD

La interfaz define la parte que será accesible remotamente, esta se
define heredando del paquete java.rmi.Remote

// Hello.java:
import java.rmi.*;
public interface Hello extends Remote {
public String sayhello() throws RemoteException;
}
 ,PSOHPHQWDUOD,QWHUID]5HPRWD


$FRQWLQXDFLyQH[SORUDUHPRVODFODVHTXHLPSOHPHQWD
ODLQWHUID]+HOORTXHLPSOHPHQWDXQREMHWRUHPRWR

(VWDFODVHWDPELpQSURSRUFLRQDHOUHVWRGHOFyGLJRTXH
FRQILJXUDHOSURJUDPDVHUYLGRUXQPpWRGRPDLQ TXH

FUHDXQHMHPSODUGHOREMHWRUHPRWR

ORUHJLVWUDFRQODIDFLOLGDGGHQRPEUDGR\

FRQILJXUDXQFRQWURODGRUGHVHJXULGDG

&RPSRQHQWHVGHODLPSOHPHQWDFLyQGHOVHUYLGRU

'HFODUDU ORV ,QWHUIDFHV 5HPRWRV TXH HVWiQ VLHQGR ,PSOHPHQWDGRV

La clase que implementa el servidor se declara como:

public class Helloimpl extends UnicastRemoteObject

implements Hello

UnicastRemoteObject es una clase definida en el API público del

RMI, que puede ser utilizada como superclase para la
implementación de objetos remotos.
 &RPSRQHQWHVGHODLPSOHPHQWDFLyQGHOVHUYLGRU

3URSRUFLRQDU XQD ,PSOHPHQWDFLyQ SDUD FDGD 0pWRGR 5HPRWR

La clase para un objeto remoto proporciona implementaciones para

todos los métodos remotos especificados en los interfaces remotos.
La interfaz Hello contiene un solo método remoto, sayhello(),
que se implementa de esta forma:

public String sayhello () {return "Hello, World!";}

&RPSRQHQWHVGHODLPSOHPHQWDFLyQGHOVHUYLGRU

(OPpWRGRPDLQ GHO6HUYLGRU

(VWHPpWRGRHVXWLOL]DGRSDUDDUUDQFDUHOVHUYLGRU\
SRUORWDQWRQHFHVLWDKDFHUODLQLFLDOL]DFLyQQHFHVDULD
SDUDSUHSDUDUVHSDUDDFHSWDUOODPDGDVGHORVFOLHQWHV

&yPRHOPpWRGRPDLQ VHGHFODUDVWDWLFQRHVWi
DVRFLDGRFRQQLQJ~QREMHWRVLQRFRQODFODVH
+HOORLPSO
 &RPSRQHQWHVGHODLPSOHPHQWDFLyQGHOVHUYLGRU

&UHDUH,QVWDODUXQ&RQWURODGRUGH6HJXULGDG

Todos los programas que utilicen RMI deben instalar un

controlador de seguridad o el RMI no descargará las clases para
los objetos que se reciban como parámetros.

(O FRQWURODGRU GH VHJXULGDG GHWHUPLQD VL HO FyGLJR GHVFDUJDGR

WLHQH DFFHVR DO VLVWHPD GH DUFKLYRV ORFDO R SXHGH UHDOL]DU
FXDOTXLHU RWUD RSHUDFLyQ SULYLOHJLDGD

El servidor utiliza un ejemplo de controlador de seguridad

suministrado como parte del RMI, el RMISecurityManager.

if (System.getSecurityManager() == null) {
System.setSecurityManager(new RMISecurityManager());
}

&RPSRQHQWHVGHODLPSOHPHQWDFLyQGHOVHUYLGRU

3RQHU HO 2EMHWR 5HPRWR D 'LVSRVLFLyQ GH ORV &OLHQWHV

Crear un ejemplar de Helloimpl

Helloimpl h= new Helloimpl();

Este constructor llama al constructor de su superclase

UnicastRemoteObject, que exporta el objeto recién creado al
sistema RMI.

Antes de que un llamador pueda invocar un método de un objeto

remoto, debe obtener una referencia al objeto remoto.
 &RPSRQHQWHVGHODLPSOHPHQWDFLyQGHOVHUYLGRU

La clase Helloimpl crea un nombre para el objeto con la instrucción:

String name = “rmi://localhost/hello";

Este nombre incluye el nombre del host localhost, en el que se

están ejecutando el registro y el objeto remoto, y un nombre hello,
que identifica el objeto remoto en el registro. Luego está el código
necesario para añadir el nombre al registro RMI que se está
ejecutando en el servidor. Esto se hace con la sentencia:

Naming.rebind(name, h);

3URJUDPD 6HUYLGRU
public class Helloimpl extends UnicastRemoteObject implements Hello

{
public Helloimpl() throws RemoteException {
super();
}

public String sayhello () { return "Hello, World!"; }

public static void main (String args[]) {

if (System.getSecurityManager() == null) {
System.setSecurityManager(new RMISecurityManager());}

try {
String name = "//localhost/hello";
Helloimpl h= new helloimpl();
Naming.rebind(name, h);
System.out.println ("Hello Server ready.");
} catch (Exception e) {
System.err.println("Exception in helloimpl: " + e.getMessage());
e.printStackTrace();}
}
}
&UHDU XQ SURJUDPD FOLHQWH

Al igual que el servidor Helloimpl, el cliente empieza instalando un

controlador de seguridad. Esto es necesario porque RMI podría
descargar código en el cliente.

Después de llamar al controlador de seguridad, el cliente busca el

objeto remoto por su nombre en el registro del host remoto usando
el método Naming.lookup. Cuando se hace la búsqueda del
nombre, el código crea una URL que específica el host donde se
está ejecutando el servidor. El nombre pasado en la llamada a
Naming.lookup tiene la misma síntaxis URL que el nombre pasado
a la llamada Naming.rebind.

La busqueda se realiza por su nombre, se obtiene su referencia y

luego se llama a sus métodos. Esta operación se realiza de la
siguiente manera:

String name = “rmi://localhost /hello";

Hello h= (Hello) Naming.lookup (name);

Una vez que se dispone de la referencia al objeto, el cliente puede

invocar métodos exactamente como si el objeto fuese local

String message = h.sayHello ();

System.out.println ("helloclient : " + message);
3URJUDPD &OLHQWH
import java.rmi.*;
public class Helloclient {
public static void main(String args[]) {

if (System.getSecurityManager() == null) {
System.setSecurityManager(new RMISecurityManager());
}

try {
String name = "//localhost /hello";
Hello h= (Hello) Naming.lookup (name);
String message = h.sayhello();
System.out.println ("helloclient : " + message);
} catch (Exception e)
{
System.out.println ("Exception in main: " + e);
}
}
}

&RPSLODFLyQ \ HMHFXFLyQ
Se utiliza el compilador javac para compilar los archivos fuentes
de Java, los cuales contienen las implementaciones de los
interfaces remotos, las clases del servidor, y del cliente.

javac Helloclient.java
javac Hello.java
javac Helloimpl.java
 (MHFXFLyQGHOSURJUDPD
Una vez compilados y creados los stubs, es necesario ejecutar el registro
RMI, que como ya mencionamos permite a los clientes remotos obtener
una referencia a un objeto remoto por su nombre.
rmiregistry
Y por ultimo, ejecutar en otras ventanas el servidor y el cliente una de las
opciones siguientes:

java -Djava.security.policy=policy.all Helloimpl

D
java -Djava.security.policy=policy.all Helloclient

java Helloimpl
E
java Helloclient 9HUVLyQFRUWDGHORVFRPDQGRVDXWLOL]DU
FXDQGRHOFyGLJRQRXWLOL]D
³6HFXULW\0DQDJHU´

-DYD3ROLF\)LOH

‡ (Q-DYDODVDSOLFDFLRQHVGHEHQDFFHVDUXQOLVWDGH
SULYLOLHJLRV3DUDHVWRFRQVXOWDQODSROtWLFDGHVHJXULGDG
VHFXULW\SROLF\PHGLDQWHXQDUFKLYRSROLF\ILOH(QHO
VLJXLHQWHHMHPSORVHSHUPLWHQWRGRVORVSULYLOHJLRV\DTXH
HOFRQWHQLGRGHODUFKLYRSROLF\DOOHV

grant {
permission java.security.AllPermission;
};
 $1(;2

¢&yPRHVFULELUDSOLFDFLRQHVFRQ-DYD50,"
Definición de la
1 interfaz remota

Implementación de la
2 interfaz remota

(.java)

3 javac

(.class)
4 rmic Servidor
(.class)
Esqueleto
8 Cliente
usa Stub
(.class)
(.class)
(.java)
5 Arrancar RMIRegistry
9 javac

(.class) 6 Crear los objetos

Ejecutar
10 Cliente 7 Registrar los objetos

CLIENTE SERVIDOR
 $1(;2

6WHSVIRU'HYHORSLQJDQ50,6\VWHP

'HILQHWKHUHPRWHLQWHUIDFH
'HYHORSWKHUHPRWHREMHFWE\LPSOHPHQWLQJWKHUHPRWH
LQWHUIDFH
'HYHORSWKHFOLHQWSURJUDP
&RPSLOHWKH-DYDVRXUFHILOHV
*HQHUDWHWKHFOLHQWVWXEVDQGVHUYHUVNHOHWRQV
6WDUWWKH50,UHJLVWU\
6WDUWWKHUHPRWHVHUYHUREMHFWV
5XQWKHFOLHQW
 6WHS'HILQLQJWKH5HPRWH,QWHUIDFH

‡ 7RFUHDWHDQ50,DSSOLFDWLRQWKHILUVWVWHSLVWKHGHILQLQJ
RIDUHPRWHLQWHUIDFHEHWZHHQWKHFOLHQWDQGVHUYHUREMHFWV

/* SampleServer.java */
import java.rmi.*;

public interface SampleServer extends Remote

{
public int sum(int a,int b) throws RemoteException;
}

6WHS'HYHORSWKHUHPRWHREMHFWDQGLWVLQWHUIDFH

‡ 7KHVHUYHULVDVLPSOHXQLFDVWUHPRWHVHUYHU
‡ &UHDWHVHUYHUE\H[WHQGLQJjava.rmi.server.UnicastRemoteObject
‡ 7KHVHUYHUXVHVWKH50,6HFXULW\0DQDJHUWRSURWHFWLWVUHVRXUFHV
ZKLOHHQJDJLQJLQUHPRWHFRPPXQLFDWLRQ

/* SampleServerImpl.java */
import java.rmi.*;
import java.rmi.server.*;
import java.rmi.registry.*;

public class SampleServerImpl extends UnicastRemoteObject

implements SampleServer
{
SampleServerImpl() throws RemoteException
{
super();
}
 6WHS'HYHORSWKHUHPRWHREMHFWDQGLWVLQWHUIDFH

‡ ,PSOHPHQWWKHUHPRWHPHWKRGV
/* SampleServerImpl.java */
public int sum(int a,int b) throws RemoteException
{
return a + b;
}
}
‡ 7KHVHUYHUPXVWELQGLWVQDPHWRWKHUHJLVWU\WKHFOLHQW
ZLOOORRNXSWKHVHUYHUQDPH
‡ 8VHjava.rmi.Naming FODVVWRELQGWKHVHUYHUQDPH
WRUHJLVWU\,QWKLVH[DPSOHWKHQDPHFDOO³6$03/(
6(59(5´
‡ ,QWKHPDLQPHWKRGRI\RXUVHUYHUREMHFWWKH50,
VHFXULW\PDQDJHULVFUHDWHGDQGLQVWDOOHG

6WHS'HYHORSWKHUHPRWHREMHFWDQGLWVLQWHUIDFH

/* SampleServerImpl.java */
public static void main(String args[])
{
try
{
System.setSecurityManager(new RMISecurityManager());
//set the security manager

//create a local instance of the object

SampleServerImpl Server = new SampleServerImpl();

//put the local instance in the registry

Naming.rebind("SAMPLE-SERVER" , Server);

System.out.println("Server waiting.....");
}
catch (java.net.MalformedURLException me) {
System.out.println("Malformed URL: " + me.toString()); }
catch (RemoteException re) {
System.out.println("Remote exception: " + re.toString()); }
}
 6WHS'HYHORSWKHFOLHQWSURJUDP

‡ ,QRUGHUIRUWKHFOLHQWREMHFWWRLQYRNHPHWKRGVRQWKH
VHUYHULWPXVWILUVWORRNXSWKHQDPHRIVHUYHULQWKH
UHJLVWU\<RXXVHWKHjava.rmi.Naming FODVVWR
ORRNXSWKHVHUYHUQDPH
‡ 7KHVHUYHUQDPHLVVSHFLILHGDV85/LQWKHIURP
UPLKRVWSRUWQDPH
‡ 'HIDXOW50,SRUWLV
‡ 7KHQDPHVSHFLILHGLQWKH85/PXVWH[DFWO\PDWFKWKH
QDPHWKDWWKHVHUYHUKDVERXQGWRWKHUHJLVWU\,QWKLV
H[DPSOHWKHQDPHLV³6$03/(6(59(5´
‡ 7KHUHPRWHPHWKRGLQYRFDWLRQLVSURJUDPPHGXVLQJWKH
UHPRWHLQWHUIDFHQDPHremoteObjectDVSUHIL[DQG
WKHUHPRWHPHWKRGQDPHsumDVVXIIL[

6WHS'HYHORSWKHFOLHQWSURJUDP
import java.rmi.*;
public class SampleClient
{
public static void main(String[] args)
{
// set the security manager for the client
System.setSecurityManager(new RMISecurityManager());
//get the remote object from the registry
try
{
System.out.println("Security Manager loaded");
String url = "//localhost/SAMPLE-SERVER";
SampleServer remoteObject = (SampleServer)Naming.lookup(url);
System.out.println("Got remote object");
System.out.println(" 1 + 2 = " + remoteObject.sum(1,2) );
}
catch (RemoteException exc) {
System.out.println("Error in lookup: " + exc.toString()); }
catch (java.net.MalformedURLException exc) {
System.out.println("Malformed URL: " + exc.toString()); }
catch (java.rmi.NotBoundException exc) {
System.out.println("NotBound: " + exc.toString());
}
}
}
6WHS &RPSLOHWKH-DYDVRXUFHILOHV *HQHUDWH
WKHFOLHQWVWXEVDQGVHUYHUVNHOHWRQV
‡ $VVXPHWKHSURJUDPFRPSLOHDQGH[HFXWLQJDW
HOSLVRQaUPL
‡ 2QFHWKHLQWHUIDFHLVFRPSOHWHG\RXQHHGWR
JHQHUDWHVWXEVDQGVNHOHWRQFRGH7KH50,V\VWHP
SURYLGHVDQ50,FRPSLOHUrmicWKDWWDNHV\RXU
JHQHUDWHGLQWHUIDFHFODVVDQGSURFHGXUHVVWXEFRGH
RQLWVVHOI
> javac SampleServer.java
> javac SampleServerImpl.java
> rmic SampleServerImpl

> javac SampleClient.java

6WHS6WDUWWKH50,UHJLVWU\

‡ 7KH50,DSSOLFDWLRQVQHHGLQVWDOOWR5HJLVWU\$QGWKH
5HJLVWU\PXVWVWDUWPDQXDOE\FDOOrmiregisty
‡ 7KHrmiregistry XVXVHVSRUWE\GHIDXOW<RXFDQ
DOVRELQGUPLUHJLVWU\WRDGLIIHUHQWSRUWE\LQGLFDWLQJWKH
QHZSRUWQXPEHUDVrmiregistry <new port>

> rmiregistry

‡ 5HPDUN2Q:LQGRZV\RXKDYHWRW\SHLQIURPWKH
FRPPDQGOLQH
> start rmiregistry
6WHSV 6WDUWWKHUHPRWHVHUYHUREMHFWV 5XQWKH
FOLHQW
‡ 2QFHWKH5HJLVWU\LVVWDUWHGWKHVHUYHUFDQEHVWDUWHGDQG
ZLOOEHDEOHWRVWRUHLWVHOILQWKH5HJLVWU\
‡ %HFDXVHRIWKHJUDLQHGVHFXULW\PRGHOLQ-DYD\RX
PXVWVHWXSDVHFXULW\SROLF\IRU50,E\VHW
java.security.policy WRWKHILOHpolicy.all

> java –Djava.security.policy=policy.all

SampleServerImpl

> java –Djava.security.policy=policy.all SampleClient

-DYD3ROLF\)LOH

‡ ,Q -DYD  WKH MDYD DSSOLFDWLRQ PXVW ILUVW REWDLQ LQIRUPDWLRQ

UHJDUGLQJ LWV SULYLOHJHV ,W FDQ REWDLQ WKH VHFXULW\ SROLF\
WKURXJK D SROLF\ ILOH ,Q DERYH H[DPSOH ZH DOORZ -DYD
FRGH WR KDYH DOO SHUPLVVLRQV WKH FRQWDLQV RI WKH SROLF\ ILOH
SROLF\DOO LV

grant {
permission java.security.AllPermission;
};
 -DYD3ROLF\)LOH

1RZZHJLYHQDQH[DPSOHIRUDVVLJQLQJUHVRXUFHSHUPLVVLRQV

JUDQW^
SHUPLVVLRQMDYDLRILOH3HUPLVVLRQ³WPS ´³UHDG´³ZULWH´
SHUPLVVLRQMDYDQHW6RFNHW3HUPLVVLRQ
³VRPHKRVWVRPHGRPDLQFRP´´FRQQHFW´
SHUPLVVLRQMDYDQHW6RFNHW3HUPLVVLRQ³ ´´FRQQHFWUHTXHVW´
SHUPLVVLRQMDYDQHW6RFNHW3HUPLVVLRQ³ ´´FRQQHFW´
`