SD - 04 - Middleware RP

https://www.geeksforgeeks.org/difference-between-rmi-and-corba/#:~:text=CORBA%20is%20a%20peer%2Dto,object%20implementation%20falls%20on%20JVM.
Middleware
Modelos RPC: CORBA, RMI
Ingeniería de
Introducción a Sistemas Distribuidos
Sistemas
CORBA (Common Object Request Broker Architecture)
Diseño de middleware que permite que los

programas de aplicación se comuniquen unos con
otros con independencia de sus lenguajes de
programación, sus plataformas de hardware y
software, las redes sobre las cuales se
comunican y sus implementaciones.
• Herencia de interfaces
• Polimorfismo
Correspondencia para los Tipos de datos básicos
Ingeniería de
Sistemas
CORBA CDR
Longitud de la cadena
“Smith”
Longitud de la cadena
“London”
long sin signo
Mensaje CORBA CDR
Ingeniería de
Sistemas
CORBA
Las aplicaciones se construyen mediante implementación de interfaces definidas
en el Lenguaje de Definición de Interfaces (IDL) CORBA.
Servicios
• Servicio de Nombres (naming)
• Los servicios de Eventos y Notificación.
• Persistencia
• Transacción y Concurrencia.
• El servicio de seguridad
• Negociación (trading)
Ingeniería de
Sistemas
Modelos de RPC - CORBA
client server
implementation interface
repository repository object skeleton
adapter
client proxy Request ORB Servant

ORB
program for A core core A
Reply
or dynamic invocation or dynamic skeleton
Arquitectura de CORBA
Ingeniería de
Sistemas
El ORB proporciona una interfaz que incluye:

• Operaciones que permiten su arranque y parada.
• Operaciones para la conversión entre referencias a objetos remotos
y cadenas de texto.
• Operaciones para obtener listas de argumentos para las llamadas
que emplean invocación dinámica.
Ingeniería de
Sistemas
Adaptador de objeto:
• Crea referencias a objetos remotos para los objetos CORBA.
• Despacha cada invocación remota a través de un skeleton hacia el servidor
apropiado.
• Activa objetos.
• Esqueletos: Las invocaciones de métodos remotos se despachan mediante el

esqueleto apropiado a un servidor concreto, y el esqueleto despacha los
argumentos desde los mensajes de petición y empaqueta las excepciones y
los resultados en mensajes de respuesta.
Ingeniería de
Sistemas
Resguardo/proxy del cliente: Se encuentra en el lenguaje del cliente.
Empaqueta los argumentos de los mensajes de invocación y
desempaqueta las excepciones y los resultados de las respuestas.
Repositorio de implementación: Activa los servidores registrados bajo

demanda y localizar los servidores que están en ejecución en cada
momento.
Repositorio de interfaz: Proporciona información sobre las interfaces

IDL registradas a los clientes y a los servidores que lo requieran.
Ingeniería de
Sistemas
El proceso de desarrollo se divide:
• Definir la interfaz remota (.idl)
• Compilar la interfaz remota
• Implementar el servidor
• Implementar el cliente
• Empezar las aplicaciones
Ingeniería de
Sistemas
El IDL define el contrato entre el cliente y el servidor, y especifica las
operaciones y atributos disponibles.
• Declarar el Módulo CORBA IDL
module HelloApp {
// Add subsequent lines of code here.
};
• Declarar la interfaz
module HelloApp {
interface Hello // Add
{ // these
// four
}; // lines.
};
Ingeniería de
Sistemas
• Declarar las operaciones
module HelloApp {
interface Hello
{
string sayHello(); // Add this line.
};
};
“Mapear” el modulo desde IDL a java
idlj –fall Hello.idl
idltojava Hello.idl (Sun)
Ingeniería de
Sistemas
• Crea:
 _XXXStub: Funcionalidad CORBA básica para el cliente, implementa la
interfaz Hello.java
 XXX.java: La versión java de la interfaz IDL.
 XXXHelper: Funcionalidad auxiliar. Contiene el método narrow() requerido
para cast, lee y escribe tipos de datos a streams CORBA
 XXHolder: Provee operaciones para argumentos de salida y entrada.
Contiene la referencia a un objeto que implementa la interfaz Hello
 XXXOperations: Realiza llamadas optimizadas (s) Contiene SayHello() y
Shutdown()
 XXXPOA: Skeleton, provee la funcionalidad básica CORBA para el servidor
Ingeniería de
Sistemas
Identificador único del objeto
Interoperable Object Reference(IOR)

IOR:000000000000000d49444c3a677269643a312e300000000000000001000000000000004c0001
000000000015756c7472612e6475626c696e2e696f6e612e696500000963000000283a5c756c7472
612e6475626c696e2e696f6e612e69653a677269643a303a3a49523a67726964003a
Ingeniería de
Sistemas
Parte básica (Aplicación del Cliente)
• Importar paquetes requeridos
import HelloApp.*; // The package containing our stubs.
import org.omg.CosNaming.*; // HelloClient will use the naming service.
import org.omg.CORBA.*; // All CORBA applications need these classes.
• Declarando la clase del cliente
public class HelloClient {
// Add the main method here in the next step.
}
• Definiendo el método principal
public static void main(String args[]) {
// Put the try-catch block here in the next step.
}
• Manejo de excepciones CORBA
try {
// Add the rest of the HelloClient code here.
} catch(Exception e) {
System.out.println("ERROR : " + e);
e.printStackTrace(System.out);
}
Ingeniería de
Sistemas
Crear el Objeto ORB

• Tanto cliente como servidor CORBA necesitan un objeto local ORB
para desempeñar todo el marshalling y trabajo IIOP.
• Cada cliente y cada servidor instancian un objeto
org.omg.CORBA.ORB.
ORB orb = ORB.init(args, null);
Ingeniería de
Sistemas
Buscando el Servidor “Hello”
• Obtener el contexto inicial
org.omg.CORBA.Object objRef = orb.resolve_initial_references("NameService");
• Convertir la referencia del objeto
NamingContext ncRef = NamingContextHelper.narrow(objRef);
• Buscando el servicio
NameComponent nc = new NameComponent("Hello", "");
NameComponent path[] = {nc};
Hello helloRef = HelloHelper.narrow(ncRef.resolve(path));
Invocando la operación sayHello
String hello = helloRef.sayHello();

System.out.println(hello);
Ingeniería de
Sistemas
Parte básica (Aplicación del servidor)
• Importar paquetes requeridos
import HelloApp.*; // The package containing our stubs.
import org.omg.CosNaming.*; // HelloClient will use the naming // service.
import org.omg.CosNaming.NamingContextPackage.*;
import org.omg.CORBA.*; // All CORBA applications need these // classes.
• Declarando la clases del servidor
public class HelloServer{
// Add the main method here in the next step.
}
• Definiendo el método principal
// Put the try-catch block here in the next step.
}
• Manejo de excepciones CORBA
try {
// Add the rest of the HelloClient code here.
} catch(Exception e) {
System.out.println("ERROR : " + e);
e.printStackTrace(System.out);
}
Ingeniería de
Sistemas
Manejando el Servant del objeto
• Instanciando el objeto Servant
HelloServant helloRef = new HelloServant();
• Definiendo la clase Servant
class HelloServant extends _HelloImplBase {
// Add the sayHello method here in the next step.
}
El Servant es una Subclase de _HelloImplBas
public String sayHello() {

// Add the method implementation here in the next step.
}
return "\nHello World!!\n";
Ingeniería de
Sistemas
Trabajando con COS Naming
• Obtener el contexto inicial
org.omg.CORBA.Object objRef = orb.resolve_initial_references("NameService");
• Convertir la referencia al objeto
NamingContext ncRef = NamingContextHelper.narrow(objRef);
• Registrar el Servant con el Servidor de Nombres
NameComponent nc = new NameComponent("Hello", "");
NameComponent path[] = {nc};
ncRef.rebind(path, helloRef);
Esperar por la invocación
java.lang.Object sync = new java.lang.Object();
synchronized(sync) {
sync.wait();
}
Ingeniería de
Sistemas
Compilando el cliente
javac HelloClient.java HelloApp\*.java
Compilando el servidor
javac HelloServer.java
Ejecutando las aplicaciones

tnameserv -ORBInitialPort nameserverport
java –cp /tmp/juan HelloServer -ORBInitialHost nameserverhost -ORBInitialPort nameserverpor
java –cp /tmp/juan HelloClient -ORBInitialHost nameserverhost -ORBInitialPort nameserverport
Ingeniería de
Sistemas
Modelos de RPC - RMI
 RMI es una extensión de la invocación a métodos locales, que permiten que
un objeto que vive en un proceso invoque los métodos de un objeto que
reside en otro proceso.
 En una invocación de método remoto están involucrados varios objetos y
módulos separados.
APP Cliente Serv. de APP

RMI RMI
JVM JVM
OS OS
Emisor Receptor
10011000100011110110
Marshalling UnMarshalling
Ingeniería de
Sistemas
RMI (Remote Method Invocation)
 Invocación remota de objetos ubicados en MV diferentes

 Permite llamar a los servidores desde los Applets
 Integrar el modelo de objetos distribuidos
 Preservar la seguridad
Ingeniería de
Sistemas
Objetivos de RMI
Transparencia. Permitir la invocación de métodos de objetos remotos que se ejecutan en otras
JVM como procesos separados, con independencia de que estos objetos estén en la misma
máquina o en máquinas diferentes.
Orientado a objetos. Integrar el modelo de objetos distribuidos en el lenguaje Java de manera
natural y preservando, siempre que sea posible, la semántica de objetos de Java.
Simple. Aplicar a la programación distribuida los mismos criterios de simplicidad de la
programación Java estándar.
Seguridad. Usar un modelo de seguridad basado en los gestores de seguridad y cargadores de
clases locales.
Ingeniería de
Sistemas
Objetivos de RMI
Portabilidad. Hacer que cualquier sistema distribuido RMI sea portable a cualquier
plataforma donde haya una JVM.
Escalabilidad. Mantener la misma arquitectura con independencia del tamaño de la
aplicación distribuida.
Robustez. Proporcionar una jerarquía de gestión de excepciones remotas para detectar y
gestionar los errores generados en el servidor.
Eficiencia. Permitir la activación, desactivación y reactivación, así como la liberación
automática de objetos remotos no referenciados, lo que mejoraría la gestión de recursos
del servidor.
Ingeniería de
Sistemas
Streams
Primitivos:
Hablan con los dispositivos directamente leyendo o escribiendo los bytes
tal como llegan de manera secuencial
FileOutputStream, FileInputStream
Intermedios:
Su función es la de envolver un stream existente. Los streams
intermedios pueden manejar datos más complejos que simples bytes,
pero se tienen que convertir en bytes cuando escriban en el dispositivo.
ObjectOutputStream, ObjectInputStream
Ingeniería de
Sistemas
Modelos de RPC -RMI
client server
remote
object A proxy for B skeleton
object B
Request & dispatcher
for B’s class
Reply
Remote Communication Communication Remote reference

reference module module module module
Arquitectura RMI
Ingeniería de
Sistemas
Modelos de RPC -RMI
 Módulo de comunicación: semántica de invocación.
 Módulo de referencia remota: Responsable de traducir las referencias entre
objetos locales y remotos, y de crear referencias a objetos remotos.
 Proxy: Invocación al método remoto transparente para los clientes, se comporta
como un objeto local para el que invoca; pero en lugar de ejecutar la invocación,
dirige el mensaje al objeto remoto (serialización de parámetros).
 Skeleton: La clase de un objeto remoto tiene un skeleton, que implementa los
métodos de una interfaz remota.
 Distribuidor: Cada servidor tiene un distribuidor y un skeleton para cada clase que
representa a un objeto remoto. (idMetodo)
Ingeniería de
Sistemas
Modelos de RPC -RMI
1. El servidor se registra (bind) en el registry con un nombre. Máquina
Genera unremota
hilo para
2. El cliente localiza (lookup) la referencia del servidor en el permanecer bind
disponible
Servidor RMI
registry por su nombre. Registro
Skeleton
3. El cliente crea un stub que hace referencia al skeleton Referencia al método y un flujo de
4. El cliente invoca el stub de forma local. bytes que resulta de serializar los
parámetros y creaLookup
un socket
5. El stub transfiere la invocación al skeleton con un mensaje .
6. El skeleton invocamente localmente el método del servidor. Máquina local
7. El skeleton transfiere los resultados obtenidos de la Stub

invocación al stub a través de mensajes. Cliente RMI
8. El stub retorna los resultados y finaliza la invocación del
cliente.
Ingeniería de
Sistemas
Modelos de RPC -RMI
 Mayor número de excepciones que en métodos locales
 Errores en la comunicación entre los procesos (fallos de
acceso, fallos de conexión)
 Problemas asociados a la invocación de métodos remotos (no
encontrar el objeto, el resguardo o el esqueleto)
 Los métodos deben especificar la excepción
RemoteException.
Ingeniería de
Sistemas
Arquitectura RMI
http://aviloria.blogspot.com.co/
Ingeniería de
Sistemas
Ingeniería de
Sistemas
• InterfaceRemota: Con todos los métodos
• ObjetoRemoto: Clase con la implementación de los métodos de InterfaceRemota
• ObjetoRemoto_Stub: Implementa InterfaceRemota, cada método hace una llamada a
través de la red
Proceso:
 Desarrollar la aplicación cliente.
 Desarrollar la aplicación servidor.
 Compilar y ejecutar la aplicación.
 Se ejecuta el RMI Registry en el procesador remoto.
 Se ejecuta el servidor en el procesador remoto.
 Se ejecuta el cliente en el procesador local
Ingeniería de
Sistemas
Código:
1. Definir las funciones de la clase remota con los métodos, como una
interfaz escrita Java.
• Hereda de la interfaz remote
• Debe lanzar una RemoteException
2. Escribir las clases de implementación y servidor.
3. Escribir un programa cliente que usa los servicios remotos
Ingeniería de
Sistemas
1. Definir las funciones de la clase remota como una interfaz escrita Java.
 Un objeto remoto es una instancia de la clase que implementa una interfaz

Remote.
 La interfaz remota debe ser pública.
 La interfaz remota extiende de la interfaz java.rmi.Remote
 Cada método debe declarar java.rmi.RemoteException como cláusula throws, en adición a
cualquiera excepción de la aplicación.
 El tipo de datos de cualquier objeto remoto que es pasado como un argumento o valor de
retorno debe ser declarado como un tipo de interfaz remoto, no la implementación de la clase.
Ingeniería de
Sistemas
package examples.hello;
import java.rmi.Remote;
import java.rmi.RemoteException;
public interfaz Hello extends Remote {

String sayHello() throws RemoteException;
}
Ingeniería de
Sistemas
2. Escribir las clases de implementación y servidor.
 Lo mínimo de la implementación de un objeto remoto es:

 La clase debe implementar al menos una interfaz remota.
 Definir el constructor para el objeto remoto
 Proveer la implementación para los métodos que pueden ser invocados
remotamente.
Ingeniería de
Sistemas
 Por otro lado, el programa servidor necesita:

 Instancia del manejador de seguridad.
 Crear una o más instancias del objeto remoto.
 Registrar al menos un objeto remoto en RMI registry.
Ingeniería de
Sistemas
IMPLEMENTACIÓN DE LA INTERFAZ REMOTA
import java.rmi.Naming;
import java.rmi.RMISecurityManager;
import java.rmi.server.UnicastRemoteObject;
public class HelloImpl extends UnicastRemoteObject implements Hello {

public HelloImpl() throws RemoteException {
super();
}
public String sayHello() {
return "Hello World!";
}
Ingeniería de
Sistemas
Servidor
// Create and install a security manager
if (System.getSecurityManager() == null) {
System.setSecurityManager(new RMISecurityManager());
}
try {
HelloImpl obj = new HelloImpl();
// Bind this object instance to the name "HelloServer"
Naming.rebind("//127.0.0.1:1099/HelloServer", obj);
System.out.println("HelloServer bound in registry");
} catch (Exception e) {
System.out.println("HelloImpl err: " + e.getMessage());
e.printStackTrace();
}
}
}
Ingeniería de
Sistemas
 Implementar una interfaz remota.
 Cuando una clase implementa una interfaz se crea un “contrato” entre
la clase y el compilador.
 Es conveniente que extienda de la clase remota
java.rmi.server.UnicastRemoteObject, donde puede usar:
 Ejecuta todo el tiempo
Public class HelloImpl extends UnicastRemoteObject implements Hello {
Ingeniería de
Sistemas
 Definir el constructor para el objeto remoto

 La instancia del objeto remoto necesita ser exportada. Exportar un
objeto remoto hace disponible:
 Aceptar solicitudes remotas de métodos.
 Escucha para llamados de objetos remotos en puertos anónimos.
Ingeniería de
Sistemas
Modelos de RPC -RMI
 Proveer una implementación para cada método remoto.

 Por defecto, los objetos locales son pasados por copia, excepto los
marcados como static o transient.
 Los objetos remotos son pasados por referencia.
public String sayHello() throws RemoteException {

return “Hello World”;
}
Ingeniería de
Sistemas
Modelos de RPC -RMI
 Crear e instalar un administrador de seguridad

 El administrador de seguridad es necesario para ejecutar y poder
garantizar que clases pueden ser leídas.
if (System.getSecurityManager() == null) {
}
Ingeniería de
Sistemas
Modelos de RPC -RMI
 Crear una o más instancias de un objeto remoto.

 El método principal del servidor necesita crear una o más instancias
de la implementación del objeto remoto que provee el servicio.
HelloImpl obj = new HelloImpl();
Ingeniería de
Sistemas
Modelos de RPC -RMI
 Registrar el objeto remoto:
 Para que un cliente pueda invocar un método en un objeto remoto, debe
primero obtener una referencia al objeto remoto.
 RMI provee registro de objetos remotos en el cual se permite registrar
nombres en formato URL.
 //host/objectname : Donde objectname es un string de un nombre simple.
 RMI registry es servidor de nombres en el lado servidor.
Ingeniería de
Sistemas
Modelos de RPC -RMI
 Primero un objeto es registrado en el servidor, los invocadores

buscan el objeto por el nombre de registro y obtienen una
referencia al objeto remoto, y entonces pueden invocar los
métodos en el objeto.
 Naming.rebind("//myhost/HelloServer", obj);
 Naming.rebind("//myhost:1234/HelloServer", obj);
Ingeniería de
Sistemas
Modelos de RPC -RMI
Programa cliente que usa el servicio remoto.
 El applet es un ejemplo de invocación remota del método sayHello
para coger una cadena que es mostrada en el cliente.
import java.applet.Applet;
import java.awt.Graphics;
import java.rmi.Naming;
public class HelloApplet extends Applet {
String message = "blank";
// "obj" es el identificador que se usará para hacer referencia al objeto remoto
que implementa el "Hello"
Ingeniería de
Sistemas
Modelos de RPC -RMI
public void init() {

try {
obj = (Hello)Naming.lookup("//" + getCodeBase().getHost() +
"/HelloServer"); message = obj.sayHello();
System.out.println("HelloApplet exception: " + e.getMessage());
}
}
public void paint(Graphics g) {
g.drawString(message, 25, 50);
}
}
Ingeniería de
Sistemas
Modelos de RPC -RMI
 El cliente coge una referencia a la implementación de un objeto remoto

del servidor de nombres.
 El cliente invoca el método de sayHello en el servidor de objetos
remoto.
 El cliente (applet) invoca el método paint, causando que se imprima la
cadena “Hello World”.
Ingeniería de
Sistemas
Modelos de RPC -RMI
Compilación:
 Compilar los archivos fuentes
 Usar rmic para generar el stub. El skeleton se hará de forma dinámica
 Mover el archivo HTML al directorio (deployment).
 Actualizar rutas para ejecución.
Ingeniería de
Sistemas
Modelos de RPC -RMI
 Asegurar que los directorios de deployment y de desarrollo son

accesibles por medio de la variable de entorno CLASSPATH.
javac -d $HOME/public_html/myclasses Hello.java HelloImpl.java HelloApplet.java

 Para crear los stubs y skeletons se utiliza la herramienta rmic.
rmic -d $HOME/public_html/myclasses examples.hello.HelloImpl
Ingeniería de
Sistemas
Modelos de RPC -RMI
 Para hacer que la página web que hace referencia al applet, el archivo
debe ser movido desde el directorio de desarrollo al directorio de código
base.
<HTML>
<title>Hello World</title>
<center> <h1>Hello World</h1> </center>
<applet codebase="myclasses/" code="examples.hello.HelloApplet" width=500 height=120>
</applet>
</HTML>
Ingeniería de
Sistemas
Modelos de RPC -RMI
 Asegurarse que el directorio público donde se encuentran las clases

(stub, skeleton) se pueden acceder desde el CLASSPATH para poder
ejecutar el servidor HelloImpl.
Ejecución:
 Ejecutar el Servidor de nombres
 Ejecutar el servidor
 Ejecutar el cliente
Ingeniería de
Sistemas
Modelos de RPC -RMI
Servidor de nombres:
 El RMI Registry es un servidor de nombres en el lado del servidor que
permite al cliente obtener referencias a un objeto remoto.
 Usado solo para localizar el primer objeto remoto en una aplicación
para poder usar los métodos que ofrece.
start rmiregistry 1500

Servicio de
directorio de Java
Ingeniería de
Sistemas
Servidor:
 Cuando se ejecuta el servidor la propiedad java.rmi.server.codebase debe ser
especificada, por lo tanto el stub puede ser dinámicamente bajada del registro al
cliente.
 Además se debe especificar el archivo de políticas de acceso.
java -Djava.rmi.server.codebase=http://myhost/~myusrname/myclasses/ -Djava.security.policy=$HOME/mysrc/policy examples.hello.HelloImpl
Ingeniería de
Sistemas
Modelos de RPC -RMI
Cliente:
 Una vez registrado el servidor de nombres y el servidor, se puede
ejecutar el cliente.
appletviewer http://myhost/~myusrname/hello.html &
Ingeniería de
Sistemas
EJEMPLO 2
Ingeniería de
Sistemas
Introducción
Implementación
• Diseño y compilación de la interfaz remota.
• Implementación de la interfaz remota en una clase y su compilación.
• Obtención de la(s) clase(s) Stub a partir de la interfaz remota.
• Desarrollo y Compilación de la Aplicación del Servidor.
• Desarrollo y Compilación de la Aplicación del Cliente.
Ejecución
• Registro de objetos remotos
• Iniciar el Servidor
• Establecer la política de seguridad
• Iniciar el Cliente.
Ingeniería de
Sistemas
Implementación
Diseño de la interfaz Remota
import java.rmi.*;
public interfaz <nombinterfazRemota> extends Remote {
// prototipos de los métodos remotos que deben lanzar la excepción RemoteException.
}
Compilación
javac <nombinterfazRemota>.java  <nombinterfazRemota>.class
interfaz de ejemplo: IntSaludo.java

import java.rmi.*;
public interfaz IntSaludo extends Remote {
// Un método remoto que recibe y devuelve una cadena
String saludo(String soy) throws RemoteException;
}
Ingeniería de
Sistemas
Implementación
Implementación de la interfaz remota
import java.rmi.*;
import java.rmi.server.*;
class <nombClase> extends UnicastRemoteObject implements IntSaludo {
// El constructor debe invocar al constructor de UnicastRemoteObject: super();
// Se deben implementar los métodos remotos de la interfaz.
}
Compilación
javac <nombClase>.java  <nombClase>.class
En nuestro ejemplo: ClsSaludo.java
import java.rmi.*;
import java.rmi.server.*;
class ClsSaludo extends UnicastRemoteObject implements IntSaludo {
public ClsSaludo() throws RemoteException { super(); }
public String saludo(String soy) throws RemoteException { return “Hola “+soy; }
}
Ingeniería de
Sistemas
Implementación
Las clases Stub y Skeleton
Las clases Stub y Skeleton son obtenidas a partir de la clase anterior.
Compilador de Java RMI: rmic
rmic <nombClase>  nombClase_Stub.class
nombClase_Skel.class
Crear un archivo .jar con las clases
jar cvf <archivoClass>.jar *.class  <archivoClass>.jar
 interfazRemota.class
nombClase.class
nombClase_Stub.class
nombClase_Skel.class
En nuestro Ejemplo jar cvf *.class saludo.jar  saludo.jar
Ingeniería de
Sistemas
Implementación
Servidor
import java.rmi.*;
public class <apServidor> {
// Establecer el gestor de seguridad
// Instancias de Objetos Remotos
// Registros de Objetos Remotos
try {
nombClase <objRemoto> = new nombClase();
Naming.rebind(“<url>\<nomObj>”, <objRemoto>);
} catch (Exception ex) {
System.err.println(“Error: " + ex.getMessage());
}
}
Compilación: javac <apServidor>.java  <apServidor>.class
Ingeniería de
Sistemas
Implementación
Servidor
import java.rmi.*;
public class apServidor {
public static void main(String arg[]) {
// Establecer el gestor de seguridad
// Instancias de Objetos Remotos, Registros de Objetos Remotos
try {
ClsSaludo objRemoto = new ClsSaludo();
Naming.rebind("//localhost/nomObj", objRemoto);
System.out.println("Objeto Registrado");
} catch (Exception ex) {
System.err.println("Error: " + ex.getMessage());
ex.printStackTrace();
}
}
}
Ingeniería de
Sistemas
Implementación
Cliente
import java.rmi.*;
public class <apCliente> {
// Obtener la referencia del objeto remoto y convertirla al tipo interfaz remota
// invocar métodos remotos
try {
obj = (<interfazRemota>) Naming.lookup(“<url>/<objRemoto>");
obj.metodoRemoto();
System.out.println("Excepcion: " + e.getMessage());
}
}
Compilación: javac <apCliente>.java  <apCliente>.class
Ingeniería de
Sistemas
Implementación
Cliente
import java.rmi.*;
public class apCliente {
public static void main(String arg[]) {
// Obtener la referencia del objeto remoto y convertirla al tipo interfaz remota
// invocar métodos remotos
try {
IntSaludo obj = (IntSaludo) Naming.lookup("//localhost/nomObj");
System.out.println(obj.saludo(“Pablo"));
System.out.println("Excepcion: " + e.getMessage());
}
}
}
Ingeniería de
Sistemas
Ejecución
Iniciar rmiregistry (puerto por default 1099)
start rmiregistry
Iniciar el servidor. Si el directorio de trabajo es c:\saludoRMI:
• Especificar el archivo .jar que contiene las clases
• Establecer la política de seguridad
java -Djava.rmi.server.codebase=file:/c:\saludoRMI\<archivoClass>.jar
-Djava.security.policy=<java.policy> <apServidor>
• archivo para la política de seguridad
grant {
permission java.net.SocketPermission "*:1024-65535", "connect,accept";
permission java.net.SocketPermission "*:80", "connect";
};
Iniciar el Cliente: java <apCliente>
Ingeniería de
Sistemas
Ejecución de nuestro ejemplo
Registrar Objetos: rmiregistry

Iniciar Servidor: (si el directorio de trabajo es c:\SaludoRMI)
java -Djava.rmi.server.codebase=file:/c:\saludoRMI\saludo.jar -Djava.security.policy=java.policy
apServidor
Iniciar Cliente
java apCliente
Ingeniería de
Sistemas
Bibliografía
 Tanenbaum,A.S., “Redes de computadoras”, Cuarta Edición, Pearson, Prentice Hall,2003.

 Stallings,W., “Comunicación y redes de Computadores”, Sexta Edición, Prentice Hall, 2003.
 Kurose,J.F.,”Redes de Computadores”, Segunda Edición, Pearson, Addison Wesley, 2004
 Couloris, G.,Dolimore J., Kindberg T., “Sistemas Distribuidos”,Tercera Edición, Addison
Wesley, 2004.
Ingeniería de
Sistemas

SD - 04 - Middleware RP

Cargado por

Información del documento

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

SD - 04 - Middleware RP

Cargado por

Copyright:

Formatos disponibles

https://www.geeksforgeeks.org/difference-between-rmi-and-corba/#:~:text=CORBA%20is%20a%20peer%2Dto,object%20implementation%20falls%20on%20JVM.

Modelos RPC: CORBA, RMI

Diseño de middleware que permite que los

Correspondencia para los Tipos de datos básicos

long sin signo

Mensaje CORBA CDR

client proxy Request ORB Servant

or dynamic invocation or dynamic skeleton

El ORB proporciona una interfaz que incluye:

• Esqueletos: Las invocaciones de métodos remotos se despachan mediante el

Repositorio de implementación: Activa los servidores registrados bajo

Repositorio de interfaz: Proporciona información sobre las interfaces

“Mapear” el modulo desde IDL a java

idlj –fall Hello.idl

idltojava Hello.idl (Sun)

Identificador único del objeto

Interoperable Object Reference(IOR)

Crear el Objeto ORB

String hello = helloRef.sayHello();

El Servant es una Subclase de _HelloImplBas

public String sayHello() {

return "\nHello World!!\n";

Ejecutando las aplicaciones

APP Cliente Serv. de APP

 Invocación remota de objetos ubicados en MV diferentes

Remote Communication Communication Remote reference

7. El skeleton transfiere los resultados obtenidos de la Stub

 Un objeto remoto es una instancia de la clase que implementa una interfaz

public interfaz Hello extends Remote {

 Lo mínimo de la implementación de un objeto remoto es:

 Por otro lado, el programa servidor necesita:

public class HelloImpl extends UnicastRemoteObject implements Hello {

Public class HelloImpl extends UnicastRemoteObject implements Hello {

 Definir el constructor para el objeto remoto

 Proveer una implementación para cada método remoto.

public String sayHello() throws RemoteException {

 Crear e instalar un administrador de seguridad

 Crear una o más instancias de un objeto remoto.

HelloImpl obj = new HelloImpl();

 Primero un objeto es registrado en el servidor, los invocadores

public void init() {

 El cliente coge una referencia a la implementación de un objeto remoto

 Asegurar que los directorios de deployment y de desarrollo son

javac -d $HOME/public_html/myclasses Hello.java HelloImpl.java HelloApplet.java

rmic -d $HOME/public_html/myclasses examples.hello.HelloImpl

 Asegurarse que el directorio público donde se encuentran las clases

start rmiregistry 1500

java -Djava.rmi.server.codebase=http://myhost/~myusrname/myclasses/ -Djava.security.policy=$HOME/mysrc/policy examples.hello.HelloImpl

appletviewer http://myhost/~myusrname/hello.html &

interfaz de ejemplo: IntSaludo.java

En nuestro Ejemplo jar cvf *.class saludo.jar  saludo.jar

Compilación: javac <apCliente>.java  <apCliente>.class

Iniciar el Cliente: java <apCliente>

Registrar Objetos: rmiregistry

 Tanenbaum,A.S., “Redes de computadoras”, Cuarta Edición, Pearson, Prentice Hall,2003.

También podría gustarte