Marcos fernandez vega_practica_sd

PRÁCTICA DE SISTEMAS DISTRIBUIDOS
Sistema de Gestión de Comercio Remoto usando Java RMI

DATOS DEL ALUMNO
Marcos Fernández Vega
71665585T
marcosfervega@gmail.com
mfernande4363@alumno.uned.es



ÍNDICE
DESCRIPCIÓN DE LA EJECUCIÓN DE LA PRÁCTICA .................................................................................................. 3
DESCRIPCIÓN DEL FUNCIONAMIENTO DE LA PRÁCTICA ......................................................................................... 6
PROYECTO REGULADOR.............................................................................................................................................. 6
CLASE REGULADOR ................................................................................................................................................. 6
CLASE SERVICIOAUTENTICACIONIMPL .................................................................................................................... 7
CLASE SERVICIOMERCANCIASIMPL ......................................................................................................................... 8
PROYECTO CLIENTE..................................................................................................................................................... 9
CLASE CLIENTE ........................................................................................................................................................ 9
PROYECTO DISTRIBUIDOR ......................................................................................................................................... 10
CLASE DISTRIBUIDOR ............................................................................................................................................ 10
CLASE SERVICIOVENTAIMPL.................................................................................................................................. 10
CLASE VENTA ........................................................................................................................................................ 10
PROYECTO COMMON ............................................................................................................................................... 11
CLASE OFERTA....................................................................................................................................................... 11
CLASE PRODUCTO ................................................................................................................................................. 11
CLASE CODEBASE .................................................................................................................................................. 11
INTERFAZ SERVICIOAUTENTICACIONINTERFACE................................................................................................... 11
INTERFAZ SERVICIOMERCANCIASINTERFACE ........................................................................................................ 12
INTERFAZ SERVICIOVENTASINTERFACE................................................................................................................. 12
DIAGRAMA DE RELACIONES REMOTAS ............................................................................................................... 12
CONCLUSIONES .................................................................................................................................................. 13

2



DESCRIPCIÓN DE LA EJECUCIÓN DE LA PRÁCTICA
Para el funcionamiento de la práctica se necesitan los tres archivos .jar de cada uno de los proyectos
(Distribuidor.jar, Cliente.jar y Regulador.jar) y de sus correspondientes ficheros .bat para arrancar las aplicaciones
(Distribuidor.bat, Cliente.bat y Regulador.bat).
Una vez situado en la raíz del proyecto se procede a ejecutar los tres ficheros de arranque, escribiendo Regulador,
Distribuidor o Cliente como se indica en el enunciado de la práctica, teniendo en cuenta que Regulador ha de ser el
primero en ser ejecutado, sino la ejecución tanto de Cliente como de Distribuidor fallará. Se pueden ejecutar tantos
Clientes y Distribuidores como se quiera.
Cuando se ejecuta el Regulador, se lanza rmiregistry.exe y se activan los servicios para el control de Autentificación y
el control de Mercancías y aparece su menú principal como se ve en la Captura 1.

Captura 1
Cuando se ejecuta o bien un Cliente o bien un Distribuidor lo primero que se nos requerirá será introducir su nombre
de usuario para identificarse en el sistema; el cual, tras recibirlo, devolverá la clave única del usuario: una C ante un
número para los clientes (C1, C2, C3…) o una D ante un número para los distribuidores (D1, D2, D3…). Después de
recibir la clave de usuario aparecerá el menú correspondiente a cada caso (Capturas 2 y 3).

Captura 2

Captura 3
3



Desde el menú de distribuidor se permite introducir una nueva oferta o visualizar las ventas realizadas (Captura 4).
Cuando introducimos una nueva oferta nos preguntara por el tipo de producto que queremos ofertar, el precio y el
número de kilos. Al introducir correctamente estos datos se registraría la oferta en el sistema. Si intentásemos
introducir una oferta con las mismas caráteristicas que otra oferta existente para el mismo distribuidor se nos
informaría de que la oferta ya existe en el sistema por lo que no se realizaría acción alguna.

Captura 4
Desde el menú de cliente se nos permitirá introducir una nueva demanda, recibir ofertas, comprar una mercancía o
bien finalizar la sesión. Si elegimos introducir una nueva demanda se nos listará el tipo de productos que existen y se
nos pedirá que elijamos aquel que deseamos demandar. Si intentásemos realizar una demanda de un producto ya
demandado el sistema nos indicará que el producto ya se encuentra demandado actualmente y no añadirá una
nueva demanda (Captura 5).

Captura 5

Cuando intentemos recibir las ofertas disponibles recibiremos las ofertas de todos aquellos vendedores que hayan
añadido alguna de los productos que tengamos demandados. Es decir, si hubiésemos hecho una demanda de Arroz y
Lentejas solamente nos aparecerían las ofertas de estos dos productos y no aparecería una oferta de, por ejemplo,
judías.
Al elegir la opción de Comprar Mercancía aparecerá una lista con las ofertas disponibles y a continuación se nos
preguntará a qué vendedor deseamos comprar y se introducirá el ID del vendedor. Una vez introducido el número
de identificación del vendedor nos aparecerán numeradas las ofertas de ese vendedor en concreto y se nos solicitará
que elijamos la oferta en la que estamos interesados (Captura 6). Es necesario añadir que todos los distribuidores se
4



abastecen en el momento de su creación con 1000 kilos de cada producto y cada vez que se realiza una venta la
cantidad disponible de ese producto disminuye. Por tanto, si intentamos comprar una oferta y no existe la suficiente
cantidad de producto para suministrarnos se nos informará de la excepción y no se realizará la compra.

Captura 6
Desde la interfaz del Regulador se pedirá elegir entre las opciones de Listar ofertas actuales que mostrará un lista de
todas las ofertas añadidas por todos los distribuidores, Listar demandas actuales que listaría las demandas de todos
los clientes registrados en el sistema; y por último las opciones de listar todos los clientes y los distribuidores
respectivamente (Captura 7).

Captura 7

5



DESCRIPCIÓN DEL FUNCIONAMIENTO DE LA PRÁCTICA
Para realizar la práctica se ha utilizado Eclipse y se han creado cuatro proyectos: Cliente (con las clases del cliente),
Distribuidor (con las clases del distribuidor), Regulador (con las clases del regulador) y Common (con las clases
comunes que serán utilizadas por el resto de proyectos). A continuación se muestran los proyectos y sus respectivas
clases para a continuación pasar a detallar cada una de ellas.








Regulador
o pq.regulador
 Regulador.java
 ServicioAutenticacionImpl.java
 ServicioMercanciasImpl.java
Cliente
o pq.cliente
 Cliente.java
Distribuidor
o pq.distribuidor
 ServicioVentaImpl.java
 Venta.java
 Distribuidor.java
Common
o pq.common
 Oferta.java
 Producto.java
 ServicioAutenticacionInterface.java
 ServicioMercanciasInterface.java
 ServicioVentaInterface.java
 Codebase.java

PROYECTO REGULADOR
CLASE REGULADOR
Esta clase contiene el main del proyecto Regulador. Lo primero que hará el main será una llamada al método
Utils.setCodeBase pasándole como parámetro una clase cualquiera para definir la ruta de ésta como la ruta del
proyecto para Java RMI. A continuación se crearan los objetos ServicioAutenticacionImpl y ServicioMercanciasImpl y
se les casteará como objetos remotos asignándoles un número de puerto y se les asignará un nombre en el registro
para poder ser accesibles por el resto de proyectos que intenten conectarse.
Una vez arrancados los servicios de Autenticación y de Mercancias se entra en un bucle donde se elige la opción que
deseamos para continuar la cual es interpretada por un switch que maneja cuatro opciones:

6



1) Llamada al método local listarOfertas().
Este método que recibe como parámetro la clase que implementa el servicio Mercancias crea un objeto de
tipo Map de tipo HashMap donde almacena todas las ofertas disponibles que recoge a través del método
getTOfertas() del objeto Mercancias. Después, utilizando como clave los números de 1 a 5 (tipos de
mercancías), recorre todo el Map mostrando las ofertas disponibles utilizando el método getOferta() del
objeto oferta.
2) Llamada al método local listarDemandas()
De manera muy parecida al método anterior listarDemandas recoge en un Map todas las demandas del
sistema a través del método getDemandas() de la clase Mercancias. Luego con un par de for anidados donde
el primero recorre los clientes y el segundo sus respectivas demandas se van mostrando las distintas
demandas de todos los clientes. Se hace uso del método getNombreCliente(clave) de la clase
ServicioAutenticacionImpl para recibir el nombre del cliente.
3) Llamada al método local listarClientes()
Este método recibe una lista de todos los clientes a través del método getClientes() de
ServicioAutenticacionImpl y los muestra uno por uno recorriendo esta lista con un bucle for.
4) Llamada al método local listarDistribuidores()
De la misma manera que se hizo con el método anterior se recorren todos los distribuidores pero esta vez
utilizando el método getDistribuidores() de la clase ServicioAutenticacionImpl.

CLASE SERVICIOAUTENTICACIONIMPL
Esta clase almacena en dos integer el valor actual del último número de identificación tanto de los clientes como de
los proveedores y tiene dos HashMap: id_nombre_cliente donde guarda el nombre de cliente utilizando como clave
su ID y otro llamado id_nombre_distribuidor que hace lo propio para los distribuidores. Contiene los siguientes
métodos:


autenticar(String nombre, boolean cliente)
Asigna a cada cliente su ID personal, si el parámetro cliente es true, entonces se trata de un cliente. Para dar
el número correspondiente se utilizan los métodos darIdC o darIdD dependiendo de que se trate de un
cliente o un distribuidor y se la pone delante una C o una D de la misma manera. También almacena el
cliente y su ID en el HashMap correspondiente. La clase es del tipo String ya que esta ID es devuelta al objeto
que realiza la llamada.



getClientes()
Clase del tipo List que devuelve todos los clientes almacenados en id_nombre_cliente



getDistribuidores()
Lo mismo que el método anterior pero para los distribuidores.



getNombreCliente(String id)
Este método de tipo String recibe como parámetro una ID de cliente que devolverá como resultado al
utilizarla como clave del método get de id_nombre_cliente;
7






darIdC ()
Devuelve el siguiente valor del número de ID de cliente.
darIdD ()
Devuelve el siguiente valor del número de ID de cliente.
numClientes()
Devuelve el número total de clientes

CLASE SERVICIOMERCANCIASIMPL
Almacena en un HashMap llamado id_demanda la lista de demandas de determinados clientes que hayan sido
añadidos. En un HashMap llamado tipo_ofertas almacena una lista de ofertas de cada tipo. Consta de los siguientes
métodos:


getOfertas(int tipo)
Método del tipo List que recoge en una lista todas las ofertas del tipo que se pase como parámetro y es
devuelta al objeto que lo llame.



registrarOferta(int tipo, float precio, int kilos, String idVendedor)
Registra una oferta en la lista de ofertas de tipo_ofertas. Para ello crea un objeto del tipo List que estará
vinculado con la lista del HashMap por lo que al agregar una oferta en esta se actualizará la lista del
HashMap. El método es de tipo String así que si existe ya una oferta de ese tipo, con el mismo vendedor, al
mismo precio y el mismo número de kilos devolverá “Oferta ya existente” de lo contrario, si se realizará con
existo, devolverá “Oferta agregada al sistema”.



registrarDemanda(int tipo, String idCliente)
Funciona de la misma manera que el método anterior sólo que esta vez se utiliza para almacenar las
demandas de los clientes en id_demanda.



getTOfertas()
Devuelve el HashMap tipo_ofertas



getDemandas()
Devuelve el HashMap id_demanda

8



PROYECTO CLIENTE
CLASE CLIENTE
Es la única clase que contiene el proyecto Cliente. Lo primero que se hace desde el main será crear las dos interfaces
remotas, Autenticacion y Mercancias, y a continuación una llamada al método autenticar() para recibir el ID de
cliente con el método autenticar() del objeto Autenticacion al que se le pasa como parámetros el nombre de cliente
y true para indicar que se trata de un cliente. A continuación se repite en un bucle do-while las distintas opciones
que se pueden manejar desde la interfaz de cliente, opción que es recogida en un switch con las siguientes opciones:
1) Llamada al método local demandar()
Se pregunta qué producto se desea demandar y se lista a través del método listaProdutos() los productos
existentes. Si la opción elegida esta entre 1 y 5 se registra la demanda con el método registrarDemanda del
objeto Mercancias, si la demanda ya ha sido efectuada con anterioridad el método devolverá la String
“Demanda ya existente”.
2) Llamada al método recibirOfertas()
Si no hubiera ninguna demanda se devuelve por pantalla un mensaje indicándolo, en caso contrario para
cada demanda se recogería en una lista las ofertas para ese producto desde el método getOfertas del objeto
Mercancias. Después se imprime por pantalla la información de cada una de esas ofertas con el método
getOferta de la clase Oferta.
3) Llamada al método iniciarCompra()
Desde este método se llama al anterior para listar todas las ofertas disponibles según nuestras demandas.
Después se pregunta por la ID del vendedor al que queremos realizar la compra y se utiliza esta misma para
conectarnos al Servicio de Venta de este vendedor. Después, en un HashMap se recogen todas las ofertas de
este vendedor numeradas mediante el método getOfertasVendedor, el cual recoge en un Map todas las
ofertas del vendedor que se pasa como parámetro, utilizando un valor entero que se incrementa por cada
iteración como clave del mapa de manera que aparecen numeradas. Si este HashMap no estuviese vacío se
pregunta por pantalla que producto se desea comprar y se utiliza la opción elegida para extraer del Map la
Oferta correspondiente. Por último se muestra el resultado de la venta utilizando el método iniciarVenta del
objeto Venta y dándole como parámetros el nombre de cliente, id y las características de la oferta.

9



PROYECTO DISTRIBUIDOR
CLASE DISTRIBUIDOR
Esta clase define a un distribuidor y contiene el main del proyecto Distribuidor. En primer lugar se crea un objeto del
tipo ServicioVentasImpl, Ventas, casteado como objeto remoto y se le asigna de número de puerto un entero
aleatorio entre 20.000 y 60.000. Más adelante se crean las dos interfaces remotas Autenticacion y Mercancias. El
cuerpo central del main se trata de un bucle do-while donde se recoge la opción a realizar por el programa de las dos
disponibles:
1) Llamada al método introducirOferta()
Este método introduce una nueva oferta en Mercancias, utilizando su método registrarOferta(), con los
parámetros que son recogidos a través de pantalla. En caso de existir una oferta con las mismas
características se informará de lo sucedido.
2) Utiliza el método getVentas() del objeto Ventas

CLASE SERVICIOVENTAIMPL
Clase que implementa la interfaz remota ServicioVentaInterface. Contiene un ArrayList llamado Ventas donde se
almacenan las Ventas realizadas por su distribuidor y un HashMap donde se almacenan las cantidades de producto
restantes de cada tipo de producto. Contiene los siguientes métodos:






iniciarVenta(String nombreCliente, String sesionIdCliente, Producto producto, int kilos, float precio)
Tras comprobar que existe la suficiente cantidad de producto para los kilos demandados se añade un nuevo
objeto Venta con las características que se pasan como parámetro al Array Ventas.
avastecer()
Rellena el HashMap con 5 claves de números enteros (1-5) que representan los 5 tipos de productos con 500
como valor que representa la cantidad inicial de producto.
getVentas()
Si el ArrayList Ventas estuviera vacío se informaría de ello y de lo contrario se obtendría la información de
cada Venta que contiene utilizando su método getInfoVenta().

CLASE VENTA
Clase que representa cada Venta realizada con éxito. Al construirse rellena información relativa al nombre y ID del
Cliente que realizó la compra, al tipo de producto, al número de kilos y al precio por el que fue vendido. A su vez se
le asigna un número de venta. Contiene un único método, getInfoVenta(), que escribe por pantalla toda su
información.

10



PROYECTO COMMON
Este proyecto es compartido por el resto de proyectos y forma parte del Build Path de todos ellos.

CLASE OFERTA
Describe una Oferta y tiene como variables: el Producto ofertado, el precio de la oferta, la cantidad de kilos, la ID del
vendedor que la oferta y una cadena para almacenar el nombre del producto. Es un objeto del tipo Serializable lo
que quiere decir que se enviará una copia del mismo al terminal que lo solicite. Contiene los siguiente métodos:


getVendedor()
Devuelve una String con el nombre del vendedor.



getKilos()
Devuelve un entero con el número de kilos.



getPrecio()
Devuelve un float con el precio de la oferta.



getProducto()
Devuelve el Producto.



getOferta()
Devuelve un String con la descripción de la oferta.

CLASE PRODUCTO
Al igual que la clase anterior implementa Serializable. Almacena un entero con el tipo de producto (1-5) y el nombre
del producto. Cuando se construye un producto se le pasa el tipo de producto y según el tipo le asigna el nombre
correspondiente. Contiene dos métodos:



getTipo()
Devuelve un entero con el tipo de producto.
getNombre()
Devuelve un String con el nombre de producto.

CLASE CODEBASE
Esta clase sirve para indicarle a Java RMI donde va a estar el código que necesitará cuando se solicite. Por tanto se le
pasa una clase cualquiera y de esta se extrae la ruta de donde se encuentra para luego asignarse a la propiedad de la
máquina virtual de java: java.rmi.server.codebase.

INTERFAZ SERVICIOAUTENTICACIONINTERFACE
Interfaz, que extiende a Remote, que incluye los métodos que implanta la clase ServicioAutenticacionImpl que vimos
anteriormente.

11



INTERFAZ SERVICIOMERCANCIASINTERFACE
Interfaz, que extiende a Remote, que incluye los métodos que implanta la clase ServicioMercanciasImpl que vimos
anteriormente.

INTERFAZ SERVICIOVENTASINTERFACE
Interfaz, que extiende a Remote, que incluye los métodos que implanta la clase ServicioVentasImpl que vimos
anteriormente.

DIAGRAMA DE RELACIONES REMOTAS

En el anterior diagrama de clases se muestran las relaciones que existen entre clases e interfaces ubicadas
remotamente y se omiten algunas relaciones que existen entre alguna clase con clases del paquete common por
claridad. Por ejemplo, se ha omitido la relación entre Distribuidor y Producto. Hay que tener en cuenta que el
paquete common se encuentra en cada uno de los programas tanto en Regulador.jar, Cliente.jar o Distribuidor.jar.

12



CONCLUSIONES
A lo largo de la práctica se ha utilizado Java RMI para compartir código remotamente. Se han utilizado dos tipos de
objetos: Serializables y Remote. Cuando se utiliza un objeto Serializable se pasa una copia exacta del objeto para que
sea manipulada por el programa que lo recibe por lo que los cambios no se verán alterados en el objeto original. En
el caso del objeto Remote se enviará una referencia del objeto y los cambios se verán reflejados en ambos lados.
El uso de Java RMI resulta relativamente sencillo y su aplicación puede utilizarse para ejecutar código remoto de una
manera bastante intuitiva, prácticamente como si tratásemos con código local.
Respecto a la presente práctica se podrían haber realizado varias mejoras de diseño como el uso de una interfaz
gráfica o una mayor complejidad a la hora de tratar los tratos mercantiles como, por ejemplo, la posibilidad de
comprar productos fuera de las ofertas o la de añadir nuevos productos desde la interfaz de vendedor. Muchas de
estas cuestiones no se han abordado por entenderse fuera de los requisitos de la práctica.

13

Marcos fernandez vega_practica_sd

Recomendados

Recomendados

Más contenido relacionado

Similar a Marcos fernandez vega_practica_sd

Similar a Marcos fernandez vega_practica_sd (20)

Marcos fernandez vega_practica_sd