TECNOLOGICO DE ESTUDIOS SUPERIORES DE SAN FELIPE DEL

PROGRESO

INGENIERIA INFORMATICA

PROGRAMACIÓN EN AMBIENTE CLIENTE-SERVIDOR

INVESTIGACION:
“Estructura de RMI”

MTRO. ALEX RAMÍREZ GALINDO

DAVID MARTINEZ EULOGIO

OLIVER SEGUNDO SANCHEZ
LUIS GUSTAVO FABIÁN ACEVEDO
JUAN CARLOS GARCÍA MARTÍNEZ

SEXTO SEMESTRE GRUPO: 702

 Índice

Contenido
Introducción ....................................................................................................................................... 3
Planteamiento del problema ........................................................................................................... 4
Objetivos ............................................................................................................................................ 5
Objetivo General ........................................................................................................................... 5
Objetivos específicos ................................................................................................................... 5
Justificación ....................................................................................................................................... 6
Alcances............................................................................................................................................. 7
Estructura de RMI............................................................................................................................. 9
Conclusiones ................................................................................................................................... 17
Referencias ..................................................................................................................................... 18
 Índice de imágenes

Ilustración 1: Vista de RMI .................................................................................................................. 9

Ilustración 2: Arquitectura RMI ......................................................................................................... 11
Ilustración 3:Define la interfaz remota ............................................................................................. 14
Ilustración 4: Implementa la interfaz remota ................................................................................... 14
Ilustración 5: Crea el servidor RMI .................................................................................................... 15
Ilustración 6: Crea el cliente RMI ...................................................................................................... 16
 Introducción
RMI es una tecnología desarrollada por Sun para permitir la colaboración de objetos
que están localizados remotamente, cabe destacar que esta tecnología se enmarca
en la idea de permitir colaboración entre Objetos Remotos. La idea no es que los
objetos se comuniquen a través de la programación del usuario de protocolos
estándares de red si no que es tener un objeto cliente, donde se podrá completar
un requerimiento de datos.

RMI posee un mecanismo para cargar clases dinámicamente desde otro lugar. Esto
es requerido, por ejemplo, cuando el valor retornado corresponde a una instancia
de una clase derivada de la clase conocida por el cliente. Aquí se ocupa un
mecanismo similar al usado por applets.

Mediante la siguiente investigación se busca dar a conocer la estructura de RMI ya

que esta misma se basa en el concepto de invocación remota de métodos, lo que
significa que un objeto en un sistema distribuido puede invocar métodos en un
objeto ubicado en una máquina remota, como si estuvieran en la misma máquina.
Al mismo tiempo se veremos la eficiencia y la importancia del RMI que tiene en la
actualidad para estas nuevas tecnologías.
 Planteamiento del problema
Para desarrollar una aplicación distribuida en Java que requiere que varios
componentes se comuniquen entre sí, cómo lograr que los objetos en diferentes
sistemas se comuniquen de manera eficiente y confiable. Para estodebemks
debemos de tener claro los objetos y gestión de conexiones, al utilizar la estructura
RMI (Remote Method Invocation) que generalmente se centra en las necesidades
cómo l comunicación lo q facilita la construcción de sistemas escalables en los que
diferentes componentes pueden estar en servidores separados.
 Objetivos
Objetivo General
Implementar la estructura de RMI dentro de proyectos de gestión e
innovación

Objetivos específicos
Desarrollar la estructura de RMI
Implementar dentro de proyectos la estructura de RMI en java
Aplicar la estructura de RMI en proyecto de gestión de nuevas tecnologias
 Justificación
En el presente proyecto lo que se quiere dar a conocer como es la arquitectura de
RMI (que en sus siglas en ingles es Java Remote Method Invocation) es un tema
crucial en el campo de la informática y la programación distribuida y la arquitectura
RMI es una tecnología que permite a los desarrolladores crear aplicaciones
distribuidas en Java de manera efectiva y eficiente la cual esta nos permiten en el
entorno de java permite una transición suave y una curva de aprendizaje más rápida
para aquellos que ya están o no familiarizados con el lenguaje, en lo que se puede
decir en seguridad de esta estructura de RMI incluye mecanismos de seguridad
para autenticar y autorizar las llamadas entre sistemas, lo que es esencial en
aplicaciones donde la integridad y la confidencialidad de los datos son críticas.
 Alcances
Los alcances de la estructura RMI son amplios en el desarrollo de aplicaciones
distribuidas en entornos Java.

1. Desarrollo de Aplicaciones Distribuidas: RMI permite a los desarrolladores crear

aplicaciones distribuidas en las que los objetos pueden invocar métodos en objetos
que residen en máquinas remotas como si estuvieran en la misma máquina. Esto
es fundamental para aplicaciones que requieren una arquitectura cliente-servidor o
sistemas distribuidos.

2. Abstracción de la Comunicación a Nivel de Objeto:

RMI abstrae gran parte de la complejidad de la comunicación en red y permite a los

desarrolladores pensar en la comunicación a un nivel de objeto. Los objetos remotos
pueden ser utilizados como si fueran objetos locales, lo que facilita el diseño de
aplicaciones distribuidas.

3. Integración con el Lenguaje Java:

RMI se integra perfectamente con el lenguaje Java, lo que significa que los
desarrolladores pueden aprovechar las características del lenguaje, como la gestión
automática de memoria y la seguridad, en sus aplicaciones distribuidas.

4. Flexibilidad en la Implementación:

RMI proporciona flexibilidad en la forma en que se pueden implementar los objetos

remotos. Los objetos remotos pueden ser implementados en servidores
independientes o incrustados en servidores de aplicaciones Java EE, lo que permite
adaptar la implementación a las necesidades específicas del proyecto.

5. Gestión de Transacciones:

RMI puede utilizarse en aplicaciones que requieren una gestión avanzada de

transacciones, lo que permite que las operaciones se realicen de manera atómica y
consistente en sistemas distribuidos.
6. Desarrollo de Servicios Web: A través de la combinación de RMI con tecnologías
como RMI over IIOP (RMI sobre el Protocolo de Objetos CORBA) o JAX-RPC (Java
API for XML-Based Remote Procedure Call), es posible desarrollar servicios web
que permiten la comunicación con aplicaciones basadas en tecnologías web.

7. Seguridad: RMI proporciona mecanismos de seguridad, como la autenticación y

autorización, que son esenciales para garantizar que las comunicaciones entre
objetos remotos sean seguras y que solo los clientes autorizados puedan acceder
a los servicios remotos.

8. Gestión de Excepciones: RMI proporciona un sólido manejo de excepciones, lo

que facilita la detección y el manejo de errores que pueden ocurrir durante las
invocaciones de métodos remotos.

9. Facilita la Programación Concurrente: RMI permite la creación de aplicaciones

distribuidas que pueden manejar múltiples solicitudes de manera concurrente, lo
que es esencial para aplicaciones de alto rendimiento.
 Estructura de RMI
Definición

La tecnología RMI (Remote Method Invocation) en Java es un mecanismo que

permite a los programas invocar métodos en objetos que residen en sistemas
remotos, es decir, en computadoras que se encuentran en ubicaciones distintas a
la que ejecuta el programa. RMI se basa en el Java Remote Method Protocol
(JRMP), que forma parte de la plataforma Java para la comunicación entre objetos
distribuidos.

Es un mecanismo ofrecido por Java para invocar un método de manera remota.

Forma parte del entorno estándar de ejecución de Java y proporciona un
mecanismo simple para la comunicación de servidores en aplicaciones distribuidas
basadas exclusivamente en Java.

Es un servidor simple que permite que una aplicación vea los objetos lo cuales están
siendo importados por un RMI. Una vez que se tiene un objeto que está siendo
exportado por un servidor que utiliza métodos de RMI, la comunicación es entonces
como una simple llamada a métodos de un objeto que puede existir en una máquina
diferente.

Ilustración 1: Vista de RMI

Características y Estructura de RMI

Características

• Facilidad de uso en la programación por estar específicamente diseñado

para JAVA.
• Proporciona paso de objetos por referencia.
• Recolección de basura distribuida.
• Paso de tipos arbitrarios.

Este setup requiere algunos parámetros de localización de los objetos remotos.

Es fácil llamar a objetos remotos si se tiene su ubicación.
Una vez que el objeto ha sido localizado, usarlo de manera remota es relativamente
fácil.
Para poder inicializar objetos remotos, hay que utilizar los servicios de registry.

Invocación

1) Encapsulado de los parámetros.

2) Invocación del método (del cliente con el servidor). El invocador se queda
esperando una respuesta.
3) Al terminar la ejecución, el servidor serializa el valor de retorno y lo envía al
cliente.
4) El código cliente recibe la respuesta y continúa como si la invocación hubiera
sido local.

Arquitectura

Puede verse como un modelo de cuatro capas.

1) Primera Capa: es la de aplicación y corresponde con la implementación real

de las aplicaciones cliente y servidor.
2) Segunda Capa: es la que interactúa directamente con la capa de aplicación.
Se encuentran las llamadas a objetos remotos y acciones junto con sus
parámetros y retornos de objetos.
 3) Tercera Capa: es la de referencia remota, y es responsable del manejo de la
parte semántica de las invocaciones remotas. Es responsable de la
replicación de objetos.
4) Cuarta Capa: es la de transporte; es la responsable de realizar las
conexiones necesarias y manejo del transporte de los datos de una máquina
a otra.

Ilustración 2: Arquitectura RMI

Skeleton y Stub

Dota a clientes y servidores de una interfaz que les permite localizar objetos remotos
para invocar sus métodos como si fueran locales.

El API java RMI

Es una interfaz de programación de aplicaciones provistas por los creadores del

lenguaje java, y que da a los programadores los medios para desarrollar
aplicaciones Java.

LA API de Java provee un conjunto de clases utilitarias para efectuar toda clase de
tareas dentro de un programa.

Interfaces y Clases RMI

Implementa 5 paquetes.

• Java.rmi: contiene Clases, Interfaces y Excepciones vistas por

los clientes.
• Java.rmi.server: Contiene clases, Interfaces y Excepciones vistas por los
servidores.
• Java.rmi.registry: Contiene Clases, Interfaces y Excepciones útiles para
localizar y registrar objetos remotos.
• Java.rmi.dgc: Contiene Clases, Interfaces y Excepciones para la
recolección de basura.
• Java.rmi.activation: Contiene Clases, Interfaces y Excepciones para la
activación de objetos remotos.

Componentes

Clientes: Conducen el flujo de la aplicación. Localizan e invocan métodos ofertados

como remotos por los servidores.

Servidores: Conjunto de objetos de ofrecen interfaces remotas públicas cuyos

métodos pueden ser invocados por clientes de cualquier procesador de la
plataforma.

Registro: Servicio estático que se establece en cada nudo, en el que se registran

los servidores con un nombre, y donde los clientes los localizan.

Ventajas de RMI:

1. Facilidad de uso: RMI está integrado en la plataforma Java y proporciona

un mecanismo sencillo para invocar métodos en objetos remotos. Los
desarrolladores de Java pueden utilizar RMI de manera natural sin necesidad
de aprender protocolos de comunicación complejos.

2. Seguridad: RMI permite configurar mecanismos de seguridad, como

autenticación y autorización, para proteger la comunicación entre sistemas.
Esto es crucial en aplicaciones empresariales donde la seguridad es una
preocupación importante.
 3. Orientación a objetos: RMI se basa en la orientación a objetos y permite a
los desarrolladores trabajar con objetos remotos de una manera similar a la
invocación de métodos locales, lo que facilita la programación y el
mantenimiento del código.

4. Interoperabilidad: RMI es compatible con varias plataformas y lenguajes de

programación a través del uso de Object Request Brokers (ORBs) y permite
la comunicación entre sistemas heterogéneos.

Desventajas de RMI:

Limitaciones en la escalabilidad: RMI puede enfrentar desafíos en términos de

escalabilidad, especialmente cuando se manejan grandes volúmenes de
solicitudes. La gestión de múltiples conexiones remotas puede ser complicada.

Requisito de Java: RMI es específico de Java, lo que limita su uso a aplicaciones

en este lenguaje. Esto puede ser una desventaja si se requiere interoperabilidad
con sistemas que no utilizan Java.

Comunicación síncrona: RMI se basa en llamadas síncronas, lo que significa que el

cliente espera la respuesta del servidor. Esto puede resultar en bloqueos si el
servidor tarda en responder.

Ejemplo

Paso 1: Define la interfaz remota

Primero, creemos una interfaz remota llamada Sumador que definirá el método de
suma.
 Ilustración 3:Define la interfaz remota

Paso 2: Implementa la interfaz remota en una clase de servidor

A continuación, crearemos una clase que implementa la interfaz remota en el

servidor RMI.

Ilustración 4: Implementa la interfaz remota

Paso 3: Crea el servidor RMI

A continuación, crearemos un servidor RMI que registre la implementación del

Sumador y espere a las solicitudes de clientes.
 Ilustración 5: Crea el servidor RMI

Paso 4: Crea el cliente RMI

Ahora, crearemos un cliente RMI que se conecte al servidor y use el objeto remoto
para realizar la suma.
 Ilustración 6: Crea el cliente RMI

Ejecutar primero el servidor RMI y luego el cliente RMI. Este ejemplo muestra cómo
crear un servicio de suma distribuida utilizando RMI en Java.

RMI permite la comunicación entre aplicaciones distribuidas en Java y se basa en

la invocación de métodos en objetos remotos. La estructura básica involucra la
definición de interfaces remotas, la implementación de objetos remotos, la creación
de un registro RMI, y la interacción entre clientes y servidores a través de estas
interfaces remotas.
 Conclusiones
David: RMI (Remote Method Invocation) en Java es una tecnología crucial que
permite la comunicación entre objetos distribuidos en sistemas remotos.
Proporciona una forma sencilla y efectiva de invocar métodos en objetos que
residen en ubicaciones remotas. Su integración natural en Java y la capacidad de
pasar objetos por referencia lo hacen una elección sólida para aplicaciones
distribuidas en Java.

Oliver: La arquitectura de RMI se compone de cuatro capas que facilitan la

comunicación entre sistemas distribuidos en Java. La facilidad de uso y la
orientación a objetos son aspectos destacados de RMI. Además, la posibilidad de
configurar mecanismos de seguridad brinda tranquilidad en aplicaciones
empresariales. Sin embargo, RMI puede enfrentar desafíos en términos de
escalabilidad y está limitado al entorno Java.

Juan Carlos: La tecnología RMI en Java es una poderosa herramienta para la

comunicación entre sistemas distribuidos. La implementación de interfaces remotas,
la creación de objetos remotos y la utilización de registros RMI permiten a los
desarrolladores crear sistemas distribuidos eficaces. La interoperabilidad y la
seguridad son ventajas notables, aunque la comunicación síncrona puede ser una
limitación en ciertos casos.

Luis Gustavo: En conclusión, el ejemplo proporcionado ilustra de manera efectiva

cómo implementar RMI para crear una aplicación distribuida de suma en Java. La
definición de interfaces remotas y la implementación de objetos remotos son pasos
esenciales. RMI es una tecnología sólida que facilita la comunicación entre sistemas
distribuidos en Java, pero debe utilizarse con precaución en situaciones de alta
concurrencia debido a su comunicación síncrona.
 Referencias

de Publicaciones Digitales. DGSCA-UNAM, C. (s/f). Java RMI. Unam.mx.

Recuperado el 26 de octubre de 2023, de
https://www.revista.unam.mx/vol.2/num1/art3/
Drake, J. M. (s/f). VII.1: RMI: Remote method invocation. Unican.es. Recuperado el
26 de octubre de 2023, de
https://www.ctr.unican.es/asignaturas/procodis_3_II/Doc/Procodis_7_01.pdf
La misma semántica que si fueran invocaciones locales, J. R. P. al P. E. M. de O.
R. U. (s/f). 1. Visión general de RMI. Uva.es. Recuperado el 26 de octubre de 2023,
de https://www.infor.uva.es/~fdiaz/sd/doc/rmi
Sosa Sosa, V. J. (s/f). RMI Remote Method Invocation. Cinvestav.mx. Recuperado
el 26 de octubre de 2023, de
https://www.tamps.cinvestav.mx/~vjsosa/clases/sd/DAAI_RMI.pdf
(S/f). Ugr.es. Recuperado el 26 de octubre de 2023, de
https://elvex.ugr.es/decsai/java/pdf/F4-rmi.pdf