Download Unidad: Iztapalapa División: Ciencias Básicas e

Casa abierta al tiempo
UNIVERSIDAD A U T ~ N O M AMETROPOLITANA
Unidad: Iztapalapa
División: Ciencias Básicas eIngeniería
Carreras:
Ingeniería en Electrónica
Licenciatura en Computación
Materia: Proyecto terminal I1
Título: Sistema cooperativo enJava
Fecha: Septiembre de 1999
Alumnos:
David FloresVelázquez
9222 1468
Asesor: Ing. Victor Manuel Ramos Ramos
Sisterria Cooperativo en Java
Flores Velázquez David
Solano Suárez Humberto
Univers'idad Autónoma Metropolitana
Iztapalapa
Contenido
Prefacio
iv
Introducción
vi
1 Objetivos
1
2 Fundamentos
2.1 Análisis y Diseño Orientado a Objetos . . . . . . . . . . . . . . .
2.2 Programación Distribuida . . . . . . . . . . . . . . . . . . . . . .
2.3 Comunicacióncon RPC (Remote Procedure Call) . . . . . . . . .
2.4 CORBA (CommonObject RequestBroker Architecture) . . . . .
2.4.1 IDL (Interface Definition Language) . . . . . . . . . . . .
2.4.2 ORB (Object Request
Broker)
...............
2.4.3 ORB en el servidor . . . . . . . . . . . . . . . . . . . . . .
2.4.4 ORB en el cliente . . . . . . . . . . . . . . . . . . . . . . .
2.5
RMI
(Remote Method Invocation) . . . . . . . . . . . . . . . . .
2.5.1
Nivel
stub/skeleton . . . . . . . . . . . . . . . . . . . . . .
2.5.2Nivel
de referencia remota . . . . . . . . . . . . . . . . . .
2.5.3 Nivel de transporte . . . . . . . . . . . . . . . . . . . . . .
2.5.4 Interfazdel objetoremoto . . . . . . . . . . . . . . . . . .
2.5.5 Implementación enelservidor
. . . . . . . . . . . . . . . .
2.5.6 El registro RMI . . . . . . . . . . . . . . . . . . . . . . . .
2.5.7 Stub delcliente y skeletondel servidor . . . . . . . . . . .
2.6
Serialización
de
objetos
.......................
2.7 AWT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2
2
10
10
10
11
11
11
14
15
3 Modelo de la Aplicación
3.1 Funcionalidad ofrecida . . . . . . . . . . . . . . . . . . . . . . . .
3.2 Jerarquíade Clases . . . . . . . . . . . . . . . . . . . . . . . . . .
3.2.1 Cliente . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.2.2
Servidor
............................
16
16
16
16
28
3
4
5
6
7
7
8
8
9
4
Funcionamiento del Sistema
45
5
Conclusiones
50
i
Lista de Tablas
3.1
3.2
3.3
3.4
3.5
3.6
3.7
Clases y
Clases y
Clases y
Clases y
Clases y
Clases y
Clases y
Métodos del sistema . . . . . . . . . . . . . . .
MCtodos del sistema(Continuaci6n) . . . . .
Métodos del sistema(Continuaci6n). . . . .
Métodos del sistema(Continuaci6n) . . . . .
Métodos del sistema(Continuaci6n). . . . .
Métodos del sistema(Continuaci6n) . . . . .
Métodos del sistema(Continuaci6n) . . . . .
11
......
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
.......
.......
38
39
40
41
42
43
44
Lista de Figuras
2.1 Petición local y remota . . . . . . . . . . . . . . . . . . . . . . . .
2.2 Interacción cliente .servidor . . . . . . . . . . . . . . . . . . . . .
2.3 Arquitecturadecapasde
RMI . . . . . . . . . . . . . . . . . . . .
5
6
9
3.1
3.2
3.3
3.4
3.5
3.6
Jerarquíade clasesdel cliente . . . . . . . . . . . . . . . . . . . . .
Jerarquía de clasesdel servidor . . . . . . . . . . . . . . . . . . . .
Clases relacionadas con DrawApplication. . . . . . . . . . . . .
Clases relacionadas con TextApplication . . . . . . . . . . . . . .
Clases relacionadas con la claseAdressDialog . . . . . . . . . . .
Clases que sirven para crear los dibujos y el texto . . . . . . . .
.
.
.
.
17
29
33
35
36
37
4.1
4.2
4.3
4.4
4.5
Ventanade iniciodelcliente . . . . . . . . . . . . . . . . . . . . .
Ventana de información del usuario . . . . . . . . . . . . . . . . .
Ventana para el intercambio de mensajes . . . . . . . . . . . . . .
Ventanadetexto . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Ventanadedibujo . . . . . . . . . . . . . . . . . . . . . . . . . . .
45
46
47
48
49
...
111
Prefacio
Las razones que hacen interesante la idea de trabajar en un Proyecto Terminal
son la posibilidad de vincular los conocimientos adquiridos a lo largo de la
carrera de Electrónica y Computación, así como extender estos conocimientos en
un área que permita obtener una visión distinta del trabajo en red. El presente
trabajo habla de un Sistema que permite a un grupo de personas trabajar de
manera conjunta y organizada sin necesidad de estar enel mismo sitio para
expresar sus ideas y desarrollar su trabajo. Esto puede conseguirse a través de
una red de computadoras(por ejemplo Internet), en donde se puede trabajar
en un documento (que puede ser de texto, dibujos, o archivos de algún otro
tipo) y observar de manera inmediatalos cambios que cada una de las personas
hace sobre el documento, elhecho de trabajar vía Internet implica que los
usuarios pueden encontrarse en cualquier parte del mundo; a un sistema con las
características descritas se le denomina Sistema Cooperativo. Pero no sólo es
eso lo interesante, sino poder entender qué es lo que hay detrás de este sistema y
que permite dicho comportamiento, así como entender la utilidad y los alcances
del sistema para un trabajo en grupo de manera organizada.
A lo largo de esta exposición se explicará cuáles son los elementos que
hacen posible dicho sistema y cuáles son las razones por las que se utilizan las
herramientas para el diseño e implementación.
En el capítulo 1 se presentan las objetivos que este trabajo persigue y la
forma en que se distribuye dicho trabajo.
Para el capítulo 2 se da una breve explicación de los conceptos necesarios
para el desarrollo del sistema.
En el capítulo 3 se comienza a dar el modelo generado para el sistema, así
como su implementación.
En el capítulo 4 se muestran lascaracterísticas del sistemay su funcionamiento.
Por ultimo en el capítulo 5 pueden encontrarse a
ls conclusiones de este
trabajo.
Ya existe el modelo fundamental para este Sistema y una primera aplicación, el siguiente paso es pensar en una extensión delmodelo que consiga
hacerlo más variado y por lo mismo útil. No es el objetivo de este trabajo
extender la primera aplicación sino hacer una segunda.
AI concluir la presentación del sistema podrá disponerse del código fuente
en una página en Internet que será señalada más adelante esto con la intención
iv
de proporcionar a los interesados la oportunidad de evaluar, corregir, modificar
o extender el sistema.
V
Introducción
Se puede hablar de un Sistema Cooperativo como una aplicación de 10s Sistemas Distribuidos. Este sistema pretende dar la apariencia de un documento
centralizado sobre el cual una o más personas trabajan en tiempo real(1a actualización del documento debe ser rápida para aparentar esto), lo que permite ver
los cambios que cada persona realiza sobre el documento en el momento que se
hacen. La realidad es que cada una de las personas tiene en su computadora
una copia del documento y el sistema se encarga de hacer las actualizaciones correspondientes sobre cada uno de los documentos. El sistema permite al usuario
saber cuales son los grupas de trabajo que ya existen o crear su propio grupo
de trabajo. Ya dentro del sistema se puede saber quienes son los usuarios que
se encuantran trabajando en ese momento.
Existen sistemas comerciales que poseen las características antes mensicnadas (como Netmeeting de internet explorer o Netscape Conference) aparte
de un conjunto de carcaterísticas adicionales que los hacen muy utiles para la
comunicación escrita o visual.
Para poder conseguir lo anterior es necesario entender lo que una aplicación
distribuida significa así como los requerimientos para trabajar en un ambiente
Cliente/Servidor.
Java fue el lenguaje de programación elegido para la implementación del
sistema ya que el modelo es orientado a objetos y el lenguaje permite implementar un modelo con esa característica.
Otras de las ventajas de Java son la funcionalidad que ofrece para un desarrollo sencillo de un ambiente gráfico, así como su mecanismo de interconectividad que es RMI y que hace sumamente sencilla y segura la comunicación a
través de una red.
L a primera aplicación denominada FirstAplication permite trabajar con
texto con las características citadas al inicio de la introducción, no es nuestra
intensión presentar esta aplicación pero si hacer una descripción de lo que será
la extensión del sistema creando una segunda aplicación con las mismas características de funcionamiento pero con una utilidad distinta que permitirá crear
y editar objetos gráficos y texto.
vi
Capítulo 1
Objetivos
El proyecto está dividido en dos partes.
perseguidos son:
En la primeraparte
los objetivos
o
Presentar aspectos fundamentales del paradigma orientado a objetos que
permitan entender los modelos y conceptos, expuestos mas adelante.
o
Entender los fundamentos de un Sistema Distribuido.
o
Conocer alternativas para la interconectividad como son RPC y CORBA
y realizar una comparación con RMI.
o
Conocer y trabajar con Java.
Los objetivos para la segunda fase del proyecto son:
o
Diseñar y presentar el modelo de lo que será la nueva aplicación.
e
Definira
ls características específicas del sistema y la funcionalidad que
&te ofrece.
1
Capítulo 2
Fundamentos
2.1
Análisis y Diseño Orientado a Objetos
La utilización del paradigma orientado a objetos ofrece ventajas como la abstracción que permite ladescomposición de la complejidad de los sistemas, encontrando patrones comunes de comportamiento entre los elementos de un sistema
específico. Esto permite agrupar adichos elementos en lo que se denomina como
clases que se pueden pensar como un modelo o la especificación de características
y comportamiento del objeto que la clase está modelando. Al hablar de un objeto nos referimos a una instancia de la clase, cada objeto creado de una clase
tendrá un comportamiento, estado e identidad que le permitirá ser distinguido
de los demás. La definici6n de clases resulta subjetiva porque depende del interés del individuo que quiere describir y modelar al sistema. Pensando en una
red de comunicaciones como un sistema puede ser diferente el modelo que un
ingeniero propone del que un usuario puede proponer, pues este último sólo se
preocupa por los serviciosque la red ofrece mientras que el ingeniero deberá preocuparse por todos los elementos relacionados. Un buen grado de abstracción
permite identificar las jerarquías y relaciones entre los objetos para entender
el funcionamiento del sistema de forma más adecuada, también permitirá extender el sistema agregando características nuevas sin muchas dificultades, se
podrá hablar de unaevolución del sistema y de la reutilización de elementos [l].
Como ejemplo se tiene al sistema cooperativo que pretende poder comunicar a uno o varios clientes con un servidor que se encargará de ofrecer diferentes servicios como la comunicación entre los usuarios. Lo que nos interesa en
este caso son tanto las propiedades como el comportamiento del los elementos de
este sistema. Al pensar en un comportamiento común entre los objetos podemos
pensar en que cada cliente desarrolla el mismo comportamiento aunque pueden
encontrarse, cada uno, en distintos estados y tener diferentes identidades que
permitirán distinguirlos, esto puede permitir definir una clase de tipo Cliente.
Si por ejemplo el cliente necesita crear una ventana para su área de trabajo
y ya existe una clase ventana que cuenta tal vez no con todas pero sí con la
2
mayoría de las características que se requieren se puede crear una nueva clase
ventana que tome las características de la clase ventana inicial y que además
agregue características nuevas, con esto estamos utilizando una característica
de la programación orientada a objetos llamada herencia.
Otro aspecto interesante que se puede hacer es crear una clase que defina
el comportamiento de lo que un objeto debe tener sin implementar este comportamiento, a esto se le llama interface y tiene como finalidad que la persona
implemente el comportamiento de la forma que más le convenga.
Gracias a la herencia puede definirse para una clase servidor un comportamiento inicial sabiendo 'que se puede evolucionar a la clase servidor de una
manera sencilla y sin hacer grandes cambios; se está reutilizando lo que ya existía. Desde luego tanto el cliente como el servidor en general pueden constar
de varias clases. Lo que se puede hacer es agrupar estas clases dando como resultado lacreación de un módulo, con esto se puede conseguir que la estructura
de cada módulo sea lo bastante simple para ser comprendida en su totalidad,
a lo anterior se le denomina modularidad, cada uno de estos módulos debe ser
débilmente acoplado, es decir no debe ser dependiente de otros módulos porque
esto generaría problemas para la reutilización de elementos. En el caso de las
relaciones entre objetos se define la relación de enlace para la cual el paradigma
define la comunicación enhe objetos que no es más que el paso de parámetros
entre ellos o la utilización lde los métodos de un objeto por otro. La relación de
agregación se refiere a la contención de un objeto en otro, de forma explícita se
puede encontrar la declaración de una clase dentro de otra. Un ejemplo sería
crear una clase botón y una clase ventana que siempre necesite de botones,
entonces se puede definir a la clase botón dentro de la clase ventana.
2.2
Programación Distribuida
Los siguientes conceptos son comunes para los temas de programación distribuida citecomputing y ,se hará uso de ellos a lo largo de este trabajo:
o
Marshal: Es la tarea, de empacar los argumentos de un método para entregarlos al objeto remoto y la tarea de recoger los valores regresados por
el método para el cliente [a].
o
Skeleton: Es la interfaz entre la implementación del objeto remoto y el
administrador de objetosdel lado del servidor y es usado para crear nuevas
instancias de la clase y para conducir las llamadas de métodos remotos a
l a implementación del objeto.
o
Stub: Es una interfa,z del cliente para clase de objetos y es usado por el
cliente para conducir las transacciones al objeto en el servidor.
3
2.3
Comunicación con RPC (Remote Procedure
Call)
La Llamada a Procedimientos Remotos (RPC en inglés) permite a un cliente
ejecutar procedimientos en otra computadora en la red o servidor remoto. El
término remoto no necesariamente significa que el cliente y el servidor se están
comunicando a través de la red; de hecho, pueden ambos existir en la misma
máquina. La diferencia entre llamada a procedimientos local y remoto es que
enel primer caso el cliente ejecuta el proceso en su propio espacio de direccionamiento y en la segunda el cliente y el servidor se ejecutan como dos procesos separados. La biblioteca de RPC maneja la comunicación entre estos dos
procesos. RPC utiliza un modelo de comunicación petición - respuesta [3]. El
cliente envía un mensaje de petición al servidor el cual regresa un mensaje de
respuesta. La comunicación entre el cliente y el servidor se lleva a cabo por
medio de dos stubs uno del lado del cliente y otro del lado del servidor. Aquí
puede verse una diferencia entre RMI y RPC ya que el primero no utiliza dos
sino sólo un stub que está del lado del cliente y un skeleton del lado del servidor.
En RPC un stub se define como una interface que implementa el protocolo de
RPC y especifica como serán construidos e intercambiados los mensajes. Los
stubs son generados por medio de un compilador que los liga al cliente y al
servidor.
En la figura 2.1 puede verse cómo se ejecutan una petición local y una
remota. El cliente hace una petición al servidor pasando argumentos y el servidor responde a la petición enviando resultados al cliente. En el diagrama de la
izquierda la comunicación es bastante simple, y en el diagrama de la derecha
el cliente y el servidor se valen cada uno de su propio stub para efectuar la
comunicación y los stubs utilizarán el transporte de red para comunicarse entre
ellos y dar la petición o entregar resultados a quien corresponde.
La utilización de IPC (Interprocess Communications) es esencial para el
modelo cliente-servidor, el problema es que su utilización resulta poco fácil pero
con la utilización de RPC! menos laborioso, también se evita la necesidad de
trabajar a bajo nivel. En RPC en general, losservicios se encuentranala
espera de una petición de conexión, el servicio puede dar al cliente la dirección
que necesita para abrir el canal de comunicación con el servidor. El servidor
puede entonces aceptar la petición (o denegarla) enviando la respuesta necesaria.
El servidor debe indicar al registro de puertos en que puerto estará ubicado para
que cuando el cliente haga la petición obtenga la dirección correspondiente. Los
pasos necesarios para la comunicación con RPC son:
1. Cuando cualquier servidor RPC (demonio o proceso que está a la espera
de una petición) es iniciado, este establece una dirección donde escuchará
la petición. Debe registrar el número de puerto (dirección), en el mapa
de puertos. El cliente y las aplicaciones del servidor tienen direcciones
arbitrarias.
2. Antes de que el cliente pueda hacer una llamada remota a procedimiento
4
Uamccia Locd
Figura 2.1: Petición local y remota.
(usando un número de servidor de programa), el mapa de puertos en la
máquina del servidor es consultado para identificar el número de puerto
que va a recibir el mensaje de petición de RPC.
3. El cliente y el servidor pueden entonces abrir una ruta de comunicación
para ejecutar el Procedimiento Remoto. El cliente produce una petición;
el servidor envía una, respuesta.
En la figura 2.2 puede verse como el cliente hace consulta al mapa de
puertos preguntando por Ita dirección del puerto donde el servidor escuchará las
peticiones. El servidor por su lado registraen el mapa depuertos la dirección del
puerto que utilizará para escuchar las peticiones. Una vez efectuado lo anterior
puede establecerse la ruta de comunicación.
2.4
CORBA (Common Object Request Broker
Architecture)
En 1989 fue fundada la OlMG (Object Management Group) y actualmente es
un consorcio de cerca de 700 miembros. Su principal meta es dar a
ls bases
para construir aplicaciones distribuidas orientadas a objetos, con lo cual desarrolló CORBA(Commor1 Object Request Broker Architecture). CORBA fue
diseñado para permitir que a
ls aplicaciones se comuniquen entre sí, sin importar la plataforma en la que estén, el lenguaje en el que hayan sido creados ni el
lugar donde se estén ejecutando. CORBA usa objetos para unificar la comuni-
5
I
I
r
,
Figura 2.2: Interacción cliente - servidor.
cación entre aplicaciones y también ofrece servicios para accesarlos por nombre,
guardarlos, mostrar sus estados y definir relaciones entre ellos, CORBA tiene el
potencial para tomar ventaja de cualquier otro desarrollo cliente/servidor. La
primera versión de CORBA salió en 1991, la versión 2.0 en 1994 y la versión 3.0
en 1998.
Los componentes que conforman CORBA son los siguientes:
ORB (Object Request Broker) Que es el que permite a objetos cliente que
invoquen a métodos de objetos servidor sin tener consideraciones del lugar
donde se encuentren estos últimos.
o
IDL (Interface Definition Languaje) Es usada para especificar el protocolo
por el cual los objetos distribuidos pueden ser accesados.
o
IIOP (Internet inter-ORB protocol) Un protocolo binario para la comunicación entre ORB, el cual permite mandar mensaje a sistemas remotos
de diferentes vendedores vía TCP/IP.
2.4.1
IDL (Interface Definition Language)
El lenguaje de definición de interfaz permite especificar el contrato y los límites
que tendránlos component,es,esto es que sólo hace la declaración de los métodos
y no los implementa. Cuando es compilada la interfaz en el cliente y el servidor,
a
ls entradas y salidas en los argumentos de los métodos son usadas para generar
el código marshal y unmarshal de los argumentos del método correctamente.
6
2.4.2ORB(ObjectRequestBroker)
Es la parte que permite tener objetos que hagan peticiones a otros objetos que
sean locales o remotos, esto permite obtener:
e
Invocaciones dinámicas y estáticas.
e
Unión a lenguajes de alto nivel.
e
Sistema auto descriptivo.
e
Transparencia remota/local
e
Seguridad en los mensajes.
o
Mensajes polimórficos.
La ORB del cliente es responsable de aceptar peticiones del cliente para
un objeto remoto, encontrando la implementación del objeto en el sistema distribuido, aceptando la referencia del lado del cliente con el objeto remoto. Del
lado del servidor laORBpermite que objetos del servidor registren nuevos
objetos, el servidor ORB recibe la petición del cliente ORB y usa la interfaz
del skeleton del objeto para invocar la activación del método de ese objeto, el
servidor ORB genera una referencia del objeto para elnuevo objeto y envía
esta referencia al cliente, el cliente ORB convierte esta referencia al lenguaje
específico y el cliente usa esta referencia para invocar métodos enel objeto
remoto.
2.4.3ORB
en elservidor
Una vez que las interfaz IDL ha sido escrita, esta puede ser convertida al stub
del cliente y el skeleton del servidor, para hacer esta tarea existen conversores o
compiladores que traducen la interfaz en código para ser usado por el lenguaje
en el que se realizará la implementación. Conversores de IDL existen para C,
C++, Smalltalk, Ada, Java (JOE es un compilador IDL para Java, y NEO es la
interfaz aplicación/programación que permite a los programas ser integrado a
NEO y es el que provee soporte para aplicaciones de redes integrando CORBA) ,
etc. El skeleton del servidor actúa como la base para la implementación de
la interfaz del objeto e incluye métodos específicos que el servidor ORB usa
para mapear una petición del cliente con la llamada del método del objeto
implementado. Una vez definido la implementación para el objeto, se necesita
registrar la implementaci6n del objeto con el servidor ORB y opcionalmente
ligarlo con un nombre. En lado del servidor tenemos los siguientes elementos:
e
Los stubs IDL del servidor.
0
La interfaz dinámica skeleton.
e
El adaptador de objetos.
7
o
La implementación d.el repositorio.
o
La interfaz ORB.
2.4.4
ORB en el cliente
El cliente usa un stub para accesar los datos y métodos de una instancia remota
del objeto. Un stub es generado compilando el IDL, el stub contiene métodos
específicos de CORBA para que el cliente ORB pueda realizar marshal a los
argumentos del método para ser enviados al servidor y unmarshal para valores
regresados. Los componentes que tenemos del lado del cliente son los siguientes:
o
El stub IDL del cliente.
o
La interfaz dinámica de invocación.
o
La interfaz depositora de APIs.
o
La interfaz ORB.
El stub y el skeleton no tienen porqué estar compilados enel mismo
lenguaje de programación.
Lenguajes soportados por CORBA: C, C++, Java, Ada95, Cobol y Smalltalk entre otros.
Plataformas Win32, IJnix , MVS
Protocolos de comunicación e interconexiones soportados por CORBA:
TCP/IP, IPX/SPX, FDDI., ATM, Ethernet.
Hardware: RISC y CISC.
Ventajas:
o
La creación de aplicaciones extensibles.
Soluciones escalables.
o
Desacoplo con la interfaz de usuario.
o
Independencia del lenguaje de programación.
o
Administración basa'da en el web.
Integración con productos comerciales NMS(network management system).
2.5
RMI(RemoteMethodInvocation)
El mecanismo RMI permite la acción de invocar métodos de unainterfaz remota
en un objeto remoto. RMI es parte de Java APIy ofrece loselementos necesarios
para desarrollar un sistema distribuido de objetos en Java citeRMITutoria1.
Los objetivos de RMI son:
8
Figura 2.3: Arquitectura de capas de RMI.
o
Dar soporte a llamadas de regreso del servidor a applets
o
Integrar el modelo de objetos distribuido en el lenguaje Java.
o
Desaparecer las diferencias entre modelos de objetos distribuidosy objetos
locales.
o
Hacer la escritura de aplicaciones distribuidas lo más sencilla posible.
o
Preservar la seguridad proveída por el ambiente de ejecución de Java.
El sistema RMI consiste de 3 niveles:
o
Nivel stub/skeleton
o
Nivel de referencia remota
o
Nivel de transporte
como se ve en la figura 2.3.
2.5.1
Nivel
stub/skeleton
El nivel stub/skeleton es la interfaz entre el nivel de aplicación y el resto del
sistema RMI. Esta capa no se preocupa con especificaciones de transporte, pero
transmite datos a la capa de referencia remota vía la abstracción de flujos marshal, el flujo marshal emplea un mecanismo llamado serialización de objetos el
cual permiteaobjetosJava
ser transmitidosentre direcciones remotas. Los
objetos transmitidos que usan el sistema de serialización de objetos son pasados
por copia a la dirección rernota, en caso de que los objetos transmitidos sean objetos remotos, estos son pasados por referencia. El stub para un objeto remoto
es el lado del cliente tiene como funciones:
9
o
Iniciar las llamadas a un objeto remoto.
o
Realizar el marshal a. los argumentos y mandarlos a un flujo marshal.
o
Informar al nivel de referencia remota que una llamada debe ser invocada.
o
Realizar unmarshal para el valor regresado de un flujo marshal.
o
Informar a el nivelde referencia remota que la llamadaha sido completada.
El skeleton para un objeto remoto es una entidad del lado del servidor que
contiene un método el cual atiende las llamadas para la implementación del
objeto remoto, sus funciones son descritas a continuación:
o
Realizar unmarshal de los argumentos obtenidos de un flujo de marshal.
Hacer la llamada para laimplementación del objeto remoto.
o
Realizar el marshal al valor regresado de la llamada o excepción en un
flujo marshal.
2.5.2
Nivel de referencia remota
El nivel de referencia remota se encarga de lidiar con la interfaz de transporte]
también es responsable por exteriorizar un protocolo de referencia remota específico. El nivel de referencia remota tiene 2 componentes que son cooperativos
entre si, uno del lado del cliente y otro del lado del servidor. El lado del cliente
tiene información específica para el servidor remoto y se comunica usando el
nivel de transporte vía la abstracción de un flujo orientado a conexión.
2.5.3
Nivel de transporte
El nivel de transporte es el encargado de poner la conexión con las direcciones
remotas, manejar las conexiones, escuchar las llamadas entrantes, mantener una
tabla de objetos remotos que existen en las direcciones] entre otras cosas.
Los componentes del sistema RMI son los siguientes:
2.5.4
Interfaz del objetoremoto
Es donde se hará la declaración del objeto y los métodos remotos que serán
usados por el cliente e implementados en el servidor, esta interfaz debe extender
la interfaz java.rmi.Fkmote con lo que se marcará al objetocomo objeto remoto
para el sistema RMI, el stub del cliente y el skeleton del servidor son creados
de esta interfaz.
10
2.5.5
Implementación en el servidor
Ya que sedefinió la interfaz del objetoremoto, se debe escribir la implementación de la interfaz enel servidor, este usualmente también extiende la
clase java. rmi. server .UnicastRemoteObject
y esta asu vez extiende la clase
java. m i . server.
Remoteserver
la cual es la clase base para implementar objetos en RMI.
2.5.6
El registro RMI
El registro se inicia usando el comando rmiregistry, este solo es necesario iniciarlo del lado del servidor, una vez que se inicia el registro en el servidor, por
default este usa el puerto 1099 aunque puede usarse cualquier otro. Una vez que
el registro esta funcionando uno puede registrar la implementación del objeto
usando un nombre, por medio de la interfaz java.rmi.Naming, por otro lado el
cliente puede localizar esta clase registrada usando java.rmi.Naming.lookup
2.5.7
Stub del cliente y skeleton del servidor
Una vez definida la interfaz del objeto y echa la implementación en la clase
servidor se compila la clase de forma usual en Java y para la creación del stub
y del skeleton se hace uso del compilador de stub de RMI llamado rmic [4]. El
skeleton actúa como una interfaz entre el registro RMI y las instancias de la
implementación del objeto en el servidor, cuando el cliente hace una petición
para la invocación de un método esta es recibida y el skeleton es llamado para
extraer los parámetros serializados y pasarlos a la implementación del objeto. un
stub del cliente es regresado al cliente cuando la instancia remota de la clase es
solicitada atravez de la interfaz Java.rmi.Naming, el stub tiene que engancharse
al subsistema de serialización del objeto en RMI para realizar el marshal a los
parámetros del objeto.
A continuación tenemos un ejemplo de un programa cliente/servidor implementado con RMI. Supongamos que tenemos una computadora que está
físicamente conectada a equipos de monitoreo de clima (termómetros, medidores de huwedad, etc). Este sería nuestro servidor. El método remoto que
se va a invocar es getClimaLectura( 1, se necesitará una implementación de
esto en e1 servidor, y tendremos que proveer de una interface al cliente para que
pueda saber cuales son los servicios ofrecidos.
Esta es la clase que encapsula las lecturas del clima.
import java.io.*;
public class Lectura implemeets
Serialirrable(
public String forecast;
public float lluvia;
public float temperatura;
11
public
public
float velviento;
String barometro;
public Lectura (String s,float r,float t,float w,String
b)
{
forecast = S ;
lluvia = r;
temperatura = t;
velViento = n;
barometro = b;
3
3
El código del cliente essumamente simple y se deben considerar dos aspectos importantes:
1. La definición de un administradordeseguridad;que
proporcionan las librerias de Java.
puedeserel
que
2. Definir un administrador de excepciones; el cual se encarga de notificar al
usuario de posibles problemas.
import java.rmi.*;
import java.rmi.server.RMIC1assLoader;
public class ClienteR
{
static public void main
(Stringu S ) {
System. setSecurityHanager(new RMISecurityManagero
1;
try {
Class cl= RMIClassLoader.loadClass("Ap1ic");
Runnable client= (Runnable) cl.neaInstance();
client.run();
3 catch(Exception e) {
System.out.println(e);
1
3
3
Esta es la parte del cliente
import java.
.rmi
Naming ;
12
public class Aplic implements Runnable
{
public voidrun0 C
Lectura g= null;
try C
ClimaIntf wi= (Clima1ntf)Naming.
lookup("//laryc.uam.nur/Clima");
g = wi .getClimaLecturaO;
3 catch(Exception e) C
System.out.println(e);
3
if (g! = null) C
System. out.
println("E1
clima.forecast)
es "+g
;
System.out.println(g.11uvia +
"cm. de lluvia
han caido recientemente");
System.out .println("la temperatura " es
+
g.temperatura + *'C+'>
;
System.out .println("velocidad del viento:I' +
g .velViento + "kmh") ;
System.out .println("el barometro indica
+
g.barometro);
I'
3
3
3
Esta es la interface donde se definena
ls funciones que soportará el servidor
import java.rmi.*;
C
public interface ClimaIntf extends Remote
public
Lectura
getClimaLectura0
throws
RemoteException;
3
Esta es el servidor e irnplementa los métodos que se definieron en la interfaz.
import java.rmi.*;
import java.rmi.server.UnicastRemote0bject;
13
public class ClimaImpl extends UnicastRemoteObject
implements ClimaIntfC
Lectura
g = new Lectura("soleado",O.OF,75.OF,5.OF,"steady");
public ClimaImplO throws RemoteException C
super ( 1 ;
3
public static void main (String argC1)C
System.setSecurityManager(new RMISecurityManagero);
try
ClimaImpl wi = new ClimaImplO;
Naming.rebind("Clima",wi);
System.out.println("Estaci6n de climafuncionando");
3 catch(Exception e) C
System. out.
println( "ClimaImpl error: + e) ;
3
3
public Lectura getClimaLectura() throws RemoteException C
return g;
3
3
Como puede verse es sumente simple tomar esta alternativa comparándola
con la opción de implementar la comunicación por medio de sockets. RMI
permite hacer referencia a métodos remotos, como si estos estuvieran en la
misma máquina.
2.6
Serialización de objetos
Otra facilidad que brinda RMI es la serialización de objetos, Java incluye esta
clase para poder convertir un objeto enun flujo de bytes y reensamblar los
bytes de nuevo a una copia idéntica del objeto original, en RMI la serialización
facilita el uso para realizar marshal y unmarshal a los argumentos objetos delos
métodos, cualquier objeto que sea usado como argumento en un método remoto
debe ser una extensión de java. io.Serializable [5].
Esta utilidad de serializar objetos será considerada para conseguir que el
programa guarde el trabajo realizado en un archivo, para m& tarde hacer uso
nuevamente de la información.
14
2.7
AWT
Otra de las caracteristica que será de gran ayuda para el desarrollo y diseño
de la interfaz el AWT(Abstract Window Toolkit), se debe tener en cuenta la
versión de Java que se emplea ya que hay diferencias en cuanto al modelo de
AWT que se emplea en la versión 1.0 y la versión 1.1 en adelante [6].
El cambio de java 1.1 más notable es el nuevo procesamineto de evento,
adoptado para el kit de herramientas de Interfaz de Usuario Gráfico (CUI) y de
ventanas AWT, se da esencialmente un modelo ”de llamada” citeGraficaAwt.
Cuando se crea un componente de GUI, se dice a éste qué método o métodos
debe invocar cuando ocurra un evento particular (por ejemplo, cuando el usuario
presiona un botón del mouse o elige un elemento en una lista). En este modelo
diferentes clases de Java representan las distintas clases de eventos, se da el uso
de listeners(oyentes), son objetos que se dedican a ofrecer los servicios cuando
determinado evento ocurre. Un objeto que genera eventos(un evento fuente)
mantiene una lista de oyentes interesados en saber cuándo ocurre el evento y
proporciona métodos que permiten a los oyentes agregarse y removerse de una
lista de objetos interesados.
El siguiente es un pequeño ejemplo del uso de los oyentes.
public class Escribir implements MouseListener
-t
private int ultimo-x, ultimo-y;
//le dice a este applet que objetos de MouseListener
public void i n t o
this.addMouseListener(this) ;
<
3
/ / Un método de lainterfaz MouseListener invocado cuando
// el usuario presiona el botón del ratón
public void mousePressed(MouseEvent e) <
ult imo-x
= e. getx ( ) ;
ultimo-y = e. gety()
;
3
Siempre que se emplean oyentes aun cuando algunos de sus métodos no
sean usados, como en el caso anterior, se deben definir sus métodos. Para evitar
esto se puede hacer usu de Adapatadores(Adapters) que nos permiten declarar
sólo los métodos que nos hacen falta.
15
Capítu10 3
Modelo de la Aplicación
Funcionalidad
ofrecida
3.1
La descripción del sistema comienza con la funcionalidad que este ofrecerá y
más adelante se comenzará con la descripción de los diagramas de clase.
o
Contar con un área que permita ver quienes están trabajando en ese momento con el documento que se eligió.
o
Contar con un área de envío y recepción de mensajes para lacomunicación
entre usuarios. Como característica, el usuario podrá elegircon cuales
personas desea comunicarse, o hacerlo con todas a la vez.
Disponer de un menú del cual se puedan escoger la aplicación con la cual
( así como el documento, ya que podrán existir varios
trabajos en torno a los cuales se forman grupos de trabajo).
se desea trabajar
o
Contar con un área de dibujo que permita escoger el tipo de elemento que
se desea dibujar. También debe poderse escoger el color para cada objeto.
o
De la misma forma que el punto anterior se debe contar con un área de
texto (en una ventana a parte del área de dibujo) que permita trabajar
con un documento de tipo texto.
o
Tener la posibilidad de guardar el trabajo ya hecho en un archivo con un
formato definido más adelante. Desde luego también deben poder abrirse
documentos ya creados y editarse.
3.2
3.2.1
Jerarquía deClases
Cliente
A continuación se muestra la jerarquía de clases del Cliente ver figura 3.1.
Las interfaces para
16
17
Figura 3.1: Jerarquía de ciases del cliente.
1nterface.WorkgroupInterface
Y
1nterface.FirstgroupInterface
sólo definen parte de lo que el sistema hace y serán las clases como
Workgroup
Y
Works.MainAp1icaction
las que realmente implementarán dicho comportamiento. A continuación se da
la descripción de lo que hacen a
ls funciones más importantes:
En general todas lasinterfaces extienden la clase java.rmi.Fkmote haciendo
que las clases que hagan uso de ellas, puedan ser llamadas remotamente. Siendo
la parte del protocolo que se utiliza en RMI.
La función
UpdateUserList
que pertenece a
1nterface.WorkgroupInterface
se encarga de actualizar la lista de usuarios cada vez que uno de estos
entra o deja el sistema recibiendo como parametro un elemento de tipo
java.uti1.Vector
que le permite saber quién fue el usuario que entró o salió.
o
La función displayMessage es parte de la inteface FirstgroupInteface y es
implementada en la clase MainApplication es parte del mecanismo que
implementa la comunicación entre usuarios.
o
La función Updatetopics que también es parte de FirstgroupInteface se
encarga de actualizar la lista de temas exitentes al momento de entrar un
usuario al sistema.
La clase DrawApplication se encarga de la creación y manipulación de los
objetos gráficos.
La clase TextApplication implementa aligual que las demás métodos, atributos y se vale de otras clases para poder manejar la utilidad de texto que es
parte del sistema.
Enseguida se incluye el código de la clase MainApplication.
18
package
import
import
import
import
import
import
import
//se utilizan 3 paquetes para
// modularizar el sistema
//en works se encuentran todas las
java.awt.*;
// clases relacionadas
//directamente con el cliente.
java.awt.event.*;
java.io.Serializable;
java.rmi.*;
java.rmi.server.*;
java.util.Vector;
Interface.*;
Works;
Esta parte se utiliza para incluir los paquetes necesarios empleados por
la clase. El mismo sistema se encuentra en un paquete y esto se hace con la
intención de modularizar que es una de las características mensionadas enel
capítulo de fundamentos al principio del trabajo.
//Se puede ver cuales son las clases que MainApplication
//extiende y las interfaces que implementa.
public
class
MainApplication extends Frame
implements WorkgroupInterface,
FirstgroupInterface,
Serializable,
Remote,
ActionListener,
WindowListener €
//se da ladescripción de las variables empleadas
Referencia al servidor
*/
private FirstInterface server;
private String addressserver;
private String userhlame;
private String grouphlame;
/** Indica si está conectado ha algún servidor
*/
private boolean state;
/** Contiene los nombres delos usuarios que estan en el mismo
tema */
private Vector partners;
/** Contiene los nombres de todos los usuarios del sistema
*/
private Vector allUsers;
/** Contiene los temas existentes en el servidor
*/
private Vector themes;
private ChatArea area;
/**
19
private Label statusBar;
private TextApplication textApplication;
private DrawApplication drawApplication;
public MainApplicationo{
state = false;
userName =
setMenuBar(new HenuMainApplication(this));
area = new ChatArea(this1;
add("Center",area) ;
statusBar = new Label("",Label.RIGHT);
add("South",statusBar);
pack() ;
1
//Esta función se encarga de obtener
y verificar el nombre de
// usuario
public voidactionPerformed(ActionEvent e) €
Vector v;
String S ;
Object o = e.getSource();
if ( o == area.msgField I I o == area. send)
{
S = area.msgField.getText0;
//verifica
que
nombre
el
if(s.length() > O) {
// del usuario
S = userName +
+ S + "\n"; //no tenga longitud cero
area.addMessage(s);
//y obtiene
a
los
// usuarios del grupo
area.
msgField
.setText("") ;
area.
msgField
.requestFocus( ) ;
v = area.getAlXPartners();
send(s,v) ;
'I:
'I
1
1
e.getAct
ionCommand()
;
if ( s == "salir") {
salir();
S =
1
if( s == "item 1") 4:
//paraunaaplicación de tipo
// texto
textApplication = new TextApplication(this,
"Text application: : + userName,this);
I'
textApplication.setLocation(l00,100);
textApplication.setVisible(true);
1
20
if(s == "item 2") €
//para
una
aplicación
de
// dibujo
drawApplication := new DrawApplication(this,
"Draw application: : + userName,this);
;
drawApplication. setLocation(100,lOO)
drawApplication.setVisible(true);
I'
3
3
/**
* Realiza la conexión con
* temas y de usuarios.
*/
el servidor obteniendo lista de
public boolean connecting(String address)
c
addressserver = " / , P + address + "/Firstserver";
try €
UnicastRemoteObject .exportObject(this)
;
server = (FirstInterface)Naming.lookup(addressServer);
if (server
== null) €
return false;
3
server.getListWorks(this);
3 catch(Exception e)
{
System.out.println(
"Error enMainApplication::connecting()");
e.printStackTrace();
return false
;
3
return
true;
3
/**
* Termina la conexi6n
*/
conel servidor.
public void disconnecting()<
try C
server.logoff(userNae,groupName);
state = false;
3 catch (Exception e)C
System.out.println(
"Error en MainApplication:
3
3
/**
21
:disconnecting()");
* Obtiene la direcc:i6n
* conexion.
*/
del servidor con el que se tiene
public StringgetAddress0
return addressserver;
<
{
public Vector getAllUsers()
return allUsers;
1
/**
* Obtiene
*/
el nombre del grupo donde se est& trabajando.
public StringgetGroup0 {
return groupName
;
1
public Vectorgetpartnerso
return partners;
<
3
public VectorgetThemes0 {
return themes
;
1
/**
* Obtiene
*/
el nombre de usuario que se est& usando.
public String getuser(){
return userName
;
3
/**
* Asigna
*/
un nombre de usuario
y un
nombrede grupo.
public void register(String group,String user)
{
WorkServerInterface workserver;
try <
workserver =(WorkServerInterface)
Naming.lookup(addressServer);
userName = user;
groupName = group;
if (workServer.login(this,user)) {
server.registerTopic(group,user);
state = true;
22
I
statusBar. setText("Name:" + user +
",
Theme: " + group) ;
3
3 catch (Exception e){
System.out.println(
"Error enMainApplication::register(String,String)");
3
3
public voidsalir0 c
if(state == true)
disconnectingo;
System.exit(0);
>
public void send(0bjecto ) C
send(o,partners) ;
3
/**
* Envía
*/
informaci6n
a
otros
usuarios.
public void send(0bjecto, Vector toUsers)
String partner;
if( toUsers. size(>==O)C
tousers = partners;
try C
server.
updateBuf
f
er, o )(groupName
;
3 catch(Exception e) C
System.out.println(
"Error en MainApplication:
:send(0bject ,Vector)")
;
System.out .println(" * server.updateBuffer0");
3
3
try C
for(int tmp = O; tmp < tousers.size0; tmp++) C
partner = (String)toUsers.elementAt(tmp);
if (userName. compareTo(partner)
!= O) C
server.unicastMessage(partner,o);
3
3
e) C
System.out.println(
"Error enMainApplication::send(Object,Vector)");
System.out.println(" * server.unicastMessage()");
3 catch(Exception
3
23
3
// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
// Implementacih deWindowListener
// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
public void uindowActivated(WindowEvent e) {
3
public void windowClosed(WindowEvent e) {
Object o=e.getSource();
if(o == textApplication) {
textApplication = null;
3
if(o == drawApplication) {
drawApplicat ion 1- null ;
3
3
public void uindowClosing(WindowEvent e) {
Object o=e.getSource();
if (o == textApplication) {
textApplicat ion.
exit
() ;
3
if(o == drauApplication) {
drawApplication.exit();
3
3
public void windowDeactivated(WindowEvent e) {
3
public void uindowDeiconified(WindowEvent e) {
public void windowIconified(WindouEvent e) {
3
public void windowOpened(WindowEvent e) {
3
// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
// Implementación de WorkgroupInterface
// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
24
/**
*
Recibe
mensajes
provenientes
del
servidor.
*/
public void displayConnect(String message)
throws RemoteException{
area. addHessage( message
+ "\n") ;
area.msgField.requestFocus0;
3
/**
* Recibe
*/
public
la lista de usuarios de todos los grupos.
void
updateUserList(Vector users)
{
throws RemoteException
allusers = users;
String partner;
area.removeAllUseru();
for(int tmp = O; tmp < users.size(); tmp++) {
partner = (String) users. elementAt ; (tmp)
if (userName. compareTo(partner)
!= O)
area.addAllUsers(partner);
3
// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
/ / Implementaci6n de FirstGroupInterface
// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
/**
*
Recibe la lista
de
usuarios
del
mismo
grupo.
*/
public void clients(Vector users) throws RemoteException
{
partners = users;
String partner;
area.removeUsers0;
for(int tmp = O; tmp < users.size0; tmp++) {
partner = (String) users.elementAt(tmp);
if(userName.compareTo(partner) != O)
area.addUsers(partner);
3
3
<
public void content(0bjecto ) throws RemoteException
3
25
/**
* Recibe
*/
informaci6n de otros usuarios.
public void displayHessage(0bjecto ) throws RemoteException{
String S= o. getclass( ) .getlame() ;
System-out.println("Recibiendo:
+ S);
I'
if(s.compareTo("java.1ang.String")
area.addHessage((String)o);
== 0 ) {
3
else if(s.compareTo("Works.Text") ==
if(textApplication!=null) {
textApplication.recive((Text)o);
0) {
3
1
else if(drawApplication!=null) {
drawApplication.recive((Forma)o);
3
3
/**
* Recibe la lista de temas
*/
public
disponibles
en
el
servidor.
void
updateTopics(Vector themes)
throws RemoteException{
this.themes = themes;
3
// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
public static void main(String
arg[])
{
int aux;
Vector v;
boolean b;
AddressDialog a;
RegisterDialog r;
MainApplication m= new MainApplication();
a = new AddressDialog(m,"Server address:",ll);
;
a. setTitle("Server address")
a.setLocation(i00,100);
a.setVisible(true);
if(a.getEstado0 == false) {
m.salir0;
3
System.out.print("1ntentando conexi6n
a. getTexto(
)+'I
b = m.connecting(a.getTexto());
26
.. .
") ;
con el servidor
'I+
r = new RegisterDialog(m);
System.out.print("0bteniendo temas
. ..
"1;
v = m.getThemes0;
System.out .println("listo");
if(v != null) C
System.out.println("Cargando") ;
for(aux = 0;aux <: v.sizeO;aux++) C
r.addGroupList((String)v.elementAt(aux));
3
3
System.out .print("Obteniendo usuarios
. .. " ) ;
v = m.getAllUsers();
System.out.println("listo");
if (v!= null) C
System.out .println("Cargando")
;
for(aux = 0;aux < v.size();aux++) C
r.addUserList((String)v.elementAt(aux));
3
3
r.setTitle("User register")
;
r .setLocation( iO0,ioO) ;
r.setVisible(true);:
if(r.getEstado() == false) -(
m.salir0 ;
3
m.register(r.getGroup(),r.getUser());
m.addWindowListener(new ¡fina());
m.setTitle("REMM Application");
m.setLocation(i00,100);
m.setVisible(true) ;
1
3
class wina extends WindowAdapter
{
public voidwindowClosing(WindowEvent e){
System.
exit
(O) ;
3
3
27
El texto dentro del código da una descripción de cada una de las funciones.
Las clases se encuentran dentro de paquetes para obtener modularidad en
el sistema. Existen 3 paquetes uno de ellos esworks en donde se encuentran
a
ls clases relacionadas con el cliente, en el siguiente paquete se encuetran las
clases relacionadas conel servidor y enel último paquete se encuentran las
interfaces utilizadas. Se trata de agrupar en forma lógica las clases para obtener
la modularidad buscada.
3.2.2
Servidor
La jerarquía de clases del Servidor-ver figura 3.2-que se presenta es explicada a
continuación.
En el diagrama se puede ver como las interfaces extienden a la interface
Java.Rmi.Remote para poder implementar la comunicación.
Firstserver y WorkgroupServer se encargarande implementar las funciones
de las interfaces. Algunas de las funciones más reelevantes se presentan a continuación:
En el caso de broadcastConnect() se desea de implementar un multicast
(enciar mensage a todos los usuarios que pertenecen a un mismo grupo de
trabajo).
o
Con las funciones logoin() y logoffw() se pretende conectar y desconectar
del al sistema a un usuario registrandolo en una lista o eliminandolo de
ésta.
La función connect() recupera la ista de clientes en caso de encontrar
usuarios.
La clase Register será la estructura de la lista junto con los métodos que se
encargarán de manipular sus elementos(como AddRegisterO, Erase() y Seek())
A continuación se da el código de una de las clases más importantes del
servidor que es Workgroup9
, erver.
package Server;
//Este es el
paquete donde se encuantran las
// clases
import
import
import
import
import
import
Interface.*; //relacionas con el servidor
java.rmi.*;
java.rmi.server.*;
java.rmi.registry.LocateRegistry;
java.util.*;
java. * ;
28
~~
Figura 3.2: Jerarquía de clases del servidor.
29
En el código anterior puede verse el uso del paquete server para agrupar
los elementos que forman parte del servidor. Y enseguida comienza el código de
la clase WorkgroupServer.
//Esta clase se vale del unicast para implementar
// la comunicación
public class WorkgroupServer extends UnicastRemoteObject
implements WorkServerInterf { ace
//Se declara un Hashtable para enlistar
los usuarios
// y su referencia
protected static Hashtable broadcastList
= new Hashtable();
public WorkgroupServer() throws RemoteException
{
super( 1 ;
3
public voidconnect(Workgroup1nterface client)
throws RemoteException<
if (!broadcastList.isEmpty()) € //checa si hay usuarios
Vector v= getuserlist(); //obtiene la lista de clientes
// verifica que cliente se conecto para
// actualizar la lista
try €
//hace una llamada remota enviando
la lista
// de clientes
client.updateUserList(v);
1 catch (Exception e)€
System.out.println("Error en WorkgroupServer::connect");
System. out. println("WorkServer error:
+
e. getMessage()
);
e.printStackTrace();
3
3
I'
1
public void logoffW(String user) throws RemoteException
{
// remove el cliente desde broadcastList
// permitiendo que cada uno de los clientes conozca
// su salida
if (broadcastList.containsKey(user)) {
broadcastList.remove(user) ;
String message;
message = user + " leaves the Work
'I;
30
broadcastconnect
(message)
;
System.out.println(message);//despliega en consolala
// salida del cliente
3
Vector userList= getUserList0;
Enumeration e = broadcastList.elements();// enumara los
// clientes
// conectados.
while (e.hasMoreElements()) {
WorkgroupInterface c = (WorkgroupInterface)
e.
nextElement
(1 ;
updateUserlist(c, userlist); //actualiza la lista
3
public synchronizedboolean login(Uorkgroup1nterface client,
String user)
throws RemoteException{
if (broadcastList
.containsKey(user1)
//si el usuario esta contenido manda un mensaje
+ user +
client. displayconnect ("Login name
" ' is already in use."
+ "\nPlease type another user name.
;
return false;
'I'
'I)
3
// si el usuario no esta adentro
de lalista
// el user se usa como llave
y client como valor
// de la llave
broadcastList.put(user, client);
broadcastconnect (user
+ has entered the Workgroup")
;
System-out.printlnCuser + has entered")
;
Vector userList
= getUserList( ) ;
// enumera los clientes conectodos.
Enumeration e = broadcastList.elements( ) ;
while (e.hasMoreElements0){
WorkgroupInterface c = (WorkgroupInterface)e.nextElement();
//actualiza sus listas
updateUserList(c userlist) ;
I'
I'
~
3
return
true
;
3
public void broadcastConnect(String message)
{
/ / enumera las llaves
// y manda un mensaje
a todos los clientes de
= broadcastList .keys
(1 ;
Enumeration enum
31
lalista.
while (enum.hasMoreElements()) <
String key= (String) enum.nextElement();
WorkgroupInterf ace client
= (WorkgroupInterf ace)
broadcastList.get(key);
try { //hace uso de una llamada remota
client.displayConnect(message);
3 catch (Exceptione) {
System.out.printh(
"Error enWorkgroupServer::broadcastConnect");
System.out.println("Connect:
+ e.getMessage0);
e.printStackTrace0;
3
1
3
private Vector getuserlist(){
Vector v = new Vector();
// hace un vectorde usuarios.
Enumeration e= broadcastList.keys();
while (e.hasMoreElements()) {
String user= (String) e.nextElement();
v.addElement(user);
3
return v;
3
private
voidupdateUserList(Workgroup1nterface client,
Vector userlist){
// verifica que cliente se conecto para actualizar
// la lista
try {
client.updateUserList(userList);
1 catch (Exception e){
System.out.println(
"Error en Workgroupserver
: :updateUserList");
System.out.printXn("updateList error: + e.getMessage());
;
e.
printStackTrace()
'I
3
1
3
Los siguientes diagramas presentan una parte del modelo más detallada
mostrando cómo interaccionan a
ls clases relacionadas. En el primer caso se
tiene la figura quemuestra a DrawApplication 3.3. Anteriormente se había
explicado su funcionalidad.
32
\
i
Figura 3.3: Clases relacionadas con DrawApplication.
33
La figura que se muestra enseguida muestra a Textkpplication refI'extAp.
El diagrama de la clase AdressDialog permite ver cuales sona
ls clases con
a
ls que interactúa refDialog.
Por último se tiene el diagrama que muestra las relaciones entre la clase
encargada de serializar los objetos y las clase de forma y texto refserial. La clase
de forma se vale a su vez de otras clases que le permitirán dibujar rectángulos,
circulos y líneas.
En esta última parte del capítulo se presenta en forma m& ordenada las
clases que forman parte del sistema junto con sus métodos para dar una descripción que permitirá un mejor entendimiento. Tenemos la tabla reftablita
34
Figura 3.4: Clases relacionadas con TextApplication.
35
il./
Figura 3.5: Clases relacionadas con la clase AdressDialog.
36
/
/
!
\
I
\
j
Figura 3.6: Clases que sirven para crear los dibujos y el texto.
37
main ( )
getlistwork()
unicastMessage()
updateBuf er (f)
registerTopic0
logoff ( )
updateuser()
Register()
add ( 1
erase ( )
seek()
Workgroupserver
connect ( )
logoffw()
login()
broadcastConnect ( )
getUserList ( )
updateUserList ( )
AddressDialog
actionPerformed()
actualizarEstado()
cerrar ( )
getEstado()
getTexto()
setvisible0
Descripción
Es la parte servidor del sistema, encargada
de permitir la entrada a los usuarios al sistema
y de almacenar los temas de trabajo
programa servidor del sistema
envía al usuario la lista de temas registrados
envía un objeto a un usuario específico
actuliza el buffer del servidor
realiza el registro de un usuario y su tema
da de baja a un usuario
actualiza la lista de usuarios a cada usuario
con un tema en común
Es una lista ligada para contener a los usarios
de un tema en común, manteniendo un buffer para
el trabajo echo por los mismos
inserta un nodo a la lista
borra un nodo de la lista
busca un nodo dentro de la lista
Es usado por el servidor para enviar información
a todos los usuarios, también para dar de alta y
de baja a los usuarios del sistema
envía a cada usuario la lista de usaurios de
todo el sistema
borra a un usuario de la lista y avisa a los
demás usuarios
inserta un usuario a la lista y da aviso a los
demás usuarios
envía un mensaje a todos los usuarios del
sistema
regresa una lista de todos los usuarios del
sistema
envía la lista de usuarios de todo el sitema a
un usuario
Es una interfaz gráfica, donde se pide al usuario
una dirección válida de un servidor con el que se
quiera conectar
maneja las acciones al oprimir los botones
revisa si se ha introducido información antes de
continuar
es llamado antes de terminar la ventana de
dialogo
da el valor del botón oprimido por el usuario
da el texto intriducido por el usuario
muestra u oculta la ventana
Tabla 3.1: Clases y Métodos del sistema.
38
-
Descripción
Tiene un conjunto de métodos que deberán cumplir
las aplicaiones usadas por MainApplication
para revisar que se pueda cerrar una aplicacion
para recivir objetos de una aplicación externa
para enviar objetos a una aplicación externa
Es una forma usada por la aplicación de dibujo
que permite dibujar círculos
dibuja un círculo en un objeto panel.
Es una forma usada por la aplicación de dibujo
que permite dibujar círculos con relleno
dibuja la figura en un objeto panel
Interfaz gráfica creada para tener una área
donde se puedan recibir mensajes, otra donde se
pueden editar los mensajes a enviar y una
más que muestra los destinatarios posibles
sirve para insertar nombres en la lista de todos
los usuarios
sirve para insertar nombres en la lista delos
usarios compañeros
para mostrar texto en el áres de mensajes
borra todos los nombres de la lista de los
usuarios compañeros
quita todos los nombres de la lista de todos los
usuarios
obtiene una lista con los nombres escojidos en
ambas listas por el usuario
Es la aplicación de dibujo, contiene un área
para relalizar dibujos, provee por medio de un
menú las formas a dibujar y los colores
maneja las acciones del mouse y el menú
es llamado antes de terminar la aplicación
obtiene un objeto de figura, para que sea
dibujado por la aplicación
envía un objeto de figura, para que sea
transmitido
muestra u oculta la ventana.
sirve para escojer y abrir un archivo.
sirve para guardar en un archivo las figuras
dibujadas
-
Tabla 3.2: Clases y Métodos del sistema(Continuaci6n).
39
Clase o Método
saveAsFile()
readFile()
writefile()
DrawArea
crear ( )
dibujaro
dibujaro
getcolor ()
getDraw ( )
getTipo ( )
paint ( )
setcolor()
setTipo()
Forma
dibujar()
setcolor0
Linea
dibujaro
HainApplication
main()
actionPerformed()
connecting()
disconnecting()
exit ( )
Descripción
guarda en un archivo las figuras dibujadas,
pidiendo un nombre para el archivo a crear
lee de un archivo la información de las figuras
para dibujarlas
escribe en un archivo las figuras actualmente
dibujadas
Define un área donde se puede realizar dibujos
dado unas coordenadas y un tipo de figura se
crea un objeto de figura para que sea dibujado
dibuja en el área un figura
dibuja en el área una figura y además da la
opción de enviarla
obtiene el color actual que se está utilizando
obtiene en una lista las formas dibujadas en el
área
obtiene el tipo de la figura que se está
utilizando
redibuja las formas cuando es necesario
pone el nuevo color a utilizar
establece el nuevo tipo de figura a utilizar
Clase de donde serán dervadas las demás formas
para dibujo
para que sea dibujada la figura en un objeto
Panel
cambia el color de la figura
Es una forma usada por la aplicación de dibujo
que permite dibujar líneas
dibuja una línea en un objeto panel
Es la interfaz con el usuario, es la encargada
de contactar con un servidor dada una dirección
y de obtener los temas disponibles, así como de
enviar y recibir información de los otros
usuarios vía el servidor
programa cliente
maneja las acciones del menú
esta encargada de iniciar la conexion con el
servidor
termina la conexión con el servidor
método que es llamado cuando se quiere terminar
el programa
Tabla 3.3: Clases y Métodos del sistema(Continuaci6n).
40
’
Clase o Método
getAddress0
getAllUsers()
getGroup0
getpartners ()
getThemes ( )
getuser ()
register()
send ( )
send ( )
uindouActivated()
windowClosed()
windowClosing()
windowDeactivated()
windowDeiconif ied()
windouIconified()
windowOpened()
displayconnect ()
updateUserList ( )
clientso
updateTopics ( )
displayMessage()
content ( )
MenuDrauApplication
createMenuColors()
createMenuFile0
createMenuItem()
createMenuTools()
MenuMainApplication
createMenuApplication()
createMenuFile0
createMenuItem0
-
Descripción
da la dirección del servidor con el cual se
tiene la conexión actual
da una lista de los usuarios que estan usando el
sistema
da el nombre del grupo al cual se ingresó
da una lista de los usuarios que estpan en el
mismo tema
da una lista de temas o grupos disponibles en el
sistema
da el nombre del usuario que se está usando
realiza el registro de un usuario y de su tema
envía un objeto a todos los usarios del mismo
tema
envía un objeto a una lista de usuarios
específica
no usada
activada cuando se cierra alguna aplicación
activada antes de cerrar alguna aplicacion
no usada
no usada
no usada
no usada
implmentacion de WorkgroupInterface
implmentacion de WorkgroupInterface
implmentacion de FirstgroupInterface
implmentacion de FirstgroupInterface
implmentacion de FirstgroupInterface
implmentacion de FirstgroupInterface
Es le menú usado por DrawApplication
crea un menú para la elección de colores
crea un menú con las opciones de guardar, abrir,
cerrar
inicializa los items de menú
crea un menú para elejir un tipo de herramienta
de dibujo
Es el menú usado por MainApplication
crea un menú para la elección de aplicación
crea un menu para cerrar la aplicación
inicializa los items de menú
Tabla 3.4: Clases y Métodos del sistema(Continuación).
41
Clase o Método
MenuTextApplication
createMenuFile0
reateMenuItem0
MouseDrawArea
mouseClicked()
mouseReleased0
mouseDragged0
mouseMoved0
Ovalo
dibujaro
OvaloRelleno
dibujaro
Rectángulo
dibujaro
componer()
RectAnguloRelleno
dibujar0
RegisterDialog
actionPerformed()
actualizarEstado()
addGroupList0
addUserList ( )
cerrar (1
Descripción
Es el menú usado por TextApplication
crea un menú con las opciones de guardar,
abrir, cerrar
inicializa los items de menú
Aquí se encuentran 10s métodos usados para
dibujar formas en área de dibujo usandoel
mouse
cuando recíen se oprime el botón
cuando se suelta el botón oprimido del ratón
utilzado cuando se mueve el ratón y se tiene
oprimido un botón de este
sin usar
Es una forma usada por la aplicación de dibujo
que permite dibujar un ovalo
dibuja un ovalo en un objeto panel
Es una forma usada por la aplicación de dibujo
que permite dibujar un ovalo con el interior
dibujado
dibuja el ovalo dentro de un objeto panel
Es una forma usada por laaplicación de dibujo
que permite dibujar rectángulos
dibuja l a figura en un objeto panel
rectifica que las coordenadas sean las lógicasa
para dibujar la figura
Es una forma usada por la aplicación de dibujo
que permite dibujar rectángulos que son
dibujados en su interior
dibuja la figura en un objeto panel
Esta es una interfaz gráfica para que el
usuario introduzca un nombre con el que será
identificado dentro del sistema e introduzca un
tema que bien puede ser nuevo o ya existente en
el sistema
recojea
l
s acciones al oprimir los botones
revisa si los campos que necesitan información
están llenos
muestra los nombres de los temas disponibles
muestra en una lista los nombres de usuario ya
registrados
llamado antes de cerrar la ventana de dialogo
Tabla 3.5: Clases y Métodos del sistema(Continuaci6n).
42
fl
Clase o Método
getEstado (
getGroup0
getuser()
itemstatechangedo
setvisible0
Text
getText ()
TextApplication
actionPerformed()
openFile0
readFile()
saveFile0
setvisible0
textvaluechangedo
writeFile0
exit ( )
recive0
send ( )
yncDialog
act ionperformed( )
exit (1
getstate0
FirstgroupInterface
clients ( )
I
I
Descripción
obtiene si se introdujo información en todos
los campos para poder continuar o no
obtiene el texto de el área "group name"
obtiene el texto de el área "user name"
para la elección de un tema ya registrado
muestra u oculta la ventana
Es el tipo de información usada por la
aplicación de TextApplication
da el contenido en un String
Es la aplicación de texto, cuenta con un área
donde se puede editar texto y con un menú
para sus diferentes opciones
maneja las acciones del menú
abre un archivo de texto escojido por el
usuario y lo presenta en la aplicación
lee un archivo y muestra su contenido en el
área de texto
escribe en un archivo la información que
contiebe la aplicación
muestra u oculta la ventana
es activado cuando se hace algún cambio al
texto
escribe en un archivo lo que contenga el área
de texto
es llamado antes de cerrar la aplicación
obtiene un objeto texto para presentarlo en el
área de texto
envía un objeto de texto para que sea
transmitido
Es una interfaz gráfica para realizar una
pregunta al usaurio donde solo puede contestar
si, no o cancelar
recoje las acciones al oprimir los botones
este método es llamado cuando se pretende salir
de la ventana de dialogo
da la clave del botón que fue escojido por el
usuario
Interfaz para que el servidor envíe información
al cliente
se obtiene la lista de usuarios que están en el
mismo tema
Tabla 3.6: Clases y Métodos del sistema(Continuaci6n).
43
I
'
~~
Clase o Método
content ( )
displayMessage()
updateTopics ( )
FirstInterface
getListWorks()
unicastMessage()
gisterTopic0
logoff ( 1
updateBuf er ()
f
WorkgroupInterface
displayConnect0
updateuserlist()
~~
Descripción
se recibe del servidor el contenido del tema
se recibe el objeto enviado por otro usuario
se obtiene la lista de temas disponibles en el
servidor
Interfaz para que el cliente se comunique con
el servidor
pide la lista de temas registrados
envía un objeto a otro usuario por medio del
servidor
sirve para dar de alta a un usuario o crear un
tema
sirve para dar de baja a un usuario
sirve para actualizar el buffer de un tema
Interfaz para manejar la información por
grupos, del servidor al cliente
se reciben mensajes del servidor
se obtiene la lista de usuarios registrados en
todo el sistema
Interfaz para manejar la lista de usarios y
temas
da la listade usuarios de todo el sistema
borra a un usuario de la lista y avisa a los
demás usuarios
inserta un usuario a la lista y da aviso a los
d e m k usuarios
'
WorkServerInterface
connect ( )
logoff w ( )
login()
Tabla 3.7: Clases y Métodos del sistema(Continuaci6n).
44
Capítu10 4
Funcionamiento del Sistema
En este capitulo se describe cómo funciona el sistema haciendo la observación
de que es necesario tener la versión de Java 1.1.5. (con la cual fue desarrollado
el sistema) para evitar problemas.
Como ya se mencionó anteriormente el sistema se encuentra integrado por
paquetes. Para hacerlo funcionar primero se debe ejecutar el programa del
servidor (
Server.FirstServer
) el cual obtiene en forma automática ladirección IP de la máquina en la que
se
encuentra. Despues se debe ejecutar el cliente al cual deberá proporcionarsele
la dirección donde se encuentra el servidor [ambos pueden estar en la misma
máquina).
La ventana que el cliente presenta para dar la dirección se muestra en la
figura 4.1.
A continuación se presenta una ventana divida en tres secciones. En la
parte superior se pide al usuario que teclee el nombre quelo identificará durante
su sesión de trabajo y el nombre del tema o grupo con el cual desea trabajar (o
puede dar un nombre para crear un grupo nuevo); del lado izquierdo puede verse
Figura 4.1: Ventana de inicio del cliente.
45
Figura 4.2: Ventana de información del usuario.
una lista donde aparecen los temas existentes y del lado derecho los usuarios
que se encuentran trabajando.En la figura se muestra la ventana descrita 4.2.
Después de esto tenemos la ventana desde donde se puede enviar y recibir
mensajes. En la parte superior se encuentra el cuadro que permite capturar
el mensaje que se desea enviar y aun lado de &te esta
el botón para enviar
el mensaje escrito. Siempre que se envie un mensage este llegará a todos los
usuarios que componen ese grupo, a menos que se seleccione a l a persona o
personas que se desea reciban en el mensaje enviado. Esto último puede hacerse
en la lista del lado inferior derecho. En ese mismo ladose encuentra información
del usuario. En el menú de esta ventana se encuentran tres opciones:
o
La primera que es Archivo permite guardar el trabajo en un archivo, abrir
un archivo existente y salir del sistema.
o
La segunda opción permite crear el ambiente para trabajaren una ventana
de texto.
0
La tecera permite crear el ambiente para trabajar en una ventana
dibujo.
Esta ventana se presenta en la figura 4.3.
Las últimas dos ventanas son el área de texto y el área de dibujo.
46
de
Figura 4.3: Ventana para el intercambio de mensajes.
En cualquiera de las dos cuando se realiza un cambio los demás usuarios
en el mismo grupo o tema verán los cambios en tiempo real.
En la ventana de dibujose tiene el menú de archivo para guardar, abrir un
archivo o salir de la aplicación 4.4.
En la ventana de dibujo se encuentran dos opciones de menú. La primera
es la opción de archivo con las mismas subopciones de guardar, abrir archivo y
salir. La siguiente opción permite elegir las formas disponibles a dibujar (que
son: línea, rectángulo, círculo, elipse, rectángulo relleno, círculo relleno, elipse
rellena), así comoloscolores. Siempre que seelige una forma y un color la
aplicacióna
ls seguirá utilizando hasta que el usuario las cambie. la ventana de
dibujo se muestra en la figura 4.5.
47
48
Figura 4.5: Ventana de dibujo
49
Capítulo 5
Conclusiones
Una de las intenciones de esta exposición es mostrar la sencillezcon la cual
el mecanismo de Java RMI permite implementar la comunicación entre dos O
más computadoras conectadasen una red. También, las ventajas que la programación orientada a objetos ofrece para la definición de un modelo que permita
evolucionar la aplicación de forma natural y sin necesidad de partir desde cero
Se trata de conseguir en el modelo del sistema un grado deabstracción que
lo torne flexible para que cuando sedeseenhacer adecuaciones, sólo necesite
extenderse su funcionalidad y no cambiar sus elementos.
Pensando en posibles extensiones del sistema se debe hacer la aclaración de
las limitaciones que RMI tiene en cuanto al tipo de información que maneja, tal
vez si se desea crear una aplicación que maneje archivos de imagen o archivos
de sonido (como una aplicación que pretenda comunicar a dos personas para
conversar) el sistema utilizando RMI se vuelva lento. Podría ser más adecuado
pensar tal vez en Corba aunque esta solución resulta en exceso costosa debido
al elevado precio de CORBA.
Con respecto a crear un ejecutable que evite la necesidad de la máquina
virtual de Java puede pensarse en utilizar Java Café para hacer esto. Sin embargo se perdería un punto importante por el cual se escogió Java, que es la
independencia de plataformaen la cual se ejecuta el programa, aunque por otro
lado se incrementa la velocidad del sistema.
Otra de las enormes ventajas de utilizar Java a parte de la facilidad para
comunicarse con RMI y la sencillez para crear una interface con AWT se encuentra la portabilidad delcódigoya que para poder ejecutar el sistema en
otra plataforma distintasólo debe disponerse de la máquina virtual de javasin
necesidad de hacer ninglin cambio.
Se pensó en un principio en dejar que un usuario pudiese comunicarse con
cualquier otro usuario, pero con esto se dejaría de lado el concepto de grupos
que maneja el sitema, además de que sería necesario llevar varios buffers para
saber qué se tiene con cada usuario, con lo cual se complicaría demasiado el
sistema, por eso se optó por dejar que sólo se pudieran intercambiar mensajes
con usuarios de otros temas.
50
Como planes a futuro para el programa, están el de mejorar la interfaz
gráfica sobre todo para la aplicación de dibujo, concretamenteralizar una mejor
forma de escojer colores y de elejir la herramienta para realizar el dibujo,la
adición de nuevas formas de dibujo debe ser relativamente secilla ya que el programa sehizo pensando en eso. En cuanto al programa MainApplication, se
hizolo posible para que nosele hicieran m& modificaciones, sino que sólo
se aumentaran las aplicaciones con proposito específico,comoenelcaso
de
TextApplication y de DrawApplication pensamos que una manera sencilla de
extender las aplicaciones del programa MainApplication es hacer que las aplcaciones puedan cargarse en tiempo de ejecución a manera de "plug-in", es por
este motivo que se utilizó la interfaz Application para que todas las apliciones
tengan los métodos necesarios para enviar y recibir información con la aplicación
principal.
Finalmente el código del programa y la aplicación en sí misma se pueden
obtener en la siguiente dirección 1aryc.uam.mx
51
Bibliografía
[I] Grady booch. AnaEisis y Dise o Orientado a Objetos. Prentice-Hall, 1995.
[2] Jery Edwards Robert Orfali, Dan Harkey. The Essential Distibuted Objects
Survival Guide. Addison-Wesley, 1996.
[3] John Bloomer. Power Programing with RPC. OReilly-And-Associates, sec-
ond edition, 1996.
[4]Sun Microsystems. Java Remote Method Invocation Specification. Sun, 1997.
[5] Peter Van der Linden. Just Java. Prentice-Hall, 1997.
[6] Gosling Jamesand Ken Arnold.
Addison-Wesley, 1997.
52
El Lenguaje de ProgmmacionJava.