Download Cómputo Distribuido Mediante RMI (Remote method Invocation

&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
&OLHQW
2EMHFW
-DYD9LUWXDO0DFKLQH
7&3
5HPRWH
2EMHFW
/DVFDSDVGH50,
-DYD9LUWXDO0DFKLQH
-DYD9LUWXDO0DFKLQH
&OLHQW
2EMHFW
5HPRWH
2EMHFW
6WXE
6NHOHWRQ
5HPRWH5HIHUHQFH/D\HU
5HPRWH5HIHUHQFH/D\HU
7UDQVSRUW/D\HU
7&3
7UDQVSRUW/D\HU
&RS\ULJKW‹$OH[&KDIIHH
$UTXLWHFWXUDGH-DYD50,
Capa de Aplicación
2EMHWR6HUYLGRU
2EMHWR&OLHQWH
Capa de Representantes
6WXE
Proxy
5HIHUHQFLD
5HPRWD
Capa de RMI
6NHOHWRQ
5HIHUHQFLD
5HPRWD
Capa de Protocolo de
7UDQVSRUWH
Comunicación (TCP/IP)
3URWRFRORVGH%DMR1LYHO
7UDQVSRUWH
&RPXQLFDFLyQHQWUHHO&OLHQWH\HO6HUYLGRU
2EMHWR6HUYLGRU
2EMHWR&OLHQWH
6WXE
Solicitud Cliente
5HIHUHQFLD
5HPRWD
Respuesta Servidor
6NHOHWRQ
5HIHUHQFLD
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
2EMHWRV
&ODVH
,QWHUIDFHVWXEVNHOHWRQ
5HPRWH,QWHUIDFH
LPSOHPHQWV
&OLHQW
6WXE
LPSOHPHQWV
6NHOHWRQ
5HPRWH2EMHFW
6HUYHU
&RS\ULJKW‹$OH[&KDIIHH
3DWUyQ*HQHUDOSDUDOD,QYRFDFLyQ5HPRWD
&OLHQWH
6HUYLGRU
6WXE
6NHOHWRQ
,QIUDVWUXFWXUD
‡ /ODPDGD
± (PSDFDUDUJXPHQWRV
± FRQYHUWLUDIRUPDWRGH
UHG
± /RFDOL]DUHOVHUYLGRU
± WUDQVPLWLUGDWRV
‡ 6HUYLFLR
± 5HFLELUGDWRV
± 'HVHPSDFDU
± ,QYRFDUPpWRGR
± (PSDFDUODUHVSXHVWD
± WUDQVPLWLUGDWRV
50,5HJLVWU\
‡ 50,UHJLVWU\HVXQVHUYLFLRGHQRPEUHVXELFDGRHQHOVHUYLGRU
TXHSHUPLWHTXHORVFOLHQWHVUHPRWRVREWHQHUXQDUHIHUHQFLDGH
XQREMHWRUHPRWR
‡ 3DUDHMHFXWDUHOUHJLVWU\HMHFXWHHOFRPDQGR
± UPLUHJLVWU\
‡ (OUHJLVWURXWLOL]DHOSXHUWRSRUGHIDXOW
(O6HUYLFLRGH1RPEUHVHQ50,
1DPLQJ HVXQDFODVHGHOSDTXHWHGH50,TXH
SURSRUFLRQDHOVHUYLFLRGHUHJLVWURGHREMHWRVUHPRWRV
‡ 3HUPLWHUHODFLRQDUXQQRPEUHWLSR85/FRPRSRUHMHPSOR
³UPLKRVWREMHFWQDPH´
FRQXQREMHWRUHPRWRKRVWHVHOQRPEUHR,3GHOD
PiTXLQDGRQGHVHXELFDHOREMHWR\REMHFWQDPH HVXQVWULQJ
6LVHRPLWHHOKRVWVHDVXPHTXHHVXQREMHWRORFDO
‡ 6HGHEHDJUHJDUXQQ~PHURGHSXHUWRVLHOVHUYLFLRGH
QRPEUHVQRIXHLQVWDODGRHQHOSXHUWR
³UPLKRVWREMHFWQDPH´
/DVPDQHUDVGHXVDU1DPLQJ
(QHOVHUYLGRU
(OVHUYLGRUUHJLVWUDHOREMHWRUHPRWR
HelloImp obj = new HelloImpl();
Naming.rebind(“//myhost/HelloServer”, obj);
(QHOFOLHQWH
(OFOLHQWHREWLHQHXQDUHIHUHQFLDGHOREMHWRUHPRWRPHGLDQWHVXQRPEUH
+HOORREM +HOOR1DPLQJORRNXS´P\KRVW+HOOR6HUYHU´
1DPLQJORRNXSUHJUHVDXQWLSR2EMHFWSRUORTXHHOREMHWRREWHQLGRGHEH
FRQYHUWLUVHDODFODVH
7DEODGHQRPEUHV
1DPLQJ
³EDQFR´
³FXHQWD´
³FXHQWD´
2EMHWR
5HPRWR
$
2EMHWR
5HPRWR
%
+RVWFVPW\LWHVPP[
2EMHWR
5HPRWR
&
8VRGHODWDEOD
ORRNXS³UPLFVPW\LWHVPP[FXHQWD´
1DPLQJ
2EMHWR
&OLHQWH
³EDQFR´
³FXHQWD´
5HIHUHQFLD
UHPRWD
WHFFRP
2EMHWR
5HPRWR
6HUYLGRU
³FXHQWD´
+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
&OLHQW
6HUYHU9LUWXDO0DFKLQH
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
6WXE
6NHOHWRQ
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,"
1
Definición de la
interfaz remota
2
Implementación de la
interfaz remota
(.java)
3
javac
4
rmic
(.class)
8
Cliente
usa
Servidor
(.class)
Esqueleto
(.class)
Stub
(.class)
(.java)
9
javac
(.class)
10
Ejecutar
Cliente
CLIENTE
5
Arrancar RMIRegistry
6
Crear los objetos
7
Registrar los objetos
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
UHPRWHLQWHUIDFHQDPHremoteObjectDVSUHIL[DQG
WKHUHPRWHPHWKRGQDPHsumDVVXIIL[
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,FRPSLOHUrmicWKDWWDNHV\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
6WHSV6WDUWWKHUHPRWHVHUYHUREMHFWV5XQWKH
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´
`