See

discussions, stats, and author profiles for this publication at: https://www.researchgate.net/publication/266794630

Aplicaciones Distribuidas en Java con

Tecnologia RMI

Book · January 2008

DOI: 10.13140/2.1.2208.5127

CITATIONS READS

0 2,939

2 authors:

Santi Caballé Fatos Xhafa

Universitat Oberta de Catalunya Universitat Politècnica de Catalunya
211 PUBLICATIONS 1,180 CITATIONS 657 PUBLICATIONS 4,408 CITATIONS

SEE PROFILE SEE PROFILE

Some of the authors of this publication are also working on these related projects:

ICT-FLAG: Enhancing ICT education through Formative assessment, Learning Analytics and
Gamification View project

e-Assessment View project

All content following this page was uploaded by Santi Caballé on 13 October 2014.

The user has requested enhancement of the downloaded file.

Aplicaciones Distribuidas en Java
con Tecnologia RMI

Santi Caballé y Fatos Xhafa

 I

Portadilla del tı́tulo completo sin autores

II Programación Distribuida con Java

Acerca de los autores

SANTI CABALLÉ es Profesor de la Universidad Abierta de Cataluña (UOC)

desde el año 2006 siendo profesor-colaborador en esta misma universidad en los
dos años anteriores. Su ámbito docente se centra en el área de la Ingenierı́a del Soft-
ware tanto en el desarrollo de aplicaciones en entornos distribuidos como central-
izados. Las tecnologı́as distribuidas y su aplicación, especialmente para el apren-
 dizaje colaborativo virtual, son una de sus áreas de investigación más activas en la
que ha publicado numerosos artı́culos en congresos y conferencias internacionales. Actualmente,
participa en diferentes proyectos de investigación tanto nacionales como internacionales relaciona-
dos con el desarrollo de aplicaciones distribuidas. (http://cv.uoc.edu/∼scaballe/)

FATOS XHAFA es Profesor Titular de la Universidad Politécnica de Cataluña

(UPC). Imparte docencia en los estudios presenciales de la UPC desde el año 1996
y en los estudios a distancia de la Universidad Abierta de Cataluña desde el año
2000. En su docencia ha impartido e imparte asignaturas relacionadas con la pro-
gramación distribuida y el desarrollo de aplicaciones distribuidas. Ha publicado
 varios libros de docencia de circulación nacional. La programación distribuida es
a la vez uno de los temas de investigación que le interesa; en este respecto ha participado y participa
en varios proyectos de investigación nacionales y de la EU relacionado con la programación dis-
tribuida de gran escala, ha publicado numerosos artı́culos en revistas y conferencias internacionales
y ha organizado eventos internacionales. (http://www.lsi.upc.edu/∼fatos/)
 III

Portadilla con tı́tulo, autores, universidad y logo Delta

IV Programación Distribuida con Java

Página de Copyright
 V

A nuestras famı́lias.
VI Programación Distribuida con Java
 VII

Prefacio

La programación distribuida, des de sus incios, ha formado parte de los currı́culums de los estudios
de informática y hoy en dı́a está presente no sólo en los planes de estudios informáticos sino que
también en las ingenierı́as en general, e incluso en nuevas titulaciones como las bioinformática.
Además, la comunidad de los profesionales que usan la programación distribuida como su her-
ramienta de programación ha ido siempre creciendo.
Con Internet y otras nuevas tecnologı́as, la programación distribuida ha recibido un nuevo im-
pulso. La propia naturaleza de Internet como una plataforma distribuida ha hecho de la progra-
mación distribuida un paradigma indispensable para el desarrollo de aplicaciones de Internet. Como
consecuencia, la programación distribuida ha resultado aún más importante para los estudios uni-
versitarios.
El libro Aplicaciones Distribuidas con Java explica los fundamentos de la programación dis-
tribuida con Java. El contenido propuesto tiene como objetivo cubrir las necesidades de las titula-
ciones de ingenierı́as técnicas y superior en Informática en cuanto a asignaturas de arquitectura y
programación intermedia y avanzada. Por otra parte, el contenido representa un punto de partida
para profesionales informáticos que deseen introducirse en la programación distribuida. Los con-
tenidos del libro cubren el desarrollo de las aplicaciones distribuidas paso a paso transmitiendo ası́
la metodologı́a que el estudiante y el profesional necesitan y pueden aplicar para afianzar los con-
ceptos teóricos. Para ello, se ha considerado el caso de la tecnologı́a RMI de manera sistemática:
empezando por los conceptos basicos, ejemplos y aplicaciones sencillas hasta llegar a aplicaciones
complejas.
El libro tiene un enfoque eminentemente pragmático combinando los conceptos teóricos prin-
cipales con gran cantidad de ejemplos. Estos ejemplos se encuentran en forma de gráficos para
representar los modelos de arquitecturas expuestas conceptualmente y sobretodo incluye casos re-
sueltos tanto especı́ficos como completos en forma de código fuente. Los ejemplos presentados a
lo largo del libro se han escogido cuidadosamente y motivados por problemas reales.
El objetivo del libro es que se pueda utilizar como material de soporte para estudiantes univer-
sitarios que tienen que afrontar ejercicios prácticos como parte del plan de estudios para superar
las asignaturas. Además se ha concebido como una obra para el aprendizaje incremental desde
los conceptos básicos hasta los más avanzados. El libro no presupone ningun conocimiento de la
programación distribuida si bien presupone algunos conocimientos muy básicos de Programación
Orientada a Objetos (POO). Óbviamente, en las aplicaciones distribuidas, las bases de datos juegan
un papel importante y por tanto algunos conocimientos básicos de bases de datos y SQL facilitarı́an
la lectura del libro. Remarcamos, de todas formas, que no ha sido objetivo de este libro explicar
temas de bases de datos si bien se han explicado en detalle las bases de datos en el contexto de los
VIII Programación Distribuida con Java

ejemplos prácticos.
A partir de una lectura secuencial del libro, cualquier lector (estudiante o profesional) podrá
avanzar en sus conocimientos de programación distribuida y su aplicación en Java de forma grad-
ual. También se facilitará al lector la posibilidad de experimentar a fondo con todos los ejemplos
ofrecidos en el libro mediante la disposición de material complementario que se encuentra en el
sitio Web de Delta Publicaciones. El objetivo es aprovechar los altos beneficios pedagógicos que
ofrecen las prácticas en este sentido al implicar la instalación y el uso de las tecnologı́as necesarias
para experimentar con los ejemplos del libro.
Nuestros agradecimientos a Joan Carles Giménez Alcober por su ayuda en la preparación del
material. Este libro se ha beneficiado de las sugerencias de los estudiantes de la asignatura Técnicas
de Desarrollo de Software de la Universidad Abierta de Cataluña (UOC) y muy particularmente a
los estudiantes del grupo JAVA22 de los estudios de Informatica de Gestión de la UOC.

Barcelona, Agosto de 2007. Los autores

Contenido IX

Contenido

Introducción 1

1 El paradigma de la computación distribuida 11

1.1 Introducción . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
1.1.1 Sistemas distribuidos y centralizados . . . . . . . . . . . . . . . . . . . . 12
1.2 Que es la computación distribuida . . . . . . . . . . . . . . . . . . . . . . . . . . 13
1.3 Anatomı́a de un entorno de computación distribuida . . . . . . . . . . . . . . . . . 15
1.3.1 Capa hardware . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
1.3.2 Capa sistema operativo de red . . . . . . . . . . . . . . . . . . . . . . . . 16
1.3.2.1 Procesos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
1.3.2.2 Threads . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
1.3.2.3 Comunicación a redes . . . . . . . . . . . . . . . . . . . . . . . 17
1.3.3 Capa software intermediario (middleware) . . . . . . . . . . . . . . . . . . 18
1.3.4 Capa aplicación . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
1.4 Beneficios de la computación distribuida . . . . . . . . . . . . . . . . . . . . . . . 19
1.4.1 Escalabilidad . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
1.4.2 Apertura . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
1.4.3 Heterogeneidad . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
1.4.4 Fiabilidad . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
1.4.5 Viabilidad . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
1.5 Costes y soluciones en la computación distribuida . . . . . . . . . . . . . . . . . . 24
1.5.1 Interoperabilidad . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
1.5.2 Eficiencia y seguridad . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
1.5.3 Visión global . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
1.5.3.1 Coherencia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
1.5.3.2 Sincronización . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
1.5.3.3 Administración . . . . . . . . . . . . . . . . . . . . . . . . . . 27
1.5.3.4 Balanceo de carga . . . . . . . . . . . . . . . . . . . . . . . . . 28
1.5.4 Transparencia en la computación distribuida . . . . . . . . . . . . . . . . . 28
1.5.4.1 Transparencia de acceso . . . . . . . . . . . . . . . . . . . . . . 28
1.5.4.2 Transparencia de ubicación . . . . . . . . . . . . . . . . . . . . 29
1.5.4.3 Transparencia de migración . . . . . . . . . . . . . . . . . . . . 29
1.5.4.4 Transparencia de replicación . . . . . . . . . . . . . . . . . . . 29
1.5.4.5 Transparencia a fallos . . . . . . . . . . . . . . . . . . . . . . . 29
X Programación Distribuida con Java

1.6 Modelos de computación distribuida . . . . . . . . . . . . . . . . . . . . . . . . . 29

1.6.1 Modelo Cliente/Servidor . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
1.6.2 Arquitectura de n−capas . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
1.6.3 Entornos Grid . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
1.6.3.1 Generadores de electricidad . . . . . . . . . . . . . . . . . . . . 32
1.6.3.2 Generadores de computación . . . . . . . . . . . . . . . . . . . 33
1.6.3.3 Recursos Grid . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
1.6.3.4 Grid de ciclos inutilizados . . . . . . . . . . . . . . . . . . . . . 34
1.6.4 Sistemas Peer-to-Peer . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
1.6.4.1 Sistemas hı́bridos . . . . . . . . . . . . . . . . . . . . . . . . . 35
1.6.4.2 Sistemas P2P puros . . . . . . . . . . . . . . . . . . . . . . . . 36
Test de auto-evaluación . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38

2 Desarrollo de aplicaciones distribuidas 39

2.1 Introducción . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
2.1.1 Por qué utilizar la programación distribuida? . . . . . . . . . . . . . . . . 40
2.1.2 Las 8 falacias de la programación distribuida . . . . . . . . . . . . . . . . 41
2.2 Desarrollo de aplicaciones distribuidas . . . . . . . . . . . . . . . . . . . . . . . . 42
2.2.1 Partes de una aplicación distribuida . . . . . . . . . . . . . . . . . . . . . 43
2.2.2 Requerimentos básicos sobre una aplicación distribuida . . . . . . . . . . . 44
2.3 Tres modelos básicos de la programación distribuida . . . . . . . . . . . . . . . . 44
2.3.1 Modelo Cliente/Servidor . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
2.3.1.1 Protocolo de solicitud-respuesta del modelo C/S . . . . . . . . . 45
2.3.1.2 Modelo C/S: términos y definiciones . . . . . . . . . . . . . . . 46
Los componentes de una aplicación C/S. . . . . . . . . . . . . . . 47
El server loop. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
Interfaces del C/S: interfaces import/export. . . . . . . . . . . . . . 47
C/S: modo de comunicación. . . . . . . . . . . . . . . . . . . . . . 48
2.3.1.3 Tres tipos de procesamiento de solicitudes de servicios . . . . . 48
Proceso servidor dedicado. . . . . . . . . . . . . . . . . . . . . . . 49
Clonaje de un proceso servidor. . . . . . . . . . . . . . . . . . . . 49
Threads –procesos servidores ligeros. . . . . . . . . . . . . . . . . 49
2.3.1.4 Clientes ligeros/pesados vs. servidores pesados/ligeros . . . . . . 50
2.3.1.5 Middleware para aplicaciones Cliente/Servidor . . . . . . . . . . 50
El ejemplo del middleware ODBC. . . . . . . . . . . . . . . . . . 51
2.3.2 Remote Procedure Call . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
2.3.3 Cómo funciona el RPC . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
Similitudes y diferencias entre la llamada de procedimientos locales
y remotos. . . . . . . . . . . . . . . . . . . . . . . . . 53
2.3.4 Aplicaciones distribuidas basadas en RPC . . . . . . . . . . . . . . . . . . 53
2.3.5 Modelo basado en objetos distribuidos . . . . . . . . . . . . . . . . . . . . 54
2.3.5.1 Arquitectura general para sistemas basados en objetos distribuidos 56
2.3.5.2 Transacción de objetos remotos en tiempo de ejecución . . . . . 56
2.3.5.3 The Common Object Request Broker Adapter –CORBA . . . . . 57
2.4 Otros modelos de la programación distribuida . . . . . . . . . . . . . . . . . . . . 58
Contenido XI

2.4.1 Multi-threading . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
2.4.2 Modelo de compartición de datos . . . . . . . . . . . . . . . . . . . . . . 58
2.4.3 Modelo basado en paso de mensajes . . . . . . . . . . . . . . . . . . . . . 58
2.5 Proceso de construcción de una aplicación distribuida . . . . . . . . . . . . . . . . 59
2.5.1 Descomposición en paquetes/componentes y ciclo en espiral . . . . . . . . 59
2.5.2 Modelo-Vista-Controlador con patrón Observador . . . . . . . . . . . . . 60
Observer y Observable de Java. . . . . . . . . . . . . . . . . 61
2.5.3 Factores que miden el éxito del proceso de desarrollo de aplicaciones dis-
tribuidas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
Test de auto-evaluación . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63

3 Java para aplicaciones distribuidas 65

3.1 Paradigma de orientación a objetos . . . . . . . . . . . . . . . . . . . . . . . . . . 65
3.1.1 Modularización y ocultación de la información . . . . . . . . . . . . . . . 66
Ejemplo 3.1.: Gestión de Empleados de una Empresa. . . . . . . . 67
3.1.2 Clasificación y abstracción . . . . . . . . . . . . . . . . . . . . . . . . . . 70
Ejemplo 3.2. Abstraer el modelo de un coche. . . . . . . . . . . . . 70
3.1.3 Herencia y polimorfismo . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
3.1.4 Documentación y mantenimiento . . . . . . . . . . . . . . . . . . . . . . 74
3.2 Interoperabilidad . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
3.2.1 Interoperabilidad a nivel de plataforma . . . . . . . . . . . . . . . . . . . 75
3.2.1.1 Bytecode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
3.2.1.2 Java Native Interface . . . . . . . . . . . . . . . . . . . . . . . 76
Ejemplo de JNI. . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
3.2.2 Interoperabilidad a nivel de aplicación . . . . . . . . . . . . . . . . . . . . 78
3.2.2.1 Capa de presentación . . . . . . . . . . . . . . . . . . . . . . . 78
3.2.2.2 Capa de negocio . . . . . . . . . . . . . . . . . . . . . . . . . . 79
3.2.2.3 Capa de datos . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
3.3 Soporte al trabajo en red (networking) . . . . . . . . . . . . . . . . . . . . . . . . 79
3.3.1 Streams . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80
3.3.1.1 OutputStream . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
Ejemplo 3.3: Manejo de ficheros. . . . . . . . . . . . . . . . . . . 81
3.3.1.2 InputStream . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
Ejemplo 3.4.: Fichero de entrada. . . . . . . . . . . . . . . . . . . 82
Ejemplo 3.5.: Streams. . . . . . . . . . . . . . . . . . . . . . . . . 85
3.3.2 Sockets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
3.3.2.1 Socket . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
3.3.2.2 ServerSocket . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
Ejemplo 3.6.: Uso de sockets. . . . . . . . . . . . . . . . . . . . . 88
3.4 Soporte al modelo de objetos distribuidos . . . . . . . . . . . . . . . . . . . . . . 89
3.4.1 CORBA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
3.4.2 Remote Method Incocation –RMI . . . . . . . . . . . . . . . . . . . . . . 93
3.5 Seguridad . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95
3.5.1 Seguridad en applets y aplicaciones . . . . . . . . . . . . . . . . . . . . . 95
Ejemplo 3.7.: Ejemplo de norma y permisos. . . . . . . . . . . . . 98
XII Programación Distribuida con Java

Ejemplo 3.8. Fichero de pólizas. . . . . . . . . . . . . . . . . . . . 98

3.5.2 Seguridad en comunicación en red . . . . . . . . . . . . . . . . . . . . . . 99
Ejemplo 3.9.: Permisos. . . . . . . . . . . . . . . . . . . . . . . . 99
Ejemplo 3.10.: Permisos para todo el código. . . . . . . . . . . . . 100
3.6 Tratamiento de excepciones y robustez . . . . . . . . . . . . . . . . . . . . . . . . 101
Ejemplo 3.11.: Gestión de Excepciones. . . . . . . . . . . . . . . . 104
Test de auto-evaluación . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107

4 Introducción a Remote Method Invocation 109

4.1 Que es RMI . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109
4.2 Objetivos de RMI . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110
4.3 Caracterı́sticas básicas de RMI . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112
4.3.1 Sockets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112
4.3.2 Serialización . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
4.3.2.1 Usos de la serialización . . . . . . . . . . . . . . . . . . . . . . 114
4.3.2.2 Ventajas y problemas de la serialización . . . . . . . . . . . . . 114
4.3.2.3 Mecánica de la serialización . . . . . . . . . . . . . . . . . . . . 116
4.3.2.4 Identificador universal de serialización . . . . . . . . . . . . . . 117
4.3.2.5 Serializando objetos en RMI . . . . . . . . . . . . . . . . . . . 118
4.3.3 Paso de parámetros y valores de retorno . . . . . . . . . . . . . . . . . . . 119
4.3.4 Activación de objetos remotos . . . . . . . . . . . . . . . . . . . . . . . . 120
4.3.5 Recolector de basura distribuido . . . . . . . . . . . . . . . . . . . . . . . 122
4.3.6 Localización . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123
4.3.7 Excepciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124
4.3.8 Seguridad . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125
Ejemplo 4.1.: Permiso de aceptar conexiones. . . . . . . . . . . . . 126
4.4 Arquitectura básica RMI . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126
4.4.1 El servidor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127
4.4.2 El cliente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129
4.4.3 Stubs y skeletons . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129
4.4.3.1 Evolución de los stubs y skeletons en Java . . . . . . . . . . . . 130
4.4.3.2 Proceso de invocación Cliente/Servidor . . . . . . . . . . . . . . 130
Ejemplo 4.2.: Contenido del archivo stub . . . . . . . . . . . . . . 131
4.4.4 RMI Registry . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133
Test de auto-evaluación . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134

5 Caso de estudio RMI básico 135

5.1 Un ejemplo de RMI básico: una calculadora remota . . . . . . . . . . . . . . . . . 135
5.1.1 Desarrollar el objeto remoto . . . . . . . . . . . . . . . . . . . . . . . . . 136
5.1.1.1 La interfaz remota: definición del objeto remoto . . . . . . . . . 136
5.1.1.2 La implementación de la interfaz: implementar el objeto remoto 137
5.1.1.3 La clase servidora . . . . . . . . . . . . . . . . . . . . . . . . . 137
5.1.2 Creación del fichero de pólizas . . . . . . . . . . . . . . . . . . . . . . . . 138
5.1.3 Desarrollar el cliente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 139
5.2 Compilar y ejecutar la aplicación . . . . . . . . . . . . . . . . . . . . . . . . . . . 141
Contenido XIII

5.2.1 Compilar la interfaz remota, servidor y cliente . . . . . . . . . . . . . . . 141

5.2.2 Generar stubs y skeletons con rmic . . . . . . . . . . . . . . . . . . . . . . 141
5.2.3 Arrancar el registro (RMIRegistry) . . . . . . . . . . . . . . . . . . . . . . 142
5.2.4 Ejecutar el servidor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142
5.2.5 Ejecutar el cliente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143
5.3 Automatización de tareas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145
5.4 Despliegue y ejecución en un entorno real . . . . . . . . . . . . . . . . . . . . . . 146
Test de auto-evaluación . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 148

6 Programación RMI avanzada 151

6.1 Conceptos avanzados de la tecnologı́a RMI . . . . . . . . . . . . . . . . . . . . . 151
6.1.1 Manejo de excepciones remotas . . . . . . . . . . . . . . . . . . . . . . . 151
6.1.2 Acceso RMI a base de datos con JDBC . . . . . . . . . . . . . . . . . . . 152
6.2 Ejemplo completo: Sistema de voto electrónico . . . . . . . . . . . . . . . . . . . 155
6.2.1 El problema de voto electrónico . . . . . . . . . . . . . . . . . . . . . . . 155
6.2.2 Configuración y ejecución . . . . . . . . . . . . . . . . . . . . . . . . . . 157
6.2.2.1 Configuración . . . . . . . . . . . . . . . . . . . . . . . . . . . 157
6.2.2.2 Arrancar rmiregistry . . . . . . . . . . . . . . . . . . . . . . . . 158
6.2.2.3 Arrancar servicios del servidor . . . . . . . . . . . . . . . . . . 158
6.2.2.4 Arrancar el cliente: realizar una votación . . . . . . . . . . . . . 161
6.2.3 Pasos de la implementación . . . . . . . . . . . . . . . . . . . . . . . . . 163
6.2.3.1 Declaración de la interfaz remota: MesaRemota . . . . . . . . . 163
6.2.3.2 Implementación de la interfaz remota: ProgramaMesa . . . . . . 163
6.2.3.3 Implementación del servidor: MesaServidor . . . . . . . . . . . 165
6.2.3.4 Implementación del cliente: PantallaCabinaClienteMesa . . . . . 167
6.2.4 Juego de pruebas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171
6.3 Listado de ficheros de la aplicación . . . . . . . . . . . . . . . . . . . . . . . . . . 174
Test de auto-evaluación . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 176

7 Aplicaciones distribuidas con Java: interfaces gráficas de usuario con Swing 179
7.1 Introducción . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 179
7.2 Capa de presentación . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 180
7.3 Soporte Java a las interfaces gráficas . . . . . . . . . . . . . . . . . . . . . . . . . 181
7.4 El paquete Swing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182
7.4.1 Swing básico: componentes gráficos habituales . . . . . . . . . . . . . . . 183
7.4.1.1 Ventanas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 184
Ejemplo 7.1.: Código completo para crear una ventana. . . . . . . . 184
7.4.1.2 Paneles y organizadores de contenido (layouts) . . . . . . . . . . 185
Combinación de diferentes organizadores. . . . . . . . . . . . . . . 187
Ejemplo 7.2.: Dar color al fondo de pantalla. . . . . . . . . . . . . 188
7.4.1.3 Etiquetas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189
Ejemplo 7.3.: Etiquetas JLabel. . . . . . . . . . . . . . . . . . . . 189
7.4.1.4 Campos y áreas de texto . . . . . . . . . . . . . . . . . . . . . . 191
Ejemplo 7.4.: Campo de texto. . . . . . . . . . . . . . . . . . . . . 191
7.4.1.5 Botones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193
XIV Programación Distribuida con Java

Ejemplo 7.5.: Creación de un boton. . . . . . . . . . . . . . . . . . 193

7.4.1.6 Gestión de eventos . . . . . . . . . . . . . . . . . . . . . . . . . 195
Ejemplo 7.6.: Gestión de eventos del botón con nombre “Aceptar”. 196
Ejemplo 7.7. Gestión de eventos del botón de cerrar la ventana. . . 198
Presentación de mensajes. . . . . . . . . . . . . . . . . . . . . . . 198
Ejemplo 7.8.: Código para presentar mensajes al usuario. . . . . . . 200
7.4.2 Swing avanzado: otros componentes gráficos . . . . . . . . . . . . . . . . 203
7.4.2.1 Programación sistemática en Swing . . . . . . . . . . . . . . . . 203
Ejemplo 7.9.: Código completo de PantallaElectoral. . . . . . . . . 204
7.4.2.2 Combos, casillas de verificación y botones de radio . . . . . . . 214
Ejemplo 7.10.: Código completo de PantallaIntroducirElector. . . . 214
7.4.2.3 Menus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 221
Ejemplo 7.11.: Código completo de PantallaMesa. . . . . . . . . . 221
7.4.2.4 Tablas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 224
Ejemplo 7.12.: Código completo de PantallaEmitirVoto. . . . . . . 224
Test de auto-evaluación . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 229

8 Programación Java con JDBC y el paquete java.sql 231

8.1 Introducción . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 231
8.2 Capa de datos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 232
8.3 Soporte Java al acceso a base de datos . . . . . . . . . . . . . . . . . . . . . . . . 235
8.3.1 Pasos a seguir en el desarrollo de un programa Java con JDBC . . . . . . . 236
8.3.1.1 Creación de las base de datos e instalación de los controladores . 237
Para MS Access. . . . . . . . . . . . . . . . . . . . . . . . . . . . 237
Para PostgreSQL. . . . . . . . . . . . . . . . . . . . . . . . . . . . 239
8.3.1.2 Conexión a la base de datos . . . . . . . . . . . . . . . . . . . . 245
Clase java.sql.Connection. . . . . . . . . . . . . . . . . . . . . . . 248
URL de conexión a la base de datos. . . . . . . . . . . . . . . . . . 248
La clase GestorDiscoConexion. . . . . . . . . . . . . . . . . . . . 249
8.3.2 Realizar una sessión de trabajo con la base de datos . . . . . . . . . . . . . 252
8.3.2.1 Conectarse y trabajar con una base de datos . . . . . . . . . . . 252
La clase java.sql.Statement. . . . . . . . . . . . . . . . . . . . . . 252
La clase java.sql.PreparedStatement. . . . . . . . . . . . . . . . . . 253
Gestión de excepciones. . . . . . . . . . . . . . . . . . . . . . . . 255
8.3.2.2 Control de transacciones . . . . . . . . . . . . . . . . . . . . . . 256
8.3.2.3 Conversión entre tipos de datos Java y SQL . . . . . . . . . . . 258
8.3.3 Sentencias SQL para efectuar operaciones elementales . . . . . . . . . . . 260
La clase Persona. . . . . . . . . . . . . . . . . . . . . . . . . . . . 261
La clase Elector. . . . . . . . . . . . . . . . . . . . . . . . . . . . 265
8.3.3.1 Sentencias executeUpdate para insertar información . . . . . . . 267
La clase PantallaIntroducirElector. . . . . . . . . . . . . . . . . . . 267
La clase GestorDiscoElector para inserción. . . . . . . . . . . . . . 272
Ejecución. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 274
Resultado de la inserción de un elector. . . . . . . . . . . . . . . . 274
8.3.3.2 Sentencia executeQuery para consultar información . . . . . . . 276
Contenido XV

La clase java.sql.ResultSet. . . . . . . . . . . . . . . . . . . . . . . 276

La clase PantallaConsultarElector. . . . . . . . . . . . . . . . . . . 279
La clase GestorDiscoElector para consulta. . . . . . . . . . . . . . 282
Ejecución. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 283
Resultado de la consulta de un elector. . . . . . . . . . . . . . . . . 284
8.3.3.3 Sentencias executeUpdate para modificar información . . . . . . 284
La clase PantallaModificarElector. . . . . . . . . . . . . . . . . . . 285
La clase GestorDiscoElector para modificación. . . . . . . . . . . . 291
Ejecución. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 292
Resultados de modificar un elector. . . . . . . . . . . . . . . . . . 293
8.3.3.4 Sentencias executeUpdate para eliminar . . . . . . . . . . . . . 295
La clase PantallaBorrarElector. . . . . . . . . . . . . . . . . . . . . 295
La clase GestorDiscoElector. . . . . . . . . . . . . . . . . . . . . . 298
Ejecución. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 299
Resultado de la eliminación de un elector. . . . . . . . . . . . . . . 299
Test de auto-evaluación . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 299

9 Poniendo las piezas juntas...la aplicacion distribuida eVotoSeguro 303

9.1 Presentación del problema de la votación electrónica . . . . . . . . . . . . . . . . 303
9.2 Especificación y análisis de la aplicación eVotoSeguro . . . . . . . . . . . . . . . . 304
9.2.1 Descripción del sistema . . . . . . . . . . . . . . . . . . . . . . . . . . . 304
9.2.2 Programa Electorado . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 305
Electores. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 305
Partidos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 305
Candidatos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 306
Circunscripciones. . . . . . . . . . . . . . . . . . . . . . . . . . . 306
Comarcas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 307
Municipios. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 307
Centros. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 307
Mesas electorales. . . . . . . . . . . . . . . . . . . . . . . . . . . 308
Impresión del acta. . . . . . . . . . . . . . . . . . . . . . . . . . . 308
Envı́o de los votos a la Central Electoral. . . . . . . . . . . . . . . 308
Creación de archivos históricos. . . . . . . . . . . . . . . . . . . . 308
Escrutinio. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 308
9.2.3 Programa Contraseña . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 309
Identificación. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 309
Obtención de contraseña. . . . . . . . . . . . . . . . . . . . . . . . 309
9.2.4 Programa Votantes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 309
Identificación. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 309
Votación. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 309
Introducción de la contraseña. . . . . . . . . . . . . . . . . . . . . 310
Selección del candidato. . . . . . . . . . . . . . . . . . . . . . . . 310
Confirmación de la selección. . . . . . . . . . . . . . . . . . . . . 310
Despido. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 310
9.2.5 Resumen Esquemático . . . . . . . . . . . . . . . . . . . . . . . . . . . . 310
XVI Programación Distribuida con Java

9.2.6 Recursos necesarios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 311

9.2.7 Otros requerimientos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 311
Extensibilidad de eVotoSeguro. . . . . . . . . . . . . . . . . . . . . 311
Códigos de barras. . . . . . . . . . . . . . . . . . . . . . . . . . . 312
Pantalla táctil. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 312
Distribución del espacio y disposición de la cabina. . . . . . . . . . 312
9.2.8 Glosario . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 312
9.3 Diagramas de casos de uso . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 313
9.3.1 Requisitos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 314
9.3.1.1 Identificación de los actores . . . . . . . . . . . . . . . . . . . . 314
9.3.1.2 Diagrama de casos de uso de los requisitos . . . . . . . . . . . . 314
9.3.2 Descripción textual de los casos de uso . . . . . . . . . . . . . . . . . . . 317
Caso de uso Gestión electores. . . . . . . . . . . . . . . . . . . . . 317
Caso de uso Gestión de partidos. . . . . . . . . . . . . . . . . . . . 317
Caso de uso Gestión de candidatos. . . . . . . . . . . . . . . . . . 317
Caso de uso Gestión circunscripciones. . . . . . . . . . . . . . . . 318
Caso de uso Gestión comarcas. . . . . . . . . . . . . . . . . . . . 318
Caso de uso Gestión municipios. . . . . . . . . . . . . . . . . . . . 318
Caso de uso Gestión de centros. . . . . . . . . . . . . . . . . . . . 319
Caso de uso Gestión mesa electoral. . . . . . . . . . . . . . . . . . 319
Caso de uso Tratamiento escrutinio. . . . . . . . . . . . . . . . . . 319
Caso de uso Calcular participación. . . . . . . . . . . . . . . . . . 320
Caso de uso Identificación y finalización. . . . . . . . . . . . . . . 320
Caso de uso Identificar elector. . . . . . . . . . . . . . . . . . . . 320
Caso de uso Comprobar contraseña. . . . . . . . . . . . . . . . . . 321
Caso de uso Emitir voto. . . . . . . . . . . . . . . . . . . . . . . . 321
Caso de uso Crear acta. . . . . . . . . . . . . . . . . . . . . . . . 321
9.4 Arquitectura / diseño de la aplicación eVotoSeguro . . . . . . . . . . . . . . . . . . 322
9.4.1 Diagrama de entidades . . . . . . . . . . . . . . . . . . . . . . . . . . . . 322
9.4.2 Diagrama de paquetes . . . . . . . . . . . . . . . . . . . . . . . . . . . . 322
9.4.3 Subsistema Gestión Básica Central Electoral . . . . . . . . . . . . . . . . 324
9.4.3.1 Descripción . . . . . . . . . . . . . . . . . . . . . . . . . . . . 324
9.4.3.2 Diagramas de jerarquı́as . . . . . . . . . . . . . . . . . . . . . 325
9.4.4 Subsistema Cálculo Votos . . . . . . . . . . . . . . . . . . . . . . . . . . 325
9.4.4.1 Resultados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 327
9.4.4.2 Consultas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 328
9.4.4.3 Diagrama de clases . . . . . . . . . . . . . . . . . . . . . . . . 328
9.4.5 Subsistema Actividades Centro . . . . . . . . . . . . . . . . . . . . . . . 328
9.4.5.1 Descripción . . . . . . . . . . . . . . . . . . . . . . . . . . . . 328
9.4.5.2 Diagrama de clases . . . . . . . . . . . . . . . . . . . . . . . . 330
9.4.6 Diagrama de estados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 330
9.5 Persistencia de datos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 331
9.5.1 Descripción . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 331
9.5.2 Diseño conceptual –Diagrama ER . . . . . . . . . . . . . . . . . . . . . . 331
Descripción de los atributos . . . . . . . . . . . . . . . . . . . . . 331
 Contenido XVII

9.6 Implementación de la aplicación eVotoSeguro . . . . . . . . . . . . . . . . . . . . 333

9.6.1 Declaración de las interfaces remotas . . . . . . . . . . . . . . . . . . . . 334
9.6.1.1 Interfaz Comision remota . . . . . . . . . . . . . . . . . . . . . 334
9.6.1.2 Interfaz de la Mesa remota . . . . . . . . . . . . . . . . . . . . 334
9.6.2 Implementación de las interfaces remotas . . . . . . . . . . . . . . . . . . 335
9.6.2.1 Programa Comision . . . . . . . . . . . . . . . . . . . . . . . . 335
9.6.2.2 Programa Mesa . . . . . . . . . . . . . . . . . . . . . . . . . . 343
9.6.3 Implementación de los servidores . . . . . . . . . . . . . . . . . . . . . . 345
9.6.3.1 Servidor Comisión . . . . . . . . . . . . . . . . . . . . . . . . . 345
9.6.3.2 Servidor Mesa . . . . . . . . . . . . . . . . . . . . . . . . . . . 346
9.6.4 Implementación de los clientes . . . . . . . . . . . . . . . . . . . . . . . . 347
9.6.4.1 Cliente de la comisión (mesa electoral) . . . . . . . . . . . . . . 347
9.6.4.2 Cliente de la mesa (cabina electoral) . . . . . . . . . . . . . . . 349
9.6.5 La base de datos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 350
9.6.5.1 Creación de la base de datos . . . . . . . . . . . . . . . . . . . . 351
9.6.5.2 La conexión con la base de datos . . . . . . . . . . . . . . . . . 353
9.7 Ejecución de la aplicación eVotoSeguro . . . . . . . . . . . . . . . . . . . . . . . 357
9.8 Uso de la aplicación eVotoSeguro . . . . . . . . . . . . . . . . . . . . . . . . . . . 361
9.8.1 Programa Electorado de la comisión central. . . . . . . . . . . . . . . . . 361
9.8.2 Programa Contraseña en las mesas electorales . . . . . . . . . . . . . . . . 362
9.8.3 Programa Votantes en las cabinas de votación . . . . . . . . . . . . . . . . 364
Test de auto-evaluación . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 369

Bibliografı́a 371

Acrónimos 373

Índice de términos 374

View publication stats