1
Download TFM_Daniel Machado Fernández
Document related concepts
no text concepts found
Transcript
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo
UNIVERSIDAD DE OVIEDO
MÁSTER UNIVERSITARIO EN INGENIERÍA WEB
TRABAJO FIN DE MÁSTER
“SISTEMA UNIFICADOR Y CATALOGADOR
DE SERVICIOS WEB DE TEMÁTICA COMÚN”
DANIEL MACHADO FERNÁNDEZ
El tutor autoriza la defensa del Trabajo Fin de Máster
Fdo. D. SECUNDINO JOSÉ GONZÁLEZ PÉREZ...............
Oviedo, JUNIO de 2014
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
1
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo
Agradecimientos
A Cundi, por darme la oportunidad de realizar este trabajo.
Al C1Nn, por su inestimable ayuda cuando la he necesitado.
A Natalia, por haber hecho el camino más fácil.
2
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo
Resumen
Se propone una aplicación web que sea capaz de registrar servicios web de una temática
común con el objetivo de conocer su funcionamiento para poder obtener información de ellos
de forma unificada. Además, el sistema también será capaz de realizar un catálogo que
permita a los usuarios buscar los servicios web registrados mediante un componente buscador
que proporcionará información de los servicios web como pueden ser las operaciones que
contienen, a qué categoría pertenecen y cual es la dirección donde se pueden encontrar esos
servicios web.
Otra de las funcionalidades que ofrece el sistema es la capacidad de utilizar esos
conocimientos para ofrecer un punto de acceso a esa información que está registrada, es
decir, se podrán obtener resultados de diferentes servicios web de forma unificada.
Para conseguir obtener este conocimiento, el sistema lo hace a través de un formulario de
registro disponible en la web, que consultará el fichero WSDL y entre los registros previos y la
aplicación de funciones String Metrics determinará cómo se hace la traducción entre el
modelo de referencia y el del servicio web.
La aplicación está desarrollada con Java Enterprise Edition, además de incluir un buscador de
tipo Apache Solr (Lucene) y una base de datos NoSQL Apache Cassandra.
Otras de las tecnologías utilizadas en el desarrollo han sido Apache Maven, Spring Framework,
Apache CXF y especificaciones como JSR-330 (Inyección de dependencias) y JSR-220 (JPA).
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
3
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo
Palabras Clave
Servicios Web, Interoperabilidad, Becas, Universidades, Java, Apache CXF.
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
5
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo
Abstract
The result of this project is a web application that it is capable to register a common topic web
services with the purpose of retrieve information about its structure in a unified form.
Moreover, the system is also capable to compound a catalog that allows users search
information about the registered web services through a search engine component that
provides information about this web services like operations, categories and its WSDL's
address.
The system offers other capabilities like use the knowledge learned in the register process to
build a common access point to the registered web services to mine it in a common way.
To make the previous goal, the system "learns" this information from the register process
available in the web, from the WSDL file specified. With the previous registers and applying
String Metrics functions it determines how to make the translate between the reference
model and the registered web service.
The Application was developed with Java Enterprise Edition, and includes a search engine like
Apache Solr (Lucene) and a NoSQL database like Apache Cassandra.
Other tecnologies that has been used in this development were Apache Maven, Spring
Framework, Apache CXF and JSR-330 (Dependency Injection) and JSR-220 (JPA) specifications.
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
7
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo
Keywords
Web Services, Interoperability, Scholarships, Universities, Java, Apache CXF.
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
9
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo
Índice General
CAPÍTULO 1.
MEMORIA DEL PROYECTO ...........................................................................................17
1.1
RESUMEN DE LA MOTIVACIÓN, OBJETIVOS Y ALCANCE DEL PROYECTO ..................................................... 17
1.2
RESUMEN DE TODOS LOS ASPECTOS .................................................................................................. 18
1.2.1 Introducción.......................................................................................................................... 18
1.2.2 Referencias Técnicas............................................................................................................. 18
1.2.3 Planificación del Proyecto..................................................................................................... 18
1.2.4 Análisis.................................................................................................................................. 18
1.2.5 Diseño del sistema ................................................................................................................ 18
1.2.6 Implementación del sistema ................................................................................................. 18
1.2.7 Desarrollo de pruebas .......................................................................................................... 18
1.2.8 Manuales del Sistema........................................................................................................... 19
1.2.9 Conclusiones y ampliaciones ................................................................................................ 19
1.2.10
Presupuesto...................................................................................................................... 19
1.2.11
Referencias Bibliográficas ................................................................................................ 19
1.2.12
Apéndices ......................................................................................................................... 19
CAPÍTULO 2.
INTRODUCCIÓN ...........................................................................................................21
2.1
JUSTIFICACIÓN DEL PROYECTO .......................................................................................................... 21
2.2
OBJETIVOS DEL PROYECTO ............................................................................................................... 22
2.3
ESTUDIO DE LA SITUACIÓN ACTUAL ................................................................................................... 23
2.3.1 Evaluación de Alternativas ................................................................................................... 24
CAPÍTULO 3.
REFERENCIAS TÉCNICAS ..............................................................................................29
3.1
JAVA ........................................................................................................................................... 29
3.2
SPRING FRAMEWORK ..................................................................................................................... 30
3.2.1 Spring MVC ........................................................................................................................... 30
3.2.2 Spring Test ............................................................................................................................ 31
3.2.3 Spring Data ........................................................................................................................... 31
3.3
JUNIT .......................................................................................................................................... 32
3.4
APACHE SOLR ............................................................................................................................... 32
3.5
SISTEMAS GESTORES DE BASE DE DATOS NO-SQL ................................................................................ 32
3.5.1 Apache Cassandra ................................................................................................................ 32
3.6
POSTGRESQL ............................................................................................................................... 33
3.7
JPA ............................................................................................................................................ 33
3.8
SERVICIOS WEB ............................................................................................................................. 34
3.8.1 Apache CXF ........................................................................................................................... 34
3.9
BOOTSTRAP .................................................................................................................................. 34
3.10
JQUERY........................................................................................................................................ 34
3.11
STRING METRICS ........................................................................................................................... 35
3.11.1
Chapman matching Soundex / Soundex .......................................................................... 35
3.11.2
Smith-Waterman-Gotoh .................................................................................................. 35
3.11.3
Monge-Elkan .................................................................................................................... 35
3.12
MAVEN ....................................................................................................................................... 36
3.13
SVN ........................................................................................................................................... 36
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
11
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo
CAPÍTULO 4.
PLANIFICACIÓN DEL PROYECTO Y RESUMEN DE PRESUPUESTOS ................................ 37
4.1
PLANIFICACIÓN ..............................................................................................................................37
4.1.1 Contexto ................................................................................................................................37
4.1.2 Personal ................................................................................................................................38
4.1.3 Tareas del proyecto ...............................................................................................................38
4.1.4 Resumen................................................................................................................................44
4.1.5 Ajuste de la planificación ......................................................................................................45
4.2
CONCLUSIONES DE LA PLANIFICACIÓN .................................................................................................49
4.3
RESUMEN DEL PRESUPUESTO............................................................................................................50
CAPÍTULO 5.
ANÁLISIS ..................................................................................................................... 51
5.1
DEFINICIÓN DEL SISTEMA .................................................................................................................51
5.1.1 Determinación del Alcance del Sistema ................................................................................51
5.2
REQUISITOS DEL SISTEMA.................................................................................................................52
5.2.1 Obtención de los Requisitos del Sistema ...............................................................................52
5.2.2 Identificación de Actores del Sistema ...................................................................................54
5.2.3 Especificación de Casos de Uso .............................................................................................55
5.3
IDENTIFICACIÓN DE LOS SUBSISTEMAS EN LA FASE DE ANÁLISIS ................................................................57
5.3.1 Descripción de los Subsistemas .............................................................................................57
5.3.2 Descripción de los Interfaces entre Subsistemas...................................................................58
5.4
DIAGRAMA DE CLASES PRELIMINAR DEL ANÁLISIS .................................................................................59
5.4.1 Diagrama de Clases ..............................................................................................................59
5.4.2 Descripción de las Clases .......................................................................................................59
5.5
ANÁLISIS DE CASOS DE USO Y ESCENARIOS ..........................................................................................63
5.5.1 Registrar universidad ............................................................................................................63
5.6
ANÁLISIS DE INTERFACES DE USUARIO ................................................................................................66
5.6.1 Formulario de registro ..........................................................................................................66
5.6.2 Buscador ...............................................................................................................................67
5.6.3 Detalle de Universidad ..........................................................................................................67
5.6.4 Diagrama de Navegabilidad .................................................................................................68
5.7
ESPECIFICACIÓN DEL PLAN DE PRUEBAS ..............................................................................................69
CAPÍTULO 6.
DISEÑO DEL SISTEMA.................................................................................................. 71
6.1
ARQUITECTURA DEL SISTEMA............................................................................................................71
6.1.1 Diagramas de Paquetes ........................................................................................................71
6.1.2 Diagramas de Componentes .................................................................................................74
6.1.3 Diagramas de Despliegue .....................................................................................................74
6.2
DISEÑO DE CLASES .........................................................................................................................76
6.2.1 Diagrama de Clases ..............................................................................................................76
6.3
DIAGRAMAS DE INTERACCIÓN Y ESTADOS............................................................................................94
6.3.1 Registro de una nueva Universidad ......................................................................................94
6.3.2 Buscador ...............................................................................................................................96
6.3.3 Publicador .............................................................................................................................96
6.4
DIAGRAMAS DE ACTIVIDADES ...........................................................................................................97
6.5
DISEÑO DE LA BASE DE DATOS ..........................................................................................................98
6.5.1 Descripción del SGBD Usado .................................................................................................98
6.5.2 Integración del SGBD en Nuestro Sistema ............................................................................98
6.5.3 Diagrama E-R ........................................................................................................................98
6.6
DISEÑO DE LA INTERFAZ ...................................................................................................................99
6.6.1 Descripción de la Interfaz ......................................................................................................99
12
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
6.6.2 Descripción del Comportamiento de la Interfaz ................................................................. 106
6.7
ESPECIFICACIÓN TÉCNICA DEL PLAN DE PRUEBAS ............................................................................... 107
6.7.1 Pruebas Unitarias ............................................................................................................... 107
6.7.2 Pruebas de Integración y del Sistema ................................................................................. 109
6.7.3 Pruebas de Usabilidad y Accesibilidad ............................................................................... 109
6.7.4 Pruebas de Rendimiento ..................................................................................................... 112
CAPÍTULO 7.
IMPLEMENTACIÓN DEL SISTEMA ..............................................................................113
7.1
ESTÁNDARES Y NORMAS SEGUIDOS ................................................................................................. 113
7.1.1 HMTL 5 ............................................................................................................................... 113
7.1.2 CSS 3 ................................................................................................................................... 113
7.1.3 Java Conventions ................................................................................................................ 113
7.1.4 JPA (JSR-317) ...................................................................................................................... 113
7.1.5 Dependency Injection For Java (JSR-330) ........................................................................... 113
7.1.6 JAX-WS (JSR-224) ................................................................................................................ 113
7.1.7 MVC (Model-View-Controller) ............................................................................................ 114
7.2
LENGUAJES DE PROGRAMACIÓN ..................................................................................................... 115
7.3
HERRAMIENTAS Y PROGRAMAS USADOS PARA EL DESARROLLO............................................................. 116
7.3.1 Spring Tool Suite ................................................................................................................. 116
7.3.2 SVN ..................................................................................................................................... 116
7.3.3 Maven................................................................................................................................. 116
7.3.4 Microsoft Project ................................................................................................................ 116
7.3.5 Microsoft Office .................................................................................................................. 117
7.3.6 Enterprise Architect ............................................................................................................ 117
7.3.7 Windows 7 .......................................................................................................................... 117
7.4
CREACIÓN DEL SISTEMA ................................................................................................................ 118
7.4.1 Problemas Encontrados ...................................................................................................... 118
7.4.2 Descripción Detallada de las Clases.................................................................................... 119
CAPÍTULO 8.
DESARROLLO DE LAS PRUEBAS .................................................................................158
8.1
PRUEBAS UNITARIAS .................................................................................................................... 158
8.2
PRUEBAS DE INTEGRACIÓN Y DEL SISTEMA ........................................................................................ 159
8.3
PRUEBAS DE USABILIDAD Y ACCESIBILIDAD........................................................................................ 160
8.3.1 Pruebas de Usabilidad ........................................................................................................ 160
8.3.2 Pruebas de Accesibilidad (WCAG 2.0) ................................................................................. 163
8.4
PRUEBAS DE RENDIMIENTO ........................................................................................................... 167
CAPÍTULO 9.
MANUALES DEL SISTEMA ..........................................................................................169
9.1
MANUAL DE INSTALACIÓN ............................................................................................................. 169
9.1.1 PostgreSQL ......................................................................................................................... 169
9.1.2 Apache Cassandra .............................................................................................................. 169
9.1.3 Apache Solr ......................................................................................................................... 170
9.1.4 Apache Tomcat 7 ................................................................................................................ 170
9.2
MANUAL DE EJECUCIÓN ................................................................................................................ 171
9.3
MANUAL DE USUARIO .................................................................................................................. 172
9.4
MANUAL DEL PROGRAMADOR........................................................................................................ 173
CAPÍTULO 10.
10.1
10.2
CONCLUSIONES Y AMPLIACIONES .........................................................................175
CONCLUSIONES ........................................................................................................................... 175
AMPLIACIONES ............................................................................................................................ 176
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
13
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo
CAPÍTULO 11.
PRESUPUESTO ...................................................................................................... 177
CAPÍTULO 12.
REFERENCIAS BIBLIOGRÁFICAS ............................................................................. 179
12.1
12.2
LIBROS Y ARTÍCULOS .................................................................................................................... 179
REFERENCIAS EN INTERNET ............................................................................................................ 180
CAPÍTULO 13.
APÉNDICES ........................................................................................................... 183
13.1
GLOSARIO Y DICCIONARIO DE DATOS .............................................................................................. 183
13.2
JUSTIFICACIÓN DEL CAMBIO .......................................................................................................... 186
13.3 ESTADO DEL ARTE DE LA WEB SEMÁNTICA ....................................................................................... 187
13.3.1
Introducción ................................................................................................................... 187
13.3.2
Ontología ....................................................................................................................... 187
13.3.3
Servicios Web Semánticos ............................................................................................. 193
13.3.4
Almacenamiento de ontologías ..................................................................................... 196
13.3.5
Problemas ...................................................................................................................... 199
13.3.6
Arquitectura................................................................................................................... 200
13.3.7
Tecnologías y Herramientas seleccionadas ................................................................... 202
13.3.8
Referencias de interés.................................................................................................... 203
13.4
HOJA DE DECISIONES DEL CAMBIO .................................................................................................. 204
13.4.1
Servicios Web Semánticos ............................................................................................. 204
13.4.2
Servicios Web Unificados ............................................................................................... 205
13.4.3
Tecnológicas .................................................................................................................. 206
13.5
CONTENIDO ENTREGADO EN EL CD-ROM ....................................................................................... 208
13.5.1
Contenidos ..................................................................................................................... 208
13.5.2
Ficheros de Configuración ............................................................................................. 209
13.5.3
Log4j.properties ............................................................................................................. 219
13.5.4
Database.properties ...................................................................................................... 220
13.5.5
Persistence.xml .............................................................................................................. 220
13.5.6
Orm.xml ......................................................................................................................... 220
13.5.7
Beans ............................................................................................................................. 221
13.5.8
Publisher.wsdl ................................................................................................................ 224
13.6
CÓDIGO FUENTE ......................................................................................................................... 226
13.6.1
Define-tramites-servicios-web-unificados-buscador ..................................................... 226
13.6.2
Define-tramites-servicios-web-unificados-modelo ........................................................ 250
13.6.3
Define-tramites-servicios-web-unificados-publisher ..................................................... 277
13.6.4
Define-tramites-servicios-web-unificados-recolector .................................................... 278
13.6.5
Define-tramites-servicios-web-unificados-registrador .................................................. 281
13.6.6
Define-tramites-servicios-web-unificados-service ......................................................... 290
14
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo
Índice de Figuras
Ilustración 1. Alternativa 1 ...................................................................................................................24
Ilustración 2. Alternativa 2 ...................................................................................................................25
Ilustración 3. Alternativa 3 ...................................................................................................................26
Ilustración 4. Alternativa 4 ...................................................................................................................27
Ilustración 5. Referencias Técnicas. Spring ...........................................................................................30
Ilustración 6. Planificación. Diagrama Resumen Proyecto ....................................................................44
Ilustración 7. Planificación. Diagrama de recursos ...............................................................................44
Ilustración 8. Planificación. Coste por Componentes ............................................................................44
Ilustración 9. Resumen de los casos de uso ..........................................................................................55
Ilustración 10. Diagrama de clases previo ............................................................................................59
Ilustración 11. Casos Uso. Registrar una universidad............................................................................63
Ilustración 12. Casos Uso. Obtener información del servicio web ........................................................64
Ilustración 13. Casos Uso. Emparejamiento de campso ........................................................................65
Ilustración 14. Interfaz de Usuario. Formulario de Registro..................................................................66
Ilustración 15. Interfaz de Usuario. Buscador .......................................................................................67
Ilustración 16. Interfaz de Usuario. Detalle Universidad.......................................................................67
Ilustración 17. Diagrama de Navegabilidd ............................................................................................68
Ilustración 18. Arquitectura. Diagrama de Paquetes ............................................................................71
Ilustración 19. Arquitectura. Paquete Modelo .....................................................................................71
Ilustración 20. Arquitectura. Paquete Service ......................................................................................72
Ilustración 21. Arquitectura. Paquete Buscador ...................................................................................72
Ilustración 22. Arquitectura. Paquete Recolector .................................................................................73
Ilustración 23. Arquitectura. Paquete Registrador ...............................................................................73
Ilustración 24. Diagrama Despliegue ....................................................................................................74
Ilustración 25. Diagrama Clases. Controller ..........................................................................................76
Ilustración 26. Diagrama Clases. Search ...............................................................................................77
Ilustración 27. Diagrama Clases. SearchView .......................................................................................77
Ilustración 28. Diagrama Clases. University ..........................................................................................78
Ilustración 29. Diagramas Clases. Diagramas Clases .............................................................................78
Ilustración 30Diagrama Clases. Validator .............................................................................................79
Ilustración 31. Diagrama Clases. View ..................................................................................................80
Ilustración 32. Diagramas Clases. Model ..............................................................................................81
Ilustración 33. Diagramas Clases. NoSQL ..............................................................................................81
Ilustración 34. Diagramas Clases. Persistence ......................................................................................82
Ilustración 35. Diagramas Clases. Class ................................................................................................82
Ilustración 36. Diagramas Clases. Util ...................................................................................................82
Ilustración 37. Diagramas Clases. Wrapper ..........................................................................................83
Ilustración 38. Diagramas Clases. Publisher..........................................................................................83
Ilustración 39. Diagramas Clases. Recolector .......................................................................................84
Ilustración 40. Diagramas Clases. Ws ...................................................................................................84
Ilustración 41. Diagramas Clases. Matcher ...........................................................................................85
Ilustración 42. Diagramas Clases. Presentation ....................................................................................86
Ilustración 43. Diagramas Clases. University ........................................................................................87
Ilustración 44. Diagrama Clases. Ws .....................................................................................................88
Ilustración 45. Diagramas Clases. Builder .............................................................................................89
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
15
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo
Ilustración 46. Diagramas Clases. Business .......................................................................................... 90
Ilustración 47. Diagramas Clases. Exception ........................................................................................ 90
Ilustración 48. Diagramas Clases. Matcher .......................................................................................... 91
Ilustración 49. Diagramas Clases. SearchEngine ................................................................................... 91
Ilustración 50. Diagramas Clases. Solr .................................................................................................. 92
Ilustración 51. Diagramas Clases. University ........................................................................................ 92
Ilustración 52. Diagramas Clases. Ws ................................................................................................... 93
Ilustración 53. Diagrama Secuencia. Registro Universidad 1 ................................................................ 94
Ilustración 54. Diagrama Secuencia. Registro Universidad 2 ................................................................ 94
Ilustración 55. Diagrama Secuencia. Registro Universidad 3 ................................................................ 95
Ilustración 56. Diagrama Secuencia. Registro Universidad 4 ................................................................ 95
Ilustración 57. Diagrama Secuencia. Buscador ..................................................................................... 96
Ilustración 58. Diagrama Secuencia. Publicador ................................................................................... 96
Ilustración 59. Diagrama Actividad. Registro Universidad.................................................................... 97
Ilustración 60. Diagrama E-R ................................................................................................................ 98
Ilustración 61. Interfaz. Página de inicio .............................................................................................. 99
Ilustración 62. Interfaz. Formulario de registro .................................................................................. 100
Ilustración 63. Interfaz. Selección de Operaciones ............................................................................. 101
Ilustración 64. Interfaz. Emparejamiento campos Beca ..................................................................... 101
Ilustración 65. Interfaz. Emparejamiento campos Solicitante ............................................................ 102
Ilustración 66. Interfaz. Formulario guardado .................................................................................... 103
Ilustración 67. Interfaz. Buscador ...................................................................................................... 103
Ilustración 68. Interfaz. Detalle Universidad ...................................................................................... 104
Ilustración 69. Interfaz. Pantalla del recolector ................................................................................. 104
Ilustración 70. Interfaz. Información de la aplicación ......................................................................... 105
Ilustración 71. Interfaz. Mensaje informativo .................................................................................... 106
Ilustración 72. Interfaz. Mensajes de Error ........................................................................................ 106
Ilustración 73. Test. Resultados del procesamiento de Tests ............................................................. 158
Ilustración 74. Pruebas. Cuestionario Usuario 1 ................................................................................. 161
Ilustración 75. Pruebas. Cuestionario Usuario 2................................................................................. 162
Ilustración 76. Pruebas. Cuestionario Responsable Calidad ............................................................... 163
Ilustración 77. Pruebas. Cuestionario Responsable Calidad 2 ............................................................ 163
Ilustración 78. Nivel A Accesibilidad .................................................................................................. 164
Ilustración 79. Nivel AA Acesibilidad.................................................................................................. 165
Ilustración 80. Nivel AAA Acesibilidad ............................................................................................... 166
Ilustración 81. Stack de Tecnologías Semánticas ................................................................................ 188
Ilustración 82. Niveles de OWL .......................................................................................................... 189
Ilustración 83. Niveles de WSML ........................................................................................................ 190
Ilustración 84. Arquitectura Pellet ..................................................................................................... 192
Ilustración 85. Enfoque de WSMO ..................................................................................................... 194
Ilustración 86. Enfoque de OWL-S ...................................................................................................... 194
Ilustración 87. Interacción con WSMX ............................................................................................... 195
Ilustración 88. IBM-SOR ..................................................................................................................... 197
Ilustración 89. Arquitectura SWS ....................................................................................................... 200
Ilustración 90. Arquitectura Apache Jena .......................................................................................... 201
16
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Memoria del Proyecto | Plataforma para Interoperabilidad de sistemas de información
dentro de un mismo ámbito organizativo
Capítulo 1. Memoria del Proyecto
1.1 Resumen de la Motivación, Objetivos y
Alcance del Proyecto
Debido a la problemática que existe en materia de intercambio de expedientes universitarios,
es común pensar que se le ha de buscar alguna solución. Estando en una sociedad de la
información en la que nos encontramos, que para que una universidad concreta que necesite
un expediente de un alumno o conocer el sistema de becas ofertadas de otra universidad, no
pueda obtenerlas de forma automática si no que bien se tenga que realizar un componente
específico o que la solución sea consultarlas en una página web o mediante correos
electrónicos entre responsables, es una gran pérdida de tiempo.
Se podía diseñar un sistema que sea capaz de facilitar esta tarea y que allanase el camino para
poder explotar la información que pueden obtener las universidades unas de otras bien sea en
forma de mejores programas, facilidades para becas de movilidad, ahorro de tiempo y trabajo
de operarios y en recursos.
A colación de estos hechos, este proyecto busca hacer esta tarea de la interoperabilidad entre
universidades algo menos árida, pues se propone que cada universidad mediante un registro
en un formulario deje constancia de cómo son sus servicios web y de esta forma el sistema
pueda conseguir traducir sus servicios web a un formato común para que la información que
se comparta entre universidades sea transparente provenga del punto del que provenga.
Por otro lado, también se ofrecerá la posibilidad de consumir esta información de las
universidades mediante un único punto de acceso a través de un servicio web parametrizable
para obtener los resultados que el usuario desee más convenientes. Este punto de acceso se
abastecerá de los registros que se realicen en el punto anteriomente explicado pues conocerá
cómo realizar las traducciones entre universidad y sistema.
Este proyecto también ha de servir para generar un catálogo de servicios web a nivel nacional
pues contendrá un buscador que realizará las tareas de biblioteca donde consultar los servicios
web que están registrados, qué operaciones tienen y en qué dirección se pueden encontrar.
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
17
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Memoria del Proyecto
1.2 Resumen de Todos los Aspectos
1.2.1
Introducción
En este apartado de la documentación, se irá guiando al lector a través de los puntos más
básicos del proyecto como por ejemplo pueden ser la motivación, los objetivos que se buscan,
la situación actual…
1.2.2
Referencias Técnicas
Rincón técnico donde se explicarán los términos y tecnologías que se han utilizado a la hora de
elaborar el proyecto.
1.2.3
Planificación del Proyecto
Apoyándose en un diagrama de Gantt, se replicará el calendario que se siguió en la ejecución
del proyecto, dando así una estimación en caso de querer reproducir el mismo.
1.2.4
Análisis
Se desentrañará parte del trabajo previo a la ejecución del proyecto. Requisitos del sistema,
casos de uso, alcance del proyecto, pruebas, etc.
1.2.5
Diseño del sistema
Aquí se plasma la mayor parte del trabajo de ejecución del proyecto. Diagramas de clases, de
interacción, más pruebas de rendimiento, unitarias, etc.
1.2.6
Implementación del sistema
Se describirán las tecnologías utilizadas, las normas seguidas y las herramientas utilizadas para
la implementación.
1.2.7
Desarrollo de pruebas
Como se ha venido diciendo en los capítulos anteriores, aquí se detallarán las pruebas que se
han realizado y los resultados.
18
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Memoria del Proyecto | Plataforma para Interoperabilidad de sistemas de información
dentro de un mismo ámbito organizativo
1.2.8
Manuales del Sistema
Aquí se facilitarán una serie de manuales que se espera puedan ayudar a los futuros
programadores, usuarios y administradores a utilizar el proyecto facilitando.
1.2.9
Conclusiones y ampliaciones
Este es un buen sitio para plasmar las posibles ampliaciones del proyecto que se podrían
realizar, además de reseñar las impresiones que se han tenido en la consecución del proyecto.
1.2.10
Presupuesto
Estimación monetaria del montante que supondría realizar el proyecto para una
empresa/usuario que deseara replicar el proyecto. Se facilita el presupuesto general y el
detallado.
1.2.11
Referencias Bibliográficas
Referencias que se han consultado para la obtención de conocimientos que no se tenían a la
hora de realizar el proyecto.
1.2.12
Apéndices
Se detallarán anexos que se han considerado oportunos para la comprensión más profunda del
proyecto. Se especificará la información facilitada en el CD-ROM que acompaña a esta
documentación.
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
19
Introducción | Plataforma para Interoperabilidad de sistemas de información dentro de un
mismo ámbito organizativo
Capítulo 2. Introducción
2.1 Justificación del Proyecto
Hoy en día uno de los grandes problemas que las entidades o empresas manejan es la
organización de información. Organizar la información que poseen o con la que trabajan es
una tarea compleja, pero si además esa información se ha de compartir con otras empresas
del mismo ámbito, la tarea se vuelve mucho más complicada. Actualmente el canal por el que
se comparte esa información entre las diferentes empresas si se tiene en cuenta que están
informatizadas y actualizadas, será Internet y el medio común más utilizado será exponer una
serie de servicios web que ofrecerán esa información que quieren compartir bajo unos
criterios concretos.
Como se puede deducir, cada empresa o entidad tendrá sus propios servicios web publicados,
teniendo cada uno una finalidad concreta. Por ejemplo, se puede comprender que un hospital
concreto pueda “difundir” los expedientes clínicos de sus “clientes” entre otros hospitales bajo
demanda. Si una persona de Oviedo va al médico por una urgencia en Valencia, el médico que
le trate en Valencia deberá conocer sus datos, con lo que si el hospital de Oviedo tiene su
repositorio de información particular y el de Valencia el suyo (que sería lo más común para
focalizar y no ralentizar los sistemas), tendrán que transmitir esa información de algún modo.
Parece bastante sencillo pensar que no existe problema en este caso, pues si los servicios
informáticos del hospital de Oviedo tienen un servicio web con el que puedan obtener el
expediente clínico del paciente desde Valencia el problema está resuelto. ¿Y qué ocurre con la
forma? Para que desde Valencia sepan que 66 son los kilogramos que pesa el paciente y no la
edad hay que darle sentido a los datos que se reciben y ese sentido entre dos sistemas que se
comunican de forma automática es complicado tenerlo, a lo mejor no entre dos, pero hay que
darse cuenta que hospitales existen muchos. ¿Cómo se podría solucionar esto? La forma más
sencilla sería que cada hospital adaptara sus servicios web a un estándar común que un
organismo regulador debería de definir, pero a falta de esta entidad/sistema, no queda más
remedio que utilizar un sistema que intente adivinar que esos 66 finalmente sean los
kilogramos y no la edad.
Este trabajo se centrará en el ámbito universitario, concretamente en la compartición de
catálogo de becas entre universidades, aunque el caso que se ha expuesto haya sido el de un
hospital para que sea más fácil entender el problema al que se enfrenta el trabajo y lo
extensible que pueda ser.
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
21
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Introducción
2.2 Objetivos del Proyecto
La finalidad por la que se realiza este proyecto es facilitar la comunicación y el traspaso de
información de ámbito similar entre dos entidades que anteriormente bien por
desconocimiento de que podrían compartir información o bien por falta de entendimiento
entre las partes no podían realizarlo.
Además también permitirá llevar acabo un catálogo de los servicios que estén registrados, a
modo de repositorio desde el cual se podrá obtener información de todos los servicios.
Este catálogo también será indexado y será posible acceder a su contenido mediante
búsquedas para su fácil acceso.
Para que estos servicios estén disponibles, se pondrá a disposición de los usuarios un
formulario de registro semi-inteligente que será capaz de adivinar las similitudes entre el
sistema base o de referencia y el que se está registrando.
Los servicios del catálogo, serán capaces de ser llamados de forma conjunta, para recibir la
información de forma homogénea, siendo independiente la entidad que los sirva.
22
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Introducción | Plataforma para Interoperabilidad de sistemas de información dentro de un
mismo ámbito organizativo
2.3 Estudio de la Situación Actual
La Ley 11/2007 LAECSP “Ley de Acceso Electrónico de los Ciudadanos a los Servicios Públicos”
fue una ley en la que se obligaba a las Administraciones Públicas a ofrecer sus servicios a los
ciudadanos por medios telemáticos. Por razones obvias, como la recesión económica y la crisis
económica por la que estamos atravesando, esta Ley, de obligado cumplimiento a 1 de enero
de 2010, se relajó y las administraciones fueron adaptándose en función a sus posibilidades.
La tramitación electrónica trajo consigo la necesidad de modificar los procedimientos
administrativos a los que estábamos acostumbrados, la mayoría de los cuales se tramitaban en
papel y a través de una ventanilla, en la que muchas veces teníamos que hacer largas colas
para la tramitación de ciertos servicios, e incluso, presentar información redundante, por
ejemplo, fotocopia del DNI, estar al corriente de nuestros pagos, certificado del padrón, etc.
En muchos de estos casos se ofreció la posibilidad de simplificar el procedimiento, evitando
que el ciudadano tuviese que presentar información que, de alguna forma, ya estuviese en
poder de la propia administración u organismos públicos. Aquí nace un nuevo término de
Interoperabilidad administrativa, se hace necesaria la comunicación entre los distintos
organismos para el intercambio de información, evitando que el ciudadano presente
información redundante, sólo se le solicitará autorización para realizar dicha consulta desde el
organismo correspondiente en cada momento. Esto trae consigo la creación y aprobación del
ENS y del ENI, RD 3 y 4 de 2010 en la que se establecen las normas técnicas de seguridad y de
interoperabilidad, respectivamente, de la información. Los ESQUEMAS NACIONALES son
normativas muy avanzadas y exigentes cuyo fin es crear condiciones objetivas de
interoperabilidad y de seguridad que faciliten el ejercicio de derechos y el cumplimiento de
deberes a través de los medios electrónicos.
El ENI se define en el apartado 1 del artículo 42 de la Ley 11/2007, “… el conjunto de criterios y
recomendaciones en materia de seguridad, conservación y normalización de la información, de
los formatos y de las aplicaciones que deben ser tenidos en cuenta por las Administraciones
Públicas para la toma de decisiones tecnológicas que garanticen la interoperabilidad”.
Además, las Normas Técnicas de Interoperabilidad desarrollan aspectos concretos de diversas
cuestiones necesarios para asegurar los aspectos más prácticos y operativos de la
interoperabilidad entre las Administraciones Públicas y el ciudadano. La relación de normas
incluye los estándares del documento electrónico, del expediente electrónico, digitalización de
documentos, política de firma electrónica y de certificados de la Administración e, incluso, el
tratamiento de ficheros de intercambio de información, que no son más que la definición
estándar de una estructura de ficheros XML. Todo esto no es suficiente para el intercambio de
información entre organismos, por ejemplo, las Universidades que quieren intercambiar un
expediente académico de un alumno en el que éste desea cambiar de una Universidad a otra,
en la actualidad, se tiene que hacer con el expediente en formato papel. Se pretende que el
cambio se realice de forma electrónica, para ello es necesario crear estructuras comunes de
información y, a través de una capa de servicios, se puede intercambiar la información de
forma que las universidades sigan con el mismo sistema de información, pero que puedan
interactuar con una capa de servicios para intercambiarse el expediente académico. Dicha
capa de servicios debe contener una cierta inteligencia o semántica para la interpretación del
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
23
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Introducción
modelo de datos de un expediente e, incluso, para la interpretación de la información del
expediente.
La solución planteada debería ser válida para otros sectores y otras funcionalidades, por
ejemplo, el Ministerio de Educación quiere obtener los expedientes o notas medias de todos
los alumnos becados, y que lo dicho se pueda llevar a cabo.
2.3.1
Evaluación de Alternativas
Debido a la propia idiosincrasia de los servicios web, el punto conflictivo no está en conseguir
recopilar todos estos servicios, que también, pero sobretodo, lo árido del asunto es cómo se
consigue normalizar toda la información que presenta cada uno de los servicios web ya que al
estar construidos de forma independiente unos de otros, se deberá de depender de un
organismo regulador que proponga un estándar o norma por el cual se tendrán que regir estos
servicios web, o al menos, los datos que ofrecen.
2.3.1.1 Introducción de XSD comunes
Una vez existe la necesidad de tener que cambiar el modelo, la primera opción y más compleja
de llevar a cabo es modificar los servicios web existentes y que sea cada una de las
universidades la responsable de llevar a cabo esta modificación de sus servicios, que teniendo
en cuenta cómo está actualmente la situación, no es probable que suceda este cambio de
modelo por parte de cada una de ellas.
Ilustración 1. Alternativa 1
24
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Introducción | Plataforma para Interoperabilidad de sistemas de información dentro de un
mismo ámbito organizativo
2.3.1.2 Web semántica
En lugar de que cada universidad redefina otra vez sus servicios web, se podría optar por
externalizar este proceso de traducción de cada uno de los modelos, aprovechando las
bondades que proporciona una tecnología tan novedosa como puede ser la web semántica. De
esta forma el objetivo estaría en conseguir mediante consultas sobre una ontología en SPARQL
las conexiones entre un campo del servicio web de una universidad concreta y el del nuevo
modelo genérico. Una vez los datos estén convertidos en el modelo genérico, se volverían a
publicar unos nuevos servicios web con la información transformada pero recogiendo la
información solicitada.
El mayor inconveniente de esta solución es que la ontología adecuada para realizar la
traducción que resultaría, sería excesivamente degenerada en el sentido de que solamente
estaría compuesta por clases aprovechando el sistema de herencia y aun así, no daría soporte
completo a todos los campos y probabilidades que podrían encontrarse.
Ilustración 2. Alternativa 2
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
25
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Introducción
2.3.1.3 Repositorios de información y XSD común
Esta última alternativa sería una revisión de la anterior, mejorándola en el sentido de que se
sustituiría una ontología que proporciona conocimiento semántico, por una base de datos que
en principio será NoSQL, acompañada de Lucene que nos permitirá por un lado tener un
almacén de términos con sus correspondientes traducciones y un índice que permitirá
enriquecer léxicamente las búsquedas y traducciones. Ésta es la alternativa que sobre el papel
parece más factible de realizarse. Si se tiene en cuenta que la Alternativa 1 es inviable por el
costo de trabajo de cada universidad y que la Alternativa 2 sugiere el uso de una tecnología de
forma inadecuada, lo más adecuado a parte de porque técnicamente es una solución buena
parece que sí da con el perfil que se busca.
Ilustración 3. Alternativa 3
26
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Introducción | Plataforma para Interoperabilidad de sistemas de información dentro de un
mismo ámbito organizativo
2.3.1.4 Modelo mapeado
Debido a que Lucene no proporcionaba lo que se creía en un principio, se intentó utilizar esta
biblioteca para realizar el matching de campos entre los modelos de la universidad concreta y
el modelo genérico pero se descartó debido a que está orientado a la indexación de archivos.
Finalmente se decidió cambiar el modelo anterior y remozarlo para obtener la versión final
que se terminará implantando.
Se utilizará un modelo mapeado que consiste en generar un repositorio de conocimiento con
los emparejamientos que se vayan haciendo y de esta forma los siguientes emparejamientos
pueden ir siendo predichos en función del tamaño del repositorio. Además para apoyar la
teoría anterior se utilizarán una serie de funciones matemáticas catalogadas como String
Metrics que proporcionan mediciones sobre cuánto se parecen dos cadenas de texto (no
semánticamente, pero sí léxicamente), con lo que entre las dos soluciones se puede llevar a
cabo un mapeo casi automático de los servicios web.
Este mapeo se realizará durante el registro y a partir de la información que se obtenga a partir
del fichero WSDL que define los servicios web. Toda la información se hará mediante una
instanciación dinámica de los métodos de los servicios web y se hará uso también de la
introspección del lenguaje.
Ilustración 4. Alternativa 4
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
27
Referencias técnicas | Plataforma para Interoperabilidad de sistemas de información dentro
de un mismo ámbito organizativo
Capítulo 3. Referencias técnicas
3.1 Java
Java es un lenguaje de programación orientado a objetos de propósito general, que hizo su
aparición en 1995 y fue escrito por James Gosling y la empresa Sun Microsystems (ahora
adquirida por Oracle). Lo que le diferencia del resto de lenguajes es que debido a que para
ejecutar sus programas hace falta una máquina virtual que los hospede, una vez se realiza la
compilación de un programa a bytecodes, se puede ejecutar en cualquier máquina virtual de
Java.
En sus inicios, la mayor cuota de mercado que manejaba este lenguaje eran sistemas que
albergaban microcontroladores como pueden ser lavadoras, neveras, etc. Aunque ahora como
más éxito ha conseguido es como lenguaje para aplicaciones empresariales (anteriormente
conocido como J2EE, ahora JEE) y por ser el lenguaje utilizado a la hora de desarrollar
aplicaciones para sistemas Android.
Gran parte de su éxito es debido a que es multiplataforma y muy fácil de usar para las
personas que no son todavía muy expertas en el desarrollo de programas pues la curva de
aprendizaje es bastante liviana y al estar ejecutado dentro de la Máquina Virtual de Java, no es
posible realizar acciones dañinas sobre el computador que las ejecuta, como podría serlo por
ejemplo el lenguaje C en sus inicios.
Al no llevar esta gestión de la memoria y referencias de objetos es un lenguaje más pesado y
menos potente comparándolo con lenguajes como C++ pues el sistema recolector de basura,
es el encargado dentro del ámbito Java de liberar las referencias que ya no se utilicen dentro
del programa cada una cantidad determinada de minutos para liberar memoria.
En este proyecto, se utilizará Java 7 a pesar de que ya ha salido la octava versión del lenguaje
que intenta acercarse un poco más a ciertos lenguajes dinámicos pues comienza a incluir
funciones lambda.
El mayor punto fuerte de Java es que tiene un ecosistema que permite realizar aplicaciones
web de forma muy sencilla mediante el uso de diversos frameworks web.
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
29
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Referencias técnicas
3.2 Spring Framework
Es un framework de acogida mundial cuyo fin es la Inyección de Dependencias o Inversión de
Control (Inversion of Control, IoC) además de incluir soporte para la programación orientada a
aspectos que tan de moda está últimamente. Para la implementación del IoC Spring lo hace
mediante un contenedor. Por otra parte, Spring también posee una serie de bibliotecas que
proporcionan funcionalidad en varios ámbitos de la programación como pueden ser
frameworks web (Spring MVC), para la gestión de la persistencia (Spring JDBC, Spring Data),
para la gestión de transacciónes (no sólo de persistencia, a nivel de negocio también con
Spring TX), para la generación de procesos batch (Spring Batch) y muchos más.
Ilustración 5. Referencias Técnicas. Spring
3.2.1
Spring MVC
Es un framework que permite la realización de aplicaciones bajo el patrón MVC. Para ello,
mediante un Servlet definido en el archivo web.xml que denominan DispatcherServlet que
realiza funciones de front controller (de igual forma que lo hace Struts), lo que hace es filtrar
todas las peticiones HTTP y las distribuye por las diferentes clases anotadas con @Controller
que tienen mapeada una dirección. Este controlador, a su vez, pasará el control a la vista
correspondiente (generalmente, una página JSP) donde se renderizará el resultado de las
operaciones de negocio necesarias en función de cada petición. Para ejecutar lógica en la
presentación, Spring MVC proporciona una serie de etiquetas para la gestión de los
formularios ya que permiten orientarlos a modelos de la aplicación y así inyectar los campos
directamente en atributos de las clases, a parte de las tradicionales JSTL. Como es de esperar,
también tiene soporte para la internacionalización y localización de la página mediante
ficheros properties, interceptores para filtrar peticiones, control de errores mediante la
captura de excepciones, resolvedor de recursos de la vista para filtrar qué se hace público y
qué no mediante rutas…
30
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Referencias técnicas | Plataforma para Interoperabilidad de sistemas de información dentro
de un mismo ámbito organizativo
3.2.2
Spring Test
Spring Test es una herramienta de utilidad que se utiliza para poder ejecutar pruebas unitarias
en entornos Spring. Es especialmente necesario utilizar esta herramienta, debido a que será la
proveedora del contexto Spring para que funcione la inyección de dependencias en la
aplicación. Además también es útil, porque permitirá poder ejecutar contextos diferentes a la
hora de realizar tanto las pruebas como la ejecución real de la aplicación: tener diferentes
configuraciones de las bases de datos, diferentes unidades de persistencia, carga de diferentes
módulos (baterías de mock, por ejemplo).
3.2.3
Spring Data
Gracias a Spring Data es relativamente sencillo interactuar con las fuentes de datos que se
encargan de la persistencia en un proyecto, siendo posible utilizar Spring Data con JPA, JDBC,
Solr, Redis, Hadoop, etc.
Esta fácil interacción, es debido a que en la versión de JPA, proporciona de forma transparente
las operaciones CRUD para un modelo (mediante templates) además de generar búsquedas
sencillas de forma automática mediante un interface con lo que no es necesario
implementarlas, sólo definirlas y extender de CRUDRepository. En el caso de Solr, permite
gestionar la generación de índices de forma sencilla y similar a como se hace con Spring Data
JPA. Para la gestión de los recursos con las bases de datos y el buscador se define
3.2.3.1 Spring Data JPA
Permite llevar la gestión completa del ORM de Java de forma casi transparente, tan solo basta
con implementar unas interfaces que incluye. Permite la realización de consultas básicas de
forma transparente para el usuario, además de añadir la posibilidad de realizar las consultas en
lenguaje JPQL. Realiza la gestión de las transacciones y además también permite incluir las
anotaciones JPA para la elaboración del modelo relacional en las bases de datos.
3.2.3.2 Spring Data Solr
Al igual que en el caso anterior, este componente simplifica enormemente la integración de
Apache Solr con una aplicación web. Si ya puede ser complejo integrar un buscador de
contenidos dentro de una aplicación con todo lo que ello conlleva, el realizar las consultas
sobre los índices de Solr es tan sencillo como implementar una serie de interfaces de la
biblioteca según nos convengan unos tipos de búsqueda u otros.
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
31
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Referencias técnicas
3.3 JUnit
Framework por excelencia en entornos Java para la realización de pruebas unitarias. Una gran
integración como plugin con el IDE Eclipse y la capacidad de su utilización mediante
anotaciones en las clases que serán detectadas como pruebas hacen de su uso algo muy
sencillo.
3.4 Apache Solr
Es un motor de búsqueda web referencia basado en la plataforma Apache Lucene y que está
apoyado en la Apache Software Foundation. Proporciona funciones de búsqueda de texto
completo y parcial mediante la generación de índices de contenido asociado a un término. Al
estar desplegado sobre un servidor web que incluye el producto, es posible visualizar y
monitorizar cómo se está gestionando en todo momento el propio motor, siendo posible ver
los recursos que se están consumiendo de la máquina host, realizar consultas sobre las
colecciones generadas, etc.
Por otro lado, la configuración de este motor se realiza mediante ficheros de tipo XML donde
se definen las estructuras de datos necesarias para la generación de los índices y del contenido
que se almacenará bajo esos índices.
3.5 Sistemas Gestores de Base de datos No-SQL
Las bases de datos No-SQL son una evolución de las bases de datos tradicionales (relacionales,
en red, etc) en las que predomina más la información que se va a guardar en ellas que la
estructura que deben seguir, aunque esto no quiere decir que no puedan seguir un esquema
predeterminado.
3.5.1
Apache Cassandra
Es un sistema gestor de base de datos distribuida de tipo NoSQL adoptado por la Apache
Software Foundation de código abierto y que originalmente fue desarrollada por Facebook
para ser el motor de búsqueda de su Inbox.
El modelo interno de almacenamiento que utiliza es una BigTable (Sistema de almacenamiento
propietario y comprimido de Google) sobre una infraestructura similar a la de Amazon
Dynamo.
La clasificación genérica de este producto es concretamente, una NoSQL de tipo Clave-Valor,
con lo que se pueden almacenar bajo una clave, una serie de campos o tablas, así que en este
sentido tiene un cierto “parecido” con CouchDB (orientada a documentos) en lugar de con
Redis que es una Clave-Valor pura.
32
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Referencias técnicas | Plataforma para Interoperabilidad de sistemas de información dentro
de un mismo ámbito organizativo
Las características más destacables podrían ser que es descentralizada, y por consiguiente no
tiene nodos críticos con los que poner en riesgo el sistema (cuando se utilice de forma
distribuida), también tolerante a fallos pues tiene replicación automática a través de diversos
nodos para mantener la consistencia y gestiona la consistencia para evitar problemas de
lectura/escritura a lo largo de los nodos distribuidos.
Para la realización de consultas, este producto tiene un lenguaje propio llamado CQL
(Cassandra Query Language) que es un lenguaje de consultas de tipo SQL aunque
generalmente se utilicen interfaces que solucionan el trabajo más “áspero” de interacción con
la solución como pueden ser Hector o Firebrand para emular un ORM.
3.6 PostgreSQL
Sistema gestor de bases de datos (generalmente SGBD o DBMS en inglés) de tipo relacional
con lo que basa su almacenamiento en un sistema de tablas o registros de la propia empresa
PostgreSQL Global Development Group, distribuido sobre una licencia de tipo MIT y que es
libre, de código abierto y que cumple con las características ACID (Atomicity, Consistency,
Isolation and Durability) para la gestión de operaciones transaccionales. Como es habitual en
este software, el lenguaje de consultas es SQL, concretamente la versión 2008 además de
soportar conexiones por ODBC y la posibilidad de aplicar una capa gráfica para la gestión de la
base de datos como puede ser pgAdmin. PostgreSQL es junto con MySQL el software líder en
SGBDs relacionales.
3.7 JPA
Es la referencia de Java para la Persistencia (JSR-303). Por sí sola define las operaciones y el
sistema que hay que seguir para utilizar Object Relational Models en las aplicaciones Java.
Es un avance importante respecto al uso más convencional de las consultas y las bases de
datos relacionales pues agrega una capa entre la base de datos y la aplicación donde se
mapean las clases de la aplicación y se traducen al modelo relacional. De esta forma, siempre
se están utilizando objetos de la aplicación y se separa la responsabilidad de usar registros que
eran más comunes en épocas de lenguajes procedimentales como C y se pasan a utilizar
objetos mapeados donde además es posible controlar y gestionar el ciclo de vida del objeto en
todo momento.
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
33
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Referencias técnicas
3.8 Servicios Web
Es una nueva forma de transmisión de información entre aplicaciones, que tiene como base la
compartición de información entre dos puntos mediante la red bajo el protocolo SOAP. Esta
información, habitualmente es presentada en forma de exposición de métodos de clases y que
se pueden invocar de forma remota, como si fueran métodos de la propia clase, de forma
transparente.
Estos servicios web, generalmente vienen descritos en un lenguaje denominado WSDL (Web
Service Description Language) y en un archivo de mismo nombre, donde se puede identificar
como un contrato, pues se definirán los tipos de los parámetros, los nombres de los métodos
(que se utilizarán en el extremo como una interfaz) y el tipo del retorno además de la
definición de las clases que intervienen en el proceso.
3.8.1
Apache CXF
Framework para Servicios Web, bajo la especificación de Java para Servicios Web (JAX-WS –
JSR 311) facilita la creación de servicios web mediante anotaciones y el consumo de los
mismos a partir de su archivo WSDL.
Su inclusión en el proyecto frente a otros como por ejemplo Axis es la capacidad de realizar
instanciaciones de forma dinámica de servicios web sin necesidad de crear el stack de clases
necesario (clases originales y sus response, por ejemplo).
3.9 Bootstrap
Framework web que facilita el diseño responsivo en las páginas web. Su implementación se
basa fundamentalmente en JavaScript y en CSS y su funcionamiento es tan simple como
ajustar un diseño web original a los diferentes cambios de pantalla que puedan ser factibles de
realizarse sobre diferentes tipos de navegadores como por ejemplo móviles, tablets, tamaños
de pantalla poco comunes, etc.
3.10 jQuery
Framework JavaScript que permite trabajar de forma más eficiente y rápida sobre el árbol
DOM que se construye a partir del documento HTML. Facilita la forma de trabajar y de mutar
el árbol añadiendo además componentes AJAX para mejorar la experiencia de usuario.
34
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Referencias técnicas | Plataforma para Interoperabilidad de sistemas de información dentro
de un mismo ámbito organizativo
3.11 String Metrics
Son una serie de funciones matemáticas que cuantifican cuánto se parecen dos cadenas de
texto entre sí.
3.11.1
Chapman matching Soundex / Soundex
Soundex es un algoritmo que mide cuanto se parecen dos palabras fonéticamente. Si bien la
implementación original y el algoritmo original están centradas en el Inglés, las pruebas
realizadas han demostrado que puede ser válido en habla hispana para los propósitos del
proyecto.
3.11.2
Smith-Waterman-Gotoh
Es una métrica para realizar alineamiento local de secuencias biológicas (ADN, ARN, proteínas)
es decir, busca similitudes entre pares de secuencias.
Se basa en la utilización de algoritmos de programación dinámica, de tal forma que tiene la
propiedad de garantizar el alineamiento entre dos cadenas respecto a una puntuación que es
obtenida de matrices de sustitución. Debido a esto último es fácil encontrar similitudes con la
famosa distancia Levenshtein de sustitución.
3.11.3
Monge-Elkan
Al contario de lo que se piensa, no es una implementación de Smith-Waterman, es una
revisión de Smith-Waterman Gotoh, este enfoque realiza otra serie de pruebas teniendo en
cuenta la similaridad semántica de un número de campos o subcampos. Cada subcampo es
evaluado contra el subcampo en la cadena de comparación usando la distancia Gotoh entre los
campos y esto se combina después con un algoritmo de matching.
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
35
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Referencias técnicas
3.12 Maven
Es una herramienta de despliegue automático de aplicaciones Java. Se puede ver como una
remodelación del antiguo Apache Ant, que fue tan exitoso en la generación de ficheros WAR
para su posible despliegue en entornos JEE. La mayor mejora que supone Maven es que se
encarga de la gestión de las dependencias en forma de bibliotecas que puedan tener los
proyectos, él las instala de forma automática, además de tener un amplio abanico de plantillas
para crear proyectos sin comenzar de cero. Para la gestión de las bibliotecas, éstas han de ser
incluidas en forma de dependencias dentro de un fichero XML denominado pom.xml que
además permitirá la gestión completa del proyecto, con qué plugins compilar, metadatos del
proyecto, gestión del empaquetamiento, etc. Ligada a esta nueva filosofía de las
dependencias, también acoge la nueva tendencia del multiproyecto por la cual se aconseja
tener un proyecto por cada capa (Tier) de la aplicación. Por último, otro de sus grandes
ventajas es su perfecta integración como plugin de Eclipse para la gestión de los proyectos.
3.13 SVN
Apache Subversion es un controlador de versionado que permite sincronizar archivos contra
un servidor para llevar un control de los cambios que se van haciendo en un proyecto y
permitir de esta forma la separación del proyecto en etapas. En caso de fallos, es posible poder
volver a versiones antiguas del proyecto, por ejemplo sin necesidad de realizar copias del
propio proyecto a mano.
36
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Planificación del Proyecto y Resumen de Presupuestos | Plataforma para Interoperabilidad de
sistemas de información dentro de un mismo ámbito organizativo
Capítulo 4. Planificación
Proyecto
y
Resumen
Presupuestos
del
de
4.1 Planificación
Para realizar una planificación más “real”, se ha optado por describir una organización ideal en
lugar de utilizar el trabajo de una sola persona para llevarla a cabo.
4.1.1
Contexto
La empresa que llevará a cabo el proyecto será una empresa típica del sector TIC asturiano de
en torno a 80-100 empleados. En ella habrá diferentes perfiles profesionales desde el punto de
vista jerárquico, en la cumbre de la pirámide estarían los Socios capitalistas que serán los
propios dueños de la empresa. Debajo de ellos, gestionando las áreas desde dentro de la
empresa estarán los Gerentes, que serán los encargados de realizar propuestas, buscar
clientes… Para gestionar los proyectos conseguidos por los Gerentes, estarán los Jefes de
Proyecto que se encargarán de planificar y coordinar los proyectos que tengan asignados. Para
ayudar en la gestión a los Jefes de Proyecto, nos encontramos con los Analistas que serán los
encargados de realizar trabajos de análisis. Tanto los Jefes de Proyecto como los Analistas no
trabajan solamente para un proyecto, si no que se van rotando en diferentes proyectos según
se necesitan de sus prestaciones. En el fondo de la pirámide, nos encontraríamos a los
Programadores, Administradores de Sistemas, Diseñadores y Testers que serán los que
llevarán el mayor peso del proyecto. Tanto los testers como los Administradores de Sistemas y
Diseñadores estarán rotando entre proyectos según se les requiera.
Verticalmente trabajará un equipo de calidad, que estará pendiente de que se cumplan los
procedimientos en todos los proyectos de la empresa.
Departamentalmente, la empresa estará dividida en una consultoría, una sección de
Investigación+Desarrollo+Innovación, calidad y sistemas.
Los perfiles técnicos de los programadores tendrán que ser grandes conocedores de la
tecnología Java, haber trabajado con JPA, Spring y al menos conocer el funcionamiento de un
buscador. También sería conveniente que hubiesen trabajado con Servicios Web.
Los recursos de los que dispone la empresa, son un edificio propio construido hace 5 años,
secretaria en el hall del edificio, personal de contabilidad y de recursos humanos, cada persona
de la organización cuenta con su puesto de trabajo compuesto de mesa, silla, ordenador y una
impresora para compartir cada 10. Además también se dispone de una granja de servidores
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
37
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Planificación del Proyecto y Resumen de Presupuestos
para permitir dar hosting a los clientes que lo necesiten además de permitir compartir recursos
entre empleados como por ejemplo software, repositorios de código o guías de estilo.
Como gastos fijos de la empresa podríamos incluir seguros del edificio, de la propia empresa,
de los empleados, luz, agua, calefacción, mantenimiento de los equipos, consumibles como
tóner, CDs, papel, internet, teléfono, sueldos de empleados, intereses de préstamos bancarios,
dietas…
El horario de la empresa, de 9:00 a 19:00 con una hora para comer y un descanso a media
mañana de treinta minutos. Con un horario de jornada reducida en verano, que será de 8:00 a
15:00 aunque no afectaría al proyecto.
4.1.2
Personal
Puesto
Cantidad
1
Jefe de Proyecto
2
Analista
4
Programador
1
Administrador de Sistemas
1
Diseñador
1
Tester
Tabla 1. Planificación. Personal de la empresa
Puesto
Servidor
Portátil
4.1.3
Cantidad
1
10
Tabla 2. Planificación. Otros recursos
Tareas del proyecto
Para una mejor comprensión de las tareas se aconseja mirar la documentación adjunta en los
archivos de Microsoft Project.
4.1.3.1 Previo
Para comenzar el proyecto, lo primero que se ha tenido que realizar ha sido la
cumplimentación de diversa documentación y análisis del proyecto para tener una visión más
concreta de lo que se iba a desarrollar, estudiar alternativas factibles de desarrollarse, realizar
los diagramas de clases y componentes del proyecto, selección de tecnologías… en definitiva
una serie de preparativos para poder arrancar el proyecto con las consiguientes puestas a
punto de equipos y entornos.
38
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Planificación del Proyecto y Resumen de Presupuestos | Plataforma para Interoperabilidad de
sistemas de información dentro de un mismo ámbito organizativo
Duración final del Sprint 18 días.
Nombre de tarea
Duración
Previo
18,13 días
Análisis
12 días
Cubrimiento del "pliego" (Anteproyecto)
3 días
Entrega del "pliego"
1 día
Estudio de alternativas
3 días
Casos de Uso
2 días
Diagrama de Clases
2 días
Diagrama de Interacción
2 días
Modelado de datos
3 días
Selección de tecnologías
1 día
Diagrama de componentes
1 día
Diseño
2 días
Diseño de la arquitectura
2 días
Implementación
2,13 días
Preparación del servidor Tomcat
3 horas
Preparación de la Base de Datos PostgreSQL
3 horas
Preparación de la Base de Datos Cassandra
2 horas
Preparación del Entorno de Desarrollo STS
2 horas
Preparación de Solr
1 día
Configuración del SVN
5 horas
Configuración de Maven
4 horas
Test
1 día
Test de software
1 día
Test de servidores
1 día
Test de base de datos
1 día
Entrega de propuesta y documentación
1 día
Tabla 3. Planificación. Listado de Tareas Previo
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
39
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Planificación del Proyecto y Resumen de Presupuestos
4.1.3.2 Componente Registrador
Comienza la implantación de los componentes propiamente dicha, se empiezan a realizar los
ajustes necesarios introducidos por el cliente de las partes que no le han gustado y se
comienza a realizar el análisis y diseño del componente, además también se comienza con la
realización de la búsqueda de las funciones String Metrics para las mediciones del sistema de
aprendizaje que apoyará el Matcher de Servicios Web.
Otro de los desarrollos que se llevarán a cabo será la realización de las introspecciones de
Servicios Web así como la persistencia y el modelado.
Finalmente se realizará el testeo de todos los componentes desarrollados y la entrega del
componente desarrollado en el sprint.
Duración final del Sprint 24 días.
Nombre de tarea
Duración
Componente Registrador
24 días
Ajustes de cambios introducidos por el cliente
1 día
Análisis
2 días
Casos de Uso
1 día
Diagrama de Clases
1 día
Diagrama de Interacción
1 día
Implementación
16 días
Búsqueda de funciones StringMetrics para medida
8 días
entre dos cadenas
Desarrollo del Matcher
10 días
Por campo
10 días
Por método
8 días
Tratamiento de los Servicios Web
5 días
Persistencia de los nuevos Servicios Web
2 días
Introspección de los Servicios Web
5 días
Tratamiento de la Universidad
5 días
Persistencia de la Universidad
2 días
Refactorización
1 día
Test
4 días
Probar componente Matcher
1 día
Refinamiento de los emparejamientos
1 día
Probar persistencia de Servicios Web
1 día
Probar persistencia de Universidades
1 día
Entrega del componente REGISTRADOR
1 día
Tabla 4. Planificación. Listado de Tareas. Componente Registrador
40
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Planificación del Proyecto y Resumen de Presupuestos | Plataforma para Interoperabilidad de
sistemas de información dentro de un mismo ámbito organizativo
4.1.3.3 Componente Recolector
En este Sprint se realizará el desarrollo del Recolector de Servicios Web, como en cada Sprint,
el comienzo es siempre el mismo, se realizan los ajustes necesarios sobre el componente
anterior además de realizar el análisis del componente a desarrollar.
La implementación constará de la gestión para la conexión con los servicios web de cada
universidad concreta, recolección de datos de los servicios web y las transformación al modelo
de referencia además de incluir una refactorización de código que llevará al testeo del
desarrollo a realizar.
Duración final del Sprint 23 días.
Nombre de tarea
Duración
Componente Recolector
23 días
Ajustes sobre el componente anterior del cliente
1 día
Análisis
1 día
Diagrama de clases
1 día
Casos de Uso
1 día
Implementación
18 días
Conexión con los Servicios Web concretos de cada
5 días
Universidad
Recolección de datos de los Servicios Web
5 días
Transformación de los datos de los Servicios Web
8 días
concretos en un modelo común
Refactorización
1 día
Test
2 días
Testeo del componente Recolector
1 día
Test de integración
1 día
Entrega del componente RECOLECTOR
1 día
Tabla 5.Planificación. Listado de Tareas. Componente Recolector
4.1.3.4 Componente Buscador
En este Sprint se va a realizar el Buscador de Servicios web, con lo que se tendrá que hacer la
integración con el servidor que tendrá instalado el Apache Solr, además de la realización de
todas las interfaces de usuario, y el desarrollo de las mismas.
En este punto también se deberá de realizar la primera integración de componentes, que
tendrá que ensamblarse junto con el Matcher y el Recolector.
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
41
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Planificación del Proyecto y Resumen de Presupuestos
Duración del Sprint 25 días.
Nombre de tarea
Duración
Componente Buscador
25 días
Ajustes sobre el componente anterior del cliente
1 día
Análisis
1 día
Casos de uso
1 día
Diagrama de clases
1 día
Diseño
14 días
Diseño de Interfaces de Usuario
7 días
Diseño de estilos del sitio web
7 días
Implementación
18 días
Configuración de Solr para el buscador
9 días
Integración de Solr con el sitio web mediante
4 días
Spring Data Solr
Implementación de la portada
5 días
Implementación del registro de Servicios Web
10 días
Implementación del apartado de ayuda
2 días
Implementación de la persistencia con Spring Data
5 días
JPA
Diseño de interfaces responsivas con Bootstrap
7 días
Realización de formularios mediante AJAX
5 días
Integración de componentes Buscador - Matcher 5 días
Recolector
Refactorización
2 días
Test
4 días
Comprobar comportamiento del diseño
1 día
responsivo en interfaces móviles y pantallas grandes
Comprobar integración entre buscador y los otros
1 día
dos componentes
Comprobar el sitio web
1 día
Comprobar la capa de servicio
1 día
Entrega del componente BUSCADOR
1 día
Tabla 6. Planificación. Listado de Tareas. Componente Buscador
42
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Planificación del Proyecto y Resumen de Presupuestos | Plataforma para Interoperabilidad de
sistemas de información dentro de un mismo ámbito organizativo
4.1.3.5 Componente Publicador
Finalmente el componente Publicador se encargará de exponer los Servicios Web que genere
el proyecto además de realizar la integración con los anteriores componentes ya ensamblados.
También será el momento en el que se cerrará el proyecto, junto con la entrega final del
mismo.
Duración del Sprint final 12 días.
Nombre de tarea
Duración
Componente Publicador
12 días
Ajustes sobre el componente anterior del cliente
1 día
Análisis
1 día
Casos de uso
1 día
Diagrama de clases
1 día
Implementación
5 días
Generar un publicador para el acceso por Servicio
5 días
Web
Integración de componentes de la aplicación
5 días
Refactorización
5 días
Test
5 días
Asegurar que se cumplen todos los test previos
5 días
Entrega de la aplicación completa
1 día
Tabla 7. Planificación. Listado de Tareas. Componente Publicador
4.1.3.6 Reuniones
A lo largo del proyecto se planea como mínimo la realización de 6 reuniones con el cliente, una
para presentar el proyecto al cliente y que dé el visto bueno del mismo, y otras 5 para entregar
los diferentes componentes que se generarán a lo largo de los diferentes Sprints.
Duración de las reuniones a lo largo del proyecto 103 días.
Nombre de tarea
Duración
Reuniones
103 días
Reunión 1 - Exposición del proyecto
1 día
Reunión 2 - Entrega del pliego Planificación de
1 día
REGISTRADOR
Reunión 3 - Entrega del REGISTRADOR Planificación
1 día
de RECOLECTOR
Reunión 4 - Entrega de RECOLECTOR Planificación
1 día
de BUSCADOR
Reunión 5 - Entrega BUSCADOR Planificación de
1 día
PUBLISHER
Reunión 6 - Cierre del proyecto
1 día
Tabla 8. Planificación. Listado de Tareas. Reuniones
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
43
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Planificación del Proyecto y Resumen de Presupuestos
4.1.4
Resumen
A continuación se presentan una serie de diagramas y de datos que resumen el desarrollo del
proyecto estimado.
Ilustración 6. Planificación. Diagrama Resumen Proyecto
Ilustración 7. Planificación. Diagrama de recursos
Ilustración 8. Planificación. Coste por Componentes
44
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Planificación del Proyecto y Resumen de Presupuestos | Plataforma para Interoperabilidad de
sistemas de información dentro de un mismo ámbito organizativo
Número de tareas: 107
Duración de la tarea mayor: 10 días (Implementación del Registro de los Servicios Web)
Duración de la tarea menor: 1 día (Comprobar la capa de servicio)
Número de tareas críticas: 6
Número máximo de tareas críticas simultáneas: 1
Media de holguras:
Presupuesto total de personal: 79.370 €
Duración total del proyecto: 103 días
Número de recursos totales: 10
Número de recursos personales: 10
4.1.5
Ajuste de la planificación
Tras realizar la primera planificación, se han tenido que realizar algunos ajustes sobre la
planificación original debido a algunos retrasos.
Los componentes que se han visto retrasados han sido los siguientes:
Nombre de tarea
Duración
Comienzo
Fin
Previo
Análisis
Cubrimiento del "pliego" (Anteproyecto)
Entrega del "pliego"
Estudio de alternativas
Casos de Uso
Diagrama de Clases
Diagrama de Interacción
Modelado de datos
Selección de tecnologías
Diagrama de componentes
Diseño
Diseño de la arquitectura
Implementación
Preparación del servidor Tomcat
Preparación de la Base de Datos PostgreSQL
Preparación de la Base de Datos Cassandra
Preparación del Entorno de Desarrollo STS
Preparación de Solr
18,13 días
12 días
3 días
1 día
3 días
2 días
2 días
2 días
3 días
1 día
1 día
2 días
2 días
2,13 días
3 horas
3 horas
2 horas
2 horas
1 día
lun 02/12/13
lun 02/12/13
lun 02/12/13
jue 05/12/13
vie 06/12/13
mié 11/12/13
mié 11/12/13
vie 13/12/13
vie 13/12/13
mié 11/12/13
mar 17/12/13
mié 18/12/13
mié 18/12/13
vie 20/12/13
vie 20/12/13
vie 20/12/13
vie 20/12/13
lun 23/12/13
vie 20/12/13
jue 26/12/13
mar 17/12/13
mié 04/12/13
jue 05/12/13
mar 10/12/13
jue 12/12/13
jue 12/12/13
lun 16/12/13
mar 17/12/13
mié 11/12/13
mar 17/12/13
jue 19/12/13
jue 19/12/13
mar 24/12/13
vie 20/12/13
vie 20/12/13
vie 20/12/13
lun 23/12/13
vie 20/12/13
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
45
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Planificación del Proyecto y Resumen de Presupuestos
Configuración del SVN
5 horas
lun 23/12/13
Configuración de Maven
4 horas
lun 23/12/13
Test
1 día
mar 24/12/13
Test de software
1 día
mar 24/12/13
Test de servidores
1 día
mar 24/12/13
Test de base de datos
1 día
mar 24/12/13
Entrega de propuesta y documentación
1 día
mié 25/12/13
Tabla 9. Planificación. Ajuste Listado Tareas. Previo
lun 23/12/13
mar 24/12/13
mié 25/12/13
mié 25/12/13
mié 25/12/13
mié 25/12/13
jue 26/12/13
A este componente sólo le ha afectado el retraso en el comienzo de las tareas, pues la
planificación se ha hecho de fin a inicio.
Nombre de tarea
Duración
Comienzo
Componente Registrador
26 días
jue 26/12/13
Ajustes de cambios introducidos por el cliente
1 día
jue 26/12/13
Análisis
2 días
vie 27/12/13
Casos de Uso
1 día
vie 27/12/13
Diagrama de Clases
1 día
vie 27/12/13
Diagrama de Interacción
1 día
lun 30/12/13
Implementación
18 días
mar 31/12/13
Búsqueda de funciones StringMetrics para
10 días
mar 31/12/13
medida entre dos cadenas
Desarrollo del Matcher
10 días
mar 31/12/13
Por campo
10 días
mar 31/12/13
Por método
8 días
mar 31/12/13
Tratamiento de los Servicios Web
5 días
mar 14/01/14
Persistencia de los nuevos Servicios Web
2 días
mar 14/01/14
Introspección de los Servicios Web
5 días
mar 14/01/14
Tratamiento de la Universidad
5 días
vie 10/01/14
Persistencia de la Universidad
2 días
mar 21/01/14
Refactorización
1 día
jue 23/01/14
Test
4 días
vie 24/01/14
Probar componente Matcher
1 día
vie 24/01/14
Refinamiento de los emparejamientos
1 día
lun 27/01/14
Probar persistencia de Servicios Web
1 día
mar 28/01/14
Probar persistencia de Universidades
1 día
mié 29/01/14
Entrega del componente REGISTRADOR
1 día
jue 30/01/14
Tabla 10. Planificación. Ajuste Listado Tareas. Registrador
46
Fin
vie 31/01/14
vie 27/12/13
mar 31/12/13
lun 30/12/13
lun 30/12/13
mar 31/12/13
vie 24/01/14
mar 14/01/14
mar 14/01/14
mar 14/01/14
vie 10/01/14
mar 21/01/14
jue 16/01/14
mar 21/01/14
vie 17/01/14
jue 23/01/14
vie 24/01/14
jue 30/01/14
lun 27/01/14
mar 28/01/14
mié 29/01/14
jue 30/01/14
vie 31/01/14
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Planificación del Proyecto y Resumen de Presupuestos | Plataforma para Interoperabilidad de
sistemas de información dentro de un mismo ámbito organizativo
Aquí se ha introducido el retraso de dos días en la tarea de Búsqueda de funciones con
StringMetrics, se han tenido que hacer unas mediciones extra pues las reglas son aplicables al
inglés, entonces se debía de comprobar que podrían ser útiles en castellano.
Nombre de tarea
Duración
Comienzo
Componente Recolector
23 días
vie 31/01/14
Ajustes sobre el componente anterior del cliente 1 día
vie 31/01/14
Análisis
1 día
lun 03/02/14
Diagrama de clases
1 día
lun 03/02/14
Casos de Uso
1 día
lun 03/02/14
Implementación
18 días
mar 04/02/14
Conexión con los Servicios Web concretos de
5 días
mar 04/02/14
cada Universidad
Recolección de datos de los Servicios Web
5 días
mar 11/02/14
Transformación de los datos de los Servicios
8 días
mar 18/02/14
Web concretos en un modelo común
Refactorización
1 día
mar 04/02/14
Test
2 días
vie 28/02/14
Testeo del componente Recolector
1 día
vie 28/02/14
Test de integración
1 día
lun 03/03/14
Entrega del componente RECOLECTOR
1 día
mar 04/03/14
Tabla 11. Planificación. Ajuste Listado Tareas. Recolector
Fin
mié 05/03/14
lun 03/02/14
mar 04/02/14
mar 04/02/14
mar 04/02/14
vie 28/02/14
mar 11/02/14
mar 18/02/14
vie 28/02/14
mié 05/02/14
mar 04/03/14
lun 03/03/14
mar 04/03/14
mié 05/03/14
Sin retrasos, tan sólo se ha movido la fecha, la duración es la misma.
Nombre de tarea
Duración
Comienzo
Fin
Componente Buscador
Ajustes sobre el componente anterior del cliente
Análisis
Casos de uso
Diagrama de clases
Diseño
Diseño de Interfaces de Usuario
Diseño de estilos del sitio web
Implementación
Configuración de Solr para el buscador
Integración de Solr con el sitio web mediante
Spring Data Solr
Implementación de la portada
Implementación del registro de Servicios Web
Implementación del apartado de ayuda
Implementación de la persistencia con Spring
Data JPA
Diseño de interfaces responsivas con Bootstrap
Realización de formularios mediante AJAX
Integración de componentes Buscador Matcher - Recolector
25 días
1 día
1 día
1 día
1 día
17 días
9 días
8 días
18 días
9 días
mié 05/03/14
mié 05/03/14
jue 06/03/14
jue 06/03/14
jue 06/03/14
mié 05/03/14
mié 05/03/14
mar 18/03/14
vie 07/03/14
vie 07/03/14
mié 09/04/14
jue 06/03/14
vie 07/03/14
vie 07/03/14
vie 07/03/14
vie 28/03/14
mar 18/03/14
vie 28/03/14
mié 02/04/14
jue 20/03/14
4 días
vie 07/03/14
jue 13/03/14
5 días
10 días
2 días
vie 07/03/14 vie 14/03/14
vie 07/03/14 vie 21/03/14
jue 20/03/14 lun 24/03/14
5 días
jue 13/03/14 jue 20/03/14
7 días
5 días
vie 14/03/14
vie 21/03/14
5 días
lun 24/03/14 lun 31/03/14
mar 25/03/14
vie 28/03/14
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
47
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Planificación del Proyecto y Resumen de Presupuestos
Refactorización
2 días
lun 31/03/14
Test
4 días
mié 02/04/14
Comprobar comportamiento del diseño
responsivo en interfaces móviles y pantallas
1 día
mié 02/04/14
grandes
Comprobar integración entre buscador y los
1 día
jue 03/04/14
otros dos componentes
Comprobar el sitio web
1 día
vie 04/04/14
Comprobar la capa de servicio
1 día
lun 07/04/14
Entrega del componente BUSCADOR
1 día
mar 08/04/14
Tabla 12. Planificación. Ajuste Listado Tareas. Buscador
mié 02/04/14
mar 08/04/14
jue 03/04/14
vie 04/04/14
lun 07/04/14
mar 08/04/14
mié 09/04/14
Sin retrasos de duración, tan solo se mueve la fecha.
Nombre de tarea
Duración
Comienzo
Componente Publicador
12 días
mié 09/04/14
Ajustes sobre el componente anterior del cliente 1 día
mié 09/04/14
Análisis
1 día
jue 10/04/14
Casos de uso
1 día
jue 10/04/14
Diagrama de clases
1 día
jue 10/04/14
Implementación
5 días
vie 11/04/14
Generar un publicador para el acceso por
5 días
vie 11/04/14
Servicio Web
Integración de componentes de la aplicación
5 días
vie 11/04/14
Refactorización
5 días
vie 11/04/14
Test
5 días
vie 18/04/14
Asegurar que se cumplen todos los test previos 5 días
vie 18/04/14
Entrega de la aplicación completa
1 día
vie 25/04/14
Tabla 13. Planificación. Ajuste Listado Tareas. Publicador
Fin
vie 25/04/14
jue 10/04/14
vie 11/04/14
vie 11/04/14
vie 11/04/14
vie 18/04/14
vie 18/04/14
vie 18/04/14
vie 18/04/14
vie 25/04/14
vie 25/04/14
lun 28/04/14
Tampoco existen retrasos en este componente, se mueve la fecha por la demora introducida
en el inicio.
48
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Planificación del Proyecto y Resumen de Presupuestos | Plataforma para Interoperabilidad de
sistemas de información dentro de un mismo ámbito organizativo
4.2 Conclusiones de la planificación
Afortunadamente, la planificación se ajustó bastante a lo que finalmente sucedió durante el
desarrollo del proyecto debido a que se realizó una planificación de fin a inicio.
Esto puede indicar dos cosas: por un lado, los plazos han sido sobreestimados o bien se han
excedido los recursos asignados y habría sido suficiente con menos personal con lo que a priori
parece una buena planificación, igual al final no lo es tanto por el ajuste final aunque los
recursos que no se utilizaron que estaban sobreestimados se derivaron a otros proyectos en
curso.
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
49
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Planificación del Proyecto y Resumen de Presupuestos
4.3 Resumen del Presupuesto
Item
1
2
3
4
Concepto
Licencias
Formación
Desarrollo
Otros
50
Cantidad
1
1
1
1
Precio(€)
Subtotal(€)
17.790,00 €
17.790,00 €
850,00 €
850,00 €
97.586,50 €
97.586,50 €
800,00 €
800,00 €
TOTAL (sin IVA)
117.026,50 €
TOTAL (con 21% IVA)
141.602,07 €
Tabla 14. Resumen del Presupuesto
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Análisis | Plataforma para Interoperabilidad de sistemas de información dentro de un mismo
ámbito organizativo
Capítulo 5. Análisis
5.1 Definición del Sistema
5.1.1
Determinación del Alcance del Sistema
Como se ha venido comentando, el alcance del sistema es construir una aplicación
multimodular que permita por una parte registrar servicios web de una universidad y
clasificarlos mediante una serie de parámetros. Además también deberá de realizar el
emparejamiento de los campos entre el modelo de referencia de forma semiautomática
aunque necesitará de supervisión.
Los servicios web que estén registrados, podrán ser localizados de forma sencilla mediante un
sistema buscador el cual tendrá diferentes campos indexados para realizar búsquedas bien sea
por el nombre de la universidad, por la categorización del servicio web…
El registro de los servicios web deberá de tener la mínima intervención humana, es decir, el
sistema se encargará de recolectar la máxima información posible del fichero WSDL que
presente la universidad a registrar. Esto incluiría la identificación de todos los métodos que
incluya el WSDL, sus parámetros y sus clases y además se hará la relación con el sistema de
referencia entre las clases.
Por otro lado, el sistema también deberá publicar un servicio web que hará posible la
obtención de información de todos los servicios web que están registrados facilitando la
recolección de datos por parte de sistemas de terceros que quieran acceder a la información
de forma unificada pues todos los datos que obtengan tendrán todos el mismo formato. Este
servicio web tendrá disponible un método que permitirá la recolección de las becas
universitarias bien por categoría, por parámetro o por universidad.
El sistema se deberá de implementar de forma que sea lo suficientemente trivial y sencillo
reciclar el desarrollo y adaptarlo para trasladarlo a otros ámbitos como pueden ser la sanidad,
el sector bancario o similares.
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
51
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Análisis
5.2 Requisitos del Sistema
5.2.1
Obtención de los Requisitos del Sistema
5.2.1.1 Requisitos funcionales
Código
RF1.1
Nombre Requisito
Registrar Universidad
RF1.1.1
RF1.2
RF1.2.1
RF1.2.2
RF1.2.3
RF1.2.3.1
RF1.2.3.2
RF1.2.4
RF1.3
RF1.3.1
RF1.3.2
RF1.4
RF1.4.1
RF1.5
RF1.5.1
52
Descripción del Requisito
Se debe permitir a las universidades registrarse en
el sistema.
Registrar el servicio web Se tendrá que registrar por cada universidad un
de la universidad
fichero WSDL.
Extraer información del Se deberá recabar toda la información posible del
servicio web de la fichero ofrecido por la universidad.
universidad
Detectar los métodos Se deberán detectar los métodos que ofrece el
disponibles en el servicio servicio web y que se entiende serán relacionados
web
con becas universitarias.
Detectar los modelos del Se deberán detectar también los atributos de las
servicio web
clases del servicio web para poder emparejarse con
los del modelo de referencia.
Emparejar campos
El sistema deberá intentar emparejar los campos
de la clase del servicio web de la universidad de
forma automática con los del modelo de referencia.
Sistema de aprendizaje
El sistema deberá de aprender con cada registro
que se haga en el sistema.
Apoyo con String Metrics El sistema, si no es capaz de decidir el
emparejamiento se basará en una serie de
funciones de String Metrics para apoyar la decisión.
Almacenar
los Estos emparejamientos realizados, deberán ser
emparejamientos
almacenados para su uso posterior.
Buscar servicios web
El sistema deberá permitir la búsqueda mediante
un buscador al estilo “Google”.
Por categoría
El buscador deberá permitir realizar búsquedas por
categorías (vicerrectorado, alumno, curso).
Por nombre
El buscador deberá permitir realizar búsquedas por
nombre de la universidad.
Interfaz web
El sistema deberá de ofrecer una interfaz web para
poder realizar el registro y la búsqueda de los
servicios web.
Interfaz de consola
El sistema también deberá de ofrecer el registro de
nuevos servicios web mediante una aplicación de
consola.
Recolectar información
El sistema deberá de permitir recolectar
información de los servicios web que estén
registrados.
Forma homogénea
El sistema deberá de ofrecer los datos de forma
homogénea, es decir, deberá de convertir los datos
recibidos del servicio web y convertirlos a un
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Análisis | Plataforma para Interoperabilidad de sistemas de información dentro de un mismo
ámbito organizativo
Código
RF1.5.2
RF1.5.3
Nombre Requisito
Descripción del Requisito
formato común.
Publicar Servicio Web
El sistema deberá de ofrecer un servicio web para
que los sistemas de terceros puedan recolectar la
información.
Parametrizable
El servicio web deberá de poder obtener becas por
alumno, vicerrectorado o universidad.
Tabla 15. Requisitos funcionales
5.2.1.2 Requisitos no funcionales
Código
RNF1.1
RNF1.2
RNF1.2.1
RNF1.3
RNF1.4
RNF1.5
RNF1.6
RNF1.7
RNF1.8
Nombre Requisito
Descripción del Requisito
Lenguaje
de El lenguaje utilizado en la aplicación será Java.
programación
Tipo del SGBD
El sistema deberá de tener dos sistemas gestores
de bases de datos, uno No SQL y otro Relacional.
SGBD
El SGBD No SQL deberá de ser compatible con un
sistema Windows.
JavaScript no disponible
La web deberá de funcionar de forma transparente
independientemente de si se tenga activado el
intérprete de JavaScript.
Interfaz responisva
La interfaz web deberá de ser adaptable a cualquier
tipo de pantalla.
Capacidad de carga
El sistema deberá de ser posible de aguantar las
conexiones que reciba de parte de las diferentes
universidades.
Modularidad
La aplicación deberá de ser ampliable o al menos
modificada de forma sencilla para poder ajustarse a
otros ámbitos, no solo al universitario.
Apache Solr
El sistema deberá de implementar un buscador,
concretamente el motor de búsqueda será Apache
Lucene, en su versión web.
Multiproyecto
El sistema deberá de ser un sistema desarrollado
mediante multiproyecto y con Apache Maven para
poder desplegarlo en el repositorio de
componentes.
Tabla 16. Requisitos no funcionales
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
53
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Análisis
5.2.2
Identificación de Actores del Sistema
5.2.2.1 Base de datos relacional
Es el servidor de base de datos relacional del sistema, en ciertas ocasiones se tendrán que
almacenar datos, consultar operaciones… en definitiva realizar trabajo de almacenamiento y
recuperación de información por lo que se estima que es una parte importante de la aplicación
y puede tener entidad como si misma.
5.2.2.2 Matcher
Componente del sistema de registro, es el encargado de realizar las operaciones de los
emparejamientos de campos, consulta con la base de datos NoSQL, aplica las reglas de String
Metrics a los campos de los servicios web obtenidos y decide los emparejamientos.
5.2.2.3 Recolector
Subsistema recolector que es utilizado por el publicador. Se encarga de obtener los datos
invocando a los diferentes servicios web registrados.
5.2.2.4 Servidor de búsqueda
Es el servidor dedicado al buscador que tendrá montado un entorno con Apache Solr. El será
capaz de resolver las consultas de las búsquedas que realicen los usuarios de la aplicación
además de indexar los nuevos servicios web registrados.
5.2.2.5 Servidores externos
Agrupación de los servidores de terceros. Estos almacenarán y expondrán los servicios web de
cada universidad.
5.2.2.6 Sistema
El propio sistema, la aplicación.
5.2.2.7 Usuario
Usuario que interactuará con la aplicación. Su función será la de buscar universidades,
registrarlas y consultar datos de las mismas.
54
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Análisis | Plataforma para Interoperabilidad de sistemas de información dentro de un mismo
ámbito organizativo
5.2.3
Especificación de Casos de Uso
Ilustración 9. Resumen de los casos de uso
Nombre del Caso de Uso
Registrar servicios web
Descripción
Creará una nueva universidad en el sistema y registrará su servicio web. En el proceso, se
encargará de recoger información del servicio web y de emparejar los campos del servicio con
los del modelo de referencia.
Nombre del Caso de Uso
Buscar servicios web
Descripción
Bien sean servicios web, universidades, métodos… Este caso de uso engloba todo lo
relacionado con la búsqueda de información de la aplicación y del uso del sistema de
búsqueda.
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
55
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Análisis
Nombre del Caso de Uso
Publicar los servicios web
Descripción
El sistema publicará un servicio web para que las universidades que lo deseen puedan
invocarlo y del cual obtendrán becas en función de los parámetros que definan de todas las
universidades que estén registradas.
Nombre del Caso de Uso
Obtener datos de los servicios web
Descripción
El sistema recolectará información de los servicios web. Es decir, invocará cada servicio web
registrado para obtener sus becas en función a los criterios definidos en la llamada. Una vez
obtenidos los datos, los transformará a un sistema de referencia común para poder devolver
los datos de forma homogénea en lugar de obtener el formato de cada universidad.
56
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Análisis | Plataforma para Interoperabilidad de sistemas de información dentro de un mismo
ámbito organizativo
5.3 Identificación de los Subsistemas en la Fase de
Análisis
Para un mejor manejo y una mejor comprensión de la aplicación se ha dividido ésta en
diferentes subsistemas en función de las tareas que realizan sus componentes. De este modo
se pueden encontrar los siguientes:
Buscador
Registrador
Recolector
Publicador
5.3.1
Descripción de los Subsistemas
5.3.1.1 Subsistema Buscador
Es el encargado de, en función de los parámetros que defina el usuario en la búsqueda web,
traducirlos para entregárselos al motor de búsqueda y obtener los resultados que se ajusten.
Además de integrar el componente de búsqueda también es el encargado de ofrecer la
aplicación web del sistema.
5.3.1.2 Subsistema Registrador
Este subsistema tiene como función realizar el registro de las nuevas universidades, además
también se encargará de en el proceso de registro, obtener los datos del archivo WSDL
presentado por la universidad en el registro y de realizar el emparejamiento de los campos del
WSDL con los del modelo de referencia.
5.3.1.3 Subsistema Recolector
Se encarga de conectarse al listado de servicios web que están almacenados, obtenidos de los
registros que haya tenido la aplicación. Además de conectarse a los mismos, tendrá el objetivo
de a partir de las reglas definidas de emparejamiento que se definieran en el registrador,
devolver los datos en un formato que sea independiente de la universidad de la que se
obtienen los datos.
5.3.1.4 Subsistema Publicador
Su función es publicar los servicios web y hacer de nexo común entre todos los servicios web
que estén registrados y las universidades que quieran obtener la información de las becas pues
será el punto de acceso que tendrán para obtener los datos.
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
57
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Análisis
5.3.2
Descripción
Subsistemas
de
los
Interfaces
entre
Como una de las características del sistema es que fuera modular, desde el primer momento
se diseñó como un sistema multiproyecto, es decir, Maven tiene la posibilidad de poder definir
este concepto dentro de sus características por lo que cada uno de los subsistemas que se han
descrito anteriormente son realmente un proyecto dentro del sistema que a su vez es otro
proyecto padre en sí mismo. Esta habilidad resulta en que los componentes serán distribuidos
a través de ellos en forma de bibliotecas JAR, para que cada subsistema pueda utilizar lo que
necesite de los otros a modo de interfaces.
De esta forma, se pueden encontrar las siguientes interfaces: MatcherManagerService,
SearchEngineService, UniversityManagerService, OperationsWrapperService y
WebServiceManagerService que serán las encargadas de ofrecer los servicios de cada
componente a los demás.
58
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Análisis | Plataforma para Interoperabilidad de sistemas de información dentro de un mismo
ámbito organizativo
5.4 Diagrama de Clases Preliminar del Análisis
5.4.1
Diagrama de Clases
Ilustración 10. Diagrama de clases previo
5.4.2
Descripción de las Clases
5.4.2.1 Subsistema Registrador
Nombre de la Clase
Matcher
Descripción
Será la encargada de aplicar los métodos de String Metrics a los campos obtenidos en el
recolector. Aunque antes deberá de conectarse a la base de datos NoSQL y obtener los
emparejamientos previos realizados y comprobarlos.
Responsabilidades
Emparejar los campos entre los campos de la universidad y los del modelo de referencia.
Atributos Propuestos
DAO: Almacenar los mapeos resultantes
Campos: Listado de campos obtenidos del servicio web.
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
59
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Análisis
Métodos Propuestos
aplicarStringMetrics: Aplicará las funciones String Metrics para medir cuanto se parecen dos
cadenas.
buscarEmparejamiento: Buscará en la base de datos de emparejamientos previos.
almacenarEmparejamientos: Guardará en base de datos los emparejamientos realizados.
Nombre de la Clase
RecolectorInformacionServiciosWeb
Descripción
Se encargará de recoger información importante del fichero WSDL mediante la instanciación
dinámica del mismo y combinándolo con reflectividad.
Responsabilidades
Recogerá toda la información posible: campos, métodos, retornos…
Además
Atributos Propuestos
WSDL: url del servicio web
Campos: Campos obtenidos del servicio web
Metodos: Métodos obtenidos del servicio web
Métodos Propuestos
getCampos: Obtendrá los campos de las clases del servicio web.
getOperaciones: Obtendrá las operaciones que se pueden ejecutar en el servicio web.
5.4.2.2 Subsistema Buscador
Nombre de la Clase
BuscadorUniversidades
Descripción
Se comunicará con el buscador para realizar la búsqueda según los criterios propuestos por el
usuario.
Responsabilidades
Traducir los parámetros introducidos por el usuario y comunicárselos al servidor Lucene para
que realice la búsqueda.
Presentar los resultados.
Atributos Propuestos
Parámetros: keywords que introducirá el usuario en el buscador.
Métodos Propuestos
Buscar: Realizará la llamada al interfaz de Solr.
Nombre de la Clase
ControladorWeb
Descripción
Será el encargado de filtrar las peticiones y mapearlas al método correspondiente según la
dirección introducida en el navegador por el usuario.
Responsabilidades
Hacer de controlador Web.
Atributos Propuestos
60
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Análisis | Plataforma para Interoperabilidad de sistemas de información dentro de un mismo
ámbito organizativo
Métodos Propuestos
Nombre de la Clase
DAO
Descripción
Interactuará con la Base de Datos y será el encargado de realizar la persistencia de la
aplicación
Responsabilidades
Gestionar comunicaciones con la base de datos.
Obtener datos de la base de datos.
Almacenar datos en la base de datos.
Atributos Propuestos
Métodos Propuestos
almacenarUniversidad: Guardará una universidad en BD.
almacenarEmparejamiento: Guardará el emparejamiento en BD.
5.4.2.3 Subsistema Recolector
Nombre de la Clase
ConectorServiciosWeb
Descripción
Su función será la de conectarse a los distintos servicios web que estén registrados en la
aplicación. Una vez conectado, hará las peticiones oportunas para obtener las becas,
traducirlas al modelo de referencia y devolverlas.
Responsabilidades
Gestionar las conexiones con los servicios web registrados.
Modificar los datos obtenidos para transformarlos a un modelo común.
Atributos Propuestos
WSDLs: listado de urls de los servicios web a invocar
Emparejamientos: emparejamientos realizados previamente para unificar los resultados
Métodos Propuestos
invocarMetodo: Invocará el método correspondiente de forma dinámica sin generar el stub
típico y con los parámetros indicados.
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
61
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Análisis
5.4.2.4 Subsistema Publicador
Nombre de la Clase
PublicadorServiciosWeb
Descripción
Deberá exponer un método capaz de hacer de entrada a las universidades para recolectar
becas. Este método tendrá que ser lo suficientemente configurable para abarcar las
diferentes configuraciones.
Responsabilidades
Ofrecer un WSDL con un método para recoger información de los servicios web registrados.
Atributos Propuestos
Categoria: Categoría que se quiere utilizar para filtrar las becas: Vicerrectorado, Alumno,
Curso…
Universidad: Si se desea filtrar por universidad, su nombre
Parametros: En caso de ser varios, filtros usar una lista de parámetros.
Métodos Propuestos
obtenerBecas: Obtendrá las becas llamando al recolector en función de los parámetros que se
definan en la llamada.
62
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Análisis | Plataforma para Interoperabilidad de sistemas de información dentro de un mismo
ámbito organizativo
5.5 Análisis de Casos de Uso y Escenarios
5.5.1
Registrar universidad
Ilustración 11. Casos Uso. Registrar una universidad
Registrar universidad
Precondiciones
Poscondiciones
Actores
Descripción
El servidor de aplicaciones deberá de estar corriendo la aplicación y el
usuario deberá de estar dentro de la página web.
La universidad y sus emparejamientos deberán de estar almacenados
en la base de datos.
Usuario, Matcher
Usuario:
1. El usuario introducirá los datos de la universidad en el
formulario.
2. El usuario validará los emparejamientos ofrecidos por el sistema
Matcher:
1. Emparejará los campos de forma automática mediante una
estimación.
Se almacenarán los emparejamientos y la universidad.
Variaciones
(escenarios
secundarios)
-
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
63
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Análisis
Registrar universidad
Excepciones
Notas
El usuario no ha introducido los campos correctos en el
formulario.
El servicio web de la universidad no está disponible.
-
5.5.1.1 Obtener información del servicio web
Ilustración 12. Casos Uso. Obtener información del servicio web
Obtener información del servicio web
Precondiciones
Poscondiciones
Actores
Descripción
El servicio web de la universidad a inscribirse ha de estar disponible
El sistema deberá presentar los emparejamientos
Sistema, Servidores Externos
Sistema:
1. Instanciará dinámicamente el servicio web.
2. Recogerá los campos obtenidos mediante reflectividad.
Servidores Externos:
1. Responderá a la llamada del sistema cuando se solicite el
servicio web.
Variaciones
(escenarios
secundarios)
-
Excepciones
Notas
64
El servicio web de la universidad no está disponible.
-
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Análisis | Plataforma para Interoperabilidad de sistemas de información dentro de un mismo
ámbito organizativo
5.5.1.2 Realizar el emparejamiento de campos
Ilustración 13. Casos Uso. Emparejamiento de campso
Realizar el emparejamiento de campos
Precondiciones
Poscondiciones
Actores
Descripción
Se deben de haber obtenido los campos del servicio web
El sistema devolverá los emparejamientos realizados automáticamente
Matcher, Sistema, Usuario
Matcher:
1. Consultar contra el sistema de conocimiento si ya se ha
realizado un emparejamiento igual previamente.
2. Aplicar reglas String Metrics en comparación con los
resultados obtenidos del sistema de conocimiento.
3. Evaluar los resultados en función de un factor.
4. Presentar los resultados obtenidos autónomamente.
Usuario:
1. Validar los parámetros que se le presentan y rectificarlos si
no son correctos.
Variaciones
(escenarios
secundarios)
Excepciones
Notas
-
-
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
65
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Análisis
5.6 Análisis de Interfaces de Usuario
El concepto que se diseñó para las interfaces de usuario es simple. Una pantalla con un
formulario para el registro de las nuevas universidades, una pantalla de buscador que muestre
los resultados y la visión del detalle de cada una de las universidades registradas.
5.6.1
Formulario de registro
Ilustración 14. Interfaz de Usuario. Formulario de Registro
Esta pantalla sería un prototipo de lo que se buscaría a la hora de registrar las nuevas
universidades.
En la parte superior siempre hay que tener en cuenta que se tendrá un buscador para poder
buscar las universidades que ya estén registradas.
La otra parte de la pantalla, se dedicará a un formulario que recogerá datos de la universidad
como puede ser el nombre, la dirección de sus servicios web, los emparejamientos de los
campos de la Beca y del Solicitante, sus métodos del servicio web…
66
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Análisis | Plataforma para Interoperabilidad de sistemas de información dentro de un mismo
ámbito organizativo
5.6.2
Buscador
Ilustración 15. Interfaz de Usuario. Buscador
Esta sería una pantalla prototípica del listado de resultados que presentaría el buscador por
ejemplo al buscar un término que pudiera ser “Universidad de Oviedo”. En el listado se pueden
ver todas las operaciones que ofrecería la universidad y se seleccionará cualquiera del listado
para ver el detalle de la misma.
5.6.3
Detalle de Universidad
Ilustración 16. Interfaz de Usuario. Detalle Universidad
En el detalle de la universidad se mostrará el nombre, su URL donde encontrar su servicio web
y el catálogo de operaciones que presenta el servicio web además de indicar la categoría de
cada una de las operaciones.
Como en todos los casos, la zona superior será destinada al buscador con el cajetín de texto
para introducir las palabras claves y el botón de buscar.
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
67
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Análisis
5.6.4
Diagrama de Navegabilidad
Ilustración 17. Diagrama de Navegabilidd
68
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Análisis | Plataforma para Interoperabilidad de sistemas de información dentro de un mismo
ámbito organizativo
5.7 Especificación del Plan de Pruebas
En este apartado se especificarán los tipos de pruebas que se tendrán en cuenta a la hora de
comprobar el buen funcionamiento de la aplicación.
Pruebas Unitarias: Estas pruebas se realizarán mediante la herramienta JUnit y se
podrán ejecutar tanto de forma autónoma, como cada vez que se haga un
empaquetado de la aplicación automáticamente (Maven antes de realizar un
empaquetado de la aplicación se encarga de pasar las pruebas unitarias para en caso
de fallar, no realizar el mismo).
Pruebas de Integración: Debido a que la aplicación está conformada por diferentes
componentes, se deberán testear los componentes para conocer si la integración
entre los mismos es la adecuada.
Pruebas del Sistema: Debido a que el sistema está basado en varios componentes, es
una buena práctica saber que a la hora de introducir un nuevo registro, éste se replica
en todos los repositorios de información que existen en la aplicación, de esta forma se
conocerá si la aplicación es consistente. También es una buena prueba del sistema
conocer los consumos de memoria que tiene la aplicación, de CPU, etc.
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
69
Diseño del Sistema | Plataforma para Interoperabilidad de sistemas de información dentro
de un mismo ámbito organizativo
Capítulo 6. Diseño del Sistema
6.1 Arquitectura del Sistema
6.1.1
Diagramas de Paquetes
Ilustración 18. Arquitectura. Diagrama de Paquetes
6.1.1.1 Modelo
Ilustración 19. Arquitectura. Paquete Modelo
Este paquete contendrá todos los modelos necesarios para utilizar la aplicación. Además
también incluye las interfaces de persistencia y las clases de Utilidad.
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
71
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Diseño del Sistema
6.1.1.2 Service
Ilustración 20. Arquitectura. Paquete Service
Este paquete incluye las interfaces correspondientes a la capa de servicio de la aplicación.
Tanto este paquete como el anterior se distribuirán a lo largo de los otros paquetes pues
contienen las operaciones de negocio necesarias para el funcionamiento desencapsulado de la
aplicación.
6.1.1.3 Buscador
Ilustración 21. Arquitectura. Paquete Buscador
Incluye todas las clases necesarias para gestionar el controlador de la aplicación y la gestión
del registro de nuevos servicios web por formulario, así como las búsquedas de los servicios
web registrados.
72
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Diseño del Sistema | Plataforma para Interoperabilidad de sistemas de información dentro
de un mismo ámbito organizativo
6.1.1.4 Recolector
Ilustración 22. Arquitectura. Paquete Recolector
Es el encargado de obtener las becas según la categoría, de esta forma ofrecerá una clase por
cada una de las categorías disponibles para la búsqueda.
6.1.1.5 Registrador
Ilustración 23. Arquitectura. Paquete Registrador
Es el encargado de llevar el peso del registro de nuevos servicios web. En él se implementan las
operaciones necesarias para el emparejador de campos, instanciador de servicios web de
forma dinámica…
6.1.1.6 Publisher
Se encarga de ofrecer los servicios web para que las aplicaciones puedan acceder a la
recolección de las becas que ofrezcan los servicios web registrados en el sistema.
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
73
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Diseño del Sistema
6.1.2
Diagramas de Componentes
Los componentes del sistema coinciden con los paquetes mostrados en el apartado anterior
con lo que para su revisión puede volver a consultarlo.
6.1.3
Diagramas de Despliegue
Ilustración 24. Diagrama Despliegue
6.1.3.1 Nodo 1
Contendrá a los componentes de la aplicación: Buscador, Registrador, Recolector y Publisher.
Además este estará ejecutado dentro del Contenedor de Aplicaciones Apache Tomcat 7 e
interactuará con el servidor buscador Apache Solr, con la base de datos relacional PostgreSQL,
con Apache Cassandra y además con los diferentes servicios web de las diferentes
universidades.
6.1.3.2 Nodo 2 y Nodo 3
Servicios web de diferentes universidades. Estos servicios web están expuestos públicamente
mediante un WSDL.
74
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Diseño del Sistema | Plataforma para Interoperabilidad de sistemas de información dentro
de un mismo ámbito organizativo
6.1.3.3 Nodo 4
Es el servidor que contiene el sistema gestor de bases de datos relacional PostgreSQL en modo
servidor que almacenará parte de la persistencia de la aplicación. La conexión con este
servidor se realizará mediante un interfaz JDBC. Este nodo puede agregar nuevos clusters en
función de la carga que se demande del mismo.
6.1.3.4 Nodo 5
Contiene un servidor Apache Cassandra con una base de datos NoSQL clusterizable en modo
servidor. Podrá generar replicación maestro-esclavo si se requiriera por motivos de
rendimiento de la aplicación.
6.1.3.5 Nodo 6
En este nodo se instalará un servidor Jetty que se encargará de ejecutar la aplicación Apache
Solr. Este servidor será el encargado de llevar la búsqueda de los servicios web registrados,
que él mismo se encarga de indexar en sus diccionarios.
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
75
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Diseño del Sistema
6.2 Diseño de Clases
6.2.1
Diagrama de Clases
Debido al entramado de referencias entre clases y a la cantidad de clases que hay es inviable
realizar un único diagrama donde se representen todas las clases, es por esto que se han
dividio por componentes para facilitar la comprensión y a su vez, en paquetes.
6.2.1.1 Buscador
6.2.1.1.1 Controller
Ilustración 25. Diagrama Clases. Controller
76
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Diseño del Sistema | Plataforma para Interoperabilidad de sistemas de información dentro
de un mismo ámbito organizativo
6.2.1.1.2 Search
Ilustración 26. Diagrama Clases. Search
Ilustración 27. Diagrama Clases. SearchView
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
77
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Diseño del Sistema
6.2.1.1.3 University
Ilustración 28. Diagrama Clases. University
Ilustración 29. Diagramas Clases. Diagramas Clases
78
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Diseño del Sistema | Plataforma para Interoperabilidad de sistemas de información dentro
de un mismo ámbito organizativo
6.2.1.1.4 Validator
Ilustración 30Diagrama Clases. Validator
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
79
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Diseño del Sistema
6.2.1.1.5 View
Ilustración 31. Diagrama Clases. View
80
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Diseño del Sistema | Plataforma para Interoperabilidad de sistemas de información dentro
de un mismo ámbito organizativo
6.2.1.2 Model
6.2.1.2.1 Model
Ilustración 32. Diagramas Clases. Model
6.2.1.2.2 NoSQL
Ilustración 33. Diagramas Clases. NoSQL
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
81
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Diseño del Sistema
6.2.1.2.3 Persistence
Ilustración 34. Diagramas Clases. Persistence
6.2.1.2.4 Solr
Ilustración 35. Diagramas Clases. Class
6.2.1.2.5 Utils
Ilustración 36. Diagramas Clases. Util
82
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Diseño del Sistema | Plataforma para Interoperabilidad de sistemas de información dentro
de un mismo ámbito organizativo
6.2.1.2.6 Wrapper
Ilustración 37. Diagramas Clases. Wrapper
6.2.1.3 Publisher
6.2.1.3.1 Publisher
Ilustración 38. Diagramas Clases. Publisher
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
83
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Diseño del Sistema
6.2.1.4 Recolector
6.2.1.4.1 Recolector
Ilustración 39. Diagramas Clases. Recolector
6.2.1.4.2 Ws
Ilustración 40. Diagramas Clases. Ws
84
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Diseño del Sistema | Plataforma para Interoperabilidad de sistemas de información dentro
de un mismo ámbito organizativo
6.2.1.5 Registrador
6.2.1.5.1 Matcher
Ilustración 41. Diagramas Clases. Matcher
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
85
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Diseño del Sistema
6.2.1.5.2 Presentation
Ilustración 42. Diagramas Clases. Presentation
86
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Diseño del Sistema | Plataforma para Interoperabilidad de sistemas de información dentro
de un mismo ámbito organizativo
6.2.1.5.3 University
Ilustración 43. Diagramas Clases. University
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
87
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Diseño del Sistema
6.2.1.5.4 Ws
Ilustración 44. Diagrama Clases. Ws
88
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Diseño del Sistema | Plataforma para Interoperabilidad de sistemas de información dentro
de un mismo ámbito organizativo
6.2.1.6 Service
6.2.1.6.1 Builder
Ilustración 45. Diagramas Clases. Builder
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
89
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Diseño del Sistema
6.2.1.6.2 Business
Ilustración 46. Diagramas Clases. Business
6.2.1.6.3 Exception
Ilustración 47. Diagramas Clases. Exception
90
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Diseño del Sistema | Plataforma para Interoperabilidad de sistemas de información dentro
de un mismo ámbito organizativo
6.2.1.6.4 Matcher
Ilustración 48. Diagramas Clases. Matcher
6.2.1.6.5 SearchEngine
Ilustración 49. Diagramas Clases. SearchEngine
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
91
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Diseño del Sistema
6.2.1.6.6 Solr
Ilustración 50. Diagramas Clases. Solr
6.2.1.6.7 University
Ilustración 51. Diagramas Clases. University
92
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Diseño del Sistema | Plataforma para Interoperabilidad de sistemas de información dentro
de un mismo ámbito organizativo
6.2.1.6.8 Ws
Ilustración 52. Diagramas Clases. Ws
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
93
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Diseño del Sistema
6.3 Diagramas de Interacción y Estados
6.3.1
Registro de una nueva Universidad
Ilustración 53. Diagrama Secuencia. Registro Universidad 1
El controlador de la aplicación deriva a la vista representada por CheckOperationsView. Este lo
primero que realiza es la validación de los campos recibidos del formulario. Se intenta
encontrar la universidad en la base de datos, se obtienen las operaciones, se intenta encontrar
la universidad por otros parámetros… todo esto para comprobar que la universidad no se ha
registrado previamente. Finalmente se devuelve el control al controlador Spring para que
represente la jsp del siguiente paso del formulario.
Ilustración 54. Diagrama Secuencia. Registro Universidad 2
94
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Diseño del Sistema | Plataforma para Interoperabilidad de sistemas de información dentro
de un mismo ámbito organizativo
En esta segunda parte del registro, es cuando se seleccionan las operaciones y el nombre del
modelo con lo que se deberán de validar los parámetros de entrada del formulario y se
devolverá el control al controlador de Spring a la jsp para seleccionar y emparejar los campos
de la Beca.
Ilustración 55. Diagrama Secuencia. Registro Universidad 3
Antes de presentar el formulario, se obtendrán los campos del servicio web de la universidad
que se registran y se intentan emparejar con los del modelo de referencia. Una vez
seleccionados los campos por el usuario, se proceden a validar antes de devolver el control a la
jsp correspondiente para introducir los datos del Solicitante.
Ilustración 56. Diagrama Secuencia. Registro Universidad 4
Como en el caso anterior, antes de presentar el formulario, se obtendrán los emparejamientos
que se creen idóneos entre el Solicitante y el modelo de referencia.
Una vez presentado, se seleccionan los emparejamientos por parte del usuario y se validan los
campos que estén de forma correcta. Cuando se tienen los emparejamientos confirmados se
procederá a guardar todos los emparejamientos y datos que se han recogido en todo el
proceso, de esta forma se evita que el sistema quede en forma inconsistente.
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
95
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Diseño del Sistema
6.3.2
Buscador
Ilustración 57. Diagrama Secuencia. Buscador
Una vez el usuario introduce los conceptos de la búsqueda, el controlador derivará en la vista
la ejecución, que a través de los managers terminará consultando contra el servidor de
búsqueda los conceptos introducidos por el usuario.
6.3.3
Publicador
Ilustración 58. Diagrama Secuencia. Publicador
A la hora de la llamada que realizarán los sistemas de terceros cuando quieran consultar datos
de becas, lo tendrán que hacer a través del ScholarshipManager, que configurarán con una
serie de parámetros (categoría, universidad) y se encargará de obtener los mapeos de la
universidad concreta entre el modelo de referencia y los modelos de la universidad para
finalmente realizar la invocación dinámica al servicio web de cada universidad.
96
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Diseño del Sistema | Plataforma para Interoperabilidad de sistemas de información dentro
de un mismo ámbito organizativo
6.4 Diagramas de Actividades
Ilustración 59. Diagrama Actividad. Registro Universidad
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
97
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Diseño del Sistema
6.5 Diseño de la Base de Datos
6.5.1
Descripción del SGBD Usado
El Sistema Gestor de Bases de Datos utilizado es PostgreSQL en modo servidor. Una
descripción más detallada se puede encontrar en las Referencias Técnicas.
6.5.2
Integración del SGBD en Nuestro Sistema
La función que tiene el sistema gestor de bases de datos en nuestro sistema es la de almacenar
las nuevas universidades que se registren en la aplicación y los mapeos entre los campos de
cada universidad y sus operaciones.
6.5.3
Diagrama E-R
Ilustración 60. Diagrama E-R
98
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Diseño del Sistema | Plataforma para Interoperabilidad de sistemas de información dentro
de un mismo ámbito organizativo
6.6 Diseño de la Interfaz
6.6.1
Descripción de la Interfaz
Ilustración 61. Interfaz. Página de inicio
La pantalla de inicio es similar a la de cualquier aplicación web que se pueda encontrar. Al
estar hablando de un buscador, el componente más destacado y central será el cuadro de
texto y el botón con la lupa de buscar que nos servirá de buscador, además de encontrarse
con un cuadro de bienvenida que conduce a la zona de información.
La parte superior será fija y constará de una serie de ítems que harán de menú de navegación
dentro de la página.
Este menú superior, incluirá un elemento para volver al inicio de la aplicación, otro para ir al
formulario de registro de nuevos servicios web, otro para acceder a la información del
recolector y otro para acceder a la información de la aplicación.
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
99
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Diseño del Sistema
Ilustración 62. Interfaz. Formulario de registro
Una vez estemos ante el formulario de registro, se podrán identificar en la zona central de la
página una serie de números, que no harán más que indicar en el paso que se encuentra el
usuario dentro del proceso de registro. Además todos los formularios tendrán la capacidad de
ir hacia adelante y de reiniciar el formulario, para ello se dispone de un botón azul para
continuar y uno rojo para reiniciar.
Estos campos que se han de cubrir en el registro, estarán marcados con símbolos de
admiración en caso de que sean obligatorios.
100
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Diseño del Sistema | Plataforma para Interoperabilidad de sistemas de información dentro
de un mismo ámbito organizativo
Ilustración 63. Interfaz. Selección de Operaciones
Una vez avanzamos a la siguiente sección del formulario se puede comprobar que la
distribución es igual que en el formulario anterior, aunque ahora se seleccionarán las
operaciones mediante botones de tipo radio y una caja de texto para registrar el nombre del
modelo.
Ilustración 64. Interfaz. Emparejamiento campos Beca
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
101
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Diseño del Sistema
En el tercer paso del registro del servicio web, se puede comprobar que es el mismo estilo que
el formulario anterior. Campos del formulario que representan atributos de la clase del
modelo.
Ilustración 65. Interfaz. Emparejamiento campos Solicitante
Cuarto paso del registro, el formulario es igual que en el caso anterior, pues cada campo sigue
siendo un atributo de la clase Solicitante del servicio web.
102
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Diseño del Sistema | Plataforma para Interoperabilidad de sistemas de información dentro
de un mismo ámbito organizativo
Ilustración 66. Interfaz. Formulario guardado
Pantalla que indica que el formulario se ha guardado con éxito. Se ve reflejado el quinto paso y
tras informar de que se ha tenido éxito en la operación, se permite trasladar al usuario al
inicio.
Ilustración 67. Interfaz. Buscador
Una vez se ha registrado el servicio web, se puede utilizar el buscador para localizarlo. Se
puede localizar por el nombre de la universidad, por algún nombre del método o por categoría.
Tras realizar la búsqueda, se presentan los resultados para poder acceder al que más nos
convenza.
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
103
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Diseño del Sistema
Ilustración 68. Interfaz. Detalle Universidad
Tras seleccionar el resultado del buscador que más se ajuste a los criterios, lo que muestra la
aplicación es el detalle de la universidad seleccionada, donde se mostrará el nombre de la
universidad, la URL del fichero WSDL y los métodos de cada categoría que se pueden invocar.
Ilustración 69. Interfaz. Pantalla del recolector
En la tercera opción que aparece en el menú superior se puede ver el Recolector, este
trasladará al usuario a la página donde se informa de la dirección del recolector y de las
operaciones invocables por los usuarios además de una explicación.
104
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Diseño del Sistema | Plataforma para Interoperabilidad de sistemas de información dentro
de un mismo ámbito organizativo
Ilustración 70. Interfaz. Información de la aplicación
La aplicación también dispone de una pantalla de información que es la cuarta opción del
menú superior. Desde cada uno de los párrafos que se presentan y que cada uno describe una
funcionalidad disponible en la página web, se puede ir a la funcionalidad desde el enlace al
final del texto.
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
105
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Diseño del Sistema
6.6.2
Descripción
Interfaz
del
Comportamiento
de
la
A la hora de mostrar mensajes de error o avisos, la aplicación generará unos mensajes en una
especie de burbujas de color anaranjado, que el usuario podrá cerrar en el aspa superior
derecha para que los mensajes desaparezcan.
Ilustración 71. Interfaz. Mensaje informativo
Si por el contrario, en un campo marcado con el símbolo de admiración no introducimos el
texto o la aplicación deduce que no es correcta la operación, también nos dará un mensaje de
error como el siguiente:
Ilustración 72. Interfaz. Mensajes de Error
106
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Diseño del Sistema | Plataforma para Interoperabilidad de sistemas de información dentro
de un mismo ámbito organizativo
6.7 Especificación Técnica del Plan de Pruebas
A la hora de probar el software que se ha desarrollado se ha probado en dos equipos de
características lo suficientemente diferentes como son:
Portátil
o Intel i7 3610QM (2.3GHz)
o 6 GB RAM
o HDD 1TB
o Windows 7 Home Premium 64 bits
Sobremesa
o Intel X
o 4GB RAM
o HDD 500 GB
o Windows 7 Professional 64 bits
Las pruebas que se realizarán estarán dentro del multiproyecto entregado dentro del CD de la
aplicación.
6.7.1
Pruebas Unitarias
La realización de las pruebas unitarias se llevará a cargo mediante la herramienta JUnit. Esta
herramienta se encargará de ejecutar las pruebas y determinar si son correctas o la aplicación
falla alguno de los tests. Estas pruebas se ejecutarán siempre cada vez que se realice un
despliegue de la aplicación a cargo de Maven.
Las clases / métodos que se han decidido probar dentro de la aplicación son aquellas que son
factibles de que puedan dar problemas. Es decir, no se probarán modelos o managers que se
utilicen como pass-through para redundar en una persistencia en la base de datos, por
ejemplo.
6.7.1.1 BecaBuilder
Con el método:
testGetBeca: Se encargará de obtener unas becas concretas de un servicio web
registrado en la aplicación. Además comprobará si la beca recibida está bien
construida.
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
107
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Diseño del Sistema
6.7.1.2 MatcherManagerService
Con los métodos:
testMatch: Comprueba la realización de una serie de emparejamientos automáticos
generados por la aplicación respecto a una serie de campos concretos.
testSaveModelWrapper: Realiza la prueba de guardar el modelo en Cassandra.
testSaveOperationWrapper: Realiza la prueba de guardar la operación en Cassandra.
6.7.1.3 SearchEngineService
Con los métodos:
testSearchOperations: Realiza una prueba a buscar en el servidor de buscador sobre
operaciones registradas anteriormente.
testSearchUniversities: Realiza una prueba a buscar en el servidor de buscador sobre
universidades registradas anteriormente.
6.7.1.4 UniversityManagerService
Con los métodos:
108
testSave: Simula un proceso de registro de una universidad.
testRemove: Prueba a borrar una universidad creada anteriormente.
testFindUniversity: Prueba a encontrar una universidad.
testFindUniversityByWsdl: Prueba a encontrar una universidad mediante la dirección
de su servicio web.
testFindUniversityByName: Prueba a encontrar una universidad mediante el nombre
de la universidad.
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Diseño del Sistema | Plataforma para Interoperabilidad de sistemas de información dentro
de un mismo ámbito organizativo
6.7.1.5 WebServiceManagerService
Con los métodos:
testFailWrongArgumentNumber: Comprueba que la aplicación falla cuando no se le
pasa el número adecuado de parámetros (derivado de la instanciación dinámica).
testFailBadArguments: Comprueba que los tipos de los parámetros recibidos son los
adecuados.
testFailMethod: Comprueba que la aplicación falla como debe fallar si no se invoca a
un método disponible.
testFailWSDL: Comprueba que la aplicación falla si no está el WSDL disponible.
testGetOperations: Realiza una prueba para obtener las operaciones disponibles en un
WSDL.
testGetOperationsIOs: Obtiene los parámetros de entrada y los de retorno de los
diferentes métodos del servicio web.
testGetClassFields: Obtiene los atributos de una clase mediante introspección.
testGetBecasByParam: Prueba a obtener una serie de becas realizando la
instanciación dinámica de servicios web.
6.7.2
Pruebas de Integración y del Sistema
Para la realización de las pruebas de Integración y del Sistema, se tendrá que el sistema
funcione como debería, las búsquedas en servicios se realicen como deben, las conexiones
entre servicios son adecuadas, etc.
6.7.3
Pruebas de Usabilidad y Accesibilidad
6.7.3.1 Diseño de Cuestionarios
6.7.3.1.1 Cuestionario de Evaluación
Para evaluar la usabilidad de la aplicación, se realizarán a un conjunto de potenciales usuarios
de la aplicación y estos cuestionaros darán como resultado lo “fácil” que es utilizar la
aplicación que se está describiendo.
Es por ello que las preguntas que se realizarán serán de varios tipos: por un lado estarán las de
carácter general para conocer realmente qué conocimientos posee de base el usuario y por
otro están las preguntas que indicarán qué sencillo es utilizar la aplicación o cómo de
gratificante es la experiencia de usuario.
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
109
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Diseño del Sistema
6.7.3.1.2 Cuestionario para el Responsable de las Pruebas
Como también es recomendable generar un cuestionario para la persona que está a cargo de
evaluar a los usuarios, también se generará un cuestionario para que el responsable pueda
aportar información extra de cada uno de los usuarios y de lo que él ha apreciado durante la
sesión de la prueba.
6.7.3.2 Actividades de las Pruebas de Usabilidad
6.7.3.2.1 Preguntas de carácter general
¿Usa un ordenador frecuentemente?
1.
2.
3.
4.
Todos los días
Varias veces a la semana
Ocasionalmente
Nunca o casi nunca
¿Qué tipo de actividades realiza con el ordenador?
1.
2.
3.
4.
Es parte de mi trabajo o profesión
Lo uso básicamente para ocio
Solo empleo aplicaciones estilo Office
Únicamente leo el correo y navego ocasionalmente
¿Ha usado alguna vez software como el de esta prueba?
1. Sí, he empleado software similar
2. No, aunque si empleo otros programas que me ayudan a realizar tareas similares
3. No, nunca
¿Qué busca principalmente en un programa?
1.
2.
3.
4.
Que sea fácil de usar
Que sea intuitivo
Que sea rápido
Que tenga todas las funciones necesarias
¿Qué tipo de programas suele utilizar en el ordenador?
1.
2.
3.
4.
Ofimáticos
Navegador Web
Ambos
Otros
¿Está acostumbrado a navegar por internet con el teléfono móvil?
1. Sí
2. No
¿Posee conocimientos de programación?
110
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Diseño del Sistema | Plataforma para Interoperabilidad de sistemas de información dentro
de un mismo ámbito organizativo
1. Sí
2. No
Tabla 17. Usabilidad. Cuestionario Preguntas generales
6.7.3.2.2 Actividades guiadas
Las actividades que han de hacer los usuarios son las siguientes:
Añadir una nueva universidad a la aplicación
Obtener ayuda en la aplicación
Conseguir acceder al detalle de una universidad
Buscar una operación de un servicio web de una categoría concreta
Obtener la URL del servicio web publicador
6.7.3.2.3 Preguntas Cortas sobre la Aplicación y Observaciones
Estas preguntas se deberán de contestar después de hacer las actividades guiadas.
Facilidad de Uso
¿Sabe dónde está dentro de la
aplicación?
¿Existe ayuda para las funciones
en caso de que tenga dudas?
¿Le resulta sencillo el uso de la
aplicación?
Funcionalidad
¿Funciona cada tarea como usted
espera?
¿El tiempo de respuesta de la
aplicación es muy grande?
¿Han sido útiles los mensajes de
error?
¿Han sido útiles los indicadores?
¿Ha sido útil la ayuda?
Aspectos gráficos
Siempre
Frecuentemente
Ocasionalmente
Nunca
Siempre
Frecuentemente
Ocasionalmente
Nunca
Calidad del Interfaz
Muy
Adecuado
Adecuado
El tipo y tamaño de letra es
Los iconos e imágenes usados son
Los colores empleados son
Diseño de la Interfaz
¿Le resulta fácil de usar?
¿El diseño de las pantallas es claro y
atractivo?
¿Cree que el programa está bien
estructurado?
¿Se ha adaptado el diseño adecuadamente a
su dispositivo?
Si
Poco
Adecuado
Nada
Adecuado
No
A veces
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
111
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Diseño del Sistema
Observaciones
Cualquier comentario del usuario
Tabla 18. Usabilidad. Cuestionario Preguntas cortas
6.7.3.2.4 Cuestionario para el Responsable de las Pruebas
Aspecto Observado
Notas
El usuario comienza a trabajar de
forma rápida por las tareas
Tiempo en realizar cada tarea
Errores leves cometidos
Errores graves cometidos
El usuario ha preguntado
Tabla 19. Usabilidad. Cuestionario Preguntas Responsable
6.7.3.3 Pruebas de Accesibilidad
Para conocer el nivel de accesibilidad que tiene la aplicación se utilizarán cuestionario con las
recomendaciones de WCAG 2.0.
Además se utilizará el validador web http://achecker.ca/checker/
6.7.4
Pruebas de Rendimiento
Para conocer el rendimiento de la aplicación se visualizarán los estados internos del sistema
sobre el que se ejecuta. Las mediciones que se harán será conocer la cantidad de memoria
RAM consumida por la aplicación, el porcentaje de CPU, consumo de datos de la aplicación,
velocidades de respuesta de la página web y velocidades de respuesta en el consumo de los
servicios web.
112
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Implementación del Sistema | Plataforma para Interoperabilidad de sistemas de información
dentro de un mismo ámbito organizativo
Capítulo 7. Implementación
Sistema
del
7.1 Estándares y Normas Seguidos
7.1.1
HMTL 5
Si bien no es un estándar oficial, sí que está en proceso de estandarización y por eso se ha
optado por generar el código de las JSPs con este lenguaje de marcado. De esta forma, la
aplicación web está escrita con esta tecnología.
7.1.2
CSS 3
Los estilos de la página web están basados en CSS y LESS. Además se apoya con JQuery y
bootstrap para aumentar la responsividad del diseño.
7.1.3
Java Conventions
A la hora de codificar la aplicación se ha decidido aplicar las reglas definidas en las Java
Conventions para la escritura y formateo del código desarrollado.
7.1.4
JPA (JSR-317)
Se ha decidido utilizar esta especificación en lugar de utilizar la implementación Hibernate. De
esta forma se consigue liberar la dependencia y poder modificar el proveedor de la
implementación sin afectar al diseño de la aplicación.
7.1.5
Dependency Injection For Java (JSR-330)
Igual que en el apartado anterior, para la inyección de dependencias se ha utilizado la
especificación mediante anotaciones @Inject y @Named. De esta forma aunque sean menos
representativos como por ejemplo lo son los estereotipos que proporciona Spring, si se da el
caso de que hay que modificar el proveedor de CDI no habrá problemas.
7.1.6
JAX-WS (JSR-224)
Para la especificación de los servicios web se han utilizado estas anotaciones proporcionadas
por la especificación.
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
113
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Implementación del Sistema
7.1.7
MVC (Model-View-Controller)
Para montar la estructura de la aplicación web se decidió utilizar este patrón arquitectónico
que es el más utilizado debido a la separación de responsabilidades entre las capas y ser la que
proporciona la tecnología utilizada para el controlador web (Spring-MVC).
114
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Implementación del Sistema | Plataforma para Interoperabilidad de sistemas de información
dentro de un mismo ámbito organizativo
7.2 Lenguajes de Programación
El lenguaje de programación utilizado ha sido Java en su versión JEE 7 para aplicaciones
empresariales. Debido a que Java suele mantener la compatibilidad con versiones anteriores
es posible utilizar JEE 6. Por debajo de esta última versión no se garantiza su correcto
funcionamiento.
Otro de los lenguajes utilizados en la programación ha sido JavaScript y concretamente con su
componente JQuery para realizar llamadas AJAX al servidor sin necesidad de refrescar la
página. La versión de JQuery utilizada es 2.0.0 minificada.
Para ver todas las versiones de los componentes utilizados se recomienda ver la sección de
anexos donde se incluirán los ficheros POM.xml de cada uno de los proyectos utilizados y que
definen tanto los componentes como sus versiones.
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
115
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Implementación del Sistema
7.3 Herramientas y Programas Usados para el
Desarrollo
7.3.1
Spring Tool Suite
Desarrollado en Java por Pivotal, es un entorno de desarrollo orientado a desarrollar
aplicaciones con Java y concretamente con los componentes SpringFramework, Maven, SVN,
JPA… Está desarrollado como un plug-in de Eclipse y enriquece enormemente la experiencia
del desarrollador teniendo un control máximo del proyecto.
7.3.2
SVN
Subversion es un sistema para el control del versionado. Es decir, permite llevar un track del
histórico de versiones de un proyecto siendo muy sencillo poder volver a una versión anterior
en caso de ser necesario y de compartir el código del proyecto pues está instalado en un
servidor.
7.3.3
Maven
Es una herramienta de despliegue automático de aplicaciones Java. Se puede ver como una
remodelación del antiguo Apache Ant, que fue tan exitoso en la generación de ficheros WAR
para su posible despliegue en entornos JEE. La mayor mejora que supone Maven es que se
encarga de la gestión de las dependencias en forma de bibliotecas que puedan tener los
proyectos, él las instala de forma automática, además de tener un amplio abanico de plantillas
para crear proyectos sin comenzar de cero. Para la gestión de las bibliotecas, éstas han de ser
incluidas en forma de dependencias dentro de un fichero XML denominado pom.xml que
además permitirá la gestión completa del proyecto, con qué plugins compilar, metadatos del
proyecto, gestión del empaquetamiento, etc. Ligada a esta nueva filosofía de las
dependencias, también acoge la nueva tendencia del multiproyecto por la cual se aconseja
tener un proyecto por cada capa (Tier) de la aplicación. Por último, otro de sus grandes
ventajas es su perfecta integración como plugin de Eclipse para la gestión de los proyectos.
7.3.4
Microsoft Project
Herramienta de Micrososft para la gestión de proyectos. Con él se ha diseñado el diagrama de
Gantt y se ha llevado a cabo la planificación del proyecto.
116
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Implementación del Sistema | Plataforma para Interoperabilidad de sistemas de información
dentro de un mismo ámbito organizativo
7.3.5
Microsoft Office
Suite ofimática que comprende programas como Microsoft Word para el procesado de textos,
Microsoft Excel para la realización de hojas de cálculo y Microsoft PowerPoint para la
realización de presentaciones.
7.3.6
Enterprise Architect
Herramienta CASE para la realización de los diagramas necesarios para documentar el
proyecto. Fundamental en el proceso de análisis y diseño ya que con él se desarrolla la
arquitectura, diagramas de clases, de interacción, de actividad, etc.
7.3.7
Windows 7
Sistema operativo de catacter propietario desarrollado por Microsoft sobre el cual se realiza la
documentación y análisis del proyecto. Para el ejemplo también será el sistema operativo
sobre el que se ejecutará la aplicación.
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
117
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Implementación del Sistema
7.4 Creación del Sistema
7.4.1
Problemas Encontrados
A la hora de realizar el desarrollo de este proyecto, el primer enfoque que se le dio fue que se
podía resolver mediante aplicando tecnologías relacionados con Web Semántica.
La convicción que se tenía en un principio fue que se podía realizar una Ontología lo
suficientemente potente como para que pudiera representar el modelo de referencia que se
plantea y que luego tanto con servicios web semánticos como mediante consultas SPARQL se
podían aplicar razonamientos a la Ontología para poder realizar los emparejamientos de
campos entre universidades.
El problema llegó desde que estaba construida la Ontología, cuando no se consiguió hacer un
modelo lo suficientemente rico semánticamente bien por no tener unos conocimientos
avanzados de la materia o porque simplemente no se estaba utilizando la tecnología en la
forma en la que se debería de utilizar. Tras desecharse este modelo se comenzó a plantear el
nuevo sistema mediante NoSQL y String Metrics.
Otro de los problemas que ocurrieron a lo largo del desarrollo del sistema fue cómo conseguir
llamar a los diferentes servicios web para obtener información o bien para realizar la
introspección de las clases y métodos incluidos en el servicio web sin generar todo el stub de
clases que se generan cuando se desarrolla un cliente para un determinado servicio web.
Esto finalmente se resolvió mediante la inclusión de Apache CXF para la instanciación dinámica
de servicios web, que si bien no es trivial, sí facilita el trabajo de forma notoria.
118
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Implementación del Sistema | Plataforma para Interoperabilidad de sistemas de información
dentro de un mismo ámbito organizativo
7.4.2
Descripción Detallada de las Clases
7.4.2.1 Buscador
7.4.2.1.1 BecaFormController
@Controller
@RequestMapping(value="/beca")
@SessionAttributes(value="beca")
public class BecaFormController
extends java.lang.Object
Controlador del formulario del modelo Beca. Atenderá las peticiones que sean de su
responsabilidad mediante las direcciones filtradas en los métodos.
Author:
Danielmf
Fields:
private IMatchBecaView
becaView
private BecaDirectorForm
builder
private static Logger logger
private MatcherManagerService
matcherService
private WebServiceManagerService webServiceService
Operations:
@RequestMapping(method=GET)
public java.lang.String setupForm(org.springframework.ui.Model m
odel,
javax.servlet.http.HttpServletRequest request)
Prepara el formulario de la Beca rellenando sus campos previamente con el modelo
Parameters:
model - a rellenar previa ejecución del formulario
request Returns:
vista a devolver el control
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
119
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Implementación del Sistema
@RequestMapping(method=POST)
public java.lang.String submitForm(@ModelAttribute(value="beca")
es.uniovi.innova.eadministracion.tramites.swu.model.wrapper.Beca
Wrapper beca,
org.springframework.validation.BindingResult result,
org.springframework.web.bind.support.SessionStatus status,
javax.servlet.http.HttpServletRequest request,
org.springframework.ui.Model model)
Recoge la acción procesada al enviar el formulario del modelo Beca
Parameters:
beca - Modelo que será mapeado por el formulario
result - Resultado del mapeo del formulario
status - estado de la sesión, en caso de que exista algo que no ocurra como
debiera
request model - Model para realizar el binding
Returns:
vista donde se devolverá el control
7.4.2.1.2 OperationsFormController
@Controller
@RequestMapping(value="/operations")
public class OperationsFormController
extends java.lang.Object
Controlador de gestión del formulario de Operaciones de los servicios web
Author:
danielmf
Fields:
private static Logger logger
private IMatchOperationsView
120
matchOperationsView
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Implementación del Sistema | Plataforma para Interoperabilidad de sistemas de información
dentro de un mismo ámbito organizativo
Operations:
@RequestMapping(method=POST)
public java.lang.String submitForm(javax.servlet.http.HttpServle
tRequest request,
@RequestParam(value="modelo")
java.lang.String modelo,
@RequestParam(value="VICERRECTORADO")
java.lang.String VC,
@RequestParam(value="CURSO")
java.lang.String curso,
@RequestParam(value="ALUMNO")
java.lang.String alumno)
Recoge la acción procesada al enviar el formulario del modelo OperationWrapper
Parameters:
request modelo - clase que emparejará con el modelo de referencia
VC - operacion para las becas del vicerrectorado
curso - operacion para las becas del curso
alumno - operacion para las becas por alumno
Returns:
7.4.2.1.3 SolicitanteFormController
@Controller
@RequestMapping(value="/solicitante")
@SessionAttributes(value="solicitante")
public class SolicitanteFormController
extends java.lang.Object
Controlador de gestión del formulario de Solicitante
Author:
danielmf
Fields:
privateBecaDirectorForm
builder
private static Logger logger
private MatcherManagerService
private ISaveProcessView
matcherService
saveProcessView
private WebServiceManagerService webServiceService
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
121
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Implementación del Sistema
Operations:
@RequestMapping(method=GET)
public java.lang.String setupForm(org.springframework.ui.Model m
odel,
javax.servlet.http.HttpServletRequest request)
Preparación del formulario del modelo para inyectar campos previamente
Parameters:
model request Returns:
@RequestMapping(method=POST)
public java.lang.String submitForm(@ModelAttribute(value="solici
tante")
es.uniovi.innova.eadministracion.tramites.swu.model.wrapper.Soli
citanteWrapper solicitante,
org.springframework.validation.BindingResult result,
org.springframework.web.bind.support.SessionStatus status,
javax.servlet.http.HttpServletRequest request,
org.springframework.ui.Model model)
Parameters:
solicitante - clase que se mapeará en el formulario
result - resultado del mapeo
status - estado para obtener los errores
request model Returns:
7.4.2.1.4 UniversityController
@Controller
public class UniversityController
extends java.lang.Object
Controlador de la University
Author:
danielmf
122
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Implementación del Sistema | Plataforma para Interoperabilidad de sistemas de información
dentro de un mismo ámbito organizativo
Fields:
private ICheckOperationsView
private IDetailView
detailView
private IDetailView
detailViewFull
checkOperationsView
private IMatchBecaView
matchBecaView
private ISaveProcessView
saveProcessView
Operations:
@RequestMapping(value="/univ/{univ}/min")
public java.lang.String detail(@PathVariable(value="univ")
java.lang.Long id,
org.springframework.ui.Model model)
Filtra las peticiones para el detalle de una universidad en caso de que se procese la
petición mediante JavaScript
Parameters:
id - de la University
model - para devolver el resultado
Returns:
@RequestMapping(value="/univ/{univ}")
public java.lang.String detailFull(@PathVariable(value="univ")
java.lang.Long id,
org.springframework.ui.Model model)
Filtra las peticiones para el detalle de una universidad en caso de que la petición se
ejecute sin JavaScript
Parameters:
id - de la University
model - para devolver el resultado
Returns:
7.4.2.1.5 UniversityFormController
@Controller
@RequestMapping(value="/form")
@SessionAttributes(value="university")
public class UniversityFormController
extends java.lang.Object
Controlador del formulario del modelo University
Author:
danielmf
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
123
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Implementación del Sistema
Fields:
private ICheckOperationsView
checkOperationsView
private static Logger logger
Operations:
@RequestMapping(method=GET)
public java.lang.String setupForm(org.springframework.ui.Model m
odel)
Prepara el formulario inyectando los parámetros necesarios para rellenar los campos
Parameters:
model Returns:
@RequestMapping(method=POST)
public java.lang.String submitForm(@ModelAttribute(value="univer
sity")
es.uniovi.innova.eadministracion.tramites.swu.model.University u
niversity,
org.springframework.validation.BindingResult result,
org.springframework.web.bind.support.SessionStatus status,
javax.servlet.http.HttpServletRequest request,
org.springframework.ui.Model model)
Recoge los datos del fomulario y los valida para continuar con el registro del formulario
Parameters:
university - objeto University rellena del formulario
result - para devolver mensajes a la vista
status - con el estado de la petición
request model Returns:
vista a la que quiere devolversele el control
7.4.2.1.6 HomeController
@Controller
public class HomeController
extends java.lang.Object
Controlador de la página inicial (Buscador)
Author:
danielmf
124
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Implementación del Sistema | Plataforma para Interoperabilidad de sistemas de información
dentro de un mismo ámbito organizativo
Fields:
private static Logger
logger
Operations:
@RequestMapping(value="/form")
public java.lang.String form()
Mapea las peticiones para el formulario de registro de los Servicios Web en la url /form
Returns:
@RequestMapping(value="/",
method=GET)
public java.lang.String home()
Filtra el tráfico inicial a la home
Returns:
@RequestMapping(value="/info")
public java.lang.String info()
Mapea las peticiones para la página de información en la url /info
Returns:
@RequestMapping(value="/retriever")
public java.lang.String retriever()
Mapea las peticiones para la información del Recolector de Becas en la url /retriever
Returns:
7.4.2.1.7 SearchEngineController
@Controller
public class SearchEngineController
extends java.lang.Object
Controlador del componente Buscador. Atenderá las peticiones que sean de su
responsabilidad mediante las direcciones filtradas en los métodos.
Author:
danielmf
Fields:
private static Logger logger
private ISearchView searchView
private ISearchViewNoScript searchViewNoScript
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
125
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Implementación del Sistema
Operations:
@RequestMapping(value="/searchMin",
method=POST)
public java.lang.String search(@RequestParam(value="search_text"
)
java.lang.String search,
org.springframework.ui.Model model)
Filtra las peticiones del buscador que atiendan a la url /searchMin
Parameters:
search - parametro que llega del formulario
model - modelo para devolver la respuesta
Returns:
@RequestMapping(value="/search",
method=POST)
public java.lang.String searchNoScript(@RequestParam(value="sear
ch_text")
java.lang.String search,
org.springframework.ui.Model model)
Filtra las peticiones del buscador con el JavaScript desactivado en la url /search
Parameters:
search - parámetro que llega del formulario
model - modelo para devolver la respuesta
Returns:
7.4.2.1.8 SearchView
@Named
public class SearchView
extends java.lang.Object
implements ISearchView
Resuelve la vista del buscador mediante la implementación del patrón Command
Author:
Danielmf
Fields:
private SearchEngineService
126
searchEngine
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Implementación del Sistema | Plataforma para Interoperabilidad de sistemas de información
dentro de un mismo ámbito organizativo
Operations:
public java.lang.String execute(java.lang.String search,
org.springframework.ui.Model model)
Specified by:
execute in interface ISearchView
7.4.2.1.9 CheckOperationsView
@Named
public class CheckOperationsView
extends java.lang.Object
implements ICheckOperationsView
Clase que implementa un patrón Command para resolver la vista de las operaciones
Author:
danielmf
Fields:
private static Logger
logger
private UniversityValidator
validator
privateWebServiceManagerService
webServiceManager
Operations:
public java.lang.String execute(javax.servlet.http.HttpServletRe
quest request,
es.uniovi.innova.eadministracion.tramites.swu.model.University u
niversity,
org.springframework.ui.Model model,
org.springframework.validation.BindingResult result)
Specified by:
execute in interface ICheckOperationsView
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
127
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Implementación del Sistema
7.4.2.1.10
DetailView
@Named
public class DetailView
extends java.lang.Object
implements IDetailView
Resuelve la vista del detalle de la University mediante un Command
Author:
danielmf
Fields:
private static Logger logger
privateUniversityManagerService
universityService
Operations:
public java.lang.String execute(java.lang.Long id,
org.springframework.ui.Model model)
Specified by:
execute in interface IDetailView
7.4.2.1.11 MatchBecaView
@Named
public class MatchBecaView
extends java.lang.Object
implements IMatchBecaView
Resuelve la vista para el matcheador de la beca mediante un Command
Author:
danielmf
Fields:
privateMatcherManagerService
matcherService
private BecaWrapperValidator
validator
private WebServiceManagerService webServiceService
128
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Implementación del Sistema | Plataforma para Interoperabilidad de sistemas de información
dentro de un mismo ámbito organizativo
Operations:
public java.lang.String execute(javax.servlet.http.HttpServletRe
quest request,
es.uniovi.innova.eadministracion.tramites.swu.model.wrapper.Beca
Wrapper beca,
org.springframework.ui.Model model,
org.springframework.validation.BindingResult result)
Specified by:
execute in interface IMatchBecaView
private java.util.Map<java.lang.String,java.lang.String> putAttr
ibutes(es.uniovi.innova.eadministracion.tramites.swu.model.wrapp
er.BecaWrapper beca)
Se encarga de meter en la session un Map con los atributos de la Beca
Parameters:
beca - recogida del formulario
Returns:
Map con el campo y el emparejamiento recogido en el formulario
7.4.2.1.12
MatchOperationsView
@Named
public class MatchOperationsView
extends java.lang.Object
implements IMatchOperationsView
Resuelve la vista para el emparejador de las operaciones
Author:
danielmf
Fields:
private BecaDirectorForm
builder
private static Logger logger
private MatcherManagerService
matcherService
private OperationsValidator operationsValidator
private WebServiceManagerService webServiceService
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
129
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Implementación del Sistema
Operations:
public java.lang.String execute(javax.servlet.http.HttpServletRe
quest request,
java.lang.String modelo,
java.lang.String VC,
java.lang.String curso,
java.lang.String alumno)
Specified by:
execute in interface IMatchOperationsView
private java.lang.String setOperations(java.lang.String VC,
java.lang.String curso,
java.lang.String alumno,
java.util.Map<java.lang.String,java.lang.String> operations)
Comprueba y almacena en un Map las operaciones seleccionadas en el formulario
Parameters:
VC - operación que relaciona con el Vicerrectorado
curso - operación que relacion con el curso
alumno - operación que relaciona con el alumno
operations - mapa donde se almacenan las operaciones
Returns:
el nombre del paquete para recoger el modelo
7.4.2.1.13
SaveProcessView
@Named
public class SaveProcessView
extends java.lang.Object
implements ISaveProcessView
Resuelve la vista para el guardado del proceso de creación de una nueva universidad
Author:
danielmf
Fields:
private MatcherManagerService
matcherService
private UniversityManagerService
universityService
private SolicitanteWrapperValidator validator
130
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Implementación del Sistema | Plataforma para Interoperabilidad de sistemas de información
dentro de un mismo ámbito organizativo
Operations:
@Transactional
public java.lang.String execute(javax.servlet.http.HttpServletRe
quest request,
es.uniovi.innova.eadministracion.tramites.swu.model.wrapper.Soli
citanteWrapper solicitante,
org.springframework.ui.Model model,
org.springframework.validation.BindingResult result)
Specified by:
execute in interface ISaveProcessView
private boolean joinable(java.lang.String key)
Comprueba si un match es compuesto
Parameters:
key - match
Returns:
si es compuesto o no
private java.util.Map<java.lang.String,java.lang.String> putAttr
ibutes(es.uniovi.innova.eadministracion.tramites.swu.model.wrapp
er.SolicitanteWrapper solicitante)
Crea un Map con los atributos del Solicitante
Parameters:
solicitante - recogido en el formulario
Returns:
el mapa con los atributos tras el match
private void setBeca(es.uniovi.innova.eadministracion.tramites.s
wu.model.University u,
java.lang.String modelo,
java.util.Map<java.lang.String,java.lang.String> fields_beca)
Guarda una beca recogida en el formulario
Parameters:
university modelo fields_beca -
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
131
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Implementación del Sistema
private void setOperations(es.uniovi.innova.eadministracion.tram
ites.swu.model.University u,
java.util.Map<java.lang.String,java.lang.String> operations)
Guarda las operaciones recogidas previamente en el formulario
Parameters:
university operations - Map con las operaciones recogidas
private void setSolicitante(java.util.Map<java.lang.String,java.
lang.String> fields,
es.uniovi.innova.eadministracion.tramites.swu.model.University u
,
java.lang.String modelo)
Guarda un Solicitante recogido previamente en el formulario
Parameters:
fields - map con los campos del solicitante
university modelo private java.lang.String[] split(java.lang.String key)
Obtiene los campos de un match compuesto
Parameters:
key - match
Returns:
un Array con los matches
7.4.2.2
Modelo
7.4.2.2.1 Beca
public class Beca
extends java.lang.Object
Modelo que representa una Beca
Author:
danielmf
132
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Implementación del Sistema | Plataforma para Interoperabilidad de sistemas de información
dentro de un mismo ámbito organizativo
Fields:
private String asunto_convocatoria
private Double cuantia_otorgada
private String curso_academico
private String destino
private String estado_solicitud
private String nombre_procedimiento_convocatoria
private Solicitante solicitante
7.4.2.2.2 Solicitante
public class Solicitante
extends java.lang.Object
Author:
danielmf
Fields:
private String apellido1_solicitante
private String apellido2_solicitante
private String documento_identificativo
private String estudios
private Integer fecha_nacimiento
private String nacionalidad
private String nombre_solicitante
private String sexo
private String tipo_documento_identificativo
7.4.2.2.3 University
@Entity
public class University
extends java.lang.Object
JavaBean que modela los datos recopilados de una Universidad
Author:
danielmf
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
133
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Implementación del Sistema
Fields:
private Long id
private Set<ModelWrapper> modelsWrapper
private String name
private Set<OperationWrapper> operationsWrapper
private String personInCharge
private String wsdl
7.4.2.2.4 Vicerrectorado
public class Vicerrectorado
extends java.lang.Object
Modelo que representa un Vicerrectorado
Author:
danielmf
Fields:
private Long id
private String nombre
private String responsible
7.4.2.2.5 Constants
public class Constants
extends java.lang.Object
Clase que define constantes que se utilizan a lo largo de la aplicación
Author:
Danielmf
134
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Implementación del Sistema | Plataforma para Interoperabilidad de sistemas de información
dentro de un mismo ámbito organizativo
Fields:
static String[] BECA
static String
INDEX
static String
MATCH
static String
MATCH_OPERATION_ALUMNO
static String
MATCH_OPERATION_CURSO
static String
MATCH_OPERATION_VICERRECTORADO
static String[] MODEL
static String
MODELCLASS
static String
NOSQL
static String[] OPS
static String[] SOLICITANTE
7.4.2.2.6 BecaWrapper
public class BecaWrapper
extends java.lang.Object
Envoltorio para utilizar Beca sin necesidad de utilizar sus agregados
Author:
danielmf
Fields:
private String asunto_convocatoria
private String cuantia_otorgada
private String curso_academico
private String destino
private String estado_solicitud
private String nombre_procedimiento_convocatoria
7.4.2.2.7 ModelWrapper
@Entity
public class ModelWrapper
extends java.lang.Object
Envoltorio para recoger los campos entre el modelo genérico y una University
Author:
danielmf
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
135
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Implementación del Sistema
Fields:
private String clazz
private String concrete
private String join
private String match
private String modelClazz
private University university
7.4.2.2.8 OperationWrapper
@Entity
public class OperationWrapper
extends java.lang.Object
Modela una relación entre las operaciones de un wsdl y una University
Author:
danielmf
Fields:
private String match
private String op
private University
university
7.4.2.2.9 OperationWrapperDocument
public class OperationWrapperDocument
extends java.lang.Object
Envoltorio para las Operaciones de los servicios web
Author:
danielmf
Fields:
private String id
private String match
private String op
private Integer university
private String university_name
136
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Implementación del Sistema | Plataforma para Interoperabilidad de sistemas de información
dentro de un mismo ámbito organizativo
7.4.2.2.10
ParamsWrapper
public class ParamsWrapper
extends java.lang.Object
Envoltorio que almacena el tipo de argumentos que recibe un método y el tipo del
retorno
Author:
danielmf
Fields:
private List<java.lang.String> fields
private String return_
7.4.2.2.11
SolicitanteWrapper
public class SolicitanteWrapper
extends java.lang.Object
Envoltorio para un Solicitante
Author:
Danielmf
Fields:
private String apellido1_solicitante
private String apellido2_solicitante
private String documento_identificativo
private String estudios
private String fecha_nacimiento
private String nacionalidad
private String nombre_solicitante
private String sexo
private String tipo_documento_identificativo
7.4.2.2.12
HashDataService
public interface HashDataService
Fachada que define las operaciones de la capa de persistencia relativa a la base de
datos NoSQL.
Author:
Danielmf
Operations:
void init()
Carga el modelo inicial (solo se ejecuta una vez)
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
137
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Implementación del Sistema
ModelWrapper queryModel(java.lang.String field,
java.lang.String modelClazz)
Busca matches previos relativos a ModelWrapper
Parameters:
field modelClazz Returns:
null o el match
OperationWrapper queryOps(OperationWrapper operationWrapper)
Busca matches previos relativos a OperationWrapper
Parameters:
operationWrapper Returns:
null o el match
void save(ModelWrapper modelWrapper)
Guarda en la base de datos NoSQL un match con el modelo
Parameters:
modelWrapper void save(OperationWrapper operationWrapper)
Guarda en la base de datos NoSQL un match con una operación
Parameters:
operationWrapper -
7.4.2.2.13
ModelWrapperDataService
@Named
public interface ModelWrapperDataService
extends
org.springframework.data.repository.CrudRepository<ModelWrapper,
ModelWrapperKey>
Capa
de
persistencia
que
encapsula
las
operaciones
de ModelWrapper mediante CrudRepository
Author:
Danielmf
138
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Implementación del Sistema | Plataforma para Interoperabilidad de sistemas de información
dentro de un mismo ámbito organizativo
Operations:
@Query(name="ModelWrapper.findByUniversityClazz")
java.util.List<ModelWrapper> findByUniversityClazz(University un
iversity, java.lang.String clazz)
7.4.2.2.14
OperationsWrapperDataService
@Named
public interface OperationsWrapperDataService
extends
org.springframework.data.repository.CrudRepository<OperationWrap
per,OperationWrapperKey>
Capa
de
persistencia
que
encapsula
las
operaciones
de OperationWrapper mediante CrudRepository
Author:
danielmf
Operations:
java.util.List<OperationWrapper> findByMatch(java.lang.String ma
tch)
@Query(name="OperationWrapper.findByMatchAndUniversityId")
java.util.List<OperationWrapper> findByMatchAndUniversityId(java
.lang.String mode, java.lang.Long id)
java.util.List<OperationWrapper> findByUniversity(University uni
versity)
7.4.2.2.15
UniversityDataService
@Named
public interface UniversityDataService
extends
org.springframework.data.repository.CrudRepository<University,ja
va.lang.Long>
Inferface que implementa CrudRepository para gestionar las CRUD con la base de
datos del modelo University
Author:
danielmf
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
139
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Implementación del Sistema
Operations:
University findByName(java.lang.String name)
Busca universidades por nombre
Parameters:
name - para identificar la Universidad
Returns:
University findByWsdl(java.lang.String wsdl)
Busca universidades por el WSDL
Parameters:
wsdl - url donde se alojan los servicios
Returns:
7.4.2.2.16
OperationsWrapperDocumentRepository
@Named
public interface OperationsWrapperDocumentRepository
extends
org.springframework.data.solr.repository.SolrCrudRepository<Oper
ationWrapperDocument,java.lang.String>
Interface que resuelve las operaciones de Spring Data Solr para la funcionalidad del
buscador.
Author:
Danielmf
Operations:
@Query(value="op:*?0* OR match:*?0* OR university_name:*?0*")
java.util.List<OperationWrapperDocument> findByMatchOrOp(java.la
ng.String keyword)
7.4.2.2.17
Helper
public class Helper
extends java.lang.Object
Helper para cargar las configuraciones y otros métodos de utilidad
Author:
danielmf
140
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Implementación del Sistema | Plataforma para Interoperabilidad de sistemas de información
dentro de un mismo ámbito organizativo
Operations:
Public
static java.lang.String getClassName(java.lang.String classNameW
ithPackage)
Obtiene el nombre de una clase sin el paquete
Parameters:
classNameWithPackage Returns:
public
static java.lang.String getProperty(java.lang.String CONF_FILE,
java.lang.String key)
Obtiene una propiedad de un fichero de propiedades bajo una clave
Parameters:
CONF_FILE key Returns:
public
static java.lang.String retrieveCompleteName(java.lang.String cl
azzName)
Obtiene el paquete base de una clase bajo un servicio web.
Parameters:
clazzName Returns:
7.4.2.3 Publisher
7.4.2.3.1 ScholarshipManager
public class ScholarshipManager
extends java.lang.Object
Ofrece un servicio web para poder obtener becas de forma unificada
Author:
danielmf
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
141
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Implementación del Sistema
Operations:
Public List<Beca> getBecasByParam(java.lang.Object param,
java.lang.String category, java.lang.String university)
Obtiene las becas en función de unos parametros
Parameters:
param category university Returns:
Listado de becas
7.4.2.4 Recolector
7.4.2.4.1 ShowBecasByAlumno
@Named
public class ShowBecasByAlumno
extends java.lang.Object
implements Executable
Presenta las becas de la categoría de Alumno
Author:
danielmf
Fields:
private String dni
private static Logger logger
private String universidad
private WebServiceManagerService webServiceService
Operations:
public void execute()
Description copied from interface: Executable
Método para asegurar que todas las clases de la capa de presentación pertenecen al
Command
Specified by:
execute in interface Executable
142
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Implementación del Sistema | Plataforma para Interoperabilidad de sistemas de información
dentro de un mismo ámbito organizativo
7.4.2.4.2 ShowBecasByCurso
@Named
public class ShowBecasByCurso
extends java.lang.Object
implements Executable
Presenta las becas generadas por la categoría de curso
Author:
danielmf
Fields:
private int curso
private static Logger logger
private String universidad
private WebServiceManagerService webServiceService
Operations:
public void execute()
Description copied from interface: Executable
Método para asegurar que todas las clases de la capa de presentación pertenecen al
Command
Specified by:
execute in interface Executable
7.4.2.4.3 ShowBecasByVicerrectorado
@Named
public class ShowBecasByVicerrectorado
extends java.lang.Object
implements Executable
Presenta las becas generadas por la categoría Vicerrectorado.
Author:
danielmf
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
143
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Implementación del Sistema
Fields:
private static Logger logger
private String universidad
private Vicerrectorado vicerrectorado
private WebServiceManagerService webServiceService
Operations:
public void execute()
Description copied from interface: Executable
Método para asegurar que todas las clases de la capa de presentación pertenecen al
Command
Specified by:
execute in interface Executable
7.4.2.5 Registrador
7.4.2.5.1 CheckStatus
@Named
public class CheckStatus
extends java.lang.Object
implements Executable
Clase que comprueba la postcondición de la aplicación para no dejar datos
inconsistentes
Author:
danielmf
Fields:
private MatcherManagerService
private University
university
private UniversityManagerService
144
matcherService
universityService
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Implementación del Sistema | Plataforma para Interoperabilidad de sistemas de información
dentro de un mismo ámbito organizativo
Operations:
public void execute()
Description copied from interface: Executable
Método para asegurar que todas las clases de la capa de presentación pertenecen al
Command
Specified by:
execute in interface Executable
7.4.2.5.2 Builder
@Named
public class Builder
extends java.lang.Object
implements Executable
Construye los resultados después de hacerse los matches
Author:
danielmf
Fields:
private static Logger logger
private MatcherManagerService matcherService
private Map< String, Object> matches
Operations:
public void execute()
Description copied from interface: Executable
Método para asegurar que todas las clases de la capa de presentación pertenecen al
Command
Specified by:
execute in interface Executable
7.4.2.5.3 MatchFields
@Named
public class MatchFields
extends java.lang.Object
implements Executable
Desencadena el matching de campos con las técnicas de String Metrics
Author:
danielmf
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
145
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Implementación del Sistema
Fields:
private String clazz
private String field
private static Logger logger
private MatcherManagerService matcherService
private Map< String, Object> matches
private String modelClazz
private University university
Operations:
public void execute()
Description copied from interface: Executable
Método para asegurar que todas las clases de la capa de presentación pertenecen al
Command
Specified by:
execute in interface Executable
7.4.2.5.4 MatchOtherFields
@Named
public class MatchOtherFields
extends java.lang.Object
implements Executable
Termina de mapear los campos que no se emparejaron mediante StringMetrics y la
NoSQL
Author:
danielmf
Fields:
private String clazz
private String field
private Map< String, Object> matches
private String modelClazz
private University university
146
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Implementación del Sistema | Plataforma para Interoperabilidad de sistemas de información
dentro de un mismo ámbito organizativo
Operations:
public void execute()
Description copied from interface: Executable
Método para asegurar que todas las clases de la capa de presentación pertenecen al
Command
Specified by:
execute in interface Executable
7.4.2.5.5 CreateUniversity
@Named
public class CreateUniversity
extends java.lang.Object
implements Executable
Crea una universidad en la base de datos
Author:
danielmf
Fields:
private University
university
private UniversityManagerService
universityService
private WebServiceManagerService webServiceService
Operations:
public void execute()
Description copied from interface: Executable
Método para asegurar que todas las clases de la capa de presentación pertenecen al
Command
Specified by:
execute in interface Executable
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
147
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Implementación del Sistema
7.4.2.5.6 ListFields
@Named
public class ListFields
extends java.lang.Object
implements Executable
Lista los campos de una clase mediante introspección
Author:
danielmf
Fields:
private String clazzName
private List< String> fields
private WebServiceManagerService webserviceService
private String wsdl
Operations:
public void execute()
Description copied from interface: Executable
Método para asegurar que todas las clases de la capa de presentación pertenecen al
Command
Specified by:
execute in interface Executable
7.4.2.5.7 ListOperations
@Named
public class ListOperations
extends java.lang.Object
implements Executable
Obtiene las operaciones de un wsdl y descarta las no interesantes para la aplicación
Author:
Danielmf
148
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Implementación del Sistema | Plataforma para Interoperabilidad de sistemas de información
dentro de un mismo ámbito organizativo
Fields:
private String choice
private static Logger logger
private MatcherManagerService
matcherService
private String modelo
private List<OperationWrapper>
operations
private List< String> ops
private University
university
private WebServiceManagerService webserviceService
Operations:
public void execute()
Description copied from interface: Executable
Método para asegurar que todas las clases de la capa de presentación pertenecen al
Command
Specified by:
execute in interface Executable
private void lastTry(es.uniovi.innova.eadministracion.tramites.s
wu.model.wrapper.OperationWrapper o)
throws java.io.IOException
Throws:
java.io.IOException
private java.util.List<java.lang.Integer> showOps(java.util.List
<java.lang.String> ops)throws java.io.IOException
Throws:
java.io.IOException
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
149
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Implementación del Sistema
7.4.2.6 Service
7.4.2.6.1 BecaBuilder
public abstract class BecaBuilder
extends java.lang.Object
Constructor (Builder) en la jerarquía Builder, define las operaciones abstractas de
construcción que implementarán los concretos.
Author:
danielmf
7.4.2.6.2 BecaDirector
public class BecaDirector
extends java.lang.Object
Director de la jerarquía Builder en la construción de la Beca
Author:
danielmf
Fields:
private static BecaBuilder
builder
private static Logger logger
Operations:
public
static es.uniovi.innova.eadministracion.tramites.swu.model.Beca
build(java.util.List<es.uniovi.innova.eadministracion.tramites.s
wu.model.wrapper.ModelWrapper> models,
java.lang.Object beca)
Dirige las operaciones de construcción por partes
Parameters:
models - información en crudo
Returns:
Beca construida por partes
private static java.lang.Object getter(java.lang.Object beca,
es.uniovi.innova.eadministracion.tramites.swu.model.wrapper.Mode
lWrapper mw)
Obtiene matches de dentro del objeto
Parameters:
beca - sacada de la invocación del SW
mw - para hacer el emparejamiento
Returns:
el valor de la beca del emparejamiento
150
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Implementación del Sistema | Plataforma para Interoperabilidad de sistemas de información
dentro de un mismo ámbito organizativo
7.4.2.6.3 BecaDirectorForm
@Component
public class BecaDirectorForm
extends java.lang.Object
Builder para construir el modelo del formulario
Author:
Danielmf
Fields:
private ConcreteFormBecaBuilder builder
private static Logger logger
private MatcherManagerService matcherManager
Operations:
public es.uniovi.innova.eadministracion.tramites.swu.model.wrapp
er.BecaWrapper build(java.util.List<java.lang.String> fields)
Dirige las operaciones de construcción por partes
Parameters:
fields - información en crudo
Returns:
Beca construida por partes
public es.uniovi.innova.eadministracion.tramites.swu.model.wrapp
er.SolicitanteWrapper buildSol(java.util.List<java.lang.String>
fields)
7.4.2.6.4 ConcreteBecaBuilder
public class ConcreteBecaBuilder
extends BecaBuilder
Author:
Danielmf
Fields:
private Beca beca
private Solicitante
solicitante
7.4.2.6.5 ConcreteFormBecaBuilder
public class ConcreteFormBecaBuilder
extends BecaBuilder
Author:
Danielmf
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
151
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Implementación del Sistema
Fields:
private Beca beca
private Solicitante
solicitante
7.4.2.6.6 MatcherManagerService
public interface MatcherManagerService
Fachada que define las operaciones de los matchers NoSQL y StringMetrics
Author:
danielmf
Operations:
void init()
Inicializa la base de datos con los datos necesarios
java.lang.String match(java.lang.String field,java.lang.String m
odelClazz)
Busca el campo más factible de casar con el modelo externo
Parameters:
field - campo externo
Returns:
campo del modelo propio con el que casa
es.uniovi.innova.eadministracion.tramites.swu.model.wrapper.Mode
lWrapper save(es.uniovi.innova.eadministracion.tramites.swu.mode
l.wrapper.ModelWrapper modelWrapper)
Guarda en la base de datos la relación para un campo
Parameters:
modelWrapper Returns:
modelWrapper con id
es.uniovi.innova.eadministracion.tramites.swu.model.wrapper.Oper
ationWrapper save(es.uniovi.innova.eadministracion.tramites.swu.
model.wrapper.OperationWrapper operationWrapper)
Guarda la Operacion en la base de datos
Parameters:
operationWrapper Returns:
operationWrapper con id
152
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Implementación del Sistema | Plataforma para Interoperabilidad de sistemas de información
dentro de un mismo ámbito organizativo
boolean checkStatus(es.uniovi.innova.eadministracion.tramites.sw
u.model.University university)
Comprueba si la base de datos tiene operaciones relativas a una University para
temas de consistencia
Parameters:
universidad Returns:
void delete(es.uniovi.innova.eadministracion.tramites.swu.model.
wrapper.ModelWrapper m)
Borra un match entre campos
Parameters:
mvoid delete(es.uniovi.innova.eadministracion.tramites.swu.model.
wrapper.OperationWrapper op)
Borra un match entre operaciones
Parameters:
op -
7.4.2.6.7 OperationsWrapperService
public interface OperationsWrapperService
Operaciones necesarias para Spring Data Solr y que alimentan al buscador
Author:
danielmf
Operations:
void addToIndex(es.uniovi.innova.eadministracion.tramites.swu.mo
del.wrapper.OperationWrapper operationWrapper)
Añade al indice una operación
Parameters:
operationWrapper void deleteFromIndex(es.uniovi.innova.eadministracion.tramites.s
wu.model.wrapper.OperationWrapper operationWrapper)
Borra del índice una operación
Parameters:
operationWrapper -
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
153
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Implementación del Sistema
java.util.List<es.uniovi.innova.eadministracion.tramites.swu.mod
el.wrapper.OperationWrapperDocument> search(java.lang.String key
word)
Realiza la busqueda en función de una palabra clave
Parameters:
keyword Returns:
7.4.2.6.8 SearchEngineService
public interface SearchEngineService
Fachada que define las operaciones del Servicio de Buscador
Author:
danielmf
Operations:
java.util.List<es.uniovi.innova.eadministracion.tramites.swu.mod
el.wrapper.OperationWrapper> searchOperations(java.lang.String s
earch)
Busca operaciones en la base de conocimiento y en la base de datos
Parameters:
search - servicio a buscar
Returns:
lista de operaciones y de operaciones relacionadas
es.uniovi.innova.eadministracion.tramites.swu.model.University s
earchUniversities(java.lang.String search)
Busca universidades en la base de datos
Parameters:
search - universidad a buscar
Returns:
lista de universidades relacionadas
7.4.2.6.9 UniversityManagerService
public interface UniversityManagerService
Fachada que define las operaciones del modelo de la University
Author:
danielmf
154
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Implementación del Sistema | Plataforma para Interoperabilidad de sistemas de información
dentro de un mismo ámbito organizativo
Operations:
es.uniovi.innova.eadministracion.tramites.swu.model.University s
ave(es.uniovi.innova.eadministracion.tramites.swu.model.Universi
ty university)
Almacena una University en la Base de Datos
Parameters:
university void remove(es.uniovi.innova.eadministracion.tramites.swu.model.
University university)
Borra una University de la Base de Datos
Parameters:
university es.uniovi.innova.eadministracion.tramites.swu.model.University f
indUniversity(java.lang.Long id)
Obtiene una University por ID
Parameters:
id Returns:
es.uniovi.innova.eadministracion.tramites.swu.model.University f
indUniversityByWsdl(java.lang.String wsdl)
Obtiene una University a partir de un wsdl
Parameters:
wsdl Returns:
es.uniovi.innova.eadministracion.tramites.swu.model.University f
indUniversityByName(java.lang.String name)
Obtiene una University a partir de un nombre
Parameters:
name Returns:
7.4.2.6.10
WebServiceManagerService
public interface WebServiceManagerService
Fachada que define las operaciones relativas a interoperabilidad con Servicios Web
Author:
danielmf
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
155
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Implementación del Sistema
Operations:
java.util.List<java.lang.String> getOperations(java.lang.String
wsdl)
Obtiene las operaciones de un Servicio Web
Parameters:
wsdl Returns:
Listado de operaciones
java.lang.Object connect(java.lang.String wsdl,
java.lang.String method,
java.lang.Object[] args,
java.lang.ClassLoader classLoader)
throws java.lang.Exception
Realiza una inovcación genérica a un método definido en un WSDL.
Parameters:
wsdl method args - array de objects
classLoader Returns:
Throws:
java.lang.Exception
es.uniovi.innova.eadministracion.tramites.swu.model.wrapper.Para
msWrapper getOperationIOs(java.lang.String wsdl,
java.lang.String clazzName)
throws java.lang.ClassNotFoundException
Obtiene los parámetros de una clase (argumentos de entrada de un método del WSDL
y el retorno).
Parameters:
wsdl clazzName - completo con el paquete
Returns:
ParamsWrapper envoltorio con los parámetros
Throws:
java.lang.ClassNotFoundException
156
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Implementación del Sistema | Plataforma para Interoperabilidad de sistemas de información
dentro de un mismo ámbito organizativo
java.util.List<java.lang.String> getClassFields(java.lang.String
clazzName,
java.lang.String wsdl)
Obtiene los atributos de una clase dada
Parameters:
clazzName Returns:
Listado de strings con los atributos
java.util.List<es.uniovi.innova.eadministracion.tramites.swu.mod
el.Beca> getBecasByParam(java.lang.Object param,
java.lang.String mode)
Invoca a los métodos de los Servicios Web recopilados en el recolector según el tipo
de método
Parameters:
param - Parámetro que se pasa al método del Servicio Web
mode - tipo de método
Returns:
Listado de Beca recopiladas
java.util.List<es.uniovi.innova.eadministracion.tramites.swu.mod
el.Beca> getBecasByParam(java.lang.Object param,java.lang.String
mode,java.lang.String university)
Invoca a lso métodos de los Servicios Web recopilados en el recolector según el tipo
de método y la universidad
Parameters:
param - Parámetro que se pasa al método del Servicio Web
mode - Tipo de método
university - Nombre de la universidad
Returns:
Listado de Beca recopiladas
7.4.2.6.11
GenericException
public class GenericException
extends java.lang.RuntimeException
Excepción genérica para recogerla en las vistas del sitio web y mostrar mensajes
personalizados de error
Author: danielmf
Fields:
protected String msg
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
157
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Desarrollo de las Pruebas
Capítulo 8.
Desarrollo de las Pruebas
8.1 Pruebas Unitarias
Si se quiere comprobar esto, se puede realizar ejecutando las pruebas con la herramienta JUnit
y para hacerlo de forma más sencilla, se ha realizado una Suite que facilita el trabajo de
comprobación de los tests.
Ilustración 73. Test. Resultados del procesamiento de Tests
158
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Desarrollo de las Pruebas | Plataforma para Interoperabilidad de sistemas de información
dentro de un mismo ámbito organizativo
8.2 Pruebas de Integración y del Sistema
Para comprobar las pruebas de integración y de sistema, en este proyecto se ha comprobado
que todo funcionara de forma correcta.
Las pruebas unitarias son ya una prueba de integración y del sistema puesto que en ellas se
interconectan todos los componentes y en mayor o menor medida las pruebas utilizan varios
componentes que están interconectados entre sí.
Además se ha comprobado por otra parte, el gasto en memoria que supone tener el sistema
corriendo dentro de un solo ordenador.
RAM: 1.2 GB + 570 MB + 223 MB + 158 MB = 2.2 GB aprox.
Como se puede comprobar la aplicación es bastante pesada, aunque si se tiene en cuenta que
los 1.2 GB del inicio son de SpringToolSuite y del Apache Tomcat que alberga las aplicaciones
del buscador y del publicador con los servicios web disponibles.
Los 570 MB son destinados a un segundo servidor de aplicaciones Jetty con la aplicación de
Apache Solr y los 223 MB de la base de datos NoSQL Apache Cassandra.
Finalmente los 158 MB restantes son de la aplicación ejecutándose.
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
159
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Desarrollo de las Pruebas
8.3 Pruebas de Usabilidad y Accesibilidad
8.3.1
Pruebas de Usabilidad
Debido al perfil de la aplicación, no va a ser utilizada por cualquier usuario. El usuario que
utilice esta aplicación será responsable del registro de la Universidad a la que representa con
lo que se da por supuesto que tendrá unos conocimientos informáticos avanzados.
8.3.1.1 Usuario 1
El usuario 1 es un ingeniero informático superior, con amplios conocimientos informáticos y
que tiene a cargo un equipo de desarrolladores en el servicio de informática de su Universidad.
Además está acostumbrado a trabajar con arquitecturas orientadas a servicio con lo que sus
conocimientos en servicios web son amplios.
¿Usa un ordenador frecuentemente?
Todos los días
¿Qué tipo de actividades realiza con el ordenador?
Es parte de mi trabajo o profesión
¿Ha usado alguna vez software como el de esta prueba?
No, nunca
¿Qué busca principalmente en un programa?
Que tenga todas las funciones necesarias
¿Qué tipo de programas suele utilizar en el ordenador?
Otros
¿Está acostumbrado a navegar por internet con el teléfono móvil?
Sí
¿Posee conocimientos de programación?
1. Sí
Facilidad de Uso
Siempre
¿Sabe dónde está dentro de la
aplicación?
¿Existe ayuda para las funciones
en caso de que tenga dudas?
¿Le resulta sencillo el uso de la X
aplicación?
160
Frecuentemente
X
Ocasionalmente
Nunca
X
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Desarrollo de las Pruebas | Plataforma para Interoperabilidad de sistemas de información
dentro de un mismo ámbito organizativo
Funcionalidad
Siempre Frecuentemente Ocasionalmente Nunca
¿Funciona cada tarea como usted X
espera?
¿El tiempo de respuesta de la
X
aplicación es muy grande?
¿Han sido útiles los mensajes de X
error?
¿Han sido útiles los indicadores?
X
¿Ha sido útil la ayuda?
X
Calidad del Interfaz
Muy
Poco
Nada
Aspectos gráficos
Adecuado
Adecuado
Adecuado
Adecuado
El tipo y tamaño de letra es
X
Los iconos e imágenes usados son
X
Los colores empleados son
X
Diseño de la Interfaz
Si
No
A veces
¿Le resulta fácil de usar?
X
¿El diseño de las pantallas es claro y X
atractivo?
¿Cree que el programa está bien X
estructurado?
¿Se ha adaptado el diseño adecuadamente a X
su dispositivo?
Observaciones
La aplicación web es simple e intuitiva.
Ilustración 74. Pruebas. Cuestionario Usuario 1
8.3.1.2 Usuario 2
El segundo usuario que se puso a disposición de cubrir el test es una egregada en informática
del Software de 23 años que todavía no tiene el grado terminado. Nunca ha trabajado con
servicios web, tan sólo los ha visto a nivel académico. El entorno laboral lo conoce sólo a través
de una beca que está disfrutando en estos momentos en la Universidad, pero ha sido
designada para realizar la tarea.
¿Usa un ordenador frecuentemente?
Todos los días
¿Qué tipo de actividades realiza con el ordenador?
Es parte de mi trabajo o profesión
¿Ha usado alguna vez software como el de esta prueba?
No, nunca
¿Qué busca principalmente en un programa?
Que sea intuitivo
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
161
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Desarrollo de las Pruebas
¿Qué tipo de programas suele utilizar en el ordenador?
Otros
¿Está acostumbrado a navegar por internet con el teléfono móvil?
Sí
¿Posee conocimientos de programación?
Sí
Ilustración 75. Pruebas. Cuestionario Usuario 2
Facilidad de Uso
Siempre Frecuentemente
¿Sabe dónde está dentro de la
X
aplicación?
¿Existe ayuda para las funciones
X
en caso de que tenga dudas?
¿Le resulta sencillo el uso de la
X
aplicación?
Funcionalidad
Siempre Frecuentemente
¿Funciona cada tarea como usted
X
espera?
¿El tiempo de respuesta de la
aplicación es muy grande?
¿Han sido útiles los mensajes de X
error?
¿Han sido útiles los indicadores?
X
¿Ha sido útil la ayuda?
X
Calidad del Interfaz
Muy
Aspectos gráficos
Adecuado
Adecuado
El tipo y tamaño de letra es
X
Los iconos e imágenes usados son
X
Los colores empleados son
X
Diseño de la Interfaz
Si
¿Le resulta fácil de usar?
X
¿El diseño de las pantallas es claro y X
atractivo?
¿Cree que el programa está bien X
estructurado?
¿Se ha adaptado el diseño adecuadamente a X
su dispositivo?
Observaciones
Nada que añadir.
162
Ocasionalmente
Nunca
Ocasionalmente
Nunca
X
Poco
Adecuado
Nada
Adecuado
No
A veces
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Desarrollo de las Pruebas | Plataforma para Interoperabilidad de sistemas de información
dentro de un mismo ámbito organizativo
8.3.1.3 Responsable de Calidad
8.3.1.3.1 Usuario 1
Aspecto Observado
El usuario comienza a trabajar de
forma rápida por las tareas
Tiempo en realizar cada tarea
Errores leves cometidos
Notas
Sin ningún problema. Ha registrado el servicio web sin
problemas y no ha necesitado ayuda en ningún momento.
Menos de 5 minutos.
Intentar introducir el nombre del paquete en el modelo a
registrar.
Errores graves cometidos
Ninguno
El usuario ha preguntado
Nada
Ilustración 76. Pruebas. Cuestionario Responsable Calidad
8.3.1.3.2 Usuario 2
Aspecto Observado
El usuario comienza a trabajar de
forma rápida por las tareas
Tiempo en realizar cada tarea
Errores leves cometidos
Errores graves cometidos
Notas
Al principio se le vio dubitativa, no enfocaba bien las
tareas.
Más de 5 minutos
Ninguno
No introducir de forma correcta la dirección del WSDL,
pues introdujo la dirección del Servicio en lugar del
fichero.
El usuario ha preguntado
Frecuentemente, no parecía saber qué estaba haciendo o
no tener los conocimientos necesarios.
Ilustración 77. Pruebas. Cuestionario Responsable Calidad 2
8.3.2
Pruebas de Accesibilidad (WCAG 2.0)
8.3.2.1 Nivel A
WCAG
2.0
1.1.1
1.2.1
1.2.2
1.2.3
1.3.1
1.3.2
1.3.3
Titulo
Contenido no textual
Solo audio y solo
vídeo (grabado)
Subtítulos
(grabados)
Audiodescripción o
medio
alternativo
(grabado)
Información
y
relaciones
Secuencia
significativa
Características
sensoriales
Comentarios
Si
No
N/A
X
X
X
X
X
X
X
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
163
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Desarrollo de las Pruebas
WCAG
2.0
1.4.1
Titulo
1.4.2
Control del audio
X
2.1.1
Teclado
X
2.1.2
Sin trampas para el
foco del teclado
Tiempo ajustable
2.2.1
2.2.2
Comentarios
Uso del color
Si
X
X
2.4.1
2.4.2
Titulado de páginas
X
2.4.3
Orden del foco
X
2.4.4
Propósito de los
X
enlaces
(en
contexto)
Idioma de la página
Está internacionalizada pero cuando
cambia el idioma, el <html lang>
siempre es el mismo.
3.1.1
X
X
X
3.2.1
Al recibir el foco
X
3.2.2
Al recibir entradas
X
3.3.1
Identificación
errores
Etiquetas
instrucciones
Procesamiento
3.3.2
4.1.1
4.1.2
Nombre,
valor
N/A
X
Poner en pausa,
detener, ocultar
Umbral de tres
destellos o menos
Evitar bloques
No se aplica el saltado de contenido.
2.3.1
No
de Mediante mensajes de alerta
o
X
X
X
X
función,
X
Ilustración 78. Nivel A Accesibilidad
164
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Desarrollo de las Pruebas | Plataforma para Interoperabilidad de sistemas de información
dentro de un mismo ámbito organizativo
8.3.2.2 Nivel AA
WCAG
2.0
1.2.4
Titulo
Comentarios
Si
1.4.5
Sub
títulos
(en
directo)
Audiodescripción
(grabado)
Contraste (mínimo)
Cambio de tamaño
del texto
Imágenes de texto
2.4.5
Múltiples vías
2.4.6
2.4.7
Encabezados
etiquetas
Foco visible
3.1.2
Idioma de las partes
3.2.3
Navegación
X
coherente
Identificación
X
coherente
Sugerencias
ante
X
errores
Prevención
de Se debe introducir un apartado de
errores
(legales, Accesibilidad.
financieros, datos)
Ilustración 79. Nivel AA Acesibilidad
1.2.5
1.4.3
1.4.4
3.2.4
3.3.3
3.3.4
No
N/A
X
X
X
X
X
Se puede tener en cuenta la página de X
información como un Mapa Web.
y
X
X
X
X
8.3.2.3 Nivel AAA
WCAG
2.0
1.2.6
1.2.7
1.2.8
1.2.9
1.4.6
1.4.7
1.4.8
Titulo
Comentarios
Lengua de señas
(grabado)
Audiodescripción
ampliada (grabada)
Medio
alternativo
(grabado)
Solo
audio
(en
directo)
Contraste
No cumple el ratio exigido.
(mejorado)
Sonido de fondo bajo
o ausente
Presentación visual
Si
No
N/A
X
X
X
X
X
X
X
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
165
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Desarrollo de las Pruebas
WCAG
2.0
Titulo
1.4.9
2.2.3
Imágenes de texto
(sin excepciones)
Teclado
(sin
excepciones)
Sin tiempo
2.2.4
Interrupciones
X
2.2.5
Re-autentificación
X
2.3.2
Tres destellos
X
2.4.8
Ubicación
2.4.9
3.1.3
Propósito de los
enlaces
(sólo
enlaces)
Encabezados
de
sección
Palabras inusuales
3.1.4
Abreviaturas
3.1.5
Nivel de lectura
3.1.6
Pronunciación
3.2.5
Cambios a petición
3.3.5
Ayuda
3.3.6
Prevención
errores (todos)
2.1.3
2.4.10
Comentarios
Si
No
N/A
X
X
X
No existen unas migas de pan para
ubicar al usuario.
X
X
X
X
X
X
X
X
X
de
X
Ilustración 80. Nivel AAA Acesibilidad
166
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Desarrollo de las Pruebas | Plataforma para Interoperabilidad de sistemas de información
dentro de un mismo ámbito organizativo
8.4 Pruebas de Rendimiento
Las pruebas de rendimiento que se han realizado han sido básicas. Se han tomado tiempos y se
ha comprobado el consumo que tendría la aplicación (en MB descargados) por las
herramientas de desarrollador de cualquier navegador web (Mozilla Firefox o Google Chrome).
En un registro de un servicio web nuevo se realizan 99 peticiones al servidor por recursos (JS,
CSS, HTML…) con un total de 63.2 KB en 277ms. Como se puede comprobar es una aplicación
muy ligera (todos los ficheros de recursos JS están minificados con lo que su tamaño es casi
residual). El proceso de registro del servicio web tarda alrededor de 2 minutos.
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
167
Manuales del Sistema | Plataforma para Interoperabilidad de sistemas de información
dentro de un mismo ámbito organizativo
Capítulo 9. Manuales del Sistema
9.1 Manual de Instalación
Para comenzar con la instalación del sistema lo primero que hay que hacer es instalar las
herramientas de soporte que hacen falta para la aplicación.
9.1.1
PostgreSQL
Como cualquier aplicación web de hoy en día, hay que instalar un sistema gestor de bases de
datos, en esta aplicación se ha optado por utilizar PostgreSQL, pero puede ser sustituida por
cualquier otra, siendo conscientes que hay que realizar una serie de cambios en la aplicación
(fichero database.properties y persistence.xml para cambiar el driver de Postgre al utilizado,
además de IP del servidor, base de datos, nombre de usuario y contraseña).
Se puede descargar de aquí la versión que más se ajuste a nuestro sistema operativo:
http://www.enterprisedb.com/products-services-training/pgdownload#windows
Una vez instalada la base de datos, desde el gestor que incluye (seguir el wizard), hay que crear
la base de datos “universidades” y asignárselo a un usuario que crearemos (preferiblemente
distinto a postgres). No es necesario crear las tablas, pues de eso ya se encargará de hacerlo
JPA automáticamente.
9.1.2
Apache Cassandra
Una vez instalado el sistema gestor de bases de datos relacionales, hay que instalar el de la
NoSQL Clave-Valor y en este caso se ha decidido utilizar Cassandra. En este caso sí hay
dependencia de la base de datos con lo que no hay más remedio que utilizar esta.
Se
puede
descargar
la
versión
2.0.6
que
es
la
utilizada
aquí
http://www.apache.org/dyn/closer.cgi?path=/cassandra/2.0.8/apache-cassandra-2.0.8bin.tar.gz
:
Una vez descomprimido el archivo, hay que ejecutar el archivo cassandra.bat que está en la
carpeta bin del directorio descomprimido. Esto arrancará la base de datos en modo servidor y
ya estará disponible para su uso.
Cuando esté arrancada, hay que ir a la aplicación y ejecutar la clase CassandraSetUp que lo que
generará será las estructuras necesarias para soportar la aplicación en Cassandra (similar a lo
que haría JPA automáticamente).
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
169
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Manuales del Sistema
9.1.3
Apache Solr
Cuando ya tenemos la persistencia instalada, debemos descargar el servidor de búsqueda que
vamos a utilizar en la aplicación. Se puede descargar su versión 4.7.2 de aquí:
http://www.apache.org/dyn/closer.cgi/lucene/solr/4.7.2
Una vez descargada, se ha de descomprimir. Una vez descomprimida la carpeta, se ha de
navegar por el interior de la aplicación y sustituir el archivo schemas.xml (solr4.7.2/example/solr/collection1/conf/) por el que se adjunta como anexo en esta
documentación para ajustar los índices del buscador a los de la aplicación. Una vez está
sustituido el archivo, se ha de ir a solr-4.7.2/example y ejecutar java –jar start.jar para arrancar
el servidor Jetty que tiene Lucene instalado ya con las estructuras de la aplicación.
9.1.4
Apache Tomcat 7
Con toda la estructura ya en marcha, sólo queda desplegar la aplicación dentro de un
contenedor de aplicaciones. En este caso se ha elegido Apache Tomcat 7
(http://apache.rediris.es/tomcat/tomcat-7/v7.0.54/bin/apache-tomcat-7.0.54.zip) y bastará
con arrancar el archivo startup.bat para levantar el servidor. Una vez arrancado, se deberá
introducir el archivo buscador.war en la carpeta webapps del servidor además del
publisher.war para que se desplieguen.
9.1.4.1 Apache CXF
Es posible que sea necesario introducir los jars de apache CXF dentro de apache tomcat para
que se ejecuten los servicios web.
Con esto ya tendríamos nuestras aplicaciones desplegadas en el servidor local.
Si por el contrario, queremos hacerlo desde un Entorno de Desarrollo, se puede utilizar Maven
para automatizar el proceso. Con ejecutar maven clean install, se descargará todo lo necesario
(a partir del paso de Apache Solr inclusive, se tienen que hacer de todas formas) para ejecutar
la aplicación y tenerla disponible. Esto generará dos ficheros war (los antes mencionados) para
subirlos al servidor.
170
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Manuales del Sistema | Plataforma para Interoperabilidad de sistemas de información
dentro de un mismo ámbito organizativo
9.2 Manual de Ejecución
Al ser una aplicación web no es necesario un manual de ejecución puesto que se desplegará
automáticamente en el servidor, para instalarlo, sigua el manual anterior.
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
171
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Manuales del Sistema
9.3 Manual de Usuario
Una vez la aplicación ya se encuentra instalada en un servidor y desplegada, el paso a
continuación es utilizarla. Este manual servirá para introducir los conceptos más básicos a la
persona que vaya a registrar y utilizar la aplicación web.
Para
comenzar,
se
deberá
visitar
desde
el
navegador
la
dirección
http://localhost:8080/buscador (o donde se encuentre desplegada la aplicación). Lo primero
que se ve nada más entrar es la pantalla de bienvenida, que nos mostrará un buscador que
todavía no servirá de mucho, pues no hay ningún dato cargado al inicio.
Antes de utilizarlo, se deben cargar datos, con lo que para registrar la universidad se debe de
pulsar sobre sobre el menú superior en el apartado “Registrador de SW”.
Esto dirigirá al usuario a una página con un formulario dividido en 5 pasos, donde el primero
de ellos será introducir los datos de la universidad que se va a registrar (nombre, responsable y
url del servicio web).
Una vez se continúa a la siguiente pantalla, se deberá seleccionar a qué categoría pertenece
cada uno de los métodos del servicio web, y además, el nombre (solo el nombre, sin el
paquete) del modelo que incluye la beca y el solicitante.
La siguiente pantalla ya estará autorellenada, el sistema propondrá una serie de sugerencias
para el autocompletado del formulario que el usuario deberá de corregir en caso de que no
sean correctos los emparejamientos de los campos entre los propuestos y los del servicio web
que se está registrando.
Por último, habrá que repetir el paso anterior, pero esta vez con los campos del Solicitante en
lugar de la Beca. Cuando están todos los campos obligatorios cubiertos, se ha de confirmar el
registro que concluirá con una pantalla informativa del éxito del registro.
Para comprobar que el servicio se ha registrado correctamente, se puede utilizar el buscador
para encontrar lo que se acaba de registrar. El buscador se puede utilizar para encontrar
operaciones de servicios web por categoría, por nombre del servicio web, por nombre de la
universidad…
Esto resultará en un listado de resultados, que una vez seleccionado el que más satisfaga los
intereses del usuario, llevará a un detalle de la universidad, donde se mostrará la URL del
servicio web además de los métodos de la universidad por si se quieren utilizar o son de
interés.
Debido a que son temas programáticos, el uso del recolector se describirá en el manual del
programador.
172
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Manuales del Sistema | Plataforma para Interoperabilidad de sistemas de información
dentro de un mismo ámbito organizativo
9.4 Manual del Programador
Para utilizar el publicador, se ha de consumir su servicio web como si se tratara de un servicio
web común.
Este servicio web ofrece dos opciones para el método:
getBecasByParam(Object param, String category, String university).
Una es pasando la Universidad a null. De esta forma se consigue aplicar el parámetro y la
categoría seleccionada a TODOS los servicios web registrados en la aplicación. Por el contrario,
si se quere obtener los resultados de una sola universidad, se ha de pasar como parámetro el
nombre de la universidad (como viene en la página web del buscador).
Si por el contrario lo que se quiere es extender la aplicación, es probable que aunque no sea
trivial, sí que es posible cambiar el ámbito en el que está centrado. Es decir, con muy pocos
cambios se debería de poder hacer o bien parametrizable para que sirva para cualquier
dominio o bien adaptarse para utilizarse con ese fin.
Lo básico será modificar los modelos relacionados con la universidad e introducir los del nuevo
ámbito, modificar las categorías (Vicerrectorado, Alumno y Curso) y modificar los archivos web
para que la página se adapte al nuevo dominio (script.js, Controllers…).
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
173
Conclusiones y Ampliaciones | Plataforma para Interoperabilidad de sistemas de información
dentro de un mismo ámbito organizativo
Capítulo 10. Conclusiones
Ampliaciones
y
10.1 Conclusiones
Realizar un Proyecto Fin de Máster es una tarea muy dura. Si además lo compaginas con una
jornada laboral completa se hace más complicado todavía. La cantidad de tiempo que se le
puede dedicar siempre es limitada, los plazos se ajustan al límite y cualquier fallo que cometas
puede resultar en una semana de trabajo de retraso.
Si bien el enfoque que se tomó para realizar este proyecto fue realizarlo con mucho adelanto
para poder tener márgenes de tiempo holgados al final cuando se mira el trabajo realizado es
mucho pero siempre se puede mejorar o se puede tener una sensación agridulce cuando todas
esas cosas que se plantean para realizar en un inicio se tienen que cortar por falta de tiempo.
Si se ha de destacar alguna cosa buena, desde luego es la gran cantidad de tecnologías que se
han probado / utilizado en la realización de este proyecto. Algunas experimentales, otras más
consolidadas pero TODAS han sido utilizadas de forma nunca antes vistas por el autor.
Especialmente ha sido satisfactorio utilizar un motor de búsqueda como Apache Solr (Lucene)
o realizar una experiencia de usuario completamente opuesta a la que se ve en el Máster de
Ingeniería Web, es decir, de unas transiciones con recargas de páginas pesadas y poco fluidas a
unas peticiones AJAX que son transparentes para el usuario y que tan de moda está.
Las sensaciones generales de cómo se ha terminado el producto son buenas, cumple su
cometido por el que está desarrollado y servirá de base para realizar una serie de trabajos
futuros muy interesantes a nivel académico.
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
175
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Conclusiones y Ampliaciones
10.2 Ampliaciones
Si bien el sistema a la hora de realizar el emparejamiento de campos se comporta de forma
correcta, una de las posibles ampliaciones a realizar sería realizar algo más de trabajo en este
apartado. Para comenzar, se podría pensar en el emparejamiento de campos que ahora se
realiza en la aplicación de las reglas String Metrics y en los emparejamientos previos que se
han realizado.
El trabajo a realizar a partir de aquí sería pensar en el modelo en tres pasos: el primero sería el
que se está realizando tratando los nombres de campos y los otros dos serían tratar el
contenido de los campos que recibimos. A estos contenidos se les podrían aplicar sistemas de
clasificación como puede ser clustering, redes neuronales, algoritmos de los K-vecinos… y
conseguir recoger más información que ayudase al sistema que ya está construido. La última
parte sería la aplicación de reglas de decisión del tipo si cumple estas condiciones, es esta
categoría donde serían especialmente útiles patrones o expresiones regulares para
reconocerlos en los contenidos recibidos.
Otra ampliación que sería muy factible de realizar sería securizar el servicio web que se ofrece
(y la aplicación también) ya que se tratan de datos sensibles, de esta forma se debería de pedir
un usuario y una contraseña en el formulario de registro para poder autenticarse contra los
servicios web de otras universidades.
Si no se quiere realizar la securización de esa forma, se puede incluir dentro de un ESB, de esta
forma el sistema podría monitorizarse y controlar los accesos para conocer estadísiticas,
además de securizarse.
Por último, otra de las ampliaciones factibles de realizar sería la inclusión de tipos complejos a
la hora de realizar el trabajo con los servicios web pues habría que montar una estructura
excesivamente compleja pero que daría un resultado fantástico.
176
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Presupuesto | Plataforma para Interoperabilidad de sistemas de información dentro de un
mismo ámbito organizativo
Capítulo 11. Presupuesto
Concepto
Descripción
Licencias Micrososft Windows 7 Professional
Microsoft Office 2010
Enterprise Architect
Microsoft Project 2010
Java
Apache Commons
Cassandra
PostgreSQL
Ubuntu Server 12.04
Desarrollo Trabajo Previo
Componente Registrador
Componente Recolector
Componente Buscador
Componente Publicador
Entrega de aplicación
Formación Usuarios
Programadores
Administradores
Otros
Instalación
Reuniones
Precio(€)
134,00 €
379,00 €
199,00 €
1.067,00 €
- €
- €
- €
- €
- €
18.000,00 €
21.500,00 €
8.500,00 €
25.000,00 €
9.000,00 €
600,00 €
50,00 €
50,00 €
50,00 €
200,00 €
100,00 €
TOTAL (sin IVA)
TOTAL (con 21% IVA)
Tabla 20. Presupuesto. Detalle del Presupuesto
Ítem
1
2
3
4
5
6
7
8
9
10
Descripción
Programador 1
Programador 2
Programador 3
Programador 4
Analista 1
Analista 2
Tester 1
Diseñador 1
Administrador de Sistemas 1
Jefe de Proyecto 1
Cantidad
10
10
10
10
1
8
1
1
1
1
1
1
1
1
1
10
5
2
1
6
Cantidad
393
297
369
313
136
128
120
136
10
120
Precio(€)
35,00 €
35,00 €
35,00 €
35,00 €
55,00 €
55,00 €
40,00 €
30,00 €
35,00 €
74,00 €
TOTAL (sin IVA)
TOTAL (con 21% IVA)
Tabla 21. Presupuesto. Personal implicado
Subtotal(€)
1.340,00 €
3.790,00 €
1.990,00 €
10.670,00 €
- €
- €
- €
- €
- €
18.000,00 €
21.500,00 €
8.500,00 €
25.000,00 €
9.000,00 €
600,00 €
500,00 €
250,00 €
100,00 €
200,00 €
600,00 €
102.040,00 €
123.468,40 €
Subtotal(€)
13.755,00 €
10.395,00 €
12.915,00 €
10.955,00 €
7.480,00 €
7.040,00 €
4.800,00 €
4.080,00 €
350,00 €
8.880,00 €
80.650,00 €
97.586,50 €
En los presupuestos que se presentan, están desglosados los ítems genéricos del primer
presupuesto. De esta forma, se puede ver que hay dinero dedicado a licencias (algunas de las
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
177
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Presupuesto
que se incluyen son a coste cero), el precio por componente desarrollado, el dinero destinado
a formación y a otros gastos como pueden ser desplazamiento y tiempo de reuniones e
instalación del sistema. Además también se adjunta un segundo presupuesto que describe el
costo de recursos humanos dentro del proyecto, que sería aplicable como una mayor
descripción del primero.
Los gastos derivados del desarrollo como pueden ser autónomos, gastos de electricidad, de
uso de equipos y demás han sido distribuidos a lo largo de los componentes, para que de esta
forma no se tengan conceptos extraños dentro del presupuesto.
178
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Referencias Bibliográficas | Plataforma para Interoperabilidad de sistemas de información
dentro de un mismo ámbito organizativo
Capítulo 12. Referencias
Bibliográficas
12.1 Libros y Artículos
[Athena] “Advanced Technologies for Interoperability of Heterogeneous Enterprise Networks
and their Applications” – Athena.
[Cohen] “A Comparison of String Distance Metrics for Name-Matching Tasks” – William W.
Cohen et alumni.
[Heimans] “ONTOLOGY REASONING WITH LARGE DATA REPOSITORIES” – Stijn Heimans et
alumni.
[Henb] “A Database Backend for OWL” - Jorg Henb, Joachim Kleb, Stephan Grimm, Jurgen
Bock.
[LePendu] “Ontology Database: A New Method for Semantic Modeling and an Application to
Brainwave Data” - Paea LePendu, Dejing Dou, Gwen A. Frishkoff, Jiawei Rong.
[Meditskos] “Combining a DL Reasoner and a Rule Engine for Improving Entailment-based
OWL Reasoning” - Georgios Meditskos, Nick Bassiliades.
[Minerva] “Minerva: A Scalable OWL Ontology Storage and Inference System” - Jian Zhou, Li
Ma, Qiaoling Liu, Lei Zhang, Yong Yu, Yue Pan.
[Oracle] “ORACLE SPATIAL AND GRAPH RDF SEMANTIC GRAPH” – Oracle.
[Parsia] “The OWL-S Experience (are you experienced?)” - Bijan Parsia, Evren Sirin, James
Hendler.
[Srinivasan] “Adding OWL-S to UDDI, implementation and throughput” – Naveen Srinivasan,
Massimo Paolucci, Katia Sycara.
[Stanford] “Semantic Web Services” - Sheila A. McIlraith, Tran Cao Son, Honglei Zeng.
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
179
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Referencias Bibliográficas
12.2 Referencias en Internet
[BBC] “BBC World Cup 2010 dynamic semantic publishing”
http://www.bbc.co.uk/blogs/legacy/bbcinternet/2010/07/bbc_world_cup_2010_dynamic_se
m.html
[Cassandra] “Apache Cassandra Download” http://cassandra.apache.org/
[Cloud4SOA] “A Cloud interoperability framework and platform for user-centric, semantically
enhanced, service-oriented application design, deployment and distributed execution”
http://www.cloud4soa.eu/
[eGMS] “e-GMS-e-Government Metadata Standard” http://www.esd.org.uk/standards/egms/
[eGOV] “Access eGovernment An educational program” http://access-egov.info/
[EsLoMas] “Visión del W3C sobre la Web Semántica”
http://www.eslomas.com/2006/11/introduccion-web-semantica/3/
[GIC] “The Greek interoperability centre: enabling research in the interoperability domain”
http://www.istworld.org/ProjectDetails.aspx?ProjectId=bbea853dbb214d2c853e602137069fb4
[GILS] “GILS What is it? Where's it going?”
http://www.dlib.org/dlib/december96/12christian.html
[Java] “Java Development Kit 7”
http://www.oracle.com/technetwork/java/javase/downloads/jdk7-downloads-1880260.html
[Jena] “Apache Jena” http://jena.apache.org/
[KAON] “KAON, Wikipedia” http://en.wikipedia.org/wiki/KAON
[Khaos] “DBOWL: A SCALABLE OWL-DL REASONER”
http://khaos.uma.es/dbowl/html/overview.jsp
[Konstantinou]
“ONTOLOGY
AND
DATABASE
CURRENTIMPLEMENTATIONS AND FUTURE DIRECTIONS”
MAPPING:
A
SURVEY
OF
http://www.academia.edu/165762/Ontology_and_Database_Mapping_A_Survey_of_Current_
Implementations_and_Future_Directions
[LinkedData] “Linked Data - Connect Distributed Data across the Web” http://linkeddata.org/
[LinkedDataTools] “Tutorial 5: Querying Semantic Data”
http://www.linkeddatatools.com/querying-semantic-data
180
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Referencias Bibliográficas | Plataforma para Interoperabilidad de sistemas de información
dentro de un mismo ámbito organizativo
[Maven] “Apache Maven Download” http://maven.apache.org/
[MiREG] “A Framework for Management of Information Resources in E-government”
http://ieeexplore.ieee.org/xpl/login.jsp?tp=&arnumber=5592108&tag=1&url=http%3A%2F%2
Fieeexplore.ieee.org%2Fxpls%2Fabs_all.jsp%3Farnumber%3D5592108%26tag%3D1
[MisBytes] “Aplicación empresarial de Ontologías Informáticas SWWS”
http://www.misbytes.com/wp/2006/08/28/aplicacion-empresarial-de-ontologiasinformaticas-swws-1era-parte-introduccion-el-proximo-salto/
[MKBergman] “Ontology-Driven Apps Using Generic Applications”
http://www.mkbergman.com/948/ontology-driven-apps-using-generic-applications/
[MRebollo] “Servicios Web Semánticos”
http://www.slideshare.net/mrebollo/serviciosweb#btnNext
[ODP] “Ontology Design Patterns” http://ontologydesignpatterns.org/wiki/Main_Page
[OntoGOV] “Ontology enabled E-Gov Service Configuration”
http://www.istworld.org/ProjectDetails.aspx?ProjectId=f0b608ec90854d40be7eaca3abcef863
[Ontotext] “OWLIM Downloads” http://www.ontotext.com/owlim/downloads
[OWL-S] “OWL for Services” http://www.ai.sri.com/daml/services/owl-s/tools.html
[OWL-S2] “OWL-S Semantic Markup for Web Services” http://www.w3.org/Submission/OWLS/
[OWL-SKOS] “Using OWL and SKOS” http://www.w3.org/2006/07/SWD/SKOS/skos-andowl/master.html
[OWL] “Lenguaje de Ontologías Web (OWL)” http://www.w3.org/2007/09/OWL-Overviewes.html
[OWLDB] “A backend for native OWL Persistence” http://owldb.sourceforge.net/
[PAE] “Portal de Administración electronica”
http://administracionelectronica.gob.es/pae_Home?_nfpb=true&_pageLabel=P300019542127
8313231711&langPae=es#.U4n9D_m00hc
[PostgreSQL] “PostgreSQL Download” http://www.postgresql.org/
[SAKE] “SAKE: Semantic-enabled Agile Knowledge-based e-Government”
http://www.epractice.eu/en/cases/sake
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
181
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Referencias Bibliográficas
[SEEMP] “The SEEMP Approach to Semantic Interoperability for E-Employment”
http://oa.upm.es/5039/
[SemanticGOV] “SemanticGOV, Wikipedia” http://en.wikipedia.org/wiki/SemanticGov
[Simmetrics] “Simmetrics Sourceforge” http://sourceforge.net/projects/simmetrics/
[SmartGOV] “A Governmental Knowledge-based platform for public sector online services”
http://smartgov.e-gov.gr/
[Solr] “Apache Solr Download” http://lucene.apache.org/solr/downloads.html
[Spring] “Spring Framework” http://spring.io/tools/sts
[Spring2] “Spring Tool Suite Download” http://spring.io/tools/sts
[Stardog] “Stardog Documentation” http://docs.stardog.com/
[TerreGOV] “Terregov: Impact of eGovernment on Territorial Government Services"
https://www.gfi.be/hosting/gfi/website/wcmEN.nsf/pages/terregov
[Tomcat] “Apache Tomcat 7 Download” http://tomcat.apache.org/download-70.cgi
[UDEF] “Universal Data Element Framework, Wikipedia”
http://en.wikipedia.org/wiki/Universal_Data_Element_Framework
[Virtuoso] “Virtuoso Sesame Provider”
http://virtuoso.openlinksw.com/dataspace/doc/dav/wiki/Main/VirtSesame2Provider
182
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Apéndices | Plataforma para Interoperabilidad de sistemas de información dentro de un
mismo ámbito organizativo
Capítulo 13. Apéndices
13.1 Glosario y Diccionario de Datos
ABox: Conjunto de razonamiento que se basa en inferir razonamiento sobre las instancias de
una ontología.
API: Application Programming Interface, es un conjunto de clases, método e interfaces que
ofrecen una funcionalidad externa.
DDL: Data Definition Language, es el lenguaje que se utiliza en los DBMS para crear y modificar
las estructuras de las bases de datos.
DIG: Interface común que comparten los razonadores para facilitar el cambio de un razonador
por otro sin necesidad de realizar grandes modificaciones en el programa.
Eclipse: Entorno de desarrollo más utilizado por la comunidad fundamentalmente centrado en
Java y escrito en el mismo lenguaje.
Framework: Conjunto de herramientas, módulos y artefactos software que dan soporte a un
problema concreto y que permite construir software sobre él. Es común que además, el
framework sea ampliable.
IDE: Integrated Development Environment, es un entorno de desarrollo que permite al
programador escribir, compilar y ejecutar programas además de depurar los errores que
pueda tener el mismo.
Instancia: Una instancia de una clase es una concreción de un tipo. Por ejemplo, Pedro desde
un punto de vista programático podría ser una instancia de la clase Persona.
JDBC: Java Data Base Connector, es un driver basado en ODBC que permite la conexión desde
Java a una base de datos. Concretamente es una estandarización de esta conexión para
permitir el intercambio de bases de datos sin necesidad de realizar grandes cambios en la
estructura del programa.
KB: Knowledge Base, es una base de datos orientada a la gestión de unidades de
conocimiento.
KRSS: Knowledge Representation System Specification, Sistema de especificación de
representación de conocimiento, sirve para definir unidades de conocimiento.
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
183
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Apéndices
Matcher: Componente que se encarga de emparejar los campos entre una Universidad
concreta y el modelo genérico. Para realizar el emparejamiento, se utilizará primero la base de
conocimiento adquirida en los anteriores emparejamientos, pues se realimenta mediante una
base de datos NoSQL. En caso de que el match no sea válido, se pasaría a aplicar técnicas de
comparación de cadenas de texto que se denominan String Métrics, que calculan la distancia
entre dos cadenas de texto dando como resultado un valor numérico. Cuanto más grande sea
este número, mayor será la probabilidad de que se esté comparando la misma cadena de
texto. Para esta aplicación, se ha fijado un grado de compatibilidad del 70 %.
Modelo de referencia: Es un modelo propuesto por la entidad reguladora que se utilizará para
asegurar la homogeneidad en los resultados que se obtendrán en la invocación de los
diferentes SW que se han registrado previamente pues se utilizará como molde para la
traducción de los casos concretos en genéricos.
Módulo buscador: Módulo web que permite a los usuarios del sitio encontrar los diferentes
servicios registrados en el catálogo.
Módulo invocador / Recolector: Proceso que permite invocar los SW que están registrados en
el catálogo y obtener los resultados de forma homogénea, pues cada resultado de cada
método de los SW van traducidos según el Modelo genérico.
Módulo Registrador / Registrador de SW: Es un módulo web que se encarga del registro de
los Servicios Web que ofrece una Universidad concreta para añadirlos al catálogo de servicios.
Simplificándolo, se puede ver como un formulario que recoge los métodos que ofrece el WSDL,
seleccionar los más relevantes y realizar un emparejamiento de los campos del modelo que
utiliza la Universidad concreta y el modelo genérico.
NoSQL: Grupo de nuevos SGBDs que no basan su almacenamiento en un modelo relacional,
como pueden ser las orientadas a documentos, clave-valor, grafos… Es muy común que tengan
un mayor rendimiento que las antiguas relacionales además que se cree que están más
adaptados a las necesidades modernas que los registros de las relacionales.
OBDB: Ontology Based Data Bases, Igual que un RDBMs pero en lugar de orientado a modelos
relacionales lo está a ontologías.
OBO: Sirve para definir ontologías, pero orientadas a biología y genética. Son más simples de
utilizar.
ORM: Object Relational Mapper, es un conversor entre registros de la base de datos y clases
del modelo de una aplicación. De esta forma, un ORM se encarga de generar las estructuras
necesarias para replicar el modelo de la aplicación en la base de datos y de esta forma poder
persistir el estado de una instancia de una clase en registros de la base de datos pues es
habitual que un atributo de una clase esté correspondida con una columna de una tabla, y esta
misma tabla con la clase. En Java, la especificación está definida por JPA, siendo necesario
utilizar una implementación, como por ejemplo, Hibernate.
Plugin: Aplicación que permite ampliar la funcionalidad original de un producto.
184
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Apéndices | Plataforma para Interoperabilidad de sistemas de información dentro de un
mismo ámbito organizativo
RDBMs: Relational Data Base Management System, Sistema Gestor de Bases de Datos
Relacionales que permite gestionar una base de datos (conjunto de datos). Una de las más
famosas es Oracle.
Resaltado sintáctico: Capacidad casi imprescindible de cualquier buen IDE, es un soporte que
te da el editor de texto para colorear las sentencias de código en función de su categoría.
Servicio Web: Es una forma de intercambio de información entre aplicaciones que permite
hacer públicas tus aplicaciones para que cualquiera pueda conectarse a ellas mientras siga
unos protocolos establecidos. Cabe destacar que permite la interoperabilidad de sistemas
aunque estén escritos en lenguajes de programación diferentes.
SNARL: Es un sistema que permite mostrar notificaciones en el escritorio. Generalmente se
utiliza en sistemas Unix.
SOA: Service Oriented Architecture, Arquitectura que fomenta la construcción de software
mediante Servicios Web.
SOAP: Simple Object Access Protocol, es un protocolo de intercambio de datos que permite la
realización de Servicios Web.
SPARQL: SPARQL Query Language for RDF, SPARQL lenguaje de consultas para RDF es una
recomendación del W3C para la consulta de datos sobre ontologías.
Stack: Conjunto de tecnologías, servicios, herramientas, aplicaciones…
SWRL: Semantic Web Rule Language, permite definir reglas semánticas en lenguajes como
OWL mediante el lenguaje RuleML.
TBox: Conjunto de razonamiento que se basa en inferir razonamiento sobre la definición
(pertenencia a clases, por ejemplo) de una ontología.
Turtle: Es una sintaxis de RDF que permite describir documentos ontológicos RDF mediante
lenguaje natural.
W3C: World Wide Web Consorcium, empresa encargada de estandarizar y desarrollar
tecnologías Web.
WSDL: Web Service Description Language, es un lenguaje que permite definir cómo se
comporta un Servicio Web. También puede referirse a la URL donde está definido ese archivo
de forma indistinta.
XML: eXtensible Markup Language, es un formato que permite transmitir información de
modo estructurado. Su gran hándicap es la cantidad de código innecesario que se genera
entorno a los datos a transmitir.
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
185
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Apéndices
13.2 Justificación del Cambio
El motivo por el que se decidió cambiar el modelo fue en esencia, debido a que no se consiguió
elaborar un modelo semántico sobre el que realizar la aplicación, es decir, dadas las
herramientas que proporciona la construcción de ontologías, no creí que fueran suficientes
para montar un sistema semántico y similar al que ya existía. Se podría explicar de otra forma,
que con la funcionalidad que te provee OWL (tecnología definida para ontologías de obligada
utilización en la administración pública) no se ha conseguido representar el modelo que
existía, bien por desconocimiento, bien porque la tecnología no lo permite.
Además, una ontología tampoco serviría para obtener el resultado que se busca de traducir los
servicios web que ya existen en otro común, pues una ontología no te permitiría realizar
traducciones de campos de una clase, una ontología lo que te permite es hacerle preguntas en
base a las relaciones que se forman en ella. Un ejemplo perfecto de cómo funciona una
ontología sería representar un árbol genealógico, donde definirías los conceptos de padre,
hijo, tío, hermano, etc y tras realizar un árbol de una familia, podrías preguntar qué relación
existe entre Juan y Luis, a lo que te respondería que son primos, por ejemplo.
Es por ello, que decidimos cambiar el modelo en el tema funcional, manteniendo esa esencia
semántica pero desde un punto de vista más práctico, mediante el uso de diccionarios. De esta
forma, lo que hacemos es crear una base de conocimiento donde vamos recogiendo los casos
concretos de cada universidad y que pueden ser aplicados a las siguientes que se vayan a
registrar. Es decir, si la Universidad 1, dice que sus campos son ape1 y ape2 para formar
apellidos, cuando venga a registrarse la Universidad 2, y por ejemplo su campo para formar
apellidos fuera ape, nos estaría dando un matching válido o también podría ser que tuviera
ape1 y ape2 también definidos con lo que también obtendríamos el mismo resultado. Al estar
jugando con que estamos utilizando el mismo modelo pero con nombres ligeramente
distintos, la utilización de diccionarios y de las tecnologías de StringMetrics (funciones que
evalúan cuánto se parecen dos palabras) parece que son más acertadas para realizar
traducciones de unos modelos en otros.
186
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Apéndices | Plataforma para Interoperabilidad de sistemas de información dentro de un
mismo ámbito organizativo
13.3
Estado del Arte de la Web Semántica
13.3.1
Introducción
En el siguiente documento se va a recoger un estudio sobre la situación actual de la Web
Semántica. En él se tratarán términos como Ontología, qué lenguajes se pueden utilizar para
definirlas, qué herramientas son las que más repercusión están teniendo y una serie de
razonadores para ejecutar consultas sobre ontologías.
También se tratarán los Servicios Web Semánticos y en qué estado se encuentran, cómo se
definen y qué entornos de ejecución existen además de ver qué controversia existe a la hora
de utilizar una ontología cuando se tienen que crear instancias y qué bases de datos
actualmente pueden ser útiles.
Para terminar, se describirá una arquitectura que se podría seguir a la hora de implementar un
aprovechamiento semántico.
13.3.2
Ontología
Una ontología informática define de manera enriquecida y formal un modelo del dominio para
catalogar diferentes recursos Web. Esto quiere decir, que puede dar un significado semántico
compuesto por entidades (clases o conceptos) y atributos, las relaciones que existen entre
estas entidades, bien sea de modo cuantificable o categorizado así como una serie de axiomas
que permitirá obtener resultados sobre las instanciaciones de estas clases.
Debido a la obtención de este modelo enriquecido, se puede obtener una comunicación entre
sistemas más rica, permitiendo que las propias máquinas sean capaces de inferir conocimiento
sobre unos datos de forma desatendida.
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
187
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Apéndices
13.3.2.1
Lenguajes de Definición
Existen dos lenguajes de definición de ontologías que destacan sobre los demás: OWL (Web
Ontology Language) y WSMO (Web Server Modeling Ontology). Existen otros como
RDF(Resource Description FrameWork) y RDFS(RDF Schema) pero tienen un menor grado
semántico dentro de los diferentes lenguajes.
Ilustración 81. Stack de Tecnologías Semánticas
13.3.2.1.1
OWL (Web Ontology Language)
Desarrollado por el W3C y una de las más longevas. Recientemente apoyado por la
Administración Pública Española (BOE-A-2012-13501) en su Norma Técnica de
Interoperabilidad de Catálogo de Estándares, es un lenguaje de definición de ontologías que
permite definir Clases, Relaciones, Axiomas, Atributos e Instancias.
Además, existen tres grados para definir ontologías con OWL:
188
OWL Lite: Expresividad reducida y la versión más limitada de las tres.
OWL DL: Orientado al Lenguaje Descriptivo (DL), es el que exigen la mayoría de
razonadores para ejecutar sus motores de inferencia. Más enriquecido que OWL Lite,
permite añadir Reglas a la definición para aplicar inferencia en tiempo finito.
OWL Full: Está un nivel por encima de OWL DL, aumenta la expresividad del anterior
pero ya no se puede asegurar la completitud del razonamiento en tiempo finito.
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Apéndices | Plataforma para Interoperabilidad de sistemas de información dentro de un
mismo ámbito organizativo
Es posible establecer un diagrama de conjuntos entre estos lenguajes:
Ilustración 82. Niveles de OWL
13.3.2.1.2
WSMO (Web Service Modeling Ontology)
Pertenece a un conjunto de conceptos que definen una especie de framework para definir un
ciclo de vida del software completo aunque el recomendado sea OWL por su nivel de madurez.
Está constituido por WSMO (Web Service Modeling Ontology), WSML (Web Service Modeling
Language) y WSMX (Web Service Modeling eXecution environment). De esta forma, WSMO
permite definir el modelo conceptual para un Servicio Web Semántico, WSML es el propio
lenguaje en el que se desarrollará la ontología y WSMX es el entorno de ejecución en el que se
integrarán los Servicios Web Semánticos desarrollados.
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
189
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Apéndices
Al igual que OWL, WSML también presenta diferentes niveles de definición, siendo éstos:
WSML-Core: Versión básica del lenguaje de definición, permite Conceptos (clases),
relaciones binarias, instancias y relaciones jerárquicas.
WSML-DL: Versión de OWL-DL en lenguaje WSML, añade lógica descriptiva a WSMLCore.
WSML-Flight: Otra vertiente de WSML-Core, al mismo nivel de WSML-DL, permite
incluir restricciones en forma de reglas.
WSML-Rule: Incremento de WSML-Flight, además de lo anterior permite definir reglas
no seguras de completitud en tiempo finito.
WSML-Full: Aúna WSML-Rule y WSML-DL en un mismo tipo, siendo el tope jerárquico
dentro de WSML.
Ilustración 83. Niveles de WSML
13.3.2.2
Herramientas
Para la creación de ontologías y la utilización de los diferentes lenguajes, existen una serie de
herramientas específicas para cada uno de estos lenguajes. Las más destacadas pueden ser
Protégé, WSMT y WSMO Studio, la primera para OWL y las otras dos para WSMO.
13.3.2.2.1
Protégé
Desarrollado por la Universidad de Stanford, Protégé está en su versión 4.1 y permite la
creación de ontologías mediante una interfaz gráfica siendo la creación de clases y atributos un
proceso trivial. En esta versión se ha quitado funcionalidad que bajo el punto de vista del
autor, era fundamental. En la anterior versión de Protégé (3.4.8) incluía una definición de
formularios que permitía encorsetar los campos de las clases para facilitar la creación de
instancias en gran medida, además de permitir la asociación de clases a los atributos y las
relaciones en forma de operadores “OR”. Esto último es especialmente importante debido a
que si no se implementan las asociaciones mediante “OR”, las instancias que tengan esas
relaciones y esos atributos pertenecerán a todas las clases que tengan esas mismas instancias.
190
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Apéndices | Plataforma para Interoperabilidad de sistemas de información dentro de un
mismo ámbito organizativo
De esta forma, se puede tener una clase Perro que tiene un atributo nombre y una clase
Hombre que tiene el mismo atributo nombre. Cuando realizamos la asociación de los atributos
a las clases si no se utiliza “OR” impactará en la creación de una instancia Perro y una instancia
Humano, de esta forma la instancia Luis y la instancia Toby, pertenecerán a las clases Perro y
Hombre cuando sólo tendrían que pertenecer a Hombre y Perro respectivamente.
Otra de las características interesantes que incluye Protégé es la integración con diferentes
razonadores, como pueden ser Pellet y FaCT++ por defecto además de poder ser ampliados
mediante plugins.
Por estas características la versión que se recomienda óptima de utilización sería la 3.4.8 de
forma que se optimizará la creación de ontologías y sus instancias.
13.3.2.2.2
WSMT (Web Service Modeling Toolkit)
Web Service Modeling Toolkit permite desarrollar los dos conceptos que propone WSMO, la
ontología y el enriquecimiento de los Servicios Web Semánticos. Actualmente está en su
versión 2.0 y también permite la publicación de ontologías en un entorno WSMX además de
realizar consultas sobre los diferentes razonadores específicos para cada uno de los diferentes
“sabores” de WSML. Desarrollado sobre la arquitectura del IDE Eclipse, para los que estén
familiarizados con esta plataforma les puede resultar realmente sencillo crear ontologías con
esta herramienta, además de poseer un entorno gráfico de la forma que lo incluye Protégé
aunque menos vistoso y funcional, luego toda la parte de la definición es más como realizarlo
escribiendo código aunque proporcione soporte para la escritura y resaltado sintáctico como
cualquier entorno de desarrollo.
Cabe destacar que la visualización de la ontología una vez realizada por medio de diagramas de
burbujas, es mucho más clara que en Protégé pues aprovecha de mejor forma los espacios y
no realiza un gráfico atropellado como Protégé.
13.3.2.2.3
WSMO Studio
WSMO Studio pretende ser una alternativa a WSMT, de la misma forma, tiene su estructura
relacionada con Eclipse, concretamente está construido como plugins de éste, aunque también
existe la forma de encontrarlo ya integrado con Eclipse para su descarga.
Como contrapunto a WSMT, no posee razonadores para inferir conocimiento en el propio
entorno de desarrollo pero sí que tiene un entorno gráfico para construir ontologías aunque
similar al que ofrece WSMT (poco cuidado) además del propio editor de texto con resaltado
sintáctico. En el caso de las representaciones gráficas de la ontología, utiliza también el mismo
sistema que WSMT, ofreciendo un marco de trabajo más limpio que Protégé. Además tiene un
apartado de Repositorio donde permite publicar las ontologías generadas.
Para terminar, hay que destacar que es una herramienta que está en fase beta, concretamente
la 0.7.3 y data del 2008 con lo que da que pensar que está algo olvidado su desarrollo.
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
191
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Apéndices
13.3.2.3
Razonadores
En este apartado aparecerán razonadores para ambos lenguajes, de esta forma, se tratarán
Pellet y FaCT++ para OWL e IRIS para WSMO ya que otros razonadores como RACERPro son
herramientas de pago y parece que están desactualizadas (página web sin modificaciones
desde el 2009).
13.3.2.3.1
Pellet 2.3.0
Razonador sobre la capa OWL DL (permite OWL 2) escrito en Java de la empresa Clark&Parsia
bajo licencia AGPL v3 para desarrollos Open Source y bajo otras licencias no especificadas (se
entiende que comerciales) en caso de desarrollos propietarios.
Incluye soporte para consultas con SPARQL, razonamiento de tipos, soporte para reglas SWRL
además de permitir depuración de ontologías.
Existe un plugin para Protégé que integra el razonador con el IDE y nos permite realizar
consultas mediante SPARQL, inferir tipos de las clases y los atributos e inferir relaciones.
Permite razonamientos sobre ABox, TBox y sobre KB (Knowledge Base) en una ontología
completa y es especialmente interesante que esté escrito en Java, de esta forma se puede
integrar con multitud de aplicaciones programadas en este lenguaje (Jena, sobretodo).
Ilustración 84. Arquitectura Pellet
192
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Apéndices | Plataforma para Interoperabilidad de sistemas de información dentro de un
mismo ámbito organizativo
13.3.2.3.2
FaCT++ 1.6.1
Razonador escrito en C++ y de código abierto publicado bajo una licencia GNU pública
propiedad de la Universidad de Manchester, también existe en desarrollo una versión Java
denominada JFact. La última versión es la 1.6.1 del 26 de Octubre de 2012, luego se entiende
que es de las pocas herramientas que todavía están en continuo desarrollo y no abandonada
(caso de RacerPRO).
Está implementado sobre la OWL API, luego le permite interactuar con RDF, OWL, Turtle, KRSS
y OBO aunque tan solo soporta OWL 2 DL de forma parcial debido a que tiene problemas con
el soporte para ciertos tipos de datos y las claves.
Estos problemas hacen que el uso de esta herramienta sea descartado, al menos hasta que se
solventen estos problemas. Debido a la constante evolución de la herramienta, da que pensar
que se solucionará pronto.
13.3.2.3.3
IRIS (Integrated Rule Inference System)
Es un razonador escrito en Java que funciona con ontologías de tipo WSML además de con
RDFS y que permite negación de tipo well-founded, stratified y reglas no seguras. Tiene una
licencia LGPL y está financiado por SOA4ALL y European Framework 7. La última versión de
este razonador, la 0.61 es de Agosto de hace un año y no es una versión release que es la 0.60
de Febrero de 2010, con lo que se puede afirmar que el proyecto va lento pues no tiene una
versión estable lanzada, sólo betas aunque en su página web existe un apartado para realizar
una demo online donde permite la entrada de una serie de reglas y axiomas para ejecutar el
razonamiento sobre ellas.
13.3.3
Servicios Web Semánticos
Los Servicios Web Semánticos son una forma de explotar esta nueva visión de la Web
compuesta por Ontologías. Debido a su naturaleza de sistemas expuestos (o formas de
exteriorizar información) a otros sistemas, son las herramientas más indicadas para conseguir
explotar esta nueva arquitectura por buscar la inferencia de información de forma desatendida
para proporcionar esta información.
13.3.3.1
Lenguajes de Definición
Como lenguajes de definición de Servicios Web Semánticos los más utilizados y siguiendo con
los de definición de ontologías se puede hacer una conexión entre WSMO y WSML y entre
OWL y OWL-S.
En el primer caso, es el mismo lenguaje que se estaba utilizando para la creación de las
ontologías y en el segundo, lo que se hace es agregar una capa a las tecnologías existentes
(WSDL, Web Service Description Language) para permitir la compatibilidad entre OWL y los
Servicios Web.
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
193
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Apéndices
13.3.3.1.1
WSML (Web Service Modeling Language)
Es el mismo lenguaje que se utiliza para la creación de ontologías descrito anteriormente, salvo
que en esta orientación hacia los Servicios Web Semánticos, permite definir mediadores y
metas, para definir el comportamiento de los servicios web y las metas que pueda buscar el
usuario.
Ilustración 85. Enfoque de WSMO
13.3.3.1.2
OWL-S (Web Ontology Language – Services)
Como se ha comentado anteriormente, OWL-S se tiene que tomar como servicio de marcado
para los Servicios Web existentes, es más, lo que hace es enriquecer WSDL para poder dar
soporte a las Ontologías definidas con OWL.
Para lograr esto, OWL-S define tres etapas que son las del Service Profile (perfil del servicio),
Process Model (modelado del proceso) y Grounding (forma de interaccionar con la ontología).
Service Profile: Se encarga del descubrimiento y la selección de servicios.
Process Model: Ontología que se encarga de procesar las operaciones del servicio.
Grounding: Define los mensajes de interoperabilidad con otros servicios.
Ilustración 86. Enfoque de OWL-S
194
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Apéndices | Plataforma para Interoperabilidad de sistemas de información dentro de un
mismo ámbito organizativo
13.3.3.2
Entornos de Ejecución
Para conseguir ofrecer estos Servicios Web Semánticos, en el caso de OWL-S nos bastará con
un Servidor de Servicios Web común como puede ser Axis que ya se estaría utilizando para los
actuales Servicios Web, en el caso de los proporcionados por WSMO, requerirán de un entorno
de explotación concreto que viene agregado en el Stack de WSMO, el WSMX (Web Service
Modeling eXecution environment).
13.3.3.2.1
Axis
Servidor que permite desplegar Servicios Web de la fundación Apache implementando el
protocolo SOAP.
13.3.3.2.2
WSMX (Web Service Modeling eXecution environment)
Ilustración 87. Interacción con WSMX
WSMX es un entorno de ejecución que permite desplegar Servicios Web Semánticos
modelados con WSML. Este entorno se encarga de la publicación de estos servicios, además de
publicar las ontologías por separado. Para la publicación de estos servicios, internamente
también implementa un servidor Apache Axis para la publicación de Servicios Web.
Concretamente, WSMX lo que hace es permitir el descubrimiento dinámico, la mediación y la
invocación de Servicios Web. De esta forma, se encarga de utilizar los mediadores definidos
así como de definir las metas que vienen predefinidas en los archivos de WSMO seleccionando
el Servicio Web que mejor se adecúe según las necesidades de la petición.
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
195
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Apéndices
13.3.4
Almacenamiento de ontologías
Inicialmente, las ontologías fueron creadas como un modelo cerrado. Esto quiere decir que
una ontología una vez se creaba, no se modificaba posteriormente, o al menos no se pretendía
modificarla dinámicamente. Por ello, sus clases, relaciones y atributos eran definidos junto con
sus instancias y no variaban. Según en qué entornos, éste puede ser un aprovechamiento de la
tecnología muy válido y suficiente, pero si se enfoca el problema hacia el desarrollo de
aplicaciones empresariales, es necesario poder generar instancias de las clases de forma
dinámica, puesto que las propias aplicaciones empresariales generarán datos de esta forma.
Para la solución de esta controversia, existen una serie de tecnologías que pueden dar soporte
para ello.
13.3.4.1
DBOWL
Propuesto por la Universidad de Málaga, presenta una arquitectura propietaria que consta de
una RDBMS Oracle 11g para la persistencia de las instancias (ABox) que monta encima un
razonador RACER Pro. Esto implica que tanto Oracle 11g como RACER Pro son sistemas de
pago. El problema que tiene esta herramienta es que tan solo se puede interactuar con ella
mediante su web (http://khaos.uma.es/dbowl/html/overview.jsp) y se conocen sus bondades
a través de un artículo científico, con lo que no existe una forma de comprobar
fehacientemente que es una herramienta que se pueda utilizar para nuestros propósitos.
13.3.4.2
OntoDB
Para utilizar OntoDB, se debe instalar un PostgreSQL 8.2.4 (a fecha de este documento está en
la 9.2.1, puede ser un problema) y de una forma extrañamente concreta (el idioma de la
instalación por ejemplo, forzosamente debe ser el francés). Basado en la ontología de
catalogación PLIB que en los 90 fue creada para catalogar componentes industriales en
catálogos electrónicos, utiliza su propio lenguaje de consultas y de DDL, OntoQL, frente a lo
habitual, que es SPARQL.
Otro de los puntos conflictivos es que no se puede importar una ontología creada
anteriormente con un editor si no que se debe de introducir a mano mediante OntoQL, por lo
que hace excesivamente necesario el aprendizaje de este lenguaje para la utilización de la
herramienta.
196
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Apéndices | Plataforma para Interoperabilidad de sistemas de información dentro de un
mismo ámbito organizativo
13.3.4.3
DLDB-OWL
Herramienta del 2004, tan sólo se publicó esta versión 1.0. Utiliza una versión de Fact (JFact)
para realizar razonamientos. Al contrario que OntoDB, este DBMS permite la importación de la
ontología en formato OWL dentro de la base de datos, pero lo que no permite es utilizarse en
forma de servidor.
El mayor problema que presenta esta solución además de no permitir la utilización en modo
servidor, es que para persistir los datos de la ontología utiliza Microsoft Access con lo que hace
inviable su utilización en casi cualquier entorno empresarial debido a la utilización de
máquinas Unix.
13.3.4.4
IBM-SOR
Siguiendo el modelo de DBOWL, pero unos años antes, IBM también propuso un sistema
parecido, pero en este caso propone un cambio en la arquitectura que resulta muy
interesante. El mayor problema es que el artículo es de 2007 y a fecha de noviembre de 2012
no se conoce implementación de dicha herramienta.
Ilustración 88. IBM-SOR
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
197
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Apéndices
13.3.4.5
InstanceStore
Compuesta por un RDBMS y un razonador y con la premisa de utilizar el razonador única y
exclusivamente cuando sea necesario, esta solución delega todo el trabajo en la base de datos
salvo en los casos en los que la caché no pueda solventarlos que es cuando entonces ejecutará
razonamientos ABox sobre ontologías OWL.
Para cada una de las ontologías que se quieran utilizar en esta herramienta, creará una base de
datos nueva, incluso cuando sean dos esquemas iguales con lo que se tendrá que tener
especial cuidado a la hora de utilizarla e intentar aunar las ontologías bajo un mismo fichero.
Como característica destacable, no está ligado a ningún razonador concreto ni a ningún
RDBMS concreto. Esto es posible debido a que utiliza Java para la implementación luego
mediante JDBC permite el uso de Oracle, Hypersonic o MySQL y para la parte del razonador
una interface DIG que permite conexiones con FaCT, Racer y FaCT++.
13.3.4.6
OWLIM
Base de datos comercial implementada en Java, permite integración con Jena y con Sesame
para su utilización desde código. Existe en tres versiones (Lite, SE y Enterprise) siendo la
versión a utilizar en entornos empresariales la SE o si se necesita de escalabilidad la Enterprise.
La versión Lite es gratuita, pero no es posible su utilización en entornos comerciales.
Puede que sea la más famosa, debido a ser el sistema de bases de datos que utilizó la cadena
británica BBC para introducir semántica en su página web deportiva con motivo de cubrir la
Eurocopa 2010 y los Juegos Olímpicos 2012 mediante ontologías en RDF.
13.3.4.7
Stardog
Lanzada su versión 1.1 en Noviembre del 2012, Stardog es una base de datos RDF comercial
con modo servidor, que almacena sus instancias en RDF y aplica razonamiento OWL. Tanto
OWLIM como Stardog, son alternativas comerciales a las anteriores, pero cabe destacar que
son las que parecen más profesionales.
Incluye integración con Java y con Spring para una fácil utilización de la base de datos desde
código mediante Jena, Sesame y SNARL.
198
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Apéndices | Plataforma para Interoperabilidad de sistemas de información dentro de un
mismo ámbito organizativo
13.3.5
Problemas
Como se puede comprobar en los casos expuestos, hay excesiva diversidad de
implementaciones, unas con un RDBMS como soporte, otras con un sistema propio, unas con
razonadores externos, otras con él propio, otras con almacenamiento tipo RDF(tripletas), otros
bajo un esquema ontológico... pero con un denominador común, todas están en fases iniciales.
De hecho, que Stardog y OWLIM sean las más profesionales puede ser debido única y
exclusivamente a que hayan invertido dinero y tiempo en la forma de presentación del
producto mediante la creación de sus páginas web.
Otro de los puntos que más se repiten en la mayoría de las soluciones es que vienen siendo
consecuencias de publicaciones científicas por ello muchas de ellas no superan la versión 1.0 o
ni siquiera llegan a implementarse completamente y llevan sin actualizarse desde hace más de
tres años.
Por último, la inclusión de razonador o no es fundamental, debido a que si se tiene que realizar
una transformación de la base de datos a memoria para obtener OWL y luego utilizar un
razonador externo, a parte de tener que transportar gran parte de la base de datos a memoria,
se va a tener que procesar todo en memoria con el costo de tiempo que ello conlleva. Esta
inclusión del razonador también lleva implícita la problemática de tener la capacidad o no de
realizar razonamientos sobre ABox o sólo sobre la TBox.
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
199
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Apéndices
13.3.6
Arquitectura
Bajo el punto de vista del autor, una forma factible de llevar a cabo la inclusión semántica
dentro de una arquitectura SOA podría ser la siguiente:
Ilustración 89. Arquitectura SWS
Como podemos ver, el modelo de la ontología definido irá persistido en una de las bases de
datos mencionadas en este documento, además de ir agregando instancias que se puedan
generar por medio de las aplicaciones definidoras de trámites que ya están en funcionamiento.
Por otro lado tendremos los Servicios Web Semánticos que realizarán peticiones sobre una
instanciación del framework Apache Jena que se encargará de traducir las peticiones en
razonamientos sobre la capa razonadora del OBDB y devolver los resultados al Servicio Web
que realizó la petición.
13.3.6.1
Apache Jena
Este framework escrito en Java de la Apache Foundation tiene una sección propia dentro de
este documento debido a las capacidades que ofrece a los programadores. En su sitio web se
define como “una herramienta para crear aplicaciones web semánticas” y razón no les falta.
Por un lado, nos ofrece una API para procesar y escribir RDF en XML, tripletas y otros formatos.
También nos permite gestionar mediante otro API, ontologías en OWL y RDFS. Tiene un
razonador propio y además mediante interfaces se complementa con casi todos los
razonadores del mercado que tengan una interface Java (la gran mayoría).
200
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Apéndices | Plataforma para Interoperabilidad de sistemas de información dentro de un
mismo ámbito organizativo
Otra de las versatilidades que incluye, es la capacidad de almacenar contenido mediante
tripletas RDF en disco además de aplicar razonamientos mediante SPARQL.
Como contrapunto a lo anterior, todavía no da soporte para OWL 2 pero es una de las
características a las que se le espera que de soporte pronto (está incluida en su roadmap).
Además ofrece la ampliación mediante componentes propios de Jena, como pueden ser SDB y
TDB que permite persistir ontologías, la primera apoyándose en un RDBMS común (como
Oracle o PostgreSQL, por ejemplo) y la segunda utiliza un Tuple-Store habitual. Además
permiten razonamientos sobre ellos.
Ilustración 90. Arquitectura Apache Jena
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
201
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Apéndices
13.3.7
Tecnologías y Herramientas seleccionadas
Finalmente las tecnologías que se van a utilizar, en el proyecto son las siguientes:
OWL: Esta viene impuesta por la NTICAP (Norma Técnica de Interoperabilidad de
Catálogo de estándares de la Administración Pública) publicada en el BOE A-201213501 (número 262, Miércoles 31 de Octubre de 2012, Sec. III Pág. 76723) además de
ser una tecnología más madura que WSMO y no necesitar del añadido de tener que
utilizar un entorno de ejecución a parte (WSMX) ya que OWL-S puede funcionar sobre
un Apache Tomcat.
OWL-S: Debido a que sin él no podemos utilizar Servicios Web Semánticos mediante
la creación de ontologías en OWL.
Apache Jena: Es el framework que se va a utilizar para manejar las ontologías en
memoria además de crear nuevas instancias sobre las ontologías. Como punto fuerte
además tiene que nos permite solucionar el problema de la persistencia mediante
SDB y con el motor SPARQL que incluye junto con su razonador propio.
PostgreSQL: Se utilizará este RDBMS por ser el sistema utilizado en la empresa,
realmente serviría cualquiera para complementar a SDB.
Protégé: Por ser el editor más extendido en la codificación de Ontologías (se podría
haber utilizado Java combinado con Jena, pero sería muy tedioso) y ser fácil de
utilizar, además de soportar plugins para OWL-S y permitir realizar el enriquecimiento
de la ontología mediante servicios web.
Eclipse: Entorno de desarrollo para codificar el proyecto que integrará todas las
tecnologías aquí mencionadas.
pgAdmin: Interfaz que permite conectarse y gestionar PostgreSQL de manera gráfica,
es la más utilizada.
202
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Apéndices | Plataforma para Interoperabilidad de sistemas de información dentro de un
mismo ámbito organizativo
13.3.8
Referencias de interés
[Axis]: http://axis.apache.org/axis/
[DBOWL]: http://khaos.uma.es/dbowl/
[DIG]: http://dig.sourceforge.net/
[DLDB-OWL]: http://bit.ly/Zjvy52
[Eclipse]: http://www.eclipse.org/
[FaCT++]: http://code.google.com/p/factplusplus/
[IBM-SOR]: http://bit.ly/QWwFUP
[instanceStore]: http://bit.ly/TvDMAE
[IRIS]: http://www.iris-reasoner.org/
[Jena]: http://jena.apache.org/
[OntoDB]: http://www.lias-lab.fr/forge/projects/ontodb
[OWL]: http://www.w3.org/TR/owl-features/
[OWL-S]: http://www.w3.org/Submission/OWL-S/
[OWLIM]: http://www.ontotext.com/owlim
[Pellet]: http://clarkparsia.com/pellet/
[PostgreSQL]: http://www.postgresql.org.es/
[Protégé]: http://protege.stanford.edu/
[RDF]: http://www.w3.org/RDF/
[SemanticWeb]: http://semanticweb.com/
[SPARQL]: http://www.w3.org/TR/rdf-sparql-query/
[Stardog]: http://stardog.com/
[W3C]: http://www.w3.org/
[WSMO]: http://www.wsmo.org/
[WSMO-Studio]: http://www.wsmostudio.org/
[WSMT]: http://sourceforge.net/projects/wsmt/
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
203
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Apéndices
13.4 Hoja de Decisiones del cambio
13.4.1
Servicios Web Semánticos
13.4.1.1
Diseño
Utilizar el modelo vcasem y vcatalog como referencia: Debido a que se tenía que
implementar una ontología para ofrecer servicios web semánticos que ya se estaban
ofreciendo se decidió usar el mismo modelo existente traducido a una tecnología
semántica.
Cerrar el proyecto por inviabilidad del mismo: Tras un tiempo de trabajo con la
tecnología, se desechó continuar por esta vía debido a que la capa semántica que
envolvía al modelo no aportaba la suficiente semántica para ejecutar razonamientos
sobre él.
Generación de instancias dinámicamente: Debido a la naturaleza de la aplicación, se ha
decidido generar las instancias de la ontología de forma dinámica, esto es debido a
que los servicios web crean nuevas instancias y se han de hacer semánticas también.
Para llevarlo a cabo se utilizará reflectividad.
13.4.1.2
Tecnológicas
WSML: Se decidió utilizar en un principio WSML por que parecía que era la tecnología
sobre la que apoyar los desarrollos semánticos más innovadora pues extendía una
plataforma completa sobre ella (Descubrimiento de Servicios Web, Máquina de
ejecución de Servicios Web y Herramienta de Desarrollo para esos mismos Servicios).
OWL: Tras llevar un tiempo de desarrollo con WSML, se tuvo que cambiar la tecnología
para definir la ontología con lo que hubo que migrar el trabajo hecho de WSML a OWL
teniendo que habituarse a otro entorno de desarrollo y a otro lenguaje. Este cambio es
debido a la Administración Pública Española (BOE-A-2012-13501) que en su Norma
Técnica de Interoperabilidad de Catálogo de Estándares decidió que para utilizar
ontologías, se debía utilizar OWL y para los Servicios Web Semánticos OWL-S.
Stardog: Se decidió utilizar esta base de datos en su versión de prueba para comprobar
que realmente funcionaban las bases de datos para el almacenamiento de instancias
de ontologías debido a lo poco evolucionada que está la tecnología semántica en
general.
Apache Jena: Como framework para utilizar ontologías y OWL concretamente desde
Java, se ha decidido utilizar esta herramienta puesto que es la referencia en estos
casos. Además también incluye un módulo SDB para persistir la ontología con sus
instancias en una base de datos relacional.
PostgreSQL: Se decidió utilizar PostgreSQL por ser la habitual en el C1Nn y por
necesitarse con SDB pues genera una serie de tablas para montar su estructura y
persistir la ontología.
204
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Apéndices | Plataforma para Interoperabilidad de sistemas de información dentro de un
mismo ámbito organizativo
13.4.2
Servicios Web Unificados
13.4.2.1
Diseño
Cambio de modelo, cambio de arquitectura: Al cambiar el modelo que se tenía
pensado originalmente, también se decidió un cambio de arquitectura. Ahora
tendríamos algo de este tipo:
Un módulo registrador, donde las universidades deberán registrarse junto con su WSDL.
Un módulo intermediario o recolector que recogerá los datos de todos los servicios web
registrados.
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
205
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Apéndices
Modelo Hash: Para la utilización de Cassandra, se ha de definir un modelo dentro de
los pares Clave-Valor. Este constará:
o Concrete: Será la clave de por la que indexará la NoSQL.
o Match: Campo con el que conecta del modelo genérico.
o Join: Campo con el que se juntaría para componer un campo del modelo
genérico.
o Clazz: Clase a la que pertenece (de la universidad concreta).
o ModelClazz: Clase a la que pertenece del modelo.
o Universidad: Id de la universidad a la que pertenece.
Paso de aplicación de consola desordenada a N-Capas: Para facilitar más adelante la
incorporación de nuevas funcionalidades y permitir la sustitución de unas capas por
otras. Desacoplamiento.
Colecciones: Se preguntará por el template de la colección al usuario, esto es debido a
que no puede obtenerse sin instanciar la colección debido a que CXF no especifica el
mismo. Y para ello se tendría que hacer una llamada válida al Servicio Web, tarea que
corresponde al otro módulo (intermediario, no registrador).
Cambio de utilización NoSQL: Originalmente la idea de utilizar la NoSQL era como una
gran tabla hash, pero fue degenerando al introducir JPA porque se intentó aprovechar
el mismo modelo que iba en la relacional y en la NoSQL redundando en el modelo
descrito en el punto Modelo Hash. Con el paso de las pruebas, me di cuenta de que si
utilizabas tal cual el modelo, sólo harías match con las que ya tienes dentro (que
concuerden con la universidad, clase, etc), entonces se ha cambiado el enfoque para
que tanto el StringMetrics y el CassandraMatcher hagan exactamente lo mismo: Vean
si hay una coincidencia en el nombre, no en el emparejamiento, que se hará
posteriormente.
13.4.3
Tecnológicas
Apache Lucene: Se intentó utilizar esta biblioteca para realizar el matching de campos
entre los modelos de la universidad concreta y el modelo genérico pero se descartó
debido a que está orientado a la indexación de archivos.
String Metrics: Para sustituir la utilización de Lucene, se decide utilizar SimMetrics
(conjunto de métricas que miden cuánto se parecen 2 términos) que se adapta
perfectamente a lo que necesitamos. De esta forma obtendremos matchs del tipo:
ape1 = [apellidos]. De entre todo el catálogo, utilizamos: ChapmanMatchingSoundex,
Soundex, SmithWatermanGotoh, SmithWatermanGotohWindowedAffine y
MongeElkan por ser las que nos dan los resultados ajustados a nuestras necesidades.
Elección de NoSQL: Para apoyar String Utils, se decide que hay que usar una NoSQL
como si fuera una gran tabla hash para encontrar matches al vuelo, en caso de que se
haya dado el match previamente. De entre las disponibles, se utilizará una Clave-Valor
por ser lo que necesitamos y de entre ellas Apache Cassandra.
206
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Apéndices | Plataforma para Interoperabilidad de sistemas de información dentro de un
mismo ámbito organizativo
Biblioteca de conexión Cassandra: Se barajó utilizar varias bibliotecas: Astyanax,
Firebrand y Hector. Se utiliza finalmente Hector por ser en la que se basan las otras
dos y además ser la que mejor funciona. Firebrand además era una solución similar a
Hibernate, por lo que podrían confluir demasiadas anotaciones similares y podría
terminar llevando a confusión además de que en el caso de Cassandra puede
interesarnos llevar un mayor control. Astyanax, por su parte, es una implementación
propuesta por Netflix que está en fase de desarrollo.
Generación de instancias dinámicas (2): Ahora se utilizará Apache CXF para la
instanciación momentánea de las clases de los Servicios Web pues las genera en un
classpath paralelo en memoria y facilita el trabajo a la hora de trabajar con Servicios
Web, ya que está preparado para ejecutarlos dinámicamente. De otra manera,
necesitaríamos utilizar órdenes de consola o utilizando el protocolo SOAP, usando el
XML…
Recolección de los tipos de datos: Para conocer los campos de las clases de las
universidades concretas, debemos utilizar alguna herramienta que nos permita
obtener los tipos de datos que hay en los WSDLs, bien sea mediante el XSD que
incorporan u otros métodos. Primero se intentó con WSDL4J, EasyWSDL y WODEN
pero ninguno consiguió dar los resultados esperados con lo que finalmente se utilizará
CXF combinado con reflectividad para obtener estos datos.
JPA+Hibernate+SpringData: Para la capa de persistencia se decidió cambiar la que
había con JDBC por una más moderna con JPA debido a que nos interesa trabajar
siempre con objetos, nos lo facilita enormemente JPA (se ha utilizado la
implementación de referencia, no las características propias de Hibernate) por lo que
si se decide cambiar Hibernate en el futuro, sería trivial.
Contenedor de Inyección de Dependencias: Debido a la separación de capas que se ha
comentado anteriormente, es recomendable agregar un contenedor de Inyección de
Dependencias como puede ser el framework Spring que además de resolvernos la
inyección de las instancias de las clases, también nos facilitará la vida a la hora de
utilizar los estereotipos de los Servicios, Repositorios, etc. Por otro lado también nos
ayudará con la configuración de JPA y en un futuro, también si decidimos agregar una
capa Web a la solución mediante Spring MVC.
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
207
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Apéndices
13.5 Contenido Entregado en el CD-ROM
13.5.1
Contenidos
Directorio
./ Directorio raíz del CD
./proyectos
./documentacion
./documentacion/img
./documentacion/uml
./documentación/Project
./documentación/Excel
208
Contenido
Contiene toda la estructura de directorios del
proyecto para desarrollo.
Contiene toda la documentación asociada al
proyecto. Es necesario incluir un fichero con
el documento final del proyecto (en formato
.doc o .docx de Word o bien .sxw de Open
Office, por ejemplo) además de un fichero
.PDF
Directorio que contiene las imágenes
utilizadas en la documentación. Estas
imágenes tendrán formato .png si son
capturas de pantalla, .wmf si son diagramas o
esquemas y .jpg sólo si son fotografías.
Ficheros que genera la herramienta (Rose,
ArgoUML, etc.) con la que se han generado
los diagramas UML y de entidad relación.
Ficheros de la planificación del proyecto de
Microsoft Project.
Presupuestos del proyecto.
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Apéndices | Plataforma para Interoperabilidad de sistemas de información dentro de un
mismo ámbito organizativo
13.5.2
Ficheros de Configuración
13.5.2.1
Maven
13.5.2.1.1
Define-tramites-servicios-web-unificados
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>es.uniovi.innova.tramites</groupId>
<artifactId>define-tramites-servicios-web-unificados</artifactId>
<version>1.0.1-BUILD-SNAPSHOT</version>
<packaging>pom</packaging>
<name>define-tramites-servicios-web-unificados</name>
<properties>
<java-version>1.7</java-version>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<org.springframework.version>3.2.3.RELEASE</org.springframework.version>
<org.springframework.data.version>1.3.2.RELEASE</org.springframework.data.version
>
<org.apache.cxf.version>2.7.11</org.apache.cxf.version>
<org.hibernate.version>4.1.10.Final</org.hibernate.version>
<org.hibernate.validator.version>5.0.0.Final</org.hibernate.validator.version>
<junit.version>4.11</junit.version>
<jpa.version>1.0.1.Final</jpa.version>
<org.commons.jdbcp.version>1.4</org.commons.jdbcp.version>
<org.slf4j.version>1.7.5</org.slf4j.version>
<postgresql.jdbc.version>9.1-901-1.jdbc4</postgresql.jdbc.version>
</properties>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.1</version>
<configuration>
<source>1.7</source>
<target>1.7</target>
<compilerArgument>-Xlint:all</compilerArgument>
<showWarnings>true</showWarnings>
<showDeprecation>true</showDeprecation>
</configuration>
</plugin>
</plugins>
</build>
<modules>
<module>
define-tramites-servicios-web-unificados-registrador
</module>
<module>define-tramites-servicios-web-unificados-modelo</module>
<module>define-tramites-servicios-web-unificados-buscador</module>
<module>
define-tramites-servicios-web-unificados-service
</module>
<module>define-tramites-servicios-web-unificados-recolector</module>
<module>define-tramites-servicios-web-unificados-publisher</module>
</modules>
<dependencies>
<!-- Logging -->
<dependency>
<groupId>org.slf4j</groupId>
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
209
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Apéndices
<artifactId>slf4j-log4j12</artifactId>
<version>${org.slf4j.version}</version>
<scope>compile</scope>
</dependency>
<!-- @Inject -->
<dependency>
<groupId>javax.inject</groupId>
<artifactId>javax.inject</artifactId>
<version>1</version>
</dependency>
<!-- Spring FW -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>${org.springframework.version}</version>
<exclusions>
<!-- Exclude Commons Logging in favor of SLF4j -->
<exclusion>
<groupId>commons-logging</groupId>
<artifactId>commons-logging</artifactId>
</exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-orm</artifactId>
<version>${org.springframework.version}</version>
<exclusions>
<exclusion>
<groupId>org.springframework</groupId>
<artifactId>spring-beans</artifactId>
</exclusion>
<exclusion>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
</exclusion>
</exclusions>
</dependency>
<!-- Solr -->
<dependency>
<groupId>org.springframework.data</groupId>
<artifactId>spring-data-solr</artifactId>
<version>1.0.0.RC1</version>
</dependency>
<dependency>
<groupId>org.apache.solr</groupId>
<artifactId>solr-core</artifactId>
<version>4.3.0</version>
<exclusions>
<exclusion>
<groupId>com.spatial4j</groupId>
<artifactId>spatial4j</artifactId>
</exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>commons-codec</groupId>
<artifactId>commons-codec</artifactId>
<version>1.8</version>
</dependency>
</dependencies>
<repositories>
<repository>
<id>spring-maven-milesone</id>
<url>http://repo.springsource.org/libs-milestone</url>
</repository>
</repositories>
</project>
210
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Apéndices | Plataforma para Interoperabilidad de sistemas de información dentro de un
mismo ámbito organizativo
13.5.2.1.2
Define-tramites-servicios-web-unificados-buscador
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
http://maven.apache.org/maven-v4_0_0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>es.uniovi.innova.tramites</groupId>
<artifactId>define-tramites-servicios-web-unificados</artifactId>
<version>1.0.1-BUILD-SNAPSHOT</version>
</parent>
<artifactId>define-tramites-servicios-web-unificados-buscador</artifactId>
<name>define-tramites-servicios-web-unificados-buscador</name>
<packaging>war</packaging>
<dependencies>
<!-- Spring -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>${org.springframework.version}</version>
</dependency>
<!-- Servlet -->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>servlet-api</artifactId>
<version>2.5</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>javax.servlet.jsp</groupId>
<artifactId>jsp-api</artifactId>
<version>2.1</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>jstl</artifactId>
<version>1.2</version>
</dependency>
<dependency>
<groupId>es.uniovi.innova.tramites</groupId>
<artifactId>
define-tramites-servicios-web-unificados-modelo
</artifactId>
<version>1.0.1-BUILD-SNAPSHOT</version>
</dependency>
<dependency>
<groupId>es.uniovi.innova.tramites</groupId>
<artifactId>
define-tramites-servicios-web-unificados-registrador
</artifactId>
<version>1.0.1-BUILD-SNAPSHOT</version>
</dependency>
<!-- TESTING -->
<!-- Spring Test -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>${org.springframework.version}</version>
<scope>test</scope>
</dependency>
<!-- JUnit -->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
211
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Apéndices
<version>${junit.version}</version>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<artifactId>maven-eclipse-plugin</artifactId>
<version>2.9</version>
<configuration>
<downloadSources>true</downloadSources>
<downloadJavadocs>true</downloadJavadocs>
<additionalProjectnatures>
<projectnature>org.springframework.ide.eclipse.core.springnature</projectnature>
</additionalProjectnatures>
<additionalBuildcommands>
<buildcommand>org.springframework.ide.eclipse.core.springbuilder</buildcommand>
</additionalBuildcommands>
<downloadSources>true</downloadSources>
<downloadJavadocs>true</downloadJavadocs>
</configuration>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-war-plugin</artifactId>
<version>2.3</version>
<configuration>
<warName>buscador</warName>
</configuration>
</plugin>
<plugin>
<groupId>org.codehaus.mojo</groupId>
<artifactId>exec-maven-plugin</artifactId>
<version>1.2.1</version>
<configuration>
<mainClass>org.test.int1.Main</mainClass>
</configuration>
</plugin>
</plugins>
</build>
</project>
13.5.2.1.3
Define-tramites-servicios-web-unificados-modelo
<?xml version="1.0"?>
<project
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
http://maven.apache.org/xsd/maven-4.0.0.xsd"
xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>es.uniovi.innova.tramites</groupId>
<artifactId>define-tramites-servicios-web-unificados</artifactId>
<version>1.0.1-BUILD-SNAPSHOT</version>
</parent>
<artifactId>define-tramites-servicios-web-unificados-modelo</artifactId>
<name>define-tramites-servicios-web-unificados-modelo</name>
<dependencies>
<!-- BBDD -->
<!-- Apache Cassandra Client (Hector) -->
<dependency>
<groupId>org.hectorclient</groupId>
<artifactId>hector-core</artifactId>
<version>1.1-2</version>
<exclusions>
212
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Apéndices | Plataforma para Interoperabilidad de sistemas de información dentro de un
mismo ámbito organizativo
<exclusion>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
</exclusion>
<exclusion>
<groupId>commons-pool</groupId>
<artifactId>commons-pool</artifactId>
</exclusion>
</exclusions>
</dependency>
<!-- PostgreSQL JDBC -->
<dependency>
<groupId>postgresql</groupId>
<artifactId>postgresql</artifactId>
<version>${postgresql.jdbc.version}</version>
</dependency>
<!-- JPA Hibernate -->
<dependency>
<groupId>org.hibernate.javax.persistence</groupId>
<artifactId>hibernate-jpa-2.0-api</artifactId>
<version>${jpa.version}</version>
</dependency>
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-entitymanager</artifactId>
<version>${org.hibernate.version}</version>
<scope>runtime</scope>
</dependency>
<!-- Gestor del pool -->
<dependency>
<groupId>commons-dbcp</groupId>
<artifactId>commons-dbcp</artifactId>
<version>${org.commons.jdbcp.version}</version>
</dependency>
<!-- Spring Data -->
<dependency>
<groupId>org.springframework.data</groupId>
<artifactId>spring-data-jpa</artifactId>
<version>${org.springframework.data.version}</version>
<exclusions>
<exclusion>
<groupId>org.springframework</groupId>
<artifactId>*</artifactId>
</exclusion>
<exclusion>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
</exclusion>
</exclusions>
</dependency>
</dependencies>
</project>
13.5.2.1.4
Define-tramites-servicios-web-unificados-publisher
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>es.uniovi.innova.tramites</groupId>
<artifactId>define-tramites-servicios-web-unificados</artifactId>
<version>1.0.1-BUILD-SNAPSHOT</version>
</parent>
<artifactId>define-tramites-servicios-web-unificados-publisher</artifactId>
<packaging>war</packaging>
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
213
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Apéndices
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<apache.cxf.version>2.7.11</apache.cxf.version>
</properties>
<name>publisher</name>
<dependencies>
<!-- Servlet -->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>servlet-api</artifactId>
<version>2.5</version>
<scope>provided</scope>
</dependency>
<!-- SW CXF -->
<dependency>
<groupId>org.apache.cxf</groupId>
<artifactId>cxf-rt-frontend-jaxws</artifactId>
<version>${apache.cxf.version}</version>
</dependency>
<dependency>
<groupId>org.apache.cxf</groupId>
<artifactId>cxf-rt-transports-http</artifactId>
<version>${apache.cxf.version}</version>
</dependency>
<dependency>
<groupId>org.apache.cxf</groupId>
<artifactId>cxf-rt-ws-security</artifactId>
<version>${apache.cxf.version}</version>
</dependency>
<dependency>
<groupId>org.apache.cxf</groupId>
<artifactId>cxf-rt-ws-policy</artifactId>
<version>${apache.cxf.version}</version>
</dependency>
<!-- Test -->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.11</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>${org.springframework.version}</version>
<exclusions>
<exclusion>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
</exclusion>
</exclusions>
</dependency>
<!-- Spring -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-web</artifactId>
<version>${org.springframework.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>${org.springframework.version}</version>
<exclusions>
<exclusion>
<groupId>org.springframework</groupId>
<artifactId>spring-beans</artifactId>
</exclusion>
214
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Apéndices | Plataforma para Interoperabilidad de sistemas de información dentro de un
mismo ámbito organizativo
<exclusion>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
</exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>es.uniovi.innova.tramites</groupId>
<artifactId>
define-tramites-servicios-web-unificados-modelo
</artifactId>
<version>1.0.1-BUILD-SNAPSHOT</version>
</dependency>
<dependency>
<groupId>es.uniovi.innova.tramites</groupId>
<artifactId>
define-tramites-servicios-web-unificados-service
</artifactId>
<version>1.0.1-BUILD-SNAPSHOT</version>
</dependency>
</dependencies>
<build>
<finalName>publisher</finalName>
<plugins>
<plugin>
<groupId>org.apache.cxf</groupId>
<artifactId>cxf-java2ws-plugin</artifactId>
<version>${apache.cxf.version}</version>
<executions>
<execution>
<id>generate-wsdl</id>
<phase>process-classes</phase>
<configuration>
<className>es.uniovi.innova.eadministracion.tramites.swu.service.ScholarshipServi
ce</className>
<genWsdl>true</genWsdl>
<verbose>true</verbose>
<outputFile>${basedir}/src/main/webapp/WEB-INF/wsdl/publisher.wsdl</outputFile>
</configuration>
<goals>
<goal>java2ws</goal>
</goals>
</execution>
</executions>
</plugin>
</plugins>
<pluginManagement>
<plugins>
<!--This plugin's configuration is used to store Eclipse
m2e settings
only. It has no influence on the Maven build
itself. -->
<plugin>
<groupId>org.eclipse.m2e</groupId>
<artifactId>lifecycle-mapping</artifactId>
<version>1.0.0</version>
<configuration>
<lifecycleMappingMetadata>
<pluginExecutions>
<pluginExecution>
<pluginExecutionFilter>
<groupId>
org.apache.cxf
</groupId>
<artifactId>
cxfjava2ws-plugin
</artifactId>
<versionRange>
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
215
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Apéndices
[2.7.11,)
</versionRange>
<goals>
<goal>java2ws</goal>
</goals>
</pluginExecutionFilter>
<action>
<ignore></ignore>
</action>
</pluginExecution>
</pluginExecutions>
</lifecycleMappingMetadata>
</configuration>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.1</version>
<configuration>
<source>1.7</source>
<target>1.7</target>
</configuration>
</plugin>
</plugins>
</pluginManagement>
</build>
</project>
13.5.2.1.5
Define-tramites-servicios-web-unificados-recolector
<?xml version="1.0"?>
<project
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
http://maven.apache.org/xsd/maven-4.0.0.xsd"
xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>es.uniovi.innova.tramites</groupId>
<artifactId>define-tramites-servicios-web-unificados</artifactId>
<version>1.0.1-BUILD-SNAPSHOT</version>
</parent>
<artifactId>define-tramites-servicios-web-unificados-recolector</artifactId>
<name>define-tramites-servicios-web-unificados-recolector</name>
<dependencies>
<!-- WS dependencies -->
<dependency>
<groupId>org.apache.cxf</groupId>
<artifactId>cxf-rt-frontend-jaxws</artifactId>
<version>${org.apache.cxf.version}</version>
</dependency>
<dependency>
<groupId>org.apache.cxf</groupId>
<artifactId>cxf-rt-transports-http</artifactId>
<version>${org.apache.cxf.version}</version>
</dependency>
<dependency>
<groupId>es.uniovi.innova.tramites</groupId>
<artifactId>
define-tramites-servicios-web-unificados-modelo
</artifactId>
<version>1.0.1-BUILD-SNAPSHOT</version>
</dependency>
216
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Apéndices | Plataforma para Interoperabilidad de sistemas de información dentro de un
mismo ámbito organizativo
<dependency>
<groupId>es.uniovi.innova.tramites</groupId>
<artifactId>
define-tramites-servicios-web-unificados-service
</artifactId>
<version>1.0.1-BUILD-SNAPSHOT</version>
</dependency>
<!-- TESTING -->
<!-- Spring Test -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>${org.springframework.version}</version>
<scope>test</scope>
</dependency>
<!-- JUnit -->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>${junit.version}</version>
<scope>test</scope>
</dependency>
</dependencies>
</project>
13.5.2.1.6
Define-tramites-servicios-web-unificados-registrador
<?xml version="1.0"?>
<project
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
http://maven.apache.org/xsd/maven-4.0.0.xsd"
xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>es.uniovi.innova.tramites</groupId>
<artifactId>define-tramites-servicios-web-unificados</artifactId>
<version>1.0.1-BUILD-SNAPSHOT</version>
</parent>
<artifactId>define-tramites-servicios-web-unificados-registrador</artifactId>
<name>define-tramites-servicios-web-unificados-registrador</name>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-shade-plugin</artifactId>
<version>2.1</version>
<executions>
<execution>
<phase>package</phase>
<goals>
<goal>shade</goal>
</goals>
<configuration>
<transformers>
<transformer
implementation="org.apache.maven.plugins.shade.resource.AppendingTransformer">
<resource>METAINF/spring.handlers</resource>
</transformer>
<transformer
implementation="org.apache.maven.plugins.shade.resource.AppendingTransformer">
<resource>METAINF/spring.schemas</resource>
</transformer>
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
217
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Apéndices
<transformer
implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransform
er">
<mainClass>es.uniovi.innova.eadministracion.tramites.swu.main.ProcessTest</mainCl
ass>
</transformer>
</transformers>
</configuration>
</execution>
</executions>
</plugin>
</plugins>
</build>
<dependencies>
<dependency>
<groupId>es.uniovi.innova.tramites</groupId>
<artifactId>
define-tramites-servicios-web-unificados-modelo
</artifactId>
<version>1.0.1-BUILD-SNAPSHOT</version>
</dependency>
<dependency>
<groupId>es.uniovi.innova.tramites</groupId>
<artifactId>
define-tramites-servicios-web-unificados-service
</artifactId>
<version>1.0.1-BUILD-SNAPSHOT</version>
</dependency>
<!-- TESTING -->
<!-- Spring Test -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>${org.springframework.version}</version>
<scope>test</scope>
</dependency>
<!-- JUnit -->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>${junit.version}</version>
<scope>test</scope>
</dependency>
</dependencies>
</project>
13.5.2.1.7
Define-tramites-servicios-web-unificados-service
<?xml version="1.0"?>
<project
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
http://maven.apache.org/xsd/maven-4.0.0.xsd"
xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>es.uniovi.innova.tramites</groupId>
<artifactId>define-tramites-servicios-web-unificados</artifactId>
<version>1.0.1-BUILD-SNAPSHOT</version>
</parent>
<artifactId>define-tramites-servicios-web-unificados-service</artifactId>
<name>define-tramites-servicios-web-unificados-service</name>
<url>http://maven.apache.org</url>
<properties>
218
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Apéndices | Plataforma para Interoperabilidad de sistemas de información dentro de un
mismo ámbito organizativo
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<dependencies>
<dependency>
<groupId>es.uniovi.innova.tramites</groupId>
<artifactId>
define-tramites-servicios-web-unificados-modelo
</artifactId>
<version>1.0.1-BUILD-SNAPSHOT</version>
</dependency>
<!-- WS dependencies -->
<dependency>
<groupId>org.apache.cxf</groupId>
<artifactId>cxf-rt-frontend-jaxws</artifactId>
<version>${org.apache.cxf.version}</version>
</dependency>
<dependency>
<groupId>org.apache.cxf</groupId>
<artifactId>cxf-rt-transports-http</artifactId>
<version>${org.apache.cxf.version}</version>
</dependency>
<dependency>
<groupId>uk.ac.shef.wit</groupId>
<artifactId>simmetrics</artifactId>
<version>1.6.2</version>
</dependency>
<!-- TESTING -->
<!-- Spring Test -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>${org.springframework.version}</version>
<scope>test</scope>
</dependency>
<!-- JUnit -->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>${junit.version}</version>
<scope>test</scope>
</dependency>
</dependencies>
<repositories>
<repository>
<id>simmetrics</id>
<url>http://maven.mse.jhu.edu/m2repository/</url>
</repository>
</repositories>
</project>
13.5.3
Log4j.properties
# Niveles de Log
log4j.rootLogger=TRACE, stdout
# Configuración del Appender de la consola
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Threshold=INFO
# Patrón de salida
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%-5p %-30.30c{1} %x - %m%n
# Excluyendo
log4j.logger.me.prettyprint.cassandra.connection.factory.HThriftClientFactoryImpl=WARN
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
219
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Apéndices
log4j.logger.org.hibernate=WARN
log4j.logger.org.springframework=WARN
13.5.4
Database.properties
#POSTGRESQL
jdbc = jdbc:postgresql://localhost:5432/universidades
login = univ
pass = univ
driver = org.postgresql.Driver
13.5.5
Persistence.xml
<?xml version="1.0" encoding="UTF-8"?>
<persistence xmlns="http://java.sun.com/xml/ns/persistence"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence
http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd"
version="2.0">
<persistence-unit name="swu-test-jpa">
<class>es.uniovi.innova.eadministracion.tramites.swu.model.Beca</class>
<class>es.uniovi.innova.eadministracion.tramites.swu.model.Solicitante</class>
<class>es.uniovi.innova.eadministracion.tramites.swu.model.Vicerrectorado</class>
<class>es.uniovi.innova.eadministracion.tramites.swu.model.University</class>
<class>es.uniovi.innova.eadministracion.tramites.swu.model.wrapper.ModelWrapper</
class>
<class>es.uniovi.innova.eadministracion.tramites.swu.model.wrapper.OperationWrapp
er</class>
<class>es.uniovi.innova.eadministracion.tramites.swu.model.wrapper.OperationWrapp
erDocument</class>
<properties>
<property name="hibernate.dialect"
value="org.hibernate.dialect.PostgreSQLDialect" />
<property name="hibernate.hbm2ddl.auto" value="create" />
<property name="hibernate.show_sql" value="false" />
</properties>
</persistence-unit>
</persistence>
13.5.6
Orm.xml
<?xml version="1.0" encoding="UTF-8"?>
<entity-mappings xmlns="http://java.sun.com/xml/ns/persistence/orm"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm
http://java.sun.com/xml/ns/persistence/orm_2_0.xsd"
version="2.0">
<!-- Queries -->
<named-query name="ModelWrapper.findByUniversityClazz">
<query>
select mw from ModelWrapper mw where mw.university = ?1 and mw.clazz= ?2
</query>
220
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Apéndices | Plataforma para Interoperabilidad de sistemas de información dentro de un
mismo ámbito organizativo
</named-query>
<named-query name="OperationWrapper.findByMatchAndUniversityId">
<query>
select ow from OperationWrapper ow where ow.match = ?1 and
ow.university.id = ?2
</query>
</named-query>
</entity-mappings>
13.5.7
Beans
13.5.7.1
Servlet-context.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.2.xsd">
<!-- DispatcherServlet Context: defines this servlet's request-processing
infrastructure -->
<!-- Enables the Spring MVC @Controller programming model -->
<mvc:annotation-driven />
<!-- Handles HTTP GET requests for /resources/** by efficiently serving
up static resources in the ${webappRoot}/resources directory -->
<mvc:resources location="/resources/" mapping="/resources/**" />
<mvc:resources location="/images/" mapping="/images/**" />
<mvc:resources location="/css/" mapping="/css/**" />
<mvc:resources location="/js/" mapping="/js/**" />
<mvc:resources location="/less/" mapping="/less/**" />
<mvc:resources location="/font/" mapping="/font/**" />
<!-- Resolves views selected for rendering by @Controllers to .jsp resources
in the /WEB-INF/views directory -->
<bean
class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver">
<property name="exceptionMappings">
<props>
<prop
key="es.uniovi.innova.eadministracion.tramites.swu.exception.GenericException">
GenericExceptionPage
</prop>
</props>
</property>
</bean>
<bean
class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="prefix" value="/WEB-INF/views/" />
<property name="suffix" value=".jsp" />
</bean>
<context:component-scan basepackage="es.uniovi.innova.eadministracion.tramites.swu" />
<bean
class="org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostPr
ocessor" />
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
221
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Apéndices
<bean id="localeResolver"
class="org.springframework.web.servlet.i18n.SessionLocaleResolver" />
<bean id="localeChangeInterceptor"
class="org.springframework.web.servlet.i18n.LocaleChangeInterceptor">
<property name="paramName" value="language" />
</bean>
<bean
class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandle
rMapping">
<property name="interceptors">
<list>
<ref bean="localeChangeInterceptor" />
</list>
</property>
</bean>
<bean id="messageSource"
class="org.springframework.context.support.ResourceBundleMessageSource">
<property name="basename" value="messages" />
</bean>
<import resource="persistence-beans.xml" />
</beans>
13.5.7.2
Persistence-beans.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:jpa="http://www.springframework.org/schema/data/jpa"
xmlns:solr="http://www.springframework.org/schema/data/solr"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx-3.2.xsd
http://www.springframework.org/schema/data/jpa
http://www.springframework.org/schema/data/jpa/spring-jpa.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.2.xsd
http://www.springframework.org/schema/data/solr
http://www.springframework.org/schema/data/solr/spring-solr.xsd">
<jpa:repositories
base-package="es.uniovi.innova.eadministracion.tramites.swu.persistence"
/>
<context:property-placeholder
location="/WEB-INF/spring/appServlet/database.properties" />
<context:annotation-config />
<tx:annotation-driven transaction-manager="transactionManager" />
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"
destroy-method="close">
<property name="driverClassName" value="${driver}" />
<property name="url" value="${jdbc}" />
<property name="username" value="${login}" />
<property name="password" value="${pass}" />
</bean>
<bean id="entityManagerFactory"
class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
<property name="dataSource" ref="dataSource" />
<property name="persistenceUnitName" value="swu-jpa" />
222
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Apéndices | Plataforma para Interoperabilidad de sistemas de información dentro de un
mismo ámbito organizativo
<property name="jpaVendorAdapter">
<bean
class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter" />
</property>
</bean>
<bean id="transactionManager"
class="org.springframework.orm.jpa.JpaTransactionManager">
<property name="entityManagerFactory" ref="entityManagerFactory" />
</bean>
<solr:repositories
base-package="es.uniovi.innova.eadministracion.tramites.swu.util.solr" />
<solr:solr-server id="solrServer" url="http://127.0.0.1:8983/solr/" />
<bean id="solrTemplate" class="org.springframework.data.solr.core.SolrTemplate">
<constructor-arg index="0" ref="solrServer" />
</bean>
</beans>
13.5.7.3
Spring-context.xml
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:jaxws="http://cxf.apache.org/jaxws"
xmlns:jaxb="http://java.sun.com/xml/ns/jaxb"
xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:solr="http://www.springframework.org/schema/data/solr"
xmlns:jpa="http://www.springframework.org/schema/data/jpa"
xmlns:cxf="http://cxf.apache.org/core"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.2.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx-3.2.xsd
http://cxf.apache.org/core http://cxf.apache.org/schemas/core.xsd
http://java.sun.com/xml/ns/jaxb http://java.sun.com/xml/ns/jaxb/bindingschema_2_0.xsd
http://cxf.apache.org/jaxws http://cxf.apache.org/schemas/jaxws.xsd
http://www.springframework.org/schema/data/jpa
http://www.springframework.org/schema/data/jpa/spring-jpa.xsd
http://www.springframework.org/schema/data/solr
http://www.springframework.org/schema/data/solr/spring-solr.xsd">
<import resource="classpath:META-INF/cxf/cxf.xml" />
<import resource="classpath:META-INF/cxf/cxf-extension-soap.xml" />
<import resource="classpath:META-INF/cxf/cxf-servlet.xml" />
<jaxws:endpoint id="ScholarshipServiceEndpoint"
implementor="#ScholarshipService" address="/ScholarshipService">
<jaxws:properties>
<entry key="mtom-enabled" value="true" />
</jaxws:properties>
</jaxws:endpoint>
<bean id="ScholarshipService"
class="es.uniovi.innova.eadministracion.tramites.swu.service.ScholarshipService"/>
<context:component-scan basepackage="es.uniovi.innova.eadministracion.tramites.swu" />
<jpa:repositories
base-package="es.uniovi.innova.eadministracion.tramites.swu.persistence"
/>
<context:property-placeholder location="/WEB-INF/database.properties" />
<context:annotation-config />
<tx:annotation-driven transaction-manager="transactionManager" />
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
223
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Apéndices
<bean
class="org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostPr
ocessor" />
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"
destroy-method="close">
<property name="driverClassName" value="${driver}" />
<property name="url" value="${jdbc}" />
<property name="username" value="${login}" />
<property name="password" value="${pass}" />
</bean>
<bean id="entityManagerFactory"
class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
<property name="dataSource" ref="dataSource" />
<property name="persistenceUnitName" value="swu-jpa" />
<property name="jpaVendorAdapter">
<bean
class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter" />
</property>
</bean>
<bean id="transactionManager"
class="org.springframework.orm.jpa.JpaTransactionManager">
<property name="entityManagerFactory" ref="entityManagerFactory" />
</bean>
<solr:repositories
base-package="es.uniovi.innova.eadministracion.tramites.swu.util.solr" />
<solr:solr-server id="solrServer" url="http://127.0.0.1:8983/solr/" />
<bean id="solrTemplate" class="org.springframework.data.solr.core.SolrTemplate">
<constructor-arg index="0" ref="solrServer" />
</bean>
</beans>
13.5.8
Publisher.wsdl
<?xml version="1.0" encoding="UTF-8"?>
<wsdl:definitions name="ScholarshipService"
targetNamespace="http://innova.uniovi.es/ScholarshipService"
xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/"
xmlns:tns="http://innova.uniovi.es/ScholarshipService"
xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/">
<wsdl:types>
<xs:schema xmlns:tns="http://innova.uniovi.es/ScholarshipService"
xmlns:xs="http://www.w3.org/2001/XMLSchema" elementFormDefault="unqualified"
targetNamespace="http://innova.uniovi.es/ScholarshipService" version="1.0">
<xs:element name="getBecasByParam" type="tns:getBecasByParam"/>
<xs:element name="getBecasByParamResponse" type="tns:getBecasByParamResponse"/>
<xs:complexType name="getBecasByParam">
<xs:sequence>
<xs:element minOccurs="0" name="arg0" type="xs:anyType"/>
<xs:element minOccurs="0" name="arg1" type="xs:string"/>
<xs:element minOccurs="0" name="arg2" type="xs:string"/>
</xs:sequence>
</xs:complexType>
<xs:complexType name="getBecasByParamResponse">
<xs:sequence>
<xs:element maxOccurs="unbounded" minOccurs="0" name="return" type="tns:beca"/>
</xs:sequence>
</xs:complexType>
<xs:complexType name="beca">
<xs:sequence>
224
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Apéndices | Plataforma para Interoperabilidad de sistemas de información dentro de un
mismo ámbito organizativo
<xs:element minOccurs="0"
<xs:element minOccurs="0"
<xs:element minOccurs="0"
<xs:element minOccurs="0"
<xs:element minOccurs="0"
<xs:element minOccurs="0"
type="xs:string"/>
<xs:element minOccurs="0"
</xs:sequence>
</xs:complexType>
name="asunto_convocatoria" type="xs:string"/>
name="cuantia_otorgada" type="xs:double"/>
name="curso_academico" type="xs:string"/>
name="destino" type="xs:string"/>
name="estado_solicitud" type="xs:string"/>
name="nombre_procedimiento_convocatoria"
name="solicitante" type="tns:solicitante"/>
<xs:complexType name="solicitante">
<xs:sequence>
<xs:element minOccurs="0" name="apellido1_solicitante" type="xs:string"/>
<xs:element minOccurs="0" name="apellido2_solicitante" type="xs:string"/>
<xs:element minOccurs="0" name="documento_identificativo" type="xs:string"/>
<xs:element minOccurs="0" name="estudios" type="xs:string"/>
<xs:element minOccurs="0" name="fecha_nacimiento" type="xs:int"/>
<xs:element minOccurs="0" name="nacionalidad" type="xs:string"/>
<xs:element minOccurs="0" name="nombre_solicitante" type="xs:string"/>
<xs:element minOccurs="0" name="sexo" type="xs:string"/>
<xs:element minOccurs="0" name="tipo_documento_identificativo" type="xs:string"/>
</xs:sequence>
</xs:complexType>
</xs:schema>
</wsdl:types>
<wsdl:message name="getBecasByParam">
<wsdl:part name="parameters" element="tns:getBecasByParam">
</wsdl:part>
</wsdl:message>
<wsdl:message name="getBecasByParamResponse">
<wsdl:part name="parameters" element="tns:getBecasByParamResponse">
</wsdl:part>
</wsdl:message>
<wsdl:portType name="ScholarshipService">
<wsdl:operation name="getBecasByParam">
<wsdl:input name="getBecasByParam" message="tns:getBecasByParam">
</wsdl:input>
<wsdl:output name="getBecasByParamResponse" message="tns:getBecasByParamResponse">
</wsdl:output>
</wsdl:operation>
</wsdl:portType>
<wsdl:binding name="ScholarshipServiceSoapBinding" type="tns:ScholarshipService">
<soap:binding style="document" transport="http://schemas.xmlsoap.org/soap/http"/>
<wsdl:operation name="getBecasByParam">
<soap:operation soapAction="" style="document"/>
<wsdl:input name="getBecasByParam">
<soap:body use="literal"/>
</wsdl:input>
<wsdl:output name="getBecasByParamResponse">
<soap:body use="literal"/>
</wsdl:output>
</wsdl:operation>
</wsdl:binding>
<wsdl:service name="ScholarshipService">
<wsdl:port name="ScholarshipServicePort"
binding="tns:ScholarshipServiceSoapBinding">
<soap:address location="http://localhost:9090/ScholarshipServicePort"/>
</wsdl:port>
</wsdl:service>
</wsdl:definitions>
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
225
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Apéndices
13.6 Código Fuente
13.6.1 Define-tramites-servicios-web-unificadosbuscador
13.6.1.1
er
Es.uniovi.innova.eadministracion.tramites.swu.controll
13.6.1.1.1
ErrorController.java
package es.uniovi.innova.eadministracion.tramites.swu.controller;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.stereotype.Controller;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.AbstractController;
import es.uniovi.innova.eadministracion.tramites.swu.exception.GenericException;
/**
* Controlador que mapea los errores genéricos de la aplicación
*
* @author danielmf
*
*/
@Controller
public class ErrorController extends AbstractController {
@Override
protected ModelAndView handleRequestInternal(HttpServletRequest arg0,
HttpServletResponse arg1) throws Exception {
throw new GenericException("No se ha podido satisfacer su petición.");
}
}
13.6.1.1.2
HomeController.java
package es.uniovi.innova.eadministracion.tramites.swu.controller;
import
import
import
import
import
org.slf4j.Logger;
org.slf4j.LoggerFactory;
org.springframework.stereotype.Controller;
org.springframework.web.bind.annotation.RequestMapping;
org.springframework.web.bind.annotation.RequestMethod;
/**
* Controlador de la página inicial (Buscador)
*
* @author danielmf
*
*/
@Controller
public class HomeController {
private static final Logger logger = LoggerFactory
.getLogger(HomeController.class);
/**
226
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Apéndices | Plataforma para Interoperabilidad de sistemas de información dentro de un
mismo ámbito organizativo
* Filtra el tráfico inicial a la home
*
* @return
*/
@RequestMapping(value = "/", method = RequestMethod.GET)
public String home() {
logger.info("Entrando en la página principal...");
return "home";
}
/**
* Mapea las peticiones para el formulario de registro de los Servicios Web
* en la url /form
*
* @return
*/
@RequestMapping(value = "/form")
public String form() {
logger.info("Comenzando el proceso de registro...");
return "register";
}
/**
* Mapea las peticiones para la información del Recolector de Becas en la
* url /retriever
*
* @return
*/
@RequestMapping(value = "/retriever")
public String retriever() {
logger.info("Mostrando el recolector...");
return "retriever";
}
/**
* Mapea las peticiones para la página de información en la url /info
*
* @return
*/
@RequestMapping(value = "/info")
public String info() {
logger.info("Mostrando la información...");
return "info";
}
}
13.6.1.2
*.search
13.6.1.2.1
SearchEngineController.java
package es.uniovi.innova.eadministracion.tramites.swu.controller.search;
import javax.inject.Inject;
import
import
import
import
import
import
import
org.slf4j.Logger;
org.slf4j.LoggerFactory;
org.springframework.stereotype.Controller;
org.springframework.ui.Model;
org.springframework.web.bind.annotation.RequestMapping;
org.springframework.web.bind.annotation.RequestMethod;
org.springframework.web.bind.annotation.RequestParam;
import es.uniovi.innova.eadministracion.tramites.swu.view.ISearchView;
import es.uniovi.innova.eadministracion.tramites.swu.view.ISearchViewNoScript;
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
227
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Apéndices
/**
* Controlador del componente Buscador. Atenderá las peticiones que sean de su
* responsabilidad mediante las direcciones filtradas en los métodos.
*
* @author danielmf
*
*/
@Controller
public class SearchEngineController {
@Inject
private ISearchView searchView;
@Inject
private ISearchViewNoScript searchViewNoScript;
private static Logger logger = LoggerFactory
.getLogger(SearchEngineController.class);
/**
* Filtra las peticiones del buscador que atiendan a la url /searchMin
*
* @param search
*
parametro que llega del formulario
* @param model
*
modelo para devolver la respuesta
*
* @return
*/
@RequestMapping(value = "/searchMin", method = RequestMethod.POST)
public String search(@RequestParam("search_text") String search, Model model) {
logger.info("[JS ON]Buscando: " + search);
return searchView.execute(search, model);
}
/**
* Filtra las peticiones del buscador con el JavaScript desactivado en la
* url /search
*
* @param search
*
parámetro que llega del formulario
* @param model
*
modelo para devolver la respuesta
*
* @return
*/
@RequestMapping(value = "/search", method = RequestMethod.POST)
public String searchNoScript(@RequestParam("search_text") String search,
Model model) {
logger.info("[JS OFF]Buscando: " + search);
return searchViewNoScript.execute(search, model);
}
}
228
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Apéndices | Plataforma para Interoperabilidad de sistemas de información dentro de un
mismo ámbito organizativo
13.6.1.3
*.university
13.6.1.3.1
BecaFormController.java
package es.uniovi.innova.eadministracion.tramites.swu.controller.university;
import java.util.List;
import javax.inject.Inject;
import javax.servlet.http.HttpServletRequest;
import
import
import
import
import
import
import
import
import
import
org.slf4j.Logger;
org.slf4j.LoggerFactory;
org.springframework.stereotype.Controller;
org.springframework.ui.Model;
org.springframework.validation.BindingResult;
org.springframework.web.bind.annotation.ModelAttribute;
org.springframework.web.bind.annotation.RequestMapping;
org.springframework.web.bind.annotation.RequestMethod;
org.springframework.web.bind.annotation.SessionAttributes;
org.springframework.web.bind.support.SessionStatus;
import
import
import
import
import
import
es.uniovi.innova.eadministracion.tramites.swu.builder.BecaDirectorForm;
es.uniovi.innova.eadministracion.tramites.swu.business.WebServiceManagerService;
es.uniovi.innova.eadministracion.tramites.swu.model.Beca;
es.uniovi.innova.eadministracion.tramites.swu.model.University;
es.uniovi.innova.eadministracion.tramites.swu.model.wrapper.BecaWrapper;
es.uniovi.innova.eadministracion.tramites.swu.view.IMatchBecaView;
/**
* Controlador del formulario del modelo {@link Beca}. Atenderá las peticiones
* que sean de su responsabilidad mediante las direcciones filtradas en los
* métodos.
*
* @author danielmf
*
*/
@Controller
@RequestMapping("/beca")
@SessionAttributes("beca")
public class BecaFormController {
private static Logger logger = LoggerFactory
.getLogger(BecaFormController.class);
@Inject
private IMatchBecaView becaView;
@Inject
private WebServiceManagerService webServiceService;
@Inject
private BecaDirectorForm builder;
/**
* Recoge la acción procesada al enviar el formulario del modelo
* {@link Beca}
*
* @param beca
*
Modelo que será mapeado por el formulario
* @param result
*
Resultado del mapeo del formulario
* @param status
*
estado de la sesión, en caso de que exista algo que no ocurra
*
como debiera
* @param request
* @param model
*
Model para realizar el binding
*
* @return vista donde se devolverá el control
*/
@RequestMapping(method = RequestMethod.POST)
public String submitForm(@ModelAttribute("beca") BecaWrapper beca,
BindingResult result, SessionStatus status,
HttpServletRequest request, Model model) {
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
229
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Apéndices
logger.info("Envío de Formulario: " + beca);
return becaView.execute(request, beca, model, result);
}
/**
* Prepara el formulario de la {@link Beca} rellenando sus campos
* previamente con el modelo
*
* @param model
*
a rellenar previa ejecución del formulario
* @param request
* @return vista a devolver el control
*/
@RequestMapping(method = RequestMethod.GET)
public String setupForm(Model model, HttpServletRequest request) {
List<String> fields = webServiceService.getClassFields((String) request
.getSession().getAttribute("modelo"), ((University) request
.getSession().getAttribute("university")).getWsdl());
BecaWrapper beca = builder.build(fields);
logger.info("Setup form: " + beca);
model.addAttribute("beca", beca);
return "beca";
}
}
13.6.1.3.2
OperationsFormController.java
package es.uniovi.innova.eadministracion.tramites.swu.controller.university;
import javax.inject.Inject;
import javax.servlet.http.HttpServletRequest;
import
import
import
import
import
import
org.slf4j.Logger;
org.slf4j.LoggerFactory;
org.springframework.stereotype.Controller;
org.springframework.web.bind.annotation.RequestMapping;
org.springframework.web.bind.annotation.RequestMethod;
org.springframework.web.bind.annotation.RequestParam;
import es.uniovi.innova.eadministracion.tramites.swu.model.wrapper.OperationWrapper;
import es.uniovi.innova.eadministracion.tramites.swu.view.IMatchOperationsView;
/**
* Controlador de gestión del formulario de Operaciones de los servicios web
*
* @author danielmf
*
*/
@Controller
@RequestMapping("/operations")
public class OperationsFormController {
private static Logger logger = LoggerFactory
.getLogger(OperationsFormController.class);
@Inject
private IMatchOperationsView matchOperationsView;
/**
* Recoge
* {@link
*
* @param
* @param
*
* @param
*
* @param
230
la acción procesada al enviar el formulario del modelo
OperationWrapper}
request
modelo
clase que emparejará con el modelo de referencia
VC
operacion para las becas del vicerrectorado
curso
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Apéndices | Plataforma para Interoperabilidad de sistemas de información dentro de un
mismo ámbito organizativo
*
operacion para las becas del curso
* @param alumno
*
operacion para las becas por alumno
* @return
*/
@RequestMapping(method = RequestMethod.POST)
public String submitForm(HttpServletRequest request,
@RequestParam("modelo") String modelo,
@RequestParam("VICERRECTORADO") String VC,
@RequestParam("CURSO") String curso,
@RequestParam("ALUMNO") String alumno) {
logger.info("Modelo: " + modelo + ", [VICERRECTORADO,CURSO,ALUMNO]: ["
+ VC + ", " + curso + ", " + alumno + "]");
return matchOperationsView.execute(request, modelo, VC, curso, alumno);
}
}
13.6.1.3.3
SolicitanteFormController.java
package es.uniovi.innova.eadministracion.tramites.swu.controller.university;
import java.util.List;
import javax.inject.Inject;
import javax.servlet.http.HttpServletRequest;
import
import
import
import
import
import
import
import
import
import
org.slf4j.Logger;
org.slf4j.LoggerFactory;
org.springframework.stereotype.Controller;
org.springframework.ui.Model;
org.springframework.validation.BindingResult;
org.springframework.web.bind.annotation.ModelAttribute;
org.springframework.web.bind.annotation.RequestMapping;
org.springframework.web.bind.annotation.RequestMethod;
org.springframework.web.bind.annotation.SessionAttributes;
org.springframework.web.bind.support.SessionStatus;
import
import
import
import
import
import
es.uniovi.innova.eadministracion.tramites.swu.builder.BecaDirectorForm;
es.uniovi.innova.eadministracion.tramites.swu.business.WebServiceManagerService;
es.uniovi.innova.eadministracion.tramites.swu.model.Solicitante;
es.uniovi.innova.eadministracion.tramites.swu.model.University;
es.uniovi.innova.eadministracion.tramites.swu.model.wrapper.SolicitanteWrapper;
es.uniovi.innova.eadministracion.tramites.swu.view.ISaveProcessView;
/**
* Controlador de gestión del formulario de {@link Solicitante}
*
* @author danielmf
*
*/
@Controller
@RequestMapping("/solicitante")
@SessionAttributes("solicitante")
public class SolicitanteFormController {
private static Logger logger = LoggerFactory
.getLogger(SolicitanteFormController.class);
@Inject
private ISaveProcessView saveProcessView;
@Inject
private WebServiceManagerService webServiceService;
@Inject
private BecaDirectorForm builder;
/**
*
* @param solicitante
*
clase que se mapeará en el formulario
* @param result
*
resultado del mapeo
* @param status
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
231
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Apéndices
*
estado para obtener los errores
* @param request
* @param model
* @return
*/
@RequestMapping(method = RequestMethod.POST)
public String submitForm(
@ModelAttribute("solicitante") SolicitanteWrapper solicitante,
BindingResult result, SessionStatus status,
HttpServletRequest request, Model model) {
logger.info("Enviando formulario: " + solicitante);
return saveProcessView.execute(request, solicitante, model, result);
}
/**
* Preparación del formulario del modelo para inyectar campos previamente
*
* @param model
* @param request
* @return
*/
@RequestMapping(method = RequestMethod.GET)
public String setupForm(Model model, HttpServletRequest request) {
List<String> fields = webServiceService.getClassFields((String) request
.getSession().getAttribute("modelo"), ((University) request
.getSession().getAttribute("university")).getWsdl());
SolicitanteWrapper solicitante = builder.buildSol(fields);
logger.info("Setup form: " + solicitante);
model.addAttribute("solicitante", solicitante);
return "solicitante";
}
}
13.6.1.3.4
UniversityController.java
package es.uniovi.innova.eadministracion.tramites.swu.controller.university;
import javax.inject.Inject;
import
import
import
import
org.springframework.stereotype.Controller;
org.springframework.ui.Model;
org.springframework.web.bind.annotation.PathVariable;
org.springframework.web.bind.annotation.RequestMapping;
import es.uniovi.innova.eadministracion.tramites.swu.model.University;
import es.uniovi.innova.eadministracion.tramites.swu.view.IDetailView;
/**
* Controlador de la {@link University}
*
* @author danielmf
*
*/
@Controller
public class UniversityController {
@Inject
private IDetailView detailView;
@Inject
private IDetailView detailViewFull;
/**
* Filtra las peticiones para el detalle de una universidad en caso de que
* se procese la petición mediante JavaScript
*
* @param id
*
de la {@link University}
232
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Apéndices | Plataforma para Interoperabilidad de sistemas de información dentro de un
mismo ámbito organizativo
* @param model
*
para devolver el resultado
*
* @return
*/
@RequestMapping(value = "/univ/{univ}/min")
public String detail(@PathVariable("univ") Long id, Model model) {
return detailView.execute(id, model);
}
/**
* Filtra las peticiones para el detalle de una universidad en caso de que
* la petición se ejecute sin JavaScript
*
* @param id
*
de la {@link University}
* @param model
*
para devolver el resultado
* @return
*/
@RequestMapping(value = "/univ/{univ}")
public String detailFull(@PathVariable("univ") Long id, Model model) {
return detailViewFull.execute(id, model);
}
}
13.6.1.3.5
UniversityFormController.java
package es.uniovi.innova.eadministracion.tramites.swu.controller.university;
import javax.inject.Inject;
import javax.servlet.http.HttpServletRequest;
import
import
import
import
import
import
import
import
import
import
org.slf4j.Logger;
org.slf4j.LoggerFactory;
org.springframework.stereotype.Controller;
org.springframework.ui.Model;
org.springframework.validation.BindingResult;
org.springframework.web.bind.annotation.ModelAttribute;
org.springframework.web.bind.annotation.RequestMapping;
org.springframework.web.bind.annotation.RequestMethod;
org.springframework.web.bind.annotation.SessionAttributes;
org.springframework.web.bind.support.SessionStatus;
import es.uniovi.innova.eadministracion.tramites.swu.model.University;
import es.uniovi.innova.eadministracion.tramites.swu.view.ICheckOperationsView;
/**
* Controlador del formulario del modelo {@link University}
*
* @author danielmf
*
*/
@Controller
@RequestMapping("/form")
@SessionAttributes("university")
public class UniversityFormController {
private static Logger logger = LoggerFactory
.getLogger(UniversityFormController.class);
@Inject
private ICheckOperationsView checkOperationsView;
/**
* Prepara el formulario inyectando los parámetros necesarios para rellenar
* los campos
*
* @param model
* @return
*/
@RequestMapping(method = RequestMethod.GET)
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
233
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Apéndices
public String setupForm(Model model) {
University university = new University();
model.addAttribute("university", university);
logger.info("Preparando el formulario: " + university);
return "register";
}
/**
* Recoge los datos del fomulario y los valida para continuar con el
* registro del formulario
*
* @param university
*
objeto {@link University} rellena del formulario
* @param result
*
para devolver mensajes a la vista
* @param status
*
con el estado de la petición
* @param request
* @param model
* @return vista a la que quiere devolversele el control
*/
@RequestMapping(method = RequestMethod.POST)
public String submitForm(
@ModelAttribute("university") University university,
BindingResult result, SessionStatus status,
HttpServletRequest request, Model model) {
logger.info("Enviando el formulario: " + university);
university.setName(university.getName().toUpperCase());
return checkOperationsView.execute(request, university, model, result);
}
}
13.6.1.4
Es.uniovi.innova.eadministracion.tramites.swu.validate
13.6.1.4.1
BecaWrapperValidator.java
package es.uniovi.innova.eadministracion.tramites.swu.validate;
import javax.inject.Named;
import org.springframework.validation.Errors;
import org.springframework.validation.ValidationUtils;
import org.springframework.validation.Validator;
import es.uniovi.innova.eadministracion.tramites.swu.model.Beca;
import es.uniovi.innova.eadministracion.tramites.swu.model.wrapper.BecaWrapper;
/**
* Validador del formulario de la {@link Beca}
*
* @author danielmf
*
*/
@Named
public class BecaWrapperValidator implements Validator {
@Override
public boolean supports(Class<?> clazz) {
return BecaWrapper.class.isAssignableFrom(clazz);
}
@Override
public void validate(Object target, Errors errors) {
ValidationUtils.rejectIfEmptyOrWhitespace(errors,
"nombre_procedimiento_convocatoria", "form.error.field",
"Nombre procedimiento convocatoria es requerido");
ValidationUtils.rejectIfEmptyOrWhitespace(errors, "destino",
"form.error.field", "Destino es requerido");
234
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Apéndices | Plataforma para Interoperabilidad de sistemas de información dentro de un
mismo ámbito organizativo
ValidationUtils.rejectIfEmptyOrWhitespace(errors, "cuantia_otorgada",
"form.error.field", "Cuantia otorgada es requerido");
ValidationUtils.rejectIfEmptyOrWhitespace(errors, "curso_academico",
"form.error.field", "Curso académico es requerido");
}
}
13.6.1.4.2
OperationsValidator.java
package es.uniovi.innova.eadministracion.tramites.swu.validate;
import javax.inject.Named;
import es.uniovi.innova.eadministracion.tramites.swu.exception.GenericException;
/**
* Validador del formulario de las operaciones
*
* @author danielmf
*
*/
@Named
public class OperationsValidator {
public void validate(String modelo, String curso, String alumno, String vc) {
boolean flag = false;
if (modelo == null || modelo.equalsIgnoreCase(""))
throw new GenericException("Debe introducir un modelo.");
if (!curso.contains("0"))
flag = true;
else if (!alumno.contains("0"))
flag = true;
else if (!vc.contains("0")) {
flag = true;
}
if (!flag) {
throw new GenericException("Debe soportar al menos una
operación.");
} else if ((!flag)
&& (curso.equalsIgnoreCase(alumno) && !curso.contains("0"))
|| (curso.equalsIgnoreCase(vc) && !curso.contains("0"))
|| (vc.equalsIgnoreCase(alumno) && !vc.contains("0"))) {
throw new GenericException("Cada operación debe de ser única");
}
}
}
13.6.1.4.3
SolicitanteWrapperValidator.java
package es.uniovi.innova.eadministracion.tramites.swu.validate;
import javax.inject.Named;
import org.springframework.validation.Errors;
import org.springframework.validation.ValidationUtils;
import org.springframework.validation.Validator;
import es.uniovi.innova.eadministracion.tramites.swu.model.Solicitante;
import es.uniovi.innova.eadministracion.tramites.swu.model.wrapper.SolicitanteWrapper;
/**
* Validador del formulario para el modelo {@link Solicitante}
*
* @author danielmf
*
*/
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
235
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Apéndices
@Named
public class SolicitanteWrapperValidator implements Validator {
@Override
public boolean supports(Class<?> clazz) {
return SolicitanteWrapper.class.isAssignableFrom(clazz);
}
@Override
public void validate(Object target, Errors errors) {
ValidationUtils.rejectIfEmptyOrWhitespace(errors, "nombre_solicitante",
"form.error.field", "Nombre del solicitante es requerido");
ValidationUtils.rejectIfEmptyOrWhitespace(errors,
"apellido1_solicitante", "form.error.field",
"Apellido1 es requerido");
ValidationUtils.rejectIfEmptyOrWhitespace(errors,
"documento_identificativo", "form.error.field",
"Documento identificativo es requerido");
ValidationUtils.rejectIfEmptyOrWhitespace(errors,
"tipo_documento_identificativo", "form.error.field",
"Tipo documento identificativo es requerido");
ValidationUtils.rejectIfEmptyOrWhitespace(errors, "estudios",
"form.error.field", "Estudios es requerido");
}
}
13.6.1.4.4
UniversityValidator.java
package es.uniovi.innova.eadministracion.tramites.swu.validate;
import java.util.List;
import javax.inject.Inject;
import javax.inject.Named;
import org.springframework.validation.Errors;
import org.springframework.validation.ValidationUtils;
import org.springframework.validation.Validator;
import es.uniovi.innova.eadministracion.tramites.swu.business.UniversityManagerService;
import es.uniovi.innova.eadministracion.tramites.swu.business.WebServiceManagerService;
import es.uniovi.innova.eadministracion.tramites.swu.model.University;
/**
* Validador del formulario del modelo {@link University}
*
* @author danielmf
*
*/
@Named
public class UniversityValidator implements Validator {
@Inject
private UniversityManagerService universityService;
@Inject
private WebServiceManagerService webServiceService;
@Override
public boolean supports(Class<?> clazz) {
return University.class.isAssignableFrom(clazz);
}
@Override
public void validate(Object target, Errors errors) {
ValidationUtils.rejectIfEmptyOrWhitespace(errors, "name",
"form.error.name", "Nombre es requerido");
ValidationUtils.rejectIfEmptyOrWhitespace(errors, "wsdl",
"form.error.wsdl", "WSDL es requerido");
University university = (University) target;
String wsdl = university.getWsdl();
236
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Apéndices | Plataforma para Interoperabilidad de sistemas de información dentro de un
mismo ámbito organizativo
String name = university.getName();
if (wsdl != null) {
if (universityService.findUniversityByWsdl(wsdl) != null) {
errors.rejectValue("wsdl", "form.error.wsdl.dup",
"Ya está registrado este WSDL");
}
List<String> l = webServiceService.getOperations(wsdl);
if (l == null || l.size() <= 0)
errors.rejectValue("wsdl", "form.error.wsd.inv",
"No se han podido conectar con el WSDL");
}
if (name != null) {
if (universityService.findUniversityByName(name) != null) {
errors.rejectValue("name", "form.error.name.dup",
"Ya está registrada esta Universidad");
}
}
}
}
13.6.1.5
Es.uniovi.innova.eadministracion.tramites.swu.view
13.6.1.5.1
ICheckOperationsView.java
package es.uniovi.innova.eadministracion.tramites.swu.view;
import javax.servlet.http.HttpServletRequest;
import org.springframework.ui.Model;
import org.springframework.validation.BindingResult;
import es.uniovi.innova.eadministracion.tramites.swu.model.University;
/**
* Resuelve la vista del formulario de la {@link University}
*
* @author danielmf
*
*/
public interface ICheckOperationsView {
String execute(HttpServletRequest request, University university,
Model model, BindingResult result);
}
13.6.1.5.2
IDetailView.java
package es.uniovi.innova.eadministracion.tramites.swu.view;
import org.springframework.ui.Model;
/**
* Resuelve la vista del detalle de una universidad
*
* @author danielmf
*
*/
public interface IDetailView {
String execute(Long id, Model model);
}
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
237
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Apéndices
13.6.1.5.3
IMatchBecaView.java
package es.uniovi.innova.eadministracion.tramites.swu.view;
import javax.servlet.http.HttpServletRequest;
import org.springframework.ui.Model;
import org.springframework.validation.BindingResult;
import es.uniovi.innova.eadministracion.tramites.swu.model.Beca;
import es.uniovi.innova.eadministracion.tramites.swu.model.wrapper.BecaWrapper;
/**
* Resuelve la vista del matcher de la {@link Beca}
*
* @author danielmf
*
*/
public interface IMatchBecaView {
String execute(HttpServletRequest request, BecaWrapper beca, Model model,
BindingResult result);
}
13.6.1.5.4
IMatchOperationsView.java
package es.uniovi.innova.eadministracion.tramites.swu.view;
import javax.servlet.http.HttpServletRequest;
/**
* Resuelve la vista de la selección de operaciones
*
* @author danielmf
*
*/
public interface IMatchOperationsView {
String execute(HttpServletRequest request, String modelo, String VC,
String curso, String alumno);
}
13.6.1.5.5
ISaveProcessView.java
package es.uniovi.innova.eadministracion.tramites.swu.view;
import javax.servlet.http.HttpServletRequest;
import org.springframework.ui.Model;
import org.springframework.validation.BindingResult;
import es.uniovi.innova.eadministracion.tramites.swu.model.Solicitante;
import es.uniovi.innova.eadministracion.tramites.swu.model.wrapper.SolicitanteWrapper;
/**
* Resuelve la vista que finaliza el proceso de registro, además, es el del
* modelo {@link Solicitante}
*
* @author danielmf
*
*/
public interface ISaveProcessView {
String execute(HttpServletRequest request, SolicitanteWrapper solicitante,
Model model, BindingResult result);
238
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Apéndices | Plataforma para Interoperabilidad de sistemas de información dentro de un
mismo ámbito organizativo
}
13.6.1.5.6
ISearchView.java
package es.uniovi.innova.eadministracion.tramites.swu.view;
import org.springframework.ui.Model;
/**
* Resuelve la vista del buscador
*
* @author danielmf
*
*/
public interface ISearchView {
String execute(String search, Model model);
}
13.6.1.5.7
ISearchViewNoScript.java
package es.uniovi.innova.eadministracion.tramites.swu.view;
import org.springframework.ui.Model;
/**
* Resuelve la vista del detalle en caso de que no haya JavaScript activado
* (Solucionando problemas de AJAX)
*
* @author danielmf
*
*/
public interface ISearchViewNoScript {
String execute(String search, Model model);
}
13.6.1.6
*.search
13.6.1.6.1
SearchView.java
package es.uniovi.innova.eadministracion.tramites.swu.view.search;
import javax.inject.Inject;
import javax.inject.Named;
import org.springframework.ui.Model;
import es.uniovi.innova.eadministracion.tramites.swu.business.SearchEngineService;
import es.uniovi.innova.eadministracion.tramites.swu.view.ISearchView;
/**
* Resuelve la vista del buscador mediante la implementación del patrón Command
*
* @author danielmf
*
*/
@Named
public class SearchView implements ISearchView {
@Inject
private SearchEngineService searchEngine;
public String execute(String search, Model model) {
if (search == null)
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
239
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Apéndices
return "home";
else {
model.addAttribute("results",
searchEngine.searchOperations(search));
model.addAttribute("keyword", search);
}
return "searchResult";
}
}
13.6.1.6.2
SearchViewNoScript.java
package es.uniovi.innova.eadministracion.tramites.swu.view.search;
import javax.inject.Inject;
import javax.inject.Named;
import org.springframework.ui.Model;
import es.uniovi.innova.eadministracion.tramites.swu.business.SearchEngineService;
import es.uniovi.innova.eadministracion.tramites.swu.view.ISearchViewNoScript;
/**
* Resuelve la vista del buscador en caso de que no haya JavaScript activado
* mediante la aplicación del patrón Command
*
* @author danielmf
*
*/
@Named
public class SearchViewNoScript implements ISearchViewNoScript {
@Inject
private SearchEngineService searchEngine;
@Override
public String execute(String search, Model model) {
if (search == null)
return "home";
else {
model.addAttribute("results",
searchEngine.searchOperations(search));
model.addAttribute("keyword", search);
}
return "searchResultFull";
}
}
13.6.1.7
*.university
13.6.1.7.1
CheckOperationsView.java
package es.uniovi.innova.eadministracion.tramites.swu.view.university;
import javax.inject.Inject;
import javax.inject.Named;
import javax.servlet.http.HttpServletRequest;
import
import
import
import
org.slf4j.Logger;
org.slf4j.LoggerFactory;
org.springframework.ui.Model;
org.springframework.validation.BindingResult;
import es.uniovi.innova.eadministracion.tramites.swu.business.WebServiceManagerService;
import es.uniovi.innova.eadministracion.tramites.swu.model.University;
import es.uniovi.innova.eadministracion.tramites.swu.validate.UniversityValidator;
240
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Apéndices | Plataforma para Interoperabilidad de sistemas de información dentro de un
mismo ámbito organizativo
import es.uniovi.innova.eadministracion.tramites.swu.view.ICheckOperationsView;
/**
* Clase que implementa un patrón Command para resolver la vista de las
* operaciones
*
* @author danielmf
*
*/
@Named
public class CheckOperationsView implements ICheckOperationsView {
@Inject
private WebServiceManagerService webServiceManager;
@Inject
private UniversityValidator validator;
private static Logger logger = LoggerFactory
.getLogger(CheckOperationsView.class);
@Override
public String execute(HttpServletRequest request, University university,
Model model, BindingResult result) {
logger.info("Comprobando universidad: [" + university + "]");
validator.validate(university, result);
if (result.hasErrors()) {
model.addAttribute("university", university);
return "register";
}
request.getSession().setAttribute("university", university);
logger.info("Operaciones: "
+ webServiceManager.getOperations(university.getWsdl()));
model.addAttribute("ops",
webServiceManager.getOperations(university.getWsdl()));
return "operations";
}
}
13.6.1.7.2
DetailView.java
package es.uniovi.innova.eadministracion.tramites.swu.view.university;
import javax.inject.Inject;
import javax.inject.Named;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.ui.Model;
import
import
import
import
es.uniovi.innova.eadministracion.tramites.swu.business.UniversityManagerService;
es.uniovi.innova.eadministracion.tramites.swu.exception.GenericException;
es.uniovi.innova.eadministracion.tramites.swu.model.University;
es.uniovi.innova.eadministracion.tramites.swu.view.IDetailView;
/**
* Resuelve la vista del detalle de la {@link University} mediante un Command
*
* @author danielmf
*
*/
@Named
public class DetailView implements IDetailView {
private static Logger logger = LoggerFactory.getLogger(DetailView.class);
@Inject
private UniversityManagerService universityService;
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
241
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Apéndices
public String execute(Long id, Model model) {
logger.info("Detalle de la Universidad: " + id);
if (id == null)
return "home";
else {
University u = universityService.findUniversity(id);
if (u != null) {
model.addAttribute("university", u);
return "detail";
} else
throw new GenericException("La Universidad no está
disponible.");
}
}
}
13.6.1.7.3
DetailViewFull.java
package es.uniovi.innova.eadministracion.tramites.swu.view.university;
import javax.inject.Inject;
import javax.inject.Named;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.ui.Model;
import
import
import
import
es.uniovi.innova.eadministracion.tramites.swu.business.UniversityManagerService;
es.uniovi.innova.eadministracion.tramites.swu.exception.GenericException;
es.uniovi.innova.eadministracion.tramites.swu.model.University;
es.uniovi.innova.eadministracion.tramites.swu.view.IDetailView;
/**
* Resuelve la vista del detalle de la {@link University} cuando no está
* habilitado el JavaScript
*
* @author danielmf
*
*/
@Named
public class DetailViewFull implements IDetailView {
private static Logger logger = LoggerFactory
.getLogger(DetailViewFull.class);
@Inject
private UniversityManagerService universityService;
@Override
public String execute(Long id, Model model) {
logger.info("Detail: " + id);
if (id == null)
return "home";
else {
University u = universityService.findUniversity(id);
if (u != null) {
model.addAttribute("university", u);
return "detailFull";
} else
throw new GenericException("La Universidad no está
disponible.");
}
}
}
242
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Apéndices | Plataforma para Interoperabilidad de sistemas de información dentro de un
mismo ámbito organizativo
13.6.1.7.4
MatchBecaView.java
package es.uniovi.innova.eadministracion.tramites.swu.view.university;
import java.util.HashMap;
import java.util.Map;
import javax.inject.Inject;
import javax.inject.Named;
import javax.servlet.http.HttpServletRequest;
import org.springframework.ui.Model;
import org.springframework.validation.BindingResult;
import
import
import
import
es.uniovi.innova.eadministracion.tramites.swu.model.Beca;
es.uniovi.innova.eadministracion.tramites.swu.model.wrapper.BecaWrapper;
es.uniovi.innova.eadministracion.tramites.swu.validate.BecaWrapperValidator;
es.uniovi.innova.eadministracion.tramites.swu.view.IMatchBecaView;
/**
* Resuelve la vista para el matcheador de la beca mediante un Command
*
* @author danielmf
*
*/
@Named
public class MatchBecaView implements IMatchBecaView {
@Inject
private BecaWrapperValidator validator;
@Override
public String execute(HttpServletRequest request, BecaWrapper beca,
Model model, BindingResult result) {
Map<String, String> fields = putAttributes(beca);
validator.validate(beca, result);
if (result.hasErrors()) {
model.addAttribute("beca", beca);
return "beca";
}
request.getSession().setAttribute("beca_fields", fields);
return "redirect:solicitante";
}
/**
* Se encarga de meter en la session un Map con los atributos de la
* {@link Beca}
*
* @param beca
*
recogida del formulario
*
* @return Map con el campo y el emparejamiento recogido en el formulario
*/
private Map<String, String> putAttributes(BecaWrapper beca) {
Map<String, String> fields = new HashMap<String, String>();
fields.put("nombre_procedimiento_convocatoria",
beca.getNombre_procedimiento_convocatoria());
fields.put("asunto_convocatoria", beca.getAsunto_convocatoria());
fields.put("estado_solicitud", beca.getEstado_solicitud());
fields.put("destino", beca.getDestino());
fields.put("cuantia_otorgada", beca.getCuantia_otorgada());
fields.put("curso_academico", beca.getCurso_academico());
return fields;
}
}
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
243
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Apéndices
13.6.1.7.5
MatchOperationsView.java
package es.uniovi.innova.eadministracion.tramites.swu.view.university;
import java.util.HashMap;
import java.util.Map;
import javax.inject.Inject;
import javax.inject.Named;
import javax.servlet.http.HttpServletRequest;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import es.uniovi.innova.eadministracion.tramites.swu.util.Helper;
import es.uniovi.innova.eadministracion.tramites.swu.validate.OperationsValidator;
import es.uniovi.innova.eadministracion.tramites.swu.view.IMatchOperationsView;
/**
* Resuelve la vista para el emparejador de las operaciones
*
* @author danielmf
*
*/
@Named
public class MatchOperationsView implements IMatchOperationsView {
private static Logger logger = LoggerFactory
.getLogger(MatchOperationsView.class);
@Inject
private OperationsValidator operationsValidator;
public String execute(HttpServletRequest request, String modelo, String VC,
String curso, String alumno) {
logger.info("Operaciones: [" + VC + ", " + curso + ", " + alumno + "]");
operationsValidator.validate(modelo, curso, alumno, VC);
String packagge = " ";
Map<String, String> operations = new HashMap<String, String>();
packagge = setOperations(VC, curso, alumno, operations);
modelo = packagge + modelo;
logger.info("Modelo: " + modelo);
request.getSession().setAttribute("modelo", modelo);
request.getSession().setAttribute("operations", operations);
return "redirect:beca";
}
/**
* Comprueba y almacena en un Map las operaciones seleccionadas en el
* formulario
*
* @param VC
*
operación que relaciona con el Vicerrectorado
* @param curso
*
operación que relacion con el curso
* @param alumno
*
operación que relaciona con el alumno
* @param operations
*
mapa donde se almacenan las operaciones
*
* @return el nombre del paquete para recoger el modelo
*/
private String setOperations(String VC, String curso, String alumno,
Map<String, String> operations) {
boolean flag = false;
String packagge = "";
244
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Apéndices | Plataforma para Interoperabilidad de sistemas de información dentro de un
mismo ámbito organizativo
if (!VC.contains("0")) {
operations.put("VICERRECTORADO", VC);
if (!flag) {
packagge = Helper.retrieveCompleteName(VC);
flag = true;
}
}
if (!alumno.contains("0")) {
operations.put("ALUMNO", alumno);
if (!flag) {
packagge = Helper.retrieveCompleteName(alumno);
flag = true;
}
}
if (!curso.contains("0")) {
operations.put("CURSO", curso);
if (!flag) {
packagge = Helper.retrieveCompleteName(curso);
flag = true;
}
}
return packagge;
}
}
13.6.1.7.6
SaveProcessView.java
package es.uniovi.innova.eadministracion.tramites.swu.view.university;
import java.util.HashMap;
import java.util.Map;
import javax.inject.Inject;
import javax.inject.Named;
import javax.servlet.http.HttpServletRequest;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.ui.Model;
import org.springframework.validation.BindingResult;
import es.uniovi.innova.eadministracion.tramites.swu.business.MatcherManagerService;
import es.uniovi.innova.eadministracion.tramites.swu.business.UniversityManagerService;
import es.uniovi.innova.eadministracion.tramites.swu.model.Solicitante;
import es.uniovi.innova.eadministracion.tramites.swu.model.University;
import es.uniovi.innova.eadministracion.tramites.swu.model.wrapper.ModelWrapper;
import es.uniovi.innova.eadministracion.tramites.swu.model.wrapper.OperationWrapper;
import es.uniovi.innova.eadministracion.tramites.swu.model.wrapper.SolicitanteWrapper;
import
es.uniovi.innova.eadministracion.tramites.swu.validate.SolicitanteWrapperValidator;
import es.uniovi.innova.eadministracion.tramites.swu.view.ISaveProcessView;
/**
* Resuelve la vista para el guardado del proceso de creación de una nueva
* universidad
*
* @author danielmf
*
*/
@Named
public class SaveProcessView implements ISaveProcessView {
@Inject
private UniversityManagerService universityService;
@Inject
private MatcherManagerService matcherService;
@Inject
private SolicitanteWrapperValidator validator;
@SuppressWarnings("unchecked")
@Override
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
245
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Apéndices
@Transactional
public String execute(HttpServletRequest request,
SolicitanteWrapper solicitante, Model model, BindingResult result)
{
Map<String, String> fields = putAttributes(solicitante);
University u = (University) request.getSession().getAttribute(
"university");
String modelo = (String) request.getSession().getAttribute("modelo");
Map<String, String> fields_beca = (Map<String, String>) request
.getSession().getAttribute("beca_fields");
Map<String, String> operations = (Map<String, String>) request
.getSession().getAttribute("operations");
validator.validate(solicitante, result);
if (result.hasErrors()) {
model.addAttribute("solicitante", solicitante);
return "solicitante";
}
universityService.save(u);
setBeca(u, modelo, fields_beca);
setSolicitante(fields, u, modelo);
setOperations(u, operations);
return "success";
}
/**
* Guarda una beca recogida en el formulario
*
* @param university
* @param modelo
* @param fields_beca
*/
private void setBeca(University u, String modelo,
Map<String, String> fields_beca) {
for (String key : fields_beca.keySet()) {
if (joinable(fields_beca.get(key))) {
String[] values = split(fields_beca.get(key));
ModelWrapper mw = new ModelWrapper();
mw.setConcrete(values[0]);
mw.setMatch(key);
mw.setUniversity(u);
mw.setModelClazz("BECA");
mw.setClazz(modelo);
mw.setJoin(values[1]);
matcherService.save(mw);
ModelWrapper mw1 = new ModelWrapper();
mw1.setConcrete(values[1]);
mw1.setMatch(key);
mw1.setUniversity(u);
mw1.setModelClazz("BECA");
mw1.setClazz(modelo);
matcherService.save(mw1);
} else {
ModelWrapper mw = new ModelWrapper();
mw.setConcrete(fields_beca.get(key));
mw.setMatch(key);
246
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Apéndices | Plataforma para Interoperabilidad de sistemas de información dentro de un
mismo ámbito organizativo
mw.setUniversity(u);
mw.setModelClazz("BECA");
mw.setClazz(modelo);
matcherService.save(mw);
}
}
}
/**
* Comprueba si un match es compuesto
*
* @param key
*
match
*
* @return si es compuesto o no
*/
private boolean joinable(String key) {
String[] values = split(key);
if (values.length > 1)
return true;
return false;
}
/**
* Obtiene los campos de un match compuesto
*
* @param key
*
match
*
* @return un Array con los matches
*/
private String[] split(String key) {
String[] values = key.split(",");
return values;
}
/**
* Guarda un {@link Solicitante} recogido previamente en el formulario
*
* @param fields
*
map con los campos del solicitante
* @param university
* @param modelo
*
*/
private void setSolicitante(Map<String, String> fields, University u,
String modelo) {
for (String key : fields.keySet()) {
if (joinable(fields.get(key))) {
String[] values = split(fields.get(key));
ModelWrapper mw = new ModelWrapper();
mw.setConcrete(values[0]);
mw.setMatch(key);
mw.setUniversity(u);
mw.setModelClazz("SOLICITANTE");
mw.setClazz(modelo);
mw.setJoin(values[1]);
matcherService.save(mw);
ModelWrapper mw1 = new ModelWrapper();
mw1.setConcrete(values[1]);
mw1.setMatch(key);
mw1.setUniversity(u);
mw1.setModelClazz("SOLICITANTE");
mw1.setClazz(modelo);
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
247
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Apéndices
matcherService.save(mw1);
} else if (fields.get(key) != "") {
ModelWrapper mw = new ModelWrapper();
mw.setConcrete(fields.get(key));
mw.setMatch(key);
mw.setUniversity(u);
mw.setModelClazz("SOLICITANTE");
mw.setClazz(modelo);
matcherService.save(mw);
}
}
}
/**
* Guarda las operaciones recogidas previamente en el formulario
*
* @param university
* @param operations
*
Map con las operaciones recogidas
*
*/
private void setOperations(University u, Map<String, String> operations) {
for (String key : operations.keySet()) {
OperationWrapper op = new OperationWrapper();
op.setUniversity(u);
op.setOp(operations.get(key));
op.setMatch(key);
matcherService.save(op);
}
}
/**
* Crea un Map con los atributos del {@link Solicitante}
*
* @param solicitante
*
recogido en el formulario
*
* @return el mapa con los atributos tras el match
*/
private Map<String, String> putAttributes(SolicitanteWrapper solicitante) {
Map<String, String> fields = new HashMap<String, String>();
fields.put("nombre_solicitante", solicitante.getNombre_solicitante());
fields.put("apellido1_solicitante",
solicitante.getApellido1_solicitante());
fields.put("apellido2_solicitante",
solicitante.getApellido2_solicitante());
fields.put("documento_identificativo",
solicitante.getDocumento_identificativo());
fields.put("tipo_documento_identificativo",
solicitante.getTipo_documento_identificativo());
fields.put("nacionalidad", solicitante.getNacionalidad());
fields.put("sexo", solicitante.getSexo());
fields.put("fecha_nacimiento", solicitante.getFecha_nacimiento());
fields.put("estudios", solicitante.getEstudios());
return fields;
}
}
248
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Apéndices | Plataforma para Interoperabilidad de sistemas de información dentro de un
mismo ámbito organizativo
13.6.1.8
Scripts.js
$(document).ready(function() {
$.ajaxSetup({
cache: false
});
$('[rel="tooltip"]').tooltip();
// Buscador
$(".container").on('click', '#searcher', function(evento) {
evento.preventDefault();
msg = "Buscando resultados...";
if($('input[id=query]').val() != null && $('input[id=query]').val() !=
""){
$(document).ajaxStart($.blockUI({message: msg,
css: {
border: 'none',
padding: '15px',
backgroundColor: '#000',
'-webkit-border-radius': '10px',
'-moz-border-radius': '10px',
opacity: .5,
color: '#fff'
} })).ajaxStop($.unblockUI);
$(".hero-unit").load("./searchMin", {
search_text : $('input[id=query]').val()
});
}else {
$("#search").append('<div class="alert alert-block"><a
class="close">×</a><h4 class="alert-heading">Alerta</h4><p>Debe introducir algún término
por el que buscar.</p></div>');
}
});
$(document).on('click', 'a.close', function(evento) {
evento.preventDefault();
$(".alert").remove();
});
$(".container").on('click','a.univ',function(e){
e.preventDefault();
msg = "Accediendo al detalle...";
$(document).ajaxStart($.blockUI({message: msg,
css: {
border: 'none',
padding: '15px',
backgroundColor: '#000',
'-webkit-border-radius': '10px',
'-moz-border-radius': '10px',
opacity: .5,
color: '#fff'
} })).ajaxStop($.unblockUI);
$(".hero-unit").load("./"+$(this).attr('href')+"/min");
});
$('#query').typeahead({source : ['Alumno','Vicerrectorado','Curso']});
});
function validateForm(){
var flag = false;
if($('input[id=modelo]').val() == null || $('input[id=modelo]').val() == ""){
$("#search").append('<div class="alert alert-block"><a
class="close">×</a><h4 class="alert-heading">Alerta</h4><p>Debe introducir un
modelo.</p></div>');
return false;
}
if($('input[id=CURSO]:checked').val() != "0")
flag = true;
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
249
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Apéndices
else if($('input[id=ALUMNO]:checked').val()!= "0")
flag = true;
else if($('input[id=VICERRECTORADO]:checked').val() != "0"){
flag = true;
}
if(!flag){
$("#search").append('<div class="alert alert-block"><a
class="close">×</a><h4 class="alert-heading">Alerta</h4><p>Debe soportar al menos una
operación.</p></div>');
return false;
}else if( ($('input[id=CURSO]:checked').val() ==
$('input[id=ALUMNO]:checked').val() && $('input[id=CURSO]:checked').val() != "0") ||
($('input[id=CURSO]:checked').val() == $('input[id=VICERRECTORADO]:checked').val() &&
$('input[id=CURSO]:checked').val() != "0") ||
($('input[id=VICERRECTORADO]:checked').val() == $('input[id=ALUMNO]:checked').val() &&
$('input[id=CURSO]:checked').val() != "0")){
$("#search").append('<div class="alert alert-block"><a
class="close">×</a><h4 class="alert-heading">Alerta</h4><p>Cada operación debe de ser
única</p></div>');
return false;
}
return true;
}
13.6.2 Define-tramites-servicios-web-unificadosmodelo
13.6.2.1
Es.uniovi.innova.eadministracion.tramites.swu.model
13.6.2.1.1
Beca.java
package es.uniovi.innova.eadministracion.tramites.swu.model;
/**
* Modelo que representa una Beca
*
* @author danielmf
*
*/
public class Beca {
private
private
private
private
private
private
private
String nombre_procedimiento_convocatoria;
String asunto_convocatoria;
String estado_solicitud;
String destino;
Double cuantia_otorgada;
String curso_academico;
Solicitante solicitante;
public Beca() {
super();
}
public Beca(String nombre_procedimiento_convocatoria,
String asunto_convocatoria, String estado_solicitud,
String destino, Double cuantia_otorgada, String curso_academico,
Solicitante solicitante) {
super();
this.nombre_procedimiento_convocatoria =
nombre_procedimiento_convocatoria;
this.asunto_convocatoria = asunto_convocatoria;
this.estado_solicitud = estado_solicitud;
this.destino = destino;
this.cuantia_otorgada = cuantia_otorgada;
this.curso_academico = curso_academico;
this.solicitante = solicitante;
}
250
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Apéndices | Plataforma para Interoperabilidad de sistemas de información dentro de un
mismo ámbito organizativo
public String getNombre_procedimiento_convocatoria() {
return nombre_procedimiento_convocatoria;
}
public void setNombre_procedimiento_convocatoria(
String nombre_procedimiento_convocatoria) {
this.nombre_procedimiento_convocatoria =
nombre_procedimiento_convocatoria;
}
public String getAsunto_convocatoria() {
return asunto_convocatoria;
}
public void setAsunto_convocatoria(String asunto_convocatoria) {
this.asunto_convocatoria = asunto_convocatoria;
}
public String getEstado_solicitud() {
return estado_solicitud;
}
public void setEstado_solicitud(String estado_solicitud) {
this.estado_solicitud = estado_solicitud;
}
public String getDestino() {
return destino;
}
public void setDestino(String destino) {
this.destino = destino;
}
public Double getCuantia_otorgada() {
return cuantia_otorgada;
}
public void setCuantia_otorgada(Double cuantia_otorgada) {
this.cuantia_otorgada = cuantia_otorgada;
}
public String getCurso_academico() {
return curso_academico;
}
public void setCurso_academico(String curso_academico) {
this.curso_academico = curso_academico;
}
public Solicitante getSolicitante() {
return solicitante;
}
public void setSolicitante(Solicitante solicitante) {
this.solicitante = solicitante;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result
+ ((curso_academico == null) ? 0 :
curso_academico.hashCode());
result = prime
* result
+ ((nombre_procedimiento_convocatoria == null) ? 0
:
nombre_procedimiento_convocatoria.hashCode());
result = prime * result
+ ((solicitante == null) ? 0 : solicitante.hashCode());
return result;
}
@Override
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
251
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Apéndices
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Beca other = (Beca) obj;
if (curso_academico == null) {
if (other.curso_academico != null)
return false;
} else if (!curso_academico.equals(other.curso_academico))
return false;
if (nombre_procedimiento_convocatoria == null) {
if (other.nombre_procedimiento_convocatoria != null)
return false;
} else if (!nombre_procedimiento_convocatoria
.equals(other.nombre_procedimiento_convocatoria))
return false;
if (solicitante == null) {
if (other.solicitante != null)
return false;
} else if (!solicitante.equals(other.solicitante))
return false;
return true;
}
@Override
public String toString() {
return "Beca [nombre_procedimiento_convocatoria="
+ nombre_procedimiento_convocatoria + ",
asunto_convocatoria="
+ asunto_convocatoria + ", estado_solicitud="
+ estado_solicitud + ", destino=" + destino
+ ", cuantia_otorgada=" + cuantia_otorgada
+ ", curso_academico=" + curso_academico + ", solicitante="
+ solicitante + "]";
}
}
13.6.2.1.2
Solicitante.java
package es.uniovi.innova.eadministracion.tramites.swu.model;
public class Solicitante {
private
private
private
private
private
private
private
private
private
String nombre_solicitante;
String apellido1_solicitante;
String apellido2_solicitante;
String documento_identificativo;
String tipo_documento_identificativo;
String nacionalidad;
String sexo;
Integer fecha_nacimiento; // año
String estudios;
public Solicitante() {
super();
}
public Solicitante(String nombre_solicitante, String apellido1_solicitante,
String apellido2_solicitante, String documento_identificativo,
String tipo_documento_identificativo, String nacionalidad,
String sexo, Integer fecha_nacimiento, String estudios) {
super();
this.nombre_solicitante = nombre_solicitante;
this.apellido1_solicitante = apellido1_solicitante;
this.apellido2_solicitante = apellido2_solicitante;
this.documento_identificativo = documento_identificativo;
this.tipo_documento_identificativo = tipo_documento_identificativo;
this.nacionalidad = nacionalidad;
this.sexo = sexo;
252
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Apéndices | Plataforma para Interoperabilidad de sistemas de información dentro de un
mismo ámbito organizativo
this.fecha_nacimiento = fecha_nacimiento;
this.estudios = estudios;
}
public String getNombre_solicitante() {
return nombre_solicitante;
}
public void setNombre_solicitante(String nombre_solicitante) {
this.nombre_solicitante = nombre_solicitante;
}
public String getApellido1_solicitante() {
return apellido1_solicitante;
}
public void setApellido1_solicitante(String apellido1_solicitante) {
this.apellido1_solicitante = apellido1_solicitante;
}
public String getApellido2_solicitante() {
return apellido2_solicitante;
}
public void setApellido2_solicitante(String apellido2_solicitante) {
this.apellido2_solicitante = apellido2_solicitante;
}
public String getDocumento_identificativo() {
return documento_identificativo;
}
public void setDocumento_identificativo(String documento_identificativo) {
this.documento_identificativo = documento_identificativo;
}
public String getTipo_documento_identificativo() {
return tipo_documento_identificativo;
}
public void setTipo_documento_identificativo(
String tipo_documento_identificativo) {
this.tipo_documento_identificativo = tipo_documento_identificativo;
}
public String getNacionalidad() {
return nacionalidad;
}
public void setNacionalidad(String nacionalidad) {
this.nacionalidad = nacionalidad;
}
public String getSexo() {
return sexo;
}
public void setSexo(String sexo) {
this.sexo = sexo;
}
public Integer getFecha_nacimiento() {
return fecha_nacimiento;
}
public void setFecha_nacimiento(Integer fecha_nacimiento) {
this.fecha_nacimiento = fecha_nacimiento;
}
public String getEstudios() {
return estudios;
}
public void setEstudios(String estudios) {
this.estudios = estudios;
}
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
253
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Apéndices
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime
* result
+ ((documento_identificativo == null) ? 0
: documento_identificativo.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Solicitante other = (Solicitante) obj;
if (documento_identificativo == null) {
if (other.documento_identificativo != null)
return false;
} else if (!documento_identificativo
.equals(other.documento_identificativo))
return false;
return true;
}
@Override
public String toString() {
return "Solicitante [nombre_solicitante=" + nombre_solicitante
+ ", apellido1_solicitante=" + apellido1_solicitante
+ ", apellido2_solicitante=" + apellido2_solicitante
+ ", documento_identificativo=" + documento_identificativo
+ ", tipo_documento_identificativo="
+ tipo_documento_identificativo + ", nacionalidad="
+ nacionalidad + ", sexo=" + sexo + ", fecha_nacimiento="
+ fecha_nacimiento + ", estudios=" + estudios + "]";
}
}
13.6.2.1.3
University.java
package es.uniovi.innova.eadministracion.tramites.swu.model;
import java.util.Collections;
import java.util.HashSet;
import java.util.Set;
import
import
import
import
import
import
import
import
javax.persistence.Column;
javax.persistence.Entity;
javax.persistence.FetchType;
javax.persistence.GeneratedValue;
javax.persistence.GenerationType;
javax.persistence.Id;
javax.persistence.OneToMany;
javax.persistence.Table;
import es.uniovi.innova.eadministracion.tramites.swu.model.wrapper.ModelWrapper;
import es.uniovi.innova.eadministracion.tramites.swu.model.wrapper.OperationWrapper;
/**
* JavaBean que modela los datos recopilados de una Universidad
*
* @author danielmf
*
*/
@Entity
@Table(name = "TUNIVERSIDADES")
public class University {
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
254
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Apéndices | Plataforma para Interoperabilidad de sistemas de información dentro de un
mismo ámbito organizativo
private Long id;
@Column(unique = true, nullable = false)
private String name;
@Column(nullable = false)
private String wsdl;
@Column(nullable = false)
private String personInCharge;
@OneToMany(mappedBy = "university", fetch = FetchType.EAGER)
private Set<OperationWrapper> operationsWrapper = new
HashSet<OperationWrapper>();
@OneToMany(mappedBy = "university", fetch = FetchType.EAGER)
private Set<ModelWrapper> modelsWrapper = new HashSet<ModelWrapper>();
public University() {
}
public University(String name, String wsdl, String personInCharge) {
this.name = name;
this.wsdl = wsdl;
this.personInCharge = personInCharge;
}
@Override
public String toString() {
return "University [id=" + id + ", name=" + name + ", wsdl=" + wsdl
+ ", personInCharge=" + personInCharge + "]";
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((name == null) ? 0 : name.hashCode());
result = prime * result + ((wsdl == null) ? 0 : wsdl.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
University other = (University) obj;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
if (wsdl == null) {
if (other.wsdl != null)
return false;
} else if (!wsdl.equals(other.wsdl))
return false;
return true;
}
public void addOperation(OperationWrapper o) {
o.setUniversity(this);
operationsWrapper.add(o);
}
public void addMW(ModelWrapper mw) {
mw.setUniversity(this);
modelsWrapper.add(mw);
}
public void removeOperation(OperationWrapper o) {
operationsWrapper.remove(o);
o.setUniversity(null);
}
public void removeModelWrapper(ModelWrapper mw) {
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
255
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Apéndices
modelsWrapper.remove(mw);
mw.setUniversity(null);
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getWsdl() {
return wsdl;
}
public void setWsdl(String wsdl) {
this.wsdl = wsdl;
}
public String getPersonInCharge() {
return personInCharge;
}
public void setPersonInCharge(String personInCharge) {
this.personInCharge = personInCharge;
}
public Long getId() {
return id;
}
public Set<OperationWrapper> getOperationsWrapper() {
return Collections.unmodifiableSet(operationsWrapper);
}
public Set<ModelWrapper> getModelsWrapper() {
return Collections.unmodifiableSet(modelsWrapper);
}
}
13.6.2.1.4
Vicerrectorado.java
package es.uniovi.innova.eadministracion.tramites.swu.model;
/**
* Modelo que representa un Vicerrectorado
*
* @author danielmf
*
*/
public class Vicerrectorado {
private Long id;
private String nombre;
private String responsable;
public Vicerrectorado() {
super();
}
public Vicerrectorado(String nombre, String responsable) {
super();
this.nombre = nombre;
this.responsable = responsable;
}
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
256
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Apéndices | Plataforma para Interoperabilidad de sistemas de información dentro de un
mismo ámbito organizativo
public String getNombre() {
return nombre;
}
public void setNombre(String nombre) {
this.nombre = nombre;
}
public String getResponsable() {
return responsable;
}
public void setResponsable(String responsable) {
this.responsable = responsable;
}
@Override
public String toString() {
return "Vicerrectorado [id=" + id + ", nombre=" + nombre
+ ", responsable=" + responsable + "]";
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((nombre == null) ? 0 : nombre.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Vicerrectorado other = (Vicerrectorado) obj;
if (nombre == null) {
if (other.nombre != null)
return false;
} else if (!nombre.equals(other.nombre))
return false;
return true;
}
}
13.6.2.2
*.types
13.6.2.2.1
Constants.java
package es.uniovi.innova.eadministracion.tramites.swu.model.types;
/**
* Clase que define constantes que se utilizan a lo largo de la aplicación
*
* @author danielmf
*
*/
public class Constants {
// *********************** Cassandra ******************************
public static final String MATCH = "match";
public static final String MODELCLASS = "modelclass";
public static final String NOSQL = "/nosql.properties";
public static final String INDEX = "/index";
// *********************** Models ******************************
public static final String[] BECA = { "nombre_procedimiento_convocatoria",
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
257
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Apéndices
"asunto_convocatoria", "estado_solicitud", "destino",
"cuantia_otorgada", "curso_academico" };
public static final String[] SOLICITANTE = { "nombre_solicitante",
"apellido1_solicitante", "apellido2_solicitante",
"documento_identificativo", "tipo_documento_identificativo",
"nacionalidad", "sexo", "fecha_nacimiento", "estudios" };
public static final String[] MODEL = { "BECA", "SOLICITANTE" };
public static final String[] OPS = { "ALUMNO", "CURSO", "VICERRECTORADO" };
public static final String MATCH_OPERATION_VICERRECTORADO = "VICERRECTORADO";
public static final String MATCH_OPERATION_ALUMNO = "ALUMNO";
public static final String MATCH_OPERATION_CURSO = "CURSO";
}
13.6.2.2.2
ModelWrapperKey.java
package es.uniovi.innova.eadministracion.tramites.swu.model.types;
import java.io.Serializable;
import es.uniovi.innova.eadministracion.tramites.swu.model.wrapper.ModelWrapper;
/**
* Clave JPA de {@link ModelWrapper}
*
* @author danielmf
*
*/
public class ModelWrapperKey implements Serializable {
private static final long serialVersionUID = -1415030955602048569L;
String concrete;
String match;
String clazz;
public ModelWrapperKey(String concrete, String match, String clazz) {
this.concrete = concrete;
this.match = match;
this.clazz = clazz;
}
public ModelWrapperKey() {
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((clazz == null) ? 0 : clazz.hashCode());
result = prime * result
+ ((concrete == null) ? 0 : concrete.hashCode());
result = prime * result + ((match == null) ? 0 : match.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
ModelWrapperKey other = (ModelWrapperKey) obj;
if (clazz == null) {
if (other.clazz != null)
return false;
} else if (!clazz.equals(other.clazz))
return false;
258
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Apéndices | Plataforma para Interoperabilidad de sistemas de información dentro de un
mismo ámbito organizativo
if (concrete == null) {
if (other.concrete != null)
return false;
} else if (!concrete.equals(other.concrete))
return false;
if (match == null) {
if (other.match != null)
return false;
} else if (!match.equals(other.match))
return false;
return true;
}
}
13.6.2.2.3
OperationWrapperKey.java
package es.uniovi.innova.eadministracion.tramites.swu.model.types;
import java.io.Serializable;
import es.uniovi.innova.eadministracion.tramites.swu.model.University;
import es.uniovi.innova.eadministracion.tramites.swu.model.wrapper.OperationWrapper;
/**
* Clave JPA de {@link OperationWrapper}
*
* @author danielmf
*
*/
public class OperationWrapperKey implements Serializable {
private static final long serialVersionUID = -4486027401624093144L;
String op;
University university;
String match;
public OperationWrapperKey(String op, University university, String match) {
this.op = op;
this.university = university;
this.match = match;
}
public OperationWrapperKey() {
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((match == null) ? 0 : match.hashCode());
result = prime * result + ((op == null) ? 0 : op.hashCode());
result = prime * result
+ ((university == null) ? 0 : university.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
OperationWrapperKey other = (OperationWrapperKey) obj;
if (match == null) {
if (other.match != null)
return false;
} else if (!match.equals(other.match))
return false;
if (op == null) {
if (other.op != null)
return false;
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
259
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Apéndices
} else if (!op.equals(other.op))
return false;
if (university == null) {
if (other.university != null)
return false;
} else if (!university.equals(other.university))
return false;
return true;
}
}
13.6.2.3
*.wrapper
13.6.2.3.1
BecaWrapper.java
package es.uniovi.innova.eadministracion.tramites.swu.model.wrapper;
/**
* Envoltorio para utilizar Beca sin necesidad de utilizar sus agregados
*
* @author danielmf
*
*/
public class BecaWrapper {
private
private
private
private
private
private
String
String
String
String
String
String
nombre_procedimiento_convocatoria;
asunto_convocatoria;
estado_solicitud;
destino;
cuantia_otorgada;
curso_academico;
public BecaWrapper() {
super();
}
public BecaWrapper(String nombre_procedimiento_convocatoria,
String asunto_convocatoria, String estado_solicitud,
String destino, String cuantia_otorgada, String curso_academico) {
super();
this.nombre_procedimiento_convocatoria =
nombre_procedimiento_convocatoria;
this.asunto_convocatoria = asunto_convocatoria;
this.estado_solicitud = estado_solicitud;
this.destino = destino;
this.cuantia_otorgada = cuantia_otorgada;
this.curso_academico = curso_academico;
}
public String getNombre_procedimiento_convocatoria() {
return nombre_procedimiento_convocatoria;
}
public void setNombre_procedimiento_convocatoria(
String nombre_procedimiento_convocatoria) {
this.nombre_procedimiento_convocatoria =
nombre_procedimiento_convocatoria;
}
public String getAsunto_convocatoria() {
return asunto_convocatoria;
}
public void setAsunto_convocatoria(String asunto_convocatoria) {
this.asunto_convocatoria = asunto_convocatoria;
}
public String getEstado_solicitud() {
return estado_solicitud;
}
public void setEstado_solicitud(String estado_solicitud) {
260
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Apéndices | Plataforma para Interoperabilidad de sistemas de información dentro de un
mismo ámbito organizativo
this.estado_solicitud = estado_solicitud;
}
public String getDestino() {
return destino;
}
public void setDestino(String destino) {
this.destino = destino;
}
public String getCuantia_otorgada() {
return cuantia_otorgada;
}
public void setCuantia_otorgada(String cuantia_otorgada) {
this.cuantia_otorgada = cuantia_otorgada;
}
public String getCurso_academico() {
return curso_academico;
}
public void setCurso_academico(String curso_academico) {
this.curso_academico = curso_academico;
}
}
13.6.2.3.2
ModelWrapper.java
package es.uniovi.innova.eadministracion.tramites.swu.model.wrapper;
import
import
import
import
import
import
javax.persistence.Column;
javax.persistence.Entity;
javax.persistence.Id;
javax.persistence.IdClass;
javax.persistence.ManyToOne;
javax.persistence.Table;
import es.uniovi.innova.eadministracion.tramites.swu.model.University;
import es.uniovi.innova.eadministracion.tramites.swu.model.types.ModelWrapperKey;
/**
* Envoltorio para recoger los campos entre el modelo genérico y una
* {@link University}
*
* @author danielmf
*
*/
@Entity
@Table(name = "TMODELSWRAPPER")
@IdClass(ModelWrapperKey.class)
public class ModelWrapper {
@Id
private String
@Id
private String
@Column(name =
private String
@Id
private String
private String
concrete;
match;
"joins")
join;
clazz;
modelClazz;
@ManyToOne
private University university;
public ModelWrapper(String concrete, String match, String join,
String clazz, String modelClazz, University university) {
super();
this.concrete = concrete;
this.match = match;
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
261
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Apéndices
this.join = join;
this.clazz = clazz;
this.modelClazz = modelClazz;
this.university = university;
}
public ModelWrapper(String concrete, String match, String join,
String clazz, String modelClazz) {
super();
this.concrete = concrete;
this.match = match;
this.join = join;
this.clazz = clazz;
this.modelClazz = modelClazz;
}
public ModelWrapper() {
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result
+ ((concrete == null) ? 0 : concrete.hashCode());
result = prime * result + ((match == null) ? 0 : match.hashCode());
result = prime * result
+ ((university == null) ? 0 : university.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
ModelWrapper other = (ModelWrapper) obj;
if (concrete == null) {
if (other.concrete != null)
return false;
} else if (!concrete.equals(other.concrete))
return false;
if (match == null) {
if (other.match != null)
return false;
} else if (!match.equals(other.match))
return false;
if (university == null) {
if (other.university != null)
return false;
} else if (!university.equals(other.university))
return false;
return true;
}
@Override
public String toString() {
return "ModelWrapper [concrete=" + concrete + ", match=" + match
+ ", join=" + join + ", clazz=" + clazz + ", modelClazz="
+ modelClazz + "]";
}
public String getMatch() {
return match;
}
public void setMatch(String match) {
this.match = match;
}
public String getJoin() {
return join;
}
262
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Apéndices | Plataforma para Interoperabilidad de sistemas de información dentro de un
mismo ámbito organizativo
public void setJoin(String join) {
this.join = join;
}
public String getClazz() {
return clazz;
}
public void setClazz(String clazz) {
this.clazz = clazz;
}
public void setConcrete(String concrete) {
this.concrete = concrete;
}
public String getConcrete() {
return concrete;
}
public University getUniversity() {
return university;
}
public void setUniversity(University university) {
this.university = university;
}
public String getModelClazz() {
return modelClazz;
}
public void setModelClazz(String modelClazz) {
this.modelClazz = modelClazz;
}
}
13.6.2.3.3
OperationWrapper.java
package es.uniovi.innova.eadministracion.tramites.swu.model.wrapper;
import
import
import
import
import
import
javax.persistence.Column;
javax.persistence.Entity;
javax.persistence.Id;
javax.persistence.IdClass;
javax.persistence.ManyToOne;
javax.persistence.Table;
import es.uniovi.innova.eadministracion.tramites.swu.model.University;
import es.uniovi.innova.eadministracion.tramites.swu.model.types.OperationWrapperKey;
/**
* Modela una relación entre las operaciones de un wsdl y una {@link University}
*
* @author danielmf
*
*/
@Entity
@Table(name = "TOPERATIONSWRAPPER")
@IdClass(OperationWrapperKey.class)
public class OperationWrapper {
@Column(nullable = false)
@Id
private String op;
@Id
private String match;
@Id
@ManyToOne
private University university;
public OperationWrapper(String op) {
super();
this.op = op;
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
263
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Apéndices
}
public OperationWrapper() {
super();
}
public OperationWrapper(String op, String match, University university) {
super();
this.op = op;
this.match = match;
this.university = university;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((match == null) ? 0 : match.hashCode());
result = prime * result + ((op == null) ? 0 : op.hashCode());
result = prime * result
+ ((university == null) ? 0 : university.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
OperationWrapper other = (OperationWrapper) obj;
if (match == null) {
if (other.match != null)
return false;
} else if (!match.equals(other.match))
return false;
if (op == null) {
if (other.op != null)
return false;
} else if (!op.equals(other.op))
return false;
if (university == null) {
if (other.university != null)
return false;
} else if (!university.equals(other.university))
return false;
return true;
}
@Override
public String toString() {
return "OperationWrapper [op=" + op + ", match=" + match + "]";
}
public String getOp() {
return op;
}
public String getMatch() {
return match;
}
public void setMatch(String match) {
this.match = match;
}
public void setOp(String op) {
this.op = op;
}
public University getUniversity() {
return university;
}
public void setUniversity(University university) {
264
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Apéndices | Plataforma para Interoperabilidad de sistemas de información dentro de un
mismo ámbito organizativo
this.university = university;
}
}
13.6.2.3.4
OperationWrapperDocument.java
package es.uniovi.innova.eadministracion.tramites.swu.model.wrapper;
import org.apache.solr.client.solrj.beans.Field;
import org.springframework.data.annotation.Id;
/**
* Envoltorio para las Operaciones de los servicios web
*
* @author danielmf
*
*/
public class OperationWrapperDocument {
@Id
@Field
private String id;
@Field
private String match;
@Field
private String op;
@Field
private String university_name;
@Field
private Integer university;
public OperationWrapperDocument(String id, String match, String op,
String university_name, Long university) {
super();
this.id = id;
this.match = match;
this.op = op;
this.university_name = university_name;
this.university = university.intValue();
}
public OperationWrapperDocument() {
super();
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getMatch() {
return match;
}
public void setMatch(String match) {
this.match = match;
}
public String getOp() {
return op;
}
public void setOp(String op) {
this.op = op;
}
public Integer getUniversity() {
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
265
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Apéndices
return university;
}
public void setUniversity(Long university) {
this.university = university.intValue();
}
public String getUniversity_name() {
return university_name;
}
public void setUniversity_name(String university_name) {
this.university_name = university_name;
}
@Override
public String toString() {
return "OperationWrapperDocument [id=" + id + ", match=" + match
+ ", op=" + op + ", university=" + university + "]";
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((id == null) ? 0 : id.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
OperationWrapperDocument other = (OperationWrapperDocument) obj;
if (id == null) {
if (other.id != null)
return false;
} else if (!id.equals(other.id))
return false;
return true;
}
}
13.6.2.3.5
ParamsWrapper.java
package es.uniovi.innova.eadministracion.tramites.swu.model.wrapper;
import java.util.ArrayList;
import java.util.List;
/**
* Envoltorio que almacena el tipo de argumentos que recibe un método y el tipo
* del retorno
*
* @author danielmf
*
*/
public class ParamsWrapper {
private List<String> fields;
private String return_;
public ParamsWrapper() {
super();
fields = new ArrayList<String>();
}
@Override
public String toString() {
return "ParamsWrapper [fields=" + fields + ", return_=" + return_ + "]";
266
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Apéndices | Plataforma para Interoperabilidad de sistemas de información dentro de un
mismo ámbito organizativo
}
public void add(String field) {
if (!fields.add(field))
throw new RuntimeException("No se ha podido insertar " + field);
}
public void remove(String field) {
if (fields.remove(field))
throw new RuntimeException("No se ha podido borrar " + field);
}
public List<String> getFields() {
return fields;
}
public void setFields(List<String> fields) {
this.fields = fields;
}
public String getReturn_() {
return return_;
}
public void setReturn_(String return_) {
this.return_ = return_;
}
}
13.6.2.3.6
SolicitanteWrapper.java
package es.uniovi.innova.eadministracion.tramites.swu.model.wrapper;
/**
* Envoltorio para un Solicitante
*
* @author danielmf
*
*/
public class SolicitanteWrapper {
private
private
private
private
private
private
private
private
private
String
String
String
String
String
String
String
String
String
nombre_solicitante;
apellido1_solicitante;
apellido2_solicitante;
documento_identificativo;
tipo_documento_identificativo;
nacionalidad;
sexo;
fecha_nacimiento;
estudios;
public SolicitanteWrapper(String nombre_solicitante,
String apellido1_solicitante, String apellido2_solicitante,
String documento_identificativo,
String tipo_documento_identificativo, String nacionalidad,
String sexo, String fecha_nacimiento, String estudios) {
super();
this.nombre_solicitante = nombre_solicitante;
this.apellido1_solicitante = apellido1_solicitante;
this.apellido2_solicitante = apellido2_solicitante;
this.documento_identificativo = documento_identificativo;
this.tipo_documento_identificativo = tipo_documento_identificativo;
this.nacionalidad = nacionalidad;
this.sexo = sexo;
this.fecha_nacimiento = fecha_nacimiento;
this.estudios = estudios;
}
public SolicitanteWrapper() {
super();
}
public String getNombre_solicitante() {
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
267
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Apéndices
return nombre_solicitante;
}
public void setNombre_solicitante(String nombre_solicitante) {
this.nombre_solicitante = nombre_solicitante;
}
public String getApellido1_solicitante() {
return apellido1_solicitante;
}
public void setApellido1_solicitante(String apellido1_solicitante) {
this.apellido1_solicitante = apellido1_solicitante;
}
public String getApellido2_solicitante() {
return apellido2_solicitante;
}
public void setApellido2_solicitante(String apellido2_solicitante) {
this.apellido2_solicitante = apellido2_solicitante;
}
public String getDocumento_identificativo() {
return documento_identificativo;
}
public void setDocumento_identificativo(String documento_identificativo) {
this.documento_identificativo = documento_identificativo;
}
public String getTipo_documento_identificativo() {
return tipo_documento_identificativo;
}
public void setTipo_documento_identificativo(
String tipo_documento_identificativo) {
this.tipo_documento_identificativo = tipo_documento_identificativo;
}
public String getNacionalidad() {
return nacionalidad;
}
public void setNacionalidad(String nacionalidad) {
this.nacionalidad = nacionalidad;
}
public String getSexo() {
return sexo;
}
public void setSexo(String sexo) {
this.sexo = sexo;
}
public String getFecha_nacimiento() {
return fecha_nacimiento;
}
public void setFecha_nacimiento(String fecha_nacimiento) {
this.fecha_nacimiento = fecha_nacimiento;
}
public String getEstudios() {
return estudios;
}
public void setEstudios(String estudios) {
this.estudios = estudios;
}
}
268
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Apéndices | Plataforma para Interoperabilidad de sistemas de información dentro de un
mismo ámbito organizativo
13.6.2.4
Es.uniovi.innova.eadministracion.tramites.swu.persiste
nce
13.6.2.4.1
HashDataService.java
package es.uniovi.innova.eadministracion.tramites.swu.persistence;
import es.uniovi.innova.eadministracion.tramites.swu.model.wrapper.ModelWrapper;
import es.uniovi.innova.eadministracion.tramites.swu.model.wrapper.OperationWrapper;
/**
* Fachada que define las operaciones de la capa de persistencia relativa a la
* base de datos NoSQL.
*
* @author danielmf
*
*/
public interface HashDataService {
/**
* Carga el modelo inicial (solo se ejecuta una vez)
*/
public void init();
/**
* Guarda en la base de datos NoSQL un match con el modelo
*
* @param modelWrapper
*/
public void save(ModelWrapper modelWrapper);
/**
* Guarda en la base de datos NoSQL un match con una operación
*
* @param operationWrapper
*/
public void save(OperationWrapper operationWrapper);
/**
* Busca matches previos relativos a {@link ModelWrapper}
*
* @param field
* @param modelClazz
*
* @return null o el match
*/
public ModelWrapper queryModel(String field, String modelClazz);
/**
* Busca matches previos relativos a {@link OperationWrapper}
*
* @param operationWrapper
*
* @return null o el match
*/
public OperationWrapper queryOps(OperationWrapper operationWrapper);
}
13.6.2.4.2
ModelWrapperDataService.java
package es.uniovi.innova.eadministracion.tramites.swu.persistence;
import java.util.List;
import javax.inject.Named;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.CrudRepository;
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
269
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Apéndices
import es.uniovi.innova.eadministracion.tramites.swu.model.University;
import es.uniovi.innova.eadministracion.tramites.swu.model.types.ModelWrapperKey;
import es.uniovi.innova.eadministracion.tramites.swu.model.wrapper.ModelWrapper;
/**
* Capa de persistencia que encapsula las operaciones de {@link ModelWrapper}
* mediante {@link CrudRepository}
*
* @author danielmf
*
*/
@Named
public interface ModelWrapperDataService extends
CrudRepository<ModelWrapper, ModelWrapperKey> {
@Query(name = "ModelWrapper.findByUniversityClazz")
public List<ModelWrapper> findByUniversityClazz(University university,
String clazz);
}
13.6.2.4.3
OperationsWrapperDataService.java
package es.uniovi.innova.eadministracion.tramites.swu.persistence;
import java.util.List;
import javax.inject.Named;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.CrudRepository;
import es.uniovi.innova.eadministracion.tramites.swu.model.University;
import es.uniovi.innova.eadministracion.tramites.swu.model.types.OperationWrapperKey;
import es.uniovi.innova.eadministracion.tramites.swu.model.wrapper.OperationWrapper;
/**
* Capa de persistencia que encapsula las operaciones de
* {@link OperationWrapper} mediante {@link CrudRepository}
*
* @author danielmf
*
*/
@Named
public interface OperationsWrapperDataService extends
CrudRepository<OperationWrapper, OperationWrapperKey> {
public List<OperationWrapper> findByMatch(String match);
public List<OperationWrapper> findByUniversity(University university);
@Query(name = "OperationWrapper.findByMatchAndUniversityId")
public List<OperationWrapper> findByMatchAndUniversityId(String mode,
Long id);
}
13.6.2.4.4
UniversityDataService.java
package es.uniovi.innova.eadministracion.tramites.swu.persistence;
import javax.inject.Named;
import org.springframework.data.repository.CrudRepository;
import es.uniovi.innova.eadministracion.tramites.swu.model.University;
/**
* Inferface que implementa {@link CrudRepository} para gestionar las CRUD con
* la base de datos del modelo {@link University}
*
* @author danielmf
*
270
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Apéndices | Plataforma para Interoperabilidad de sistemas de información dentro de un
mismo ámbito organizativo
*/
@Named
public interface UniversityDataService extends CrudRepository<University, Long> {
/**
* Busca universidades por nombre
*
* @param name
*
para identificar la Universidad
*
* @return
*/
public University findByName(String name);
/**
* Busca universidades por el WSDL
*
* @param wsdl
*
url donde se alojan los servicios
*
* @return
*/
public University findByWsdl(String wsdl);
}
13.6.2.5
*.nosql
13.6.2.5.1
CassandraMatcher.java
package es.uniovi.innova.eadministracion.tramites.swu.persistence.nosql;
import java.util.Arrays;
import javax.inject.Named;
import
import
import
import
import
import
import
import
import
import
import
import
import
me.prettyprint.cassandra.serializers.StringSerializer;
me.prettyprint.cassandra.service.ThriftKsDef;
me.prettyprint.cassandra.service.template.ColumnFamilyResult;
me.prettyprint.cassandra.service.template.ColumnFamilyTemplate;
me.prettyprint.cassandra.service.template.ColumnFamilyUpdater;
me.prettyprint.cassandra.service.template.ThriftColumnFamilyTemplate;
me.prettyprint.hector.api.Cluster;
me.prettyprint.hector.api.Keyspace;
me.prettyprint.hector.api.ddl.ColumnFamilyDefinition;
me.prettyprint.hector.api.ddl.ComparatorType;
me.prettyprint.hector.api.ddl.KeyspaceDefinition;
me.prettyprint.hector.api.exceptions.HectorException;
me.prettyprint.hector.api.factory.HFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import
import
import
import
import
es.uniovi.innova.eadministracion.tramites.swu.model.types.Constants;
es.uniovi.innova.eadministracion.tramites.swu.model.wrapper.ModelWrapper;
es.uniovi.innova.eadministracion.tramites.swu.model.wrapper.OperationWrapper;
es.uniovi.innova.eadministracion.tramites.swu.persistence.HashDataService;
es.uniovi.innova.eadministracion.tramites.swu.util.Helper;
/**
* Realiza operaciones sobre una base de datos Apache Cassandra
*
* @author danielmf
*
*/
@Named
public class CassandraMatcher implements HashDataService {
private static Logger logger = LoggerFactory
.getLogger(CassandraMatcher.class);
private ColumnFamilyTemplate<String, String> template;
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
271
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Apéndices
public CassandraMatcher() {
logger.debug("Creando el conector de Cassandra");
template = connect();
}
@Override
public void init() {
setUpModel();
setUpOps();
}
@Override
public void save(ModelWrapper modelWrapper) {
ColumnFamilyUpdater<String, String> updater = template
.createUpdater(modelWrapper.getConcrete());
updater.setString(Constants.MATCH, modelWrapper.getMatch());
updater.setString(Constants.MODELCLASS, modelWrapper.getModelClazz());
template.update(updater);
logger.info(modelWrapper + " guardado correctamente");
}
@Override
public void save(OperationWrapper operationWrapper) {
String op = Helper.getClassName(operationWrapper.getOp());
ColumnFamilyUpdater<String, String> updater = template.createUpdater(op
.toLowerCase());
updater.setString(Constants.MATCH, operationWrapper.getMatch());
template.update(updater);
logger.info(operationWrapper + " guardado correctamente.");
}
@Override
public ModelWrapper queryModel(String field, String modelClazz) {
String match = null;
String modelclazz = null;
logger.info("Buscando: " + field);
try {
ColumnFamilyResult<String, String> res = template
.queryColumns(field);
match = res.getString(Constants.MATCH);
modelclazz = res.getString(Constants.MODELCLASS);
if (match != null && modelclazz != null
&& modelclazz.equalsIgnoreCase(modelClazz)) {
ModelWrapper modelWrapper = new ModelWrapper();
modelWrapper.setConcrete(field);
modelWrapper.setMatch(match);
modelWrapper.setModelClazz(modelclazz);
return modelWrapper;
}
} catch (HectorException e) {
logger.error(e.getMessage());
}
return null;
}
@Override
public OperationWrapper queryOps(OperationWrapper operationWrapper) {
272
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Apéndices | Plataforma para Interoperabilidad de sistemas de información dentro de un
mismo ámbito organizativo
String match = null;
logger.info("Buscando :" + operationWrapper.getOp());
try {
String op = Helper.getClassName(operationWrapper.getOp());
ColumnFamilyResult<String, String> res = template.queryColumns(op
.toLowerCase());
match = res.getString(Constants.MATCH);
if (match != null) {
operationWrapper.setMatch(match);
} else
return null;
} catch (HectorException e) {
logger.error(e.getMessage());
}
return operationWrapper;
}
/**
* Crea el Schema dentro del cluster que se le pasa por parámetro
*
* @param myCluster
*
{@link Cluster} Cluster de Cassandra sobre el que se creará el
*
Schema
*/
private void createSchema(Cluster myCluster) {
logger.info("Generando esquema para la base de datos Cassandra");
String repository = Helper.getProperty(Constants.NOSQL, "repository");
String schema = Helper.getProperty(Constants.NOSQL, "schema");
ColumnFamilyDefinition cfDef = HFactory.createColumnFamilyDefinition(
repository, schema, ComparatorType.BYTESTYPE);
KeyspaceDefinition newKeyspace = HFactory.createKeyspaceDefinition(
repository, ThriftKsDef.DEF_STRATEGY_CLASS, 1,
Arrays.asList(cfDef));
myCluster.addKeyspace(newKeyspace, true);
}
/**
* Realiza la conexión con un cluster habilitado de Cassandra, además de
* conectarse a una base de datos concreta.
*
* @return {@link ColumnFamilyTemplate} template para utilizar la conexión
*
posteriormente.
*/
private ColumnFamilyTemplate<String, String> connect() {
logger.info("Conectando al cluster...");
String
String
String
String
cluster = Helper.getProperty(Constants.NOSQL, "cluster");
url = Helper.getProperty(Constants.NOSQL, "url");
repository = Helper.getProperty(Constants.NOSQL, "repository");
schema = Helper.getProperty(Constants.NOSQL, "schema");
Cluster myCluster = HFactory.getOrCreateCluster(cluster, url);
KeyspaceDefinition keyspaceDef = myCluster.describeKeyspace(repository);
if (keyspaceDef == null)
createSchema(myCluster);
Keyspace ksp = HFactory.createKeyspace(repository, myCluster);
ColumnFamilyTemplate<String, String> template = new
ThriftColumnFamilyTemplate<String, String>(
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
273
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Apéndices
ksp, schema, StringSerializer.get(),
StringSerializer.get());
return template;
}
/**
* Carga las operaciones en Cassandra
*/
private void setUpOps() {
try {
logger.info("Inicializando las operaciones en Cassandra...");
ColumnFamilyUpdater<String, String> updater = template
.createUpdater("getbecasporalumno");
updater.setString(Constants.MATCH, "getBecasPorAlumno");
template.update(updater);
updater = template.createUpdater("getbecasporcurso");
updater.setString(Constants.MATCH, "getBecasPorCurso");
template.update(updater);
updater = template.createUpdater("getbecasporvicerrectorado");
updater.setString(Constants.MATCH, "getBecasPorVicerrectorado");
template.update(updater);
} catch (HectorException e) {
logger.error(e.getMessage());
e.printStackTrace();
}
}
/**
* Carga los modelos en Cassandra
*/
private void setUpModel() {
try {
logger.info("Inicializando modelos en Cassandra...");
ColumnFamilyUpdater<String, String> updater = template
.createUpdater("apellidos");
updater.setString(Constants.MATCH, "apellidos");
updater.setString(Constants.MODELCLASS, "ALUMNO");
template.update(updater);
updater = template.createUpdater("nombre");
updater.setString(Constants.MATCH, "nombre");
updater.setString(Constants.MODELCLASS, "ALUMNO");
template.update(updater);
updater = template.createUpdater("telefono");
updater.setString(Constants.MATCH, "telefono");
updater.setString(Constants.MODELCLASS, "ALUMNO");
template.update(updater);
updater = template.createUpdater("direccion");
updater.setString(Constants.MATCH, "direccion");
updater.setString(Constants.MODELCLASS, "ALUMNO");
template.update(updater);
updater = template.createUpdater("nif");
updater.setString(Constants.MATCH, "nif");
updater.setString(Constants.MODELCLASS, "ALUMNO");
template.update(updater);
} catch (HectorException e) {
logger.error(e.getMessage());
274
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Apéndices | Plataforma para Interoperabilidad de sistemas de información dentro de un
mismo ámbito organizativo
e.printStackTrace();
}
}
}
13.6.2.5.2
CassandraSetUp.java
package es.uniovi.innova.eadministracion.tramites.swu.persistence.nosql;
/**
* Clase que inicializa la Base de datos NoSQL con los datos iniciales del
* modelo definido por la entidad reguladora.
*
* @author danielmf
*
*/
public class CassandraSetUp {
public static void main(String[] args) {
new CassandraMatcher().init();
}
}
13.6.2.6
Es.uniovi.innova.eadministracion.tramites.swu.util
13.6.2.6.1
Helper.java
package es.uniovi.innova.eadministracion.tramites.swu.util;
import java.io.IOException;
import java.util.Properties;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* Helper para cargar las configuraciones y otros métodos de utilidad
*
* @author danielmf
*
*/
public class Helper {
private static Logger logger = LoggerFactory.getLogger(Helper.class);
/**
* Obtiene una propiedad de un fichero de propiedades bajo una clave
*
* @param CONF_FILE
* @param key
*
* @return
*/
public static String getProperty(String CONF_FILE, String key) {
Properties properties = new Properties();
try {
logger.debug("Obtaining " + key);
properties.load(Helper.class.getResourceAsStream(CONF_FILE));
} catch (IOException e) {
logger.error(e.getMessage());
}
return properties.getProperty(key);
}
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
275
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Apéndices
/**
* Obtiene el nombre de una clase sin el paquete
*
* @param classNameWithPackage
*
* @return
*/
public static String getClassName(String classNameWithPackage) {
String[] strs = classNameWithPackage.split("\\.");
return strs[strs.length - 1];
}
/**
* Obtiene el paquete base de una clase bajo un servicio web.
*
* @param clazzName
*
* @return
*/
public static String retrieveCompleteName(String clazzName) {
String[] name = clazzName.split("\\.");
String res = name[0] + ".";
for (int i = 1; i < name.length - 1; i++)
res += name[i] + ".";
return res;
}
}
13.6.2.7
*.solr
13.6.2.7.1
OperationsWrapperDocumentRepository.java
package es.uniovi.innova.eadministracion.tramites.swu.util.solr;
import java.util.List;
import javax.inject.Named;
import org.springframework.data.solr.repository.Query;
import org.springframework.data.solr.repository.SolrCrudRepository;
import
es.uniovi.innova.eadministracion.tramites.swu.model.wrapper.OperationWrapperDocument;
/**
* Interface que resuelve las operaciones de Spring Data Solr para la
* funcionalidad del buscador.
*
* @author danielmf
*
*/
@Named
public interface OperationsWrapperDocumentRepository extends
SolrCrudRepository<OperationWrapperDocument, String> {
@Query("op:*?0* OR match:*?0* OR university_name:*?0*")
public List<OperationWrapperDocument> findByMatchOrOp(String keyword);
}
276
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Apéndices | Plataforma para Interoperabilidad de sistemas de información dentro de un
mismo ámbito organizativo
13.6.3 Define-tramites-servicios-web-unificadospublisher
13.6.3.1
Es.uniovi.innova.eadministracion.tramites.swu.service
13.6.3.1.1
IScholarshipService.java
package es.uniovi.innova.eadministracion.tramites.swu.service;
import java.util.List;
import es.uniovi.innova.eadministracion.tramites.swu.model.Beca;
public interface IScholarshipService {
public List<Beca> getBecasByParam(Object param, String category,
String university);
}
13.6.3.1.2
ScholarshipService.java
package es.uniovi.innova.eadministracion.tramites.swu.service;
import java.util.List;
import
import
import
import
import
javax.inject.Inject;
javax.inject.Named;
javax.jws.WebMethod;
javax.jws.WebService;
javax.xml.ws.soap.MTOM;
import es.uniovi.innova.eadministracion.tramites.swu.business.WebServiceManagerService;
import es.uniovi.innova.eadministracion.tramites.swu.model.Beca;
@Named
@MTOM
@WebService(name = "ScholarshipService", serviceName = "ScholarshipService", portName =
"ScholarshipServicePort", targetNamespace =
"http://innova.uniovi.es/ScholarshipService")
public class ScholarshipService implements IScholarshipService {
@Inject
private WebServiceManagerService webServiceService;
@WebMethod(operationName = "getBecasByParam")
@Override
public List<Beca> getBecasByParam(Object param, String category,
String university) {
List<Beca> becas;
if (university != null) {
becas = webServiceService.getBecasByParam(param, category,
university.toUpperCase());
} else {
becas = webServiceService.getBecasByParam(param, category);
}
return becas;
}
}
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
277
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Apéndices
13.6.4 Define-tramites-servicios-web-unificadosrecolector
13.6.4.1
Es.uniovi.innova.eadministracion.tramites.swu.presenta
tion
package es.uniovi.innova.eadministracion.tramites.swu.presentation;
/**
* Interface para la semi-implementación de un patrón Command para la capa de
* presentación (Siguiendo un modelo similar a Struts, por ejemplo)
*
* @author danielmf
*
*/
public interface Executable {
/**
* Método para asegurar que todas las clases de la capa de presentación
* pertenecen al Command
*/
public void execute();
}
13.6.4.2
*.ws
13.6.4.2.1
ShowBecasByAlumno.java
package es.uniovi.innova.eadministracion.tramites.swu.presentation.ws;
import java.util.List;
import javax.inject.Inject;
import javax.inject.Named;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import
import
import
import
es.uniovi.innova.eadministracion.tramites.swu.business.WebServiceManagerService;
es.uniovi.innova.eadministracion.tramites.swu.model.Beca;
es.uniovi.innova.eadministracion.tramites.swu.model.types.Constants;
es.uniovi.innova.eadministracion.tramites.swu.presentation.Executable;
/**
* Presenta las becas de la categoría de Alumno
*
* @author danielmf
*
*/
@Named
public class ShowBecasByAlumno implements Executable {
private static Logger logger = LoggerFactory
.getLogger(ShowBecasByAlumno.class);
private String dni;
private String universidad;
@Inject
private WebServiceManagerService webServiceService;
@Override
public void execute() {
List<Beca> becas;
278
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Apéndices | Plataforma para Interoperabilidad de sistemas de información dentro de un
mismo ámbito organizativo
if (universidad != null) {
becas = webServiceService
.getBecasByParam(dni,
Constants.MATCH_OPERATION_ALUMNO,
universidad.toUpperCase());
} else {
becas = webServiceService.getBecasByParam(dni,
Constants.MATCH_OPERATION_ALUMNO);
}
logger.debug(becas.toString());
logger.info("ShowBecasByAlumno ejecutado.");
}
public void setDni(String dni) {
this.dni = dni;
}
public void setUniversidad(String universidad) {
this.universidad = universidad;
}
}
13.6.4.2.2
ShowBecasByCurso.java
package es.uniovi.innova.eadministracion.tramites.swu.presentation.ws;
import java.util.List;
import javax.inject.Inject;
import javax.inject.Named;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import
import
import
import
es.uniovi.innova.eadministracion.tramites.swu.business.WebServiceManagerService;
es.uniovi.innova.eadministracion.tramites.swu.model.Beca;
es.uniovi.innova.eadministracion.tramites.swu.model.types.Constants;
es.uniovi.innova.eadministracion.tramites.swu.presentation.Executable;
/**
* Presenta las becas generadas por la categoría de curso
*
* @author danielmf
*
*/
@Named
public class ShowBecasByCurso implements Executable {
private static Logger logger = LoggerFactory
.getLogger(ShowBecasByCurso.class);
@Inject
private WebServiceManagerService webServiceService;
private int curso;
private String universidad;
@Override
public void execute() {
List<Beca> becas;
if (universidad != null) {
becas = webServiceService.getBecasByParam(curso,
Constants.MATCH_OPERATION_CURSO,
universidad.toUpperCase());
} else {
becas = webServiceService.getBecasByParam(curso,
Constants.MATCH_OPERATION_CURSO);
}
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
279
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Apéndices
System.out.println(becas);
logger.info("ShowBecasByCurso ejecutado.");
}
public void setCurso(int curso) {
this.curso = curso;
}
public void setUniversidad(String universidad) {
this.universidad = universidad;
}
}
13.6.4.2.3
ShowBecasByVicerrectorado.java
package es.uniovi.innova.eadministracion.tramites.swu.presentation.ws;
import java.util.List;
import javax.inject.Inject;
import javax.inject.Named;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import
import
import
import
import
es.uniovi.innova.eadministracion.tramites.swu.business.WebServiceManagerService;
es.uniovi.innova.eadministracion.tramites.swu.model.Beca;
es.uniovi.innova.eadministracion.tramites.swu.model.Vicerrectorado;
es.uniovi.innova.eadministracion.tramites.swu.model.types.Constants;
es.uniovi.innova.eadministracion.tramites.swu.presentation.Executable;
/**
* Presenta las becas generadas por la categoría Vicerrectorado.
*
* @author danielmf
*
*/
@Named
public class ShowBecasByVicerrectorado implements Executable {
private static Logger logger = LoggerFactory
.getLogger(ShowBecasByVicerrectorado.class);
@Inject
private WebServiceManagerService webServiceService;
private Vicerrectorado vicerrectorado;
private String universidad;
@Override
public void execute() {
List<Beca> becas;
if (universidad != null) {
becas = webServiceService.getBecasByParam(vicerrectorado,
Constants.MATCH_OPERATION_VICERRECTORADO,
universidad.toUpperCase());
} else {
becas = webServiceService.getBecasByParam(vicerrectorado,
Constants.MATCH_OPERATION_VICERRECTORADO);
}
System.out.println(becas);
logger.info("ShowBecasByVicerrectorado ejecutado.");
}
public void setVicerrectorado(Vicerrectorado vicerrectorado) {
this.vicerrectorado = vicerrectorado;
}
280
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Apéndices | Plataforma para Interoperabilidad de sistemas de información dentro de un
mismo ámbito organizativo
public void setUniversidad(String universidad) {
this.universidad = universidad;
}
}
13.6.5 Define-tramites-servicios-web-unificadosregistrador
13.6.5.1
Es.uniovi.innova.eadministracion.tramites.swu.presenta
tion
13.6.5.1.1
CheckStatus.java
package es.uniovi.innova.eadministracion.tramites.swu.presentation;
import javax.inject.Inject;
import javax.inject.Named;
import es.uniovi.innova.eadministracion.tramites.swu.business.MatcherManagerService;
import es.uniovi.innova.eadministracion.tramites.swu.business.UniversityManagerService;
import es.uniovi.innova.eadministracion.tramites.swu.model.University;
/**
* Clase que comprueba la postcondición de la aplicación para no dejar datos
* inconsistentes
*
* @author danielmf
*
*/
@Named
public class CheckStatus implements Executable {
@Inject
private UniversityManagerService universityService;
@Inject
private MatcherManagerService matcherService;
private University university;
@Override
public void execute() {
if (!matcherService.checkStatus(university))
universityService.remove(university);
}
public void setUniversity(University university) {
this.university = university;
}
}
13.6.5.1.2
Executable.java
package es.uniovi.innova.eadministracion.tramites.swu.presentation;
/**
* Interface para la semi-implementación de un patrón Command para la capa de
* presentación (Siguiendo un modelo similar a Struts, por ejemplo)
*
* @author danielmf
*
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
281
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Apéndices
*/
public interface Executable {
/**
* Método para asegurar que todas las clases de la capa de presentación
* pertenecen al Command
*/
public void execute();
}
13.6.5.2
*.matcher
13.6.5.2.1
Builder.java
package es.uniovi.innova.eadministracion.tramites.swu.presentation.matcher;
import
import
import
import
import
import
java.io.BufferedReader;
java.io.IOException;
java.io.InputStreamReader;
java.util.Iterator;
java.util.Map;
java.util.Map.Entry;
import javax.inject.Inject;
import javax.inject.Named;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import es.uniovi.innova.eadministracion.tramites.swu.business.MatcherManagerService;
import es.uniovi.innova.eadministracion.tramites.swu.model.wrapper.ModelWrapper;
import es.uniovi.innova.eadministracion.tramites.swu.presentation.Executable;
/**
* Construye los resultados después de hacerse los matches
*
* @author danielmf
*
*/
@Named
public class Builder implements Executable {
private static Logger logger = LoggerFactory.getLogger(Builder.class);
private Map<String, Object> matches;
@Inject
private MatcherManagerService matcherService;
@Override
public void execute() {
Iterator<Entry<String, Object>> iterat = matches.entrySet().iterator();
iterat = matches.entrySet().iterator();
while (iterat.hasNext()) {
Entry<String, Object> entry = iterat.next();
ModelWrapper cwp = (ModelWrapper) entry.getValue();
if (cwp.getJoin() == null) {
String origin = cwp.getMatch();
Iterator<Entry<String, Object>> iterat2 =
matches.entrySet()
.iterator();
while (iterat2.hasNext()) {
Entry<String, Object> entry2 = iterat2.next();
if (entry2.getKey() == entry.getKey())
continue;
if (cwp.getConcrete() == ((ModelWrapper)
entry2.getValue())
.getJoin())
continue;
282
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Apéndices | Plataforma para Interoperabilidad de sistemas de información dentro de un
mismo ámbito organizativo
ModelWrapper cw3 = (ModelWrapper)
entry2.getValue();
if (origin.equalsIgnoreCase(cw3.getMatch())) {
System.out.println("¿Qué relación existe?");
System.out.println("1. " + cwp.getConcrete()
+ " + "
+ cw3.getConcrete());
System.out.println("2. " + cw3.getConcrete()
+ " + "
+ cwp.getConcrete());
System.out.println("3. ninguna");
String resp = null;
try {
resp = new BufferedReader(new
InputStreamReader(
System.in)).readLine();
} catch (IOException e) {
logger.error(e.getMessage());
}
if (Integer.parseInt(resp) == 1) {
cwp.setJoin(cw3.getConcrete());
matches.put(entry.getKey(), cwp);
} else if (Integer.parseInt(resp) == 2) {
cw3.setJoin(cwp.getConcrete());
matches.put(entry2.getKey(), cw3);
}
}
}
}
}
iterat = matches.entrySet().iterator();
while (iterat.hasNext()) {
ModelWrapper cw = (ModelWrapper) iterat.next().getValue();
matcherService.save(cw);
}
}
public Map<String, Object> getMatches() {
return matches;
}
public void setMatches(Map<String, Object> matches) {
this.matches = matches;
}
}
13.6.5.2.2
MatchFields.java
package es.uniovi.innova.eadministracion.tramites.swu.presentation.matcher;
import
import
import
import
java.io.BufferedReader;
java.io.IOException;
java.io.InputStreamReader;
java.util.Map;
import javax.inject.Inject;
import javax.inject.Named;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import
import
import
import
es.uniovi.innova.eadministracion.tramites.swu.business.MatcherManagerService;
es.uniovi.innova.eadministracion.tramites.swu.model.University;
es.uniovi.innova.eadministracion.tramites.swu.model.wrapper.ModelWrapper;
es.uniovi.innova.eadministracion.tramites.swu.presentation.Executable;
/**
* Desencadena el matching de campos con las técnicas de String Metrics
*
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
283
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Apéndices
* @author danielmf
*
*/
@Named
public class MatchFields implements Executable {
private static Logger logger = LoggerFactory.getLogger(MatchFields.class);
private
private
private
private
private
String field;
University university;
Map<String, Object> matches;
String clazz;
String modelClazz;
@Inject
private MatcherManagerService matcherService;
@Override
public void execute() {
try {
ModelWrapper cw = new ModelWrapper(field, null, null, clazz,
modelClazz, university);
String match = matcherService.match(field, modelClazz);
if (match == "")
cw = null;
else
cw.setMatch(match);
if (cw != null) {
System.out.println(field + ": " + cw.getMatch());
System.out.println("¿Es correcto?(s,n)");
String resp = new BufferedReader(new InputStreamReader(
System.in)).readLine();
if (resp.equalsIgnoreCase("s"))
matches.put(field, cw);
}
} catch (IOException e) {
logger.error(e.getMessage());
}
}
public String getField() {
return field;
}
public void setField(String field) {
this.field = field;
}
public Map<String, Object> getMatches() {
return matches;
}
public void setMatches(Map<String, Object> matches) {
this.matches = matches;
}
public University getUniversity() {
return university;
}
public void setUniversity(University university) {
this.university = university;
}
public String getClazz() {
return clazz;
}
public void setClazz(String clazz) {
284
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Apéndices | Plataforma para Interoperabilidad de sistemas de información dentro de un
mismo ámbito organizativo
this.clazz = clazz;
}
public String getModelClazz() {
return modelClazz;
}
public void setModelClazz(String modelClazz) {
this.modelClazz = modelClazz;
}
}
13.6.5.2.3
MatchOtherFields.java
package es.uniovi.innova.eadministracion.tramites.swu.presentation.matcher;
import
import
import
import
java.io.BufferedReader;
java.io.IOException;
java.io.InputStreamReader;
java.util.Map;
import javax.inject.Named;
import
import
import
import
es.uniovi.innova.eadministracion.tramites.swu.model.University;
es.uniovi.innova.eadministracion.tramites.swu.model.types.Constants;
es.uniovi.innova.eadministracion.tramites.swu.model.wrapper.ModelWrapper;
es.uniovi.innova.eadministracion.tramites.swu.presentation.Executable;
/**
* Termina de mapear los campos que no se emparejaron mediante StringMetrics y
* la NoSQL
*
* @author danielmf
*
*/
@Named
public class MatchOtherFields implements Executable {
private
private
private
private
private
String field;
String clazz;
University university;
Map<String, Object> matches;
String modelClazz;
@Override
public void execute() {
String[] consts = null;
if (modelClazz.equalsIgnoreCase("BECA"))
consts = Constants.BECA;
else if (modelClazz.equalsIgnoreCase("SOLICITANTE"))
consts = Constants.SOLICITANTE;
int i = 0;
for (String key : consts) {
System.out.println(++i + ". " + key);
}
System.out.println("0. NINGUNO");
System.out.println("¿Con que campo conecta?: " + field);
String resp;
try {
resp = new BufferedReader(new InputStreamReader(System.in))
.readLine();
if (Integer.parseInt(resp) == 0)
return;
else {
ModelWrapper cw = new ModelWrapper(field,
consts[Integer.parseInt(resp) - 1], null,
clazz,
modelClazz, university);
matches.put(field, cw);
}
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
285
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Apéndices
} catch (IOException e) {
e.printStackTrace();
}
}
public void setField(String field) {
this.field = field;
}
public Map<String, Object> getMatches() {
return matches;
}
public void setMatches(Map<String, Object> matches) {
this.matches = matches;
}
public void setModelClazz(String modelClazz) {
this.modelClazz = modelClazz;
}
public void setClazz(String clazz) {
this.clazz = clazz;
}
public void setUniversity(University university) {
this.university = university;
}
}
13.6.5.3
*.university
13.6.5.3.1
CreateUniversity
package es.uniovi.innova.eadministracion.tramites.swu.presentation.university;
import javax.inject.Inject;
import javax.inject.Named;
import es.uniovi.innova.eadministracion.tramites.swu.business.UniversityManagerService;
import es.uniovi.innova.eadministracion.tramites.swu.model.University;
import es.uniovi.innova.eadministracion.tramites.swu.presentation.Executable;
/**
* Crea una universidad en la base de datos
*
* @author danielmf
*
*/
@Named
public class CreateUniversity implements Executable {
private University university;
@Inject
private UniversityManagerService universityService;
@Override
public void execute() {
/*
* university = new University( "Universidad Concreta n2",
* "http://localhost:9090/Univ2Service/services/ServicesPort?wsdl",
* "Señor Reputado");
*/
university = new University(
"Universidad Concreta n1",
286
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Apéndices | Plataforma para Interoperabilidad de sistemas de información dentro de un
mismo ámbito organizativo
"http://localhost:9090/Univ1Service/services/ServiciosPort?wsdl",
"Fulano Fulánez");
System.out.println("Introduzca su wsdl: ");
System.out.println(university.getWsdl());
System.out.println("Introducza el nombre de su Universidad: ");
System.out.println(university.getName());
System.out.println("Responsable de la operación: ");
System.out.println(university.getPersonInCharge());
System.out.println("Recolectando información del WSDL: "
+ university.getWsdl() + " ...");
university = universityService.save(university);
}
public University getUniversity() {
return university;
}
public void setUniversity(University university) {
this.university = university;
}
}
13.6.5.4
*.ws
13.6.5.4.1
ListFields.java
package es.uniovi.innova.eadministracion.tramites.swu.presentation.ws;
import java.util.List;
import javax.inject.Inject;
import javax.inject.Named;
import es.uniovi.innova.eadministracion.tramites.swu.business.WebServiceManagerService;
import es.uniovi.innova.eadministracion.tramites.swu.presentation.Executable;
/**
* Lista los campos de una clase mediante introspección
*
* @author danielmf
*
*/
@Named
public class ListFields implements Executable {
private String clazzName;
private List<String> fields;
private String wsdl;
@Inject
private WebServiceManagerService webserviceService;
@Override
public void execute() {
fields = webserviceService.getClassFields(clazzName, wsdl);
}
public String getClazzName() {
return clazzName;
}
public void setClazzName(String clazzName) {
this.clazzName = clazzName;
}
public List<String> getFields() {
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
287
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Apéndices
return fields;
}
public void setFields(List<String> fields) {
this.fields = fields;
}
public void setWSDL(String wsdl) {
this.wsdl = wsdl;
}
}
13.6.5.4.2
ListOperations.java
package es.uniovi.innova.eadministracion.tramites.swu.presentation.ws;
import
import
import
import
import
java.io.BufferedReader;
java.io.IOException;
java.io.InputStreamReader;
java.util.ArrayList;
java.util.List;
import javax.inject.Inject;
import javax.inject.Named;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import
import
import
import
import
import
import
es.uniovi.innova.eadministracion.tramites.swu.business.MatcherManagerService;
es.uniovi.innova.eadministracion.tramites.swu.business.WebServiceManagerService;
es.uniovi.innova.eadministracion.tramites.swu.model.University;
es.uniovi.innova.eadministracion.tramites.swu.model.types.Constants;
es.uniovi.innova.eadministracion.tramites.swu.model.wrapper.OperationWrapper;
es.uniovi.innova.eadministracion.tramites.swu.presentation.Executable;
es.uniovi.innova.eadministracion.tramites.swu.util.Helper;
/**
* Obtiene las operaciones de un wsdl y descarta las no interesantes para la
* aplicación
*
* @author danielmf
*
*/
@Named
public class ListOperations implements Executable {
private static Logger logger = LoggerFactory
.getLogger(ListOperations.class);
private
private
private
private
private
String choice;
String modelo;
University university;
List<String> ops;
List<OperationWrapper> operations;
@Inject
private WebServiceManagerService webserviceService;
@Inject
private MatcherManagerService matcherService;
@Override
public void execute() {
operations = new ArrayList<OperationWrapper>();
try {
ops = webserviceService.getOperations(university.getWsdl());
if (ops.size() != 0) {
List<Integer> choices = showOps(ops);
boolean flag = false;
288
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Apéndices | Plataforma para Interoperabilidad de sistemas de información dentro de un
mismo ámbito organizativo
for (int x : choices) {
for (OperationWrapper o : operations) {
if (ops.get(x - 1).contains(o.getOp()))
flag = true;
}
if (!flag) {
OperationWrapper ow = new OperationWrapper(
ops.get(x - 1));
lastTry(ow);
if (ow.getMatch() != null)
save(ow);
else
throw new RuntimeException(
"Debe seleccionar
alguna");
}
flag = false;
}
System.out.println("Modelo: ");
modelo = new BufferedReader(new
InputStreamReader(System.in))
.readLine();
modelo = Helper.retrieveCompleteName(ops.get(0)) + modelo;
}
} catch (IOException e) {
logger.error(e.getMessage());
}
}
private void save(OperationWrapper o) {
university.addOperation(o);
o = matcherService.save(o);
operations.add(o);
}
private void lastTry(OperationWrapper o) throws IOException {
String resp;
int i = 0;
for (String key : Constants.OPS) {
System.out.println(++i + ". " + key);
}
System.out.println("¿Con que operación conecta?: " + o.getOp());
resp = new BufferedReader(new InputStreamReader(System.in)).readLine();
if (Integer.parseInt(resp) == 0)
throw new RuntimeException(
"Tiene que conectar con alguna operación");
else {
o.setMatch(Constants.OPS[Integer.parseInt(resp) - 1]);
}
}
private List<Integer> showOps(List<String> ops) throws IOException {
int i = 1;
for (String op : ops) {
System.out.println(i + ". " + op);
i++;
}
System.out.println("-------------------------");
System.out
.println("¿Qué operaciones son de interés? (separe por
comas): ");
choice = new BufferedReader(new InputStreamReader(System.in))
.readLine();
return retrieveChoices(choice);
}
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
289
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Apéndices
private static List<Integer> retrieveChoices(String choice) {
List<Integer> x = new ArrayList<Integer>();
String[] ch = choice.split(",");
for (String c : ch)
x.add(Integer.parseInt(c));
return x;
}
public University getUniversity() {
return university;
}
public void setUniversity(University university) {
this.university = university;
}
public List<OperationWrapper> getOperations() {
return operations;
}
public void setOperations(List<OperationWrapper> operations) {
this.operations = operations;
}
public List<String> getOps() {
return ops;
}
public void setOps(List<String> ops) {
this.ops = ops;
}
public String getModelo() {
return modelo;
}
}
13.6.6 Define-tramites-servicios-web-unificadosservice
13.6.6.1
Es.uniovi.innova.eadministracion.tramites.swu.builder
13.6.6.1.1
BecaBuilder.java
package es.uniovi.innova.eadministracion.tramites.swu.builder;
import es.uniovi.innova.eadministracion.tramites.swu.model.Beca;
import es.uniovi.innova.eadministracion.tramites.swu.model.wrapper.BecaWrapper;
import es.uniovi.innova.eadministracion.tramites.swu.model.wrapper.SolicitanteWrapper;
/**
* Constructor (Builder) en la jerarquía Builder, define las operaciones
* abstractas de construcción que implementarán los concretos.
*
* @author danielmf
*
*/
public abstract class BecaBuilder {
/**
* Devuelve la {@link Beca} construida
*
* @return beca
290
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Apéndices | Plataforma para Interoperabilidad de sistemas de información dentro de un
mismo ámbito organizativo
*/
public abstract Beca getBeca();
/**
* Devuelve la {@link BecaWrapper} construida, que interesa para hacer el
* match de campos
*
* @return beca
*/
public abstract BecaWrapper getBecaWrapper();
/**
* Devuelve el {@link SolicitanteWrapper} construido, que interesa para
* hacer el match de campos
*
* @return solicitante
*/
public abstract SolicitanteWrapper getSolicitante();
/**
* Establece la propiedad nombre_procedimiento_convocatoria
*
* @param nombre_procedimiento_convocatoria
*/
public abstract void setNombreProcedimientoConvocatoria(
String nombre_procedimiento_convocatoria);
/**
* Establece la propiedad asunto_convocatoria
*
* @param asunto_convocatoria
*/
public abstract void setAsuntoConvocatoria(String asunto_convocatoria);
/**
* Establece la propiedad nombre_solicitante
*
* @param nombre_solicitante
*/
public abstract void setNombreSolicitante(String nombre_solicitante);
/**
* Establece la propiedad apellido1_solicitante
*
* @param apellido1_solicitante
*/
public abstract void setApellido1Solicitante(String apellido1_solicitante);
/**
* Establece la propiedad apellido2_solicitante
*
* @param apellido2_solicitante
*/
public abstract void setApellido2Solicitante(String apellido2_solicitante);
/**
* Establece la propiedad documento_identificativo
*
* @param documento_identificativo
*/
public abstract void setDocumentoIdentificativo(
String documento_identificativo);
/**
* Establece la propiedad tipo_documento_identificativo
*
* @param tipo_documento_identificativo
*/
public abstract void setTipoDocumentoIdentificativo(
String tipo_documento_identificativo);
/**
* Establece la propiedad nacionalidad
*
* @param nacionalidad
*/
public abstract void setNacionalidad(String nacionalidad);
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
291
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Apéndices
/**
* Establece la propiedad sexo
*
* @param sexo
*/
public abstract void setSexo(String sexo);
/**
* Establece la propiedad fecha_nacimiento
*
* @param fecha_nacimiento
*/
public abstract void setFechaNacimiento(Integer fecha_nacimiento);
/**
* Establece la propiedad estudios
*
* @param estudios
*/
public abstract void setEstudios(String estudios);
/**
* Establece la propiedad estado_solicitud
*
* @param estado_solicitud
*/
public abstract void setEstadoSolicitud(String estado_solicitud);
/**
* Establece la propiedad destino
*
* @param destino
*/
public abstract void setDestino(String destino);
/**
* Establece la propiedad cuantia_otorgada
*
* @param cuantia_otorgada
*/
public abstract void setCuantiaOtorgada(Double cuantia_otorgada);
/**
* Establece la propiedad curso_academico
*
* @param curso_academico
*/
public abstract void setCursoAcademico(String curso_academico);
}
13.6.6.1.2
BecaDirector.java
package es.uniovi.innova.eadministracion.tramites.swu.builder;
import java.lang.reflect.Field;
import java.util.List;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import es.uniovi.innova.eadministracion.tramites.swu.model.Beca;
import es.uniovi.innova.eadministracion.tramites.swu.model.wrapper.ModelWrapper;
/**
* Director de la jerarquía Builder en la construción de la {@link Beca}
*
* @author danielmf
*
*/
public class BecaDirector {
private static Logger logger = LoggerFactory.getLogger(BecaDirector.class);
292
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Apéndices | Plataforma para Interoperabilidad de sistemas de información dentro de un
mismo ámbito organizativo
private static BecaBuilder builder;
/**
* Dirige las operaciones de construcción por partes
*
* @param models
*
información en crudo
* @return {@link Beca} construida por partes
*/
public static Beca build(List<ModelWrapper> models, Object beca) {
logger.info("Building a Beca : " + beca);
builder = new ConcreteBecaBuilder();
for (ModelWrapper mw : models) {
switch (mw.getMatch()) {
case "nombre_procedimiento_convocatoria":
builder.setNombreProcedimientoConvocatoria((String) getter(
beca, mw));
break;
case "asunto_convocatoria":
builder.setAsuntoConvocatoria((String) getter(beca, mw));
break;
case "estado_solicitud":
builder.setEstadoSolicitud((String) getter(beca, mw));
break;
case "destino":
builder.setDestino((String) getter(beca, mw));
break;
case "cuantia_otorgada":
builder.setCuantiaOtorgada((Double) getter(beca, mw));
break;
case "curso_academico":
builder.setCursoAcademico((String) getter(beca, mw));
break;
case "nombre_solicitante":
builder.setNombreSolicitante((String) getter(beca, mw));
break;
case "apellido1_solicitante":
builder.setApellido1Solicitante((String) getter(beca, mw));
break;
case "apellido2_solicitante":
builder.setApellido2Solicitante((String) getter(beca, mw));
break;
case "documento_identificativo":
builder.setDocumentoIdentificativo((String) getter(beca,
mw));
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
293
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Apéndices
break;
case "tipo_documento_identificativo":
builder.setTipoDocumentoIdentificativo((String)
getter(beca, mw));
break;
case "nacionalidad":
builder.setNacionalidad((String) getter(beca, mw));
break;
case "sexo":
builder.setSexo((String) getter(beca, mw));
break;
case "fecha_nacimiento":
builder.setFechaNacimiento((Integer) getter(beca, mw));
break;
case "estudios":
builder.setEstudios((String) getter(beca, mw));
break;
}
}
Beca b = builder.getBeca();
logger.info("Beca succesfully built: " + b);
return b;
}
/**
* Obtiene matches de dentro del objeto
*
* @param beca
*
sacada de la invocación del SW
* @param mw
*
para hacer el emparejamiento
*
* @return el valor de la beca del emparejamiento
*/
private static Object getter(Object beca, ModelWrapper mw) {
Field f;
Object o = null;
try {
f = beca.getClass().getDeclaredField(mw.getConcrete());
f.setAccessible(true);
o = f.get(beca);
f.setAccessible(false);
} catch (IllegalArgumentException | IllegalAccessException
| NoSuchFieldException | SecurityException e) {
logger.error(e.getMessage());
}
return o;
}
}
294
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Apéndices | Plataforma para Interoperabilidad de sistemas de información dentro de un
mismo ámbito organizativo
13.6.6.1.3
BecaDirectorForm.java
package es.uniovi.innova.eadministracion.tramites.swu.builder;
import java.util.List;
import javax.inject.Inject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import
import
import
import
es.uniovi.innova.eadministracion.tramites.swu.business.MatcherManagerService;
es.uniovi.innova.eadministracion.tramites.swu.model.Beca;
es.uniovi.innova.eadministracion.tramites.swu.model.wrapper.BecaWrapper;
es.uniovi.innova.eadministracion.tramites.swu.model.wrapper.SolicitanteWrapper;
/**
* Builder para construir el modelo del formulario
*
* @author danielmf
*
*/
@Component
public class BecaDirectorForm {
private static Logger logger = LoggerFactory
.getLogger(BecaDirectorForm.class);
private ConcreteFormBecaBuilder builder;
@Inject
private MatcherManagerService matcherManager;
/**
* Dirige las operaciones de construcción por partes
*
* @param fields
*
información en crudo
* @return {@link Beca} construida por partes
*/
public BecaWrapper build(List<String> fields) {
builder = new ConcreteFormBecaBuilder();
for (String field : fields) {
String match = matcherManager.match(field, "BECA");
switch (match) {
case "nombre_procedimiento_convocatoria":
builder.setNombreProcedimientoConvocatoria(field);
break;
case "asunto_convocatoria":
builder.setAsuntoConvocatoria(field);
break;
case "estado_solicitud":
builder.setEstadoSolicitud(field);
break;
case "destino":
builder.setDestino(field);
break;
case "cuantia_otorgada":
builder.setCuantiaOtorgada(field);
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
295
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Apéndices
break;
case "curso_academico":
builder.setCursoAcademico(field);
break;
}
}
BecaWrapper b = builder.getBecaWrapper();
logger.info("Beca succesfully built: " + b);
return b;
}
public SolicitanteWrapper buildSol(List<String> fields) {
builder = new ConcreteFormBecaBuilder();
for (String field : fields) {
String match = matcherManager.match(field, "SOLICITANTE");
switch (match) {
case "nombre_solicitante":
builder.setNombreSolicitante(field);
break;
case "apellido1_solicitante":
builder.setApellido1Solicitante(field);
break;
case "apellido2_solicitante":
builder.setApellido2Solicitante(field);
break;
case "documento_identificativo":
builder.setDocumentoIdentificativo(field);
break;
case "tipo_documento_identificativo":
builder.setTipoDocumentoIdentificativo(field);
break;
case "nacionalidad":
builder.setNacionalidad(field);
break;
case "sexo":
builder.setSexo(field);
break;
case "fecha_nacimiento":
builder.setFechaNacimiento(field);
break;
case "estudios":
296
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Apéndices | Plataforma para Interoperabilidad de sistemas de información dentro de un
mismo ámbito organizativo
builder.setEstudios(field);
break;
}
}
SolicitanteWrapper b = builder.getSolicitante();
logger.info("Solicitante succesfully built: " + b);
return b;
}
}
13.6.6.1.4
ConcreteBecaBuilder.java
package es.uniovi.innova.eadministracion.tramites.swu.builder;
import
import
import
import
es.uniovi.innova.eadministracion.tramites.swu.model.Beca;
es.uniovi.innova.eadministracion.tramites.swu.model.Solicitante;
es.uniovi.innova.eadministracion.tramites.swu.model.wrapper.BecaWrapper;
es.uniovi.innova.eadministracion.tramites.swu.model.wrapper.SolicitanteWrapper;
public class ConcreteBecaBuilder extends BecaBuilder {
private Beca beca;
private Solicitante solicitante;
public ConcreteBecaBuilder() {
beca = new Beca();
solicitante = new Solicitante();
}
@Override
public Beca getBeca() {
beca.setSolicitante(solicitante);
return beca;
}
@Override
public void setNombreProcedimientoConvocatoria(
String nombre_procedimiento_convocatoria) {
beca.setNombre_procedimiento_convocatoria(nombre_procedimiento_convocatoria);
}
@Override
public void setAsuntoConvocatoria(String asunto_convocatoria) {
beca.setAsunto_convocatoria(asunto_convocatoria);
}
@Override
public void setNombreSolicitante(String nombre_solicitante) {
solicitante.setNombre_solicitante(nombre_solicitante);
}
@Override
public void setApellido1Solicitante(String apellido1_solicitante) {
solicitante.setApellido1_solicitante(apellido1_solicitante);
}
@Override
public void setApellido2Solicitante(String apellido2_solicitante) {
solicitante.setApellido2_solicitante(apellido2_solicitante);
}
@Override
public void setDocumentoIdentificativo(String documento_identificativo) {
solicitante.setDocumento_identificativo(documento_identificativo);
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
297
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Apéndices
}
@Override
public void setTipoDocumentoIdentificativo(
String tipo_documento_identificativo) {
solicitante
.setTipo_documento_identificativo(tipo_documento_identificativo);
}
@Override
public void setNacionalidad(String nacionalidad) {
solicitante.setNacionalidad(nacionalidad);
}
@Override
public void setSexo(String sexo) {
solicitante.setSexo(sexo);
}
@Override
public void setFechaNacimiento(Integer fecha_nacimiento) {
solicitante.setFecha_nacimiento(fecha_nacimiento);
}
@Override
public void setEstudios(String estudios) {
solicitante.setEstudios(estudios);
}
@Override
public void setEstadoSolicitud(String estado_solicitud) {
beca.setEstado_solicitud(estado_solicitud);
}
@Override
public void setDestino(String destino) {
beca.setDestino(destino);
}
@Override
public void setCuantiaOtorgada(Double cuantia_otorgada) {
beca.setCuantia_otorgada(cuantia_otorgada);
}
@Override
public void setCursoAcademico(String curso_academico) {
beca.setCurso_academico(curso_academico);
}
@Override
public BecaWrapper getBecaWrapper() {
return null;
}
@Override
public SolicitanteWrapper getSolicitante() {
return null;
}
}
13.6.6.1.5
ConcreteFormBecaBuilder.java
package es.uniovi.innova.eadministracion.tramites.swu.builder;
298
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Apéndices | Plataforma para Interoperabilidad de sistemas de información dentro de un
mismo ámbito organizativo
import es.uniovi.innova.eadministracion.tramites.swu.model.Beca;
import es.uniovi.innova.eadministracion.tramites.swu.model.wrapper.BecaWrapper;
import es.uniovi.innova.eadministracion.tramites.swu.model.wrapper.SolicitanteWrapper;
public class ConcreteFormBecaBuilder extends BecaBuilder {
private BecaWrapper beca;
private SolicitanteWrapper solicitante;
public ConcreteFormBecaBuilder() {
beca = new BecaWrapper();
solicitante = new SolicitanteWrapper();
}
@Override
public Beca getBeca() {
return null;
}
public BecaWrapper getBecaWrapper() {
return beca;
}
public SolicitanteWrapper getSolicitante() {
return solicitante;
}
@Override
public void setNombreProcedimientoConvocatoria(
String nombre_procedimiento_convocatoria) {
beca.setNombre_procedimiento_convocatoria(nombre_procedimiento_convocatoria);
}
@Override
public void setAsuntoConvocatoria(String asunto_convocatoria) {
beca.setAsunto_convocatoria(asunto_convocatoria);
}
@Override
public void setNombreSolicitante(String nombre_solicitante) {
solicitante.setNombre_solicitante(nombre_solicitante);
}
@Override
public void setApellido1Solicitante(String apellido1_solicitante) {
solicitante.setApellido1_solicitante(apellido1_solicitante);
}
@Override
public void setApellido2Solicitante(String apellido2_solicitante) {
solicitante.setApellido2_solicitante(apellido2_solicitante);
}
@Override
public void setDocumentoIdentificativo(String documento_identificativo) {
solicitante.setDocumento_identificativo(documento_identificativo);
}
@Override
public void setTipoDocumentoIdentificativo(
String tipo_documento_identificativo) {
solicitante
.setTipo_documento_identificativo(tipo_documento_identificativo);
}
@Override
public void setNacionalidad(String nacionalidad) {
solicitante.setNacionalidad(nacionalidad);
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
299
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Apéndices
}
@Override
public void setSexo(String sexo) {
solicitante.setSexo(sexo);
}
public void setFechaNacimiento(String fecha_nacimiento) {
solicitante.setFecha_nacimiento(fecha_nacimiento);
}
@Override
public void setEstudios(String estudios) {
solicitante.setEstudios(estudios);
}
@Override
public void setEstadoSolicitud(String estado_solicitud) {
beca.setEstado_solicitud(estado_solicitud);
}
@Override
public void setDestino(String destino) {
beca.setDestino(destino);
}
public void setCuantiaOtorgada(String cuantia_otorgada) {
beca.setCuantia_otorgada(cuantia_otorgada);
}
@Override
public void setCursoAcademico(String curso_academico) {
beca.setCurso_academico(curso_academico);
}
@Override
public void setFechaNacimiento(Integer fecha_nacimiento) {
}
@Override
public void setCuantiaOtorgada(Double cuantia_otorgada) {
}
}
13.6.6.2
Es.uniovi.innova.eadministracion.tramites.swu.business
13.6.6.2.1
MatcherManagerService.java
package es.uniovi.innova.eadministracion.tramites.swu.business;
import es.uniovi.innova.eadministracion.tramites.swu.model.University;
import es.uniovi.innova.eadministracion.tramites.swu.model.wrapper.ModelWrapper;
import es.uniovi.innova.eadministracion.tramites.swu.model.wrapper.OperationWrapper;
/**
* Fachada que define las operaciones de los matchers NoSQL y StringMetrics
*
* @author danielmf
*
*/
public interface MatcherManagerService {
300
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Apéndices | Plataforma para Interoperabilidad de sistemas de información dentro de un
mismo ámbito organizativo
/**
* Inicializa la base de datos con los datos necesarios
*/
public void init();
/**
* Busca el campo más factible de casar con el modelo externo
*
* @param field
*
campo externo
*
* @return campo del modelo propio con el que casa
*/
public String match(String field, String modelClazz);
/**
* Guarda en la base de datos la relación para un campo
*
* @param modelWrapper
*
* @return modelWrapper con id
*/
public ModelWrapper save(ModelWrapper modelWrapper);
/**
* Guarda la Operacion en la base de datos
*
* @param operationWrapper
*
* @return operationWrapper con id
*/
public OperationWrapper save(OperationWrapper operationWrapper);
/**
* Comprueba si la base de datos tiene operaciones relativas a una
* {@link University} para temas de consistencia
*
* @param universidad
*
* @return
*/
public boolean checkStatus(University university);
/**
* Borra un match entre campos
*
* @param m
*/
public void delete(ModelWrapper m);
/**
* Borra un match entre operaciones
*
* @param op
*/
public void delete(OperationWrapper op);
}
13.6.6.2.2
OperationsWrapperService.java
package es.uniovi.innova.eadministracion.tramites.swu.business;
import java.util.List;
import es.uniovi.innova.eadministracion.tramites.swu.model.wrapper.OperationWrapper;
import
es.uniovi.innova.eadministracion.tramites.swu.model.wrapper.OperationWrapperDocument;
/**
* Operaciones necesarias para Spring Data Solr y que alimentan al buscador
*
* @author danielmf
*
*/
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
301
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Apéndices
public interface OperationsWrapperService {
/**
* Añade al indice una operación
*
* @param operationWrapper
*/
public void addToIndex(OperationWrapper operationWrapper);
/**
* Borra del índice una operación
*
* @param operationWrapper
*/
public void deleteFromIndex(OperationWrapper operationWrapper);
/**
* Realiza la busqueda en función de una palabra clave
*
* @param keyword
* @return
*/
public List<OperationWrapperDocument> search(String keyword);
}
13.6.6.2.3
SearchEngineService.java
package es.uniovi.innova.eadministracion.tramites.swu.business;
import java.util.List;
import es.uniovi.innova.eadministracion.tramites.swu.model.University;
import es.uniovi.innova.eadministracion.tramites.swu.model.wrapper.OperationWrapper;
/**
* Fachada que define las operaciones del Servicio de Buscador
*
* @author danielmf
*
*/
public interface SearchEngineService {
/**
* Busca operaciones en la base de conocimiento y en la base de datos
*
* @param search
*
servicio a buscar
*
* @return lista de operaciones y de operaciones relacionadas
*/
List<OperationWrapper> searchOperations(String search);
/**
* Busca universidades en la base de datos
*
* @param search
*
universidad a buscar
*
* @return lista de universidades relacionadas
*/
University searchUniversities(String search);
}
13.6.6.2.4
UniversityManagerService.java
package es.uniovi.innova.eadministracion.tramites.swu.business;
import es.uniovi.innova.eadministracion.tramites.swu.model.University;
/**
* Fachada que define las operaciones del modelo de la {@link University}
302
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Apéndices | Plataforma para Interoperabilidad de sistemas de información dentro de un
mismo ámbito organizativo
*
* @author danielmf
*
*/
public interface UniversityManagerService {
/**
* Almacena una {@link University} en la Base de Datos
*
* @param university
*
*/
public University save(University university);
/**
* Borra una {@link University} de la Base de Datos
*
* @param university
*/
public void remove(University university);
/**
* Obtiene una {@link University} por ID
*
* @param id
*
* @return
*/
public University findUniversity(Long id);
/**
* Obtiene una {@link University} a partir de un wsdl
*
* @param wsdl
* @return
*/
public University findUniversityByWsdl(String wsdl);
/**
* Obtiene una {@link University} a partir de un nombre
*
* @param name
* @return
*/
public University findUniversityByName(String name);
}
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
303
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Apéndices
13.6.6.2.5
WebServiceManagerService.java
package es.uniovi.innova.eadministracion.tramites.swu.business;
import java.util.List;
import es.uniovi.innova.eadministracion.tramites.swu.model.Beca;
import es.uniovi.innova.eadministracion.tramites.swu.model.wrapper.ParamsWrapper;
/**
* Fachada que define las operaciones relativas a interoperabilidad con
* Servicios Web
*
* @author danielmf
*
*/
public interface WebServiceManagerService {
/**
* Obtiene las operaciones de un Servicio Web
*
* @param wsdl
*
* @return Listado de operaciones
*
*/
public List<String> getOperations(String wsdl);
/**
* Realiza una inovcación genérica a un método definido en un WSDL.
*
* @param wsdl
* @param method
* @param args
*
array de objects
* @param classLoader
*
* @return
*
* @throws Exception
*/
public Object connect(String wsdl, String method, Object[] args,
ClassLoader classLoader) throws Exception;
/**
* Obtiene los parámetros de una clase (argumentos de entrada de un método
* del WSDL y el retorno).
*
* @param wsdl
* @param clazzName
*
completo con el paquete
*
* @return {@link ParamsWrapper} envoltorio con los parámetros
* @throws ClassNotFoundException
*/
public ParamsWrapper getOperationIOs(String wsdl, String clazzName)
throws ClassNotFoundException;
/**
* Obtiene los atributos de una clase dada
*
* @param clazzName
*
* @return Listado de strings con los atributos
*/
public List<String> getClassFields(String clazzName, String wsdl);
/**
* Invoca a los métodos de los Servicios Web recopilados en el recolector
* según el tipo de método
*
* @param param
*
Parámetro que se pasa al método del Servicio Web
* @param mode
*
tipo de método
*
304
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Apéndices | Plataforma para Interoperabilidad de sistemas de información dentro de un
mismo ámbito organizativo
* @return Listado de {@link Beca} recopiladas
*/
public List<Beca> getBecasByParam(Object param, String mode);
/**
* Invoca a lso métodos de los Servicios Web recopilados en el recolector
* según el tipo de método y la universidad
*
* @param param
*
Parámetro que se pasa al método del Servicio Web
* @param mode
*
Tipo de método
* @param university
*
Nombre de la universidad
*
* @return Listado de {@link Beca} recopiladas
*/
public List<Beca> getBecasByParam(Object param, String mode,
String university);
}
13.6.6.3
*.matcher
13.6.6.3.1
MatcherManager.java
package es.uniovi.innova.eadministracion.tramites.swu.business.matcher;
import java.util.ArrayList;
import java.util.List;
import javax.inject.Inject;
import javax.inject.Named;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.transaction.annotation.Transactional;
import uk.ac.shef.wit.simmetrics.similaritymetrics.AbstractStringMetric;
import uk.ac.shef.wit.simmetrics.similaritymetrics.ChapmanMatchingSoundex;
import uk.ac.shef.wit.simmetrics.similaritymetrics.MongeElkan;
import uk.ac.shef.wit.simmetrics.similaritymetrics.SmithWatermanGotoh;
import uk.ac.shef.wit.simmetrics.similaritymetrics.SmithWatermanGotohWindowedAffine;
import uk.ac.shef.wit.simmetrics.similaritymetrics.Soundex;
import es.uniovi.innova.eadministracion.tramites.swu.business.MatcherManagerService;
import es.uniovi.innova.eadministracion.tramites.swu.business.OperationsWrapperService;
import es.uniovi.innova.eadministracion.tramites.swu.model.University;
import es.uniovi.innova.eadministracion.tramites.swu.model.types.Constants;
import es.uniovi.innova.eadministracion.tramites.swu.model.wrapper.ModelWrapper;
import es.uniovi.innova.eadministracion.tramites.swu.model.wrapper.OperationWrapper;
import es.uniovi.innova.eadministracion.tramites.swu.persistence.HashDataService;
import
es.uniovi.innova.eadministracion.tramites.swu.persistence.ModelWrapperDataService;
import
es.uniovi.innova.eadministracion.tramites.swu.persistence.OperationsWrapperDataService;
/**
* Servicio que implementa la fachada {@link MatcherManagerService} para
* encapsular la lógica del matcher.
*
* @author danielmf
*
*/
@Named
public class MatcherManager implements MatcherManagerService {
private static Logger logger = LoggerFactory
.getLogger(MatcherManager.class);
@Inject
private HashDataService hashDataService;
@Inject
private ModelWrapperDataService modelWrapperDataService;
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
305
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Apéndices
@Inject
private OperationsWrapperDataService operationsWrapperDataService;
@Inject
private OperationsWrapperService operationsWrapperService;
@Override
public void init() {
hashDataService.init();
}
@Override
public String match(String field, String modelClazz) {
ModelWrapper mw = hashDataService.queryModel(field, modelClazz);
if (mw == null) {
List<String> matches = new ArrayList<String>();
if (modelClazz.equalsIgnoreCase("BECA"))
matches = match(field, Constants.BECA);
else
matches = match(field, Constants.SOLICITANTE);
if (matches.size() > 0)
return matches.get(0);
} else
return mw.getMatch();
return "";
}
@Override
@Transactional
public ModelWrapper save(ModelWrapper modelWrapper) {
logger.info("Guardando Model Wrapper: " + modelWrapper);
modelWrapper = modelWrapperDataService.save(modelWrapper);
saveHash(modelWrapper);
return modelWrapper;
}
@Override
@Transactional
public OperationWrapper save(OperationWrapper operationWrapper) {
logger.info("Guardando Operation Wrapper: " + operationWrapper);
operationWrapper = operationsWrapperDataService.save(operationWrapper);
operationsWrapperService.addToIndex(operationWrapper);
saveHash(operationWrapper);
return operationWrapper;
}
@Override
public boolean checkStatus(University university) {
List<OperationWrapper> res = operationsWrapperDataService
.findByUniversity(university);
return (res != null && res.size() > 0);
}
@Override
public void delete(ModelWrapper m) {
modelWrapperDataService.delete(m);
}
@Override
306
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Apéndices | Plataforma para Interoperabilidad de sistemas de información dentro de un
mismo ámbito organizativo
public void delete(OperationWrapper op) {
operationsWrapperDataService.delete(op);
operationsWrapperService.deleteFromIndex(op);
}
/**
* Comprueba las probabilidades de que dos campos sean el mismo
*
* @param concrete
*
campo a comparar
* @param constants
*
constantes del modelo generico
*
* @return listado de campos que pueden coincidir
*/
private List<String> match(String concrete, String[] constants) {
logger.info("Matching: (" + concrete + ", " + constants.toString()
+ ")");
List<String> options = new ArrayList<String>();
for (String s : constants) {
if (checkProbabilities(s, concrete) >= 70)
options.add(s);
}
return options;
}
/**
* Aplica StringMetrics para comprobar dos cadenas de texto
*
* @param generic
* @param concrete
*
* @return porcentaje de parentesco
*/
private float checkProbabilities(String generic, String concrete) {
logger.info(generic + " vs " + concrete);
concrete = preProcessing(concrete);
generic = preProcessing(generic);
AbstractStringMetric metric;
float avg = 0F, result = 0F;
metric = new ChapmanMatchingSoundex();
result = metric.getSimilarity(generic, concrete);
formatter(result, metric);
avg += result;
metric = new Soundex();
result = metric.getSimilarity(generic, concrete);
formatter(result, metric);
avg += result;
metric = new SmithWatermanGotoh();
result = metric.getSimilarity(generic, concrete);
formatter(result, metric);
avg += result;
metric = new SmithWatermanGotohWindowedAffine();
result = metric.getSimilarity(generic, concrete);
formatter(result, metric);
avg += result;
metric = new MongeElkan();
result = metric.getSimilarity(generic, concrete);
formatter(result, metric);
avg += result;
int res = Math.round((avg / 5.0F) * 100.0F);
logger.info(res + "%");
return res;
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
307
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Apéndices
}
/**
* Guarda un {@link ModelWrapper} en la NoSQL
*
* @param modelWrapper
*/
private void saveHash(ModelWrapper modelWrapper) {
logger.info("Guardando Hash Model Wrapper: " + modelWrapper);
hashDataService.save(modelWrapper);
}
/**
* Guarda un {@link OperationWrapper} en la NoSQL
*
* @param operationWrapper
*/
private void saveHash(OperationWrapper operationWrapper) {
logger.info("Guardando Hash Operation Wrapper: " + operationWrapper);
hashDataService.save(operationWrapper);
}
/**
* Formateador de cadenas para mostrar la técnica y el porcentaje
*
* @param result
*
Resultado obtenido
* @param metric
*
{@link AbstractStringMetric} métrica usada
*/
private static void formatter(final float result,
final AbstractStringMetric metric) {
logger.info("Usando la metrica " + metric.getShortDescriptionString()
+ " tenemos una puntuacion de " + (result * 100 / 1) +
"%");
}
/**
* Preprocesa el campo concreto para aumentar las probabilidades de hacer
* matching.
*
* @param concrete
*
Campo del modelo concreto
*
* @return Cadena procesada "sin impurezas"
*/
private String preProcessing(String concrete) {
concrete = concrete.replaceAll("[^\\p{Alpha}]", "");
concrete = concrete.toLowerCase();
concrete = concrete.trim();
return concrete;
}
}
308
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Apéndices | Plataforma para Interoperabilidad de sistemas de información dentro de un
mismo ámbito organizativo
13.6.6.4
*.searchengine
13.6.6.4.1
SearchEngineService.java
package es.uniovi.innova.eadministracion.tramites.swu.business.searchengine;
import java.util.ArrayList;
import java.util.List;
import javax.inject.Inject;
import javax.inject.Named;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import es.uniovi.innova.eadministracion.tramites.swu.business.OperationsWrapperService;
import es.uniovi.innova.eadministracion.tramites.swu.business.SearchEngineService;
import es.uniovi.innova.eadministracion.tramites.swu.model.University;
import es.uniovi.innova.eadministracion.tramites.swu.model.wrapper.OperationWrapper;
import
es.uniovi.innova.eadministracion.tramites.swu.model.wrapper.OperationWrapperDocument;
import es.uniovi.innova.eadministracion.tramites.swu.persistence.UniversityDataService;
/**
* Service de las operaciones del buscador
*
* @author danielmf
*
*/
@Named
public class SearchEngineManager implements SearchEngineService {
private static Logger logger = LoggerFactory
.getLogger(SearchEngineManager.class);
@Inject
private UniversityDataService universityDataService;
@Inject
private OperationsWrapperService operationsWrapperService;
@Override
public List<OperationWrapper> searchOperations(String search) {
logger.info("Buscando Operacion: " + search);
List<OperationWrapperDocument> ows = operationsWrapperService
.search(search);
List<OperationWrapper> list = new ArrayList<OperationWrapper>();
for (OperationWrapperDocument ow : ows) {
list.add(new OperationWrapper(ow.getOp(), ow.getMatch(),
universityDataService.findOne((ow.getUniversity()
.longValue()))));
}
if (list.size() > 0)
return list;
else
return null;
}
@Override
public University searchUniversities(String search) {
logger.info("Buscando universidad: " + search);
return universityDataService.findByName(search);
}
}
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
309
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Apéndices
13.6.6.5
*.solr
13.6.6.5.1
OperationsWrapperManager.java
package es.uniovi.innova.eadministracion.tramites.swu.business.solr;
import java.util.List;
import javax.inject.Inject;
import javax.inject.Named;
import es.uniovi.innova.eadministracion.tramites.swu.business.OperationsWrapperService;
import es.uniovi.innova.eadministracion.tramites.swu.model.wrapper.OperationWrapper;
import
es.uniovi.innova.eadministracion.tramites.swu.model.wrapper.OperationWrapperDocument;
import
es.uniovi.innova.eadministracion.tramites.swu.util.solr.OperationsWrapperDocumentReposit
ory;
/**
* Implementa las operaciones de la interface {@link OperationsWrapperService}
* que se utilizan para funciones de buscador
*
* @author danielmf
*
*/
@Named
public class OperationsWrapperManager implements OperationsWrapperService {
@Inject
private OperationsWrapperDocumentRepository operationsWrapperDocumentRepository;
@Override
public void addToIndex(OperationWrapper operationWrapper) {
OperationWrapperDocument operationWrapperDocument = new
OperationWrapperDocument();
operationWrapperDocument.setId(operationWrapper.getUniversity().getId()
+ "-" + operationWrapper.getMatch() + "-"
+ operationWrapper.getOp());
operationWrapperDocument.setOp(operationWrapper.getOp());
operationWrapperDocument.setMatch(operationWrapper.getMatch());
operationWrapperDocument.setUniversity(operationWrapper.getUniversity()
.getId());
operationWrapperDocument.setUniversity_name(operationWrapper
.getUniversity().getName());
operationsWrapperDocumentRepository.save(operationWrapperDocument);
}
@Override
public List<OperationWrapperDocument> search(String keyword) {
return operationsWrapperDocumentRepository.findByMatchOrOp(keyword);
}
@Override
public void deleteFromIndex(OperationWrapper operationWrapper) {
operationsWrapperDocumentRepository.delete(operationWrapper
.getUniversity().getId()
+ "-"
+ operationWrapper.getMatch()
+ "-" + operationWrapper.getOp());
}
}
310
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Apéndices | Plataforma para Interoperabilidad de sistemas de información dentro de un
mismo ámbito organizativo
13.6.6.6
*.university
13.6.6.6.1
UniversityManager.java
package es.uniovi.innova.eadministracion.tramites.swu.business.university;
import javax.inject.Inject;
import javax.inject.Named;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.transaction.annotation.Transactional;
import es.uniovi.innova.eadministracion.tramites.swu.business.UniversityManagerService;
import es.uniovi.innova.eadministracion.tramites.swu.model.University;
import es.uniovi.innova.eadministracion.tramites.swu.persistence.UniversityDataService;
/**
* Servicio que implementa la fachada {@link UniversityManagerService} con las
* operaciones relativas al modelo {@link University}
*
* @author danielmf
*
*/
@Named
public class UniversityManager implements UniversityManagerService {
private static Logger logger = LoggerFactory
.getLogger(UniversityManager.class);
@Inject
private UniversityDataService universityDataService;
@Override
@Transactional
public University save(University university) {
logger.info("Guardando universidad: " + university);
university = universityDataService.save(university);
return university;
}
@Override
@Transactional
public void remove(University university) {
universityDataService.delete(university);
}
@Override
public University findUniversity(Long id) {
return universityDataService.findOne(id);
}
@Override
public University findUniversityByWsdl(String wsdl) {
return universityDataService.findByWsdl(wsdl);
}
@Override
public University findUniversityByName(String name) {
return universityDataService.findByName(name);
}
}
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
311
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Apéndices
13.6.6.7
*.ws
13.6.6.7.1
WebServiceManager.java
package es.uniovi.innova.eadministracion.tramites.swu.business.ws;
import
import
import
import
import
import
import
java.lang.reflect.Field;
java.util.ArrayList;
java.util.HashMap;
java.util.Iterator;
java.util.LinkedList;
java.util.List;
java.util.Map;
import javax.inject.Inject;
import javax.inject.Named;
import
import
import
import
import
import
import
import
import
import
import
import
import
org.apache.commons.lang.StringUtils;
org.apache.cxf.endpoint.Client;
org.apache.cxf.endpoint.ClientImpl;
org.apache.cxf.endpoint.Endpoint;
org.apache.cxf.endpoint.dynamic.DynamicClientFactory;
org.apache.cxf.jaxws.endpoint.dynamic.JaxWsDynamicClientFactory;
org.apache.cxf.service.model.BindingInfo;
org.apache.cxf.service.model.BindingMessageInfo;
org.apache.cxf.service.model.BindingOperationInfo;
org.apache.cxf.service.model.MessagePartInfo;
org.apache.cxf.service.model.ServiceInfo;
org.slf4j.Logger;
org.slf4j.LoggerFactory;
import es.uniovi.innova.eadministracion.tramites.swu.builder.BecaDirector;
import es.uniovi.innova.eadministracion.tramites.swu.business.WebServiceManagerService;
import es.uniovi.innova.eadministracion.tramites.swu.exception.GenericException;
import es.uniovi.innova.eadministracion.tramites.swu.model.Beca;
import es.uniovi.innova.eadministracion.tramites.swu.model.University;
import es.uniovi.innova.eadministracion.tramites.swu.model.wrapper.ModelWrapper;
import es.uniovi.innova.eadministracion.tramites.swu.model.wrapper.OperationWrapper;
import es.uniovi.innova.eadministracion.tramites.swu.model.wrapper.ParamsWrapper;
import
es.uniovi.innova.eadministracion.tramites.swu.persistence.ModelWrapperDataService;
import
es.uniovi.innova.eadministracion.tramites.swu.persistence.OperationsWrapperDataService;
import es.uniovi.innova.eadministracion.tramites.swu.persistence.UniversityDataService;
import es.uniovi.innova.eadministracion.tramites.swu.util.Helper;
/**
* Servicio que implementa la fachada {@link WebServiceManagerService} con las
* operaciones relativas a la interoperabilidad con Servicios Web
*
* @author danielmf
*
*/
@Named
public class WebServiceManager implements WebServiceManagerService {
private static Logger logger = LoggerFactory
.getLogger(WebServiceManager.class);
private Map<String, List<String>> returns;
@Inject
private ModelWrapperDataService modelWrapperDataService;
@Inject
private OperationsWrapperDataService operationsWrapperDataService;
@Inject
private UniversityDataService universityDataService;
@Override
public List<String> getOperations(String wsdl) {
logger.info("Obteniendo operaciones del WSDL: " + wsdl);
List<String> l = new LinkedList<String>();
312
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Apéndices | Plataforma para Interoperabilidad de sistemas de información dentro de un
mismo ámbito organizativo
try {
JaxWsDynamicClientFactory factory = JaxWsDynamicClientFactory
.newInstance();
Client client = factory.createClient(wsdl,
WebServiceManager.class.getClassLoader());
ClientImpl clientImpl = (ClientImpl) client;
Endpoint endpoint = clientImpl.getEndpoint();
ServiceInfo serviceInfo = endpoint.getService().getServiceInfos()
.get(0);
BindingInfo binding = serviceInfo.getBindings().iterator().next();
Iterator<BindingOperationInfo> it = binding.getOperations()
.iterator();
while (it.hasNext()) {
BindingOperationInfo boi = it.next();
BindingMessageInfo inputMessageInfo = boi.getInput();
List<MessagePartInfo> parts = inputMessageInfo
.getMessageParts();
MessagePartInfo partInfo = parts.get(0);
if (partInfo.getTypeClass() != null)
l.add(partInfo.getTypeClass().getCanonicalName());
}
if (l.size() == 0)
throw new GenericException(
"El WSDL proporcionado no es válido.");
logger.info("Operaciones obtenidas satisfactoriamente: " +
l.size());
} catch (Exception e) {
logger.error("WSDL no disponible.");
throw new GenericException("El WSDL proporcionado no es válido.");
}
return l;
}
@Override
public Object connect(String wsdl, String method, Object[] args,
ClassLoader classLoader) throws Exception {
logger.info("Invocando " + method + " en " + wsdl);
if (classLoader == null)
classLoader = WebServiceManager.class.getClassLoader();
JaxWsDynamicClientFactory dcf = JaxWsDynamicClientFactory.newInstance();
Client client = dcf.createClient(wsdl, classLoader);
Object[] res = client.invoke(method, args);
logger.info("Operación del Servicio Web invocada satisfactoriamente");
return res[0];
}
@Override
public ParamsWrapper getOperationIOs(String wsdl, String clazzName)
throws ClassNotFoundException {
logger.info("Invocando " + clazzName + " en " + wsdl);
if (returns == null)
returns = new HashMap<String, List<String>>();
ParamsWrapper pw = new ParamsWrapper();
JaxWsDynamicClientFactory dcf = JaxWsDynamicClientFactory.newInstance();
dcf.createClient(wsdl, WebServiceManager.class.getClassLoader());
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
313
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Apéndices
Object clazz = getInstance(clazzName);
if (clazz.getClass().getDeclaredFields().length > 0) {
for (Field m : clazz.getClass().getDeclaredFields()) {
pw.add(m.getType().getCanonicalName());
}
}
return pw;
}
@SuppressWarnings("unused")
@Override
public List<String> getClassFields(String clazzName, String wsdl) {
try {
JaxWsDynamicClientFactory factory = JaxWsDynamicClientFactory
.newInstance();
Client client = factory.createClient(wsdl,
WebServiceManager.class.getClassLoader());
Class<?> c = Thread.currentThread().getContextClassLoader()
.loadClass(clazzName);
List<String> fields = new ArrayList<String>();
for (Field f : c.getDeclaredFields())
fields.add(f.getName());
return fields;
} catch (ClassNotFoundException e) {
logger.error("No se ha podido crear la clase: " + clazzName);
throw new GenericException("No se ha podido crear la clase: "
+ clazzName);
}
}
@Override
public List<Beca> getBecasByParam(Object param, String mode) {
logger.info("Obteniendo operaciones de: " + mode);
List<Beca> list = new ArrayList<Beca>();
List<OperationWrapper> operations = operationsWrapperDataService
.findByMatch(mode);
logger.info(operations.size() + " operaciones obtenidas con éxito.");
for (OperationWrapper operationWrapper : operations) {
logger.info("Invocando operacion: " + operationWrapper.getOp()
+ " en " +
operationWrapper.getUniversity().getWsdl());
invoke(param, list, operationWrapper);
}
return list;
}
@Override
public List<Beca> getBecasByParam(Object param, String mode,
String university) {
logger.info("Obteniendo operaciones de: " + mode);
List<Beca> list = new ArrayList<Beca>();
University u = universityDataService.findByName(university);
314
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
Apéndices | Plataforma para Interoperabilidad de sistemas de información dentro de un
mismo ámbito organizativo
List<OperationWrapper> operations = operationsWrapperDataService
.findByMatchAndUniversityId(mode, u.getId());
logger.info(operations.size() + " operaciones obtenidas con éxito.");
for (OperationWrapper operationWrapper : operations) {
logger.info("Invocando operación : " + operationWrapper.getOp()
+ " en " +
operationWrapper.getUniversity().getWsdl());
invoke(param, list, operationWrapper);
}
return list;
}
/**
* Realiza la llamada dinámica a un servicio web
*
* @param param
*
con el que se llamará al método
* @param list
*
con las becas obtenidas
* @param operationWrapper
*
operación a llamar
*/
private void invoke(Object param, List<Beca> list,
OperationWrapper operationWrapper) {
try {
DynamicClientFactory dcf = DynamicClientFactory.newInstance();
Client client = dcf.createClient(operationWrapper.getUniversity()
.getWsdl(),
WebServiceManager.class.getClassLoader());
Object[] results = client.invoke(StringUtils.uncapitalize(Helper
.getClassName(operationWrapper.getOp())), param);
list.addAll(parseResult(results[0],
operationWrapper.getUniversity()));
} catch (Exception e) {
logger.error(e.getMessage());
}
}
/**
* Convierte la beca concreta en un genérica
*
* @param results
* @param university
* @return
*/
private List<Beca> parseResult(Object results, University university) {
List<Beca> becas = new ArrayList<Beca>();
Object[] result = (Object[]) results;
List<ModelWrapper> models = modelWrapperDataService
.findByUniversityClazz(university, result[0].getClass()
.getCanonicalName());
for (Object beca : result) {
becas.add(BecaDirector.build(models, beca));
}
return becas;
}
/**
* Genera una instancia para un nombre de clase dada
Máster en Ingeniería Web - Centro Internacional de Postgrado - Universidad de
Oviedo | Daniel Machado Fernández
315
Plataforma para Interoperabilidad de sistemas de información dentro de un mismo ámbito
organizativo | Apéndices
*
* @param clazzName
*
* @return Object
*/
private Object getInstance(String clazzName) {
logger.info("Instanciando " + clazzName);
Object clazz = null;
try {
clazz = Thread.currentThread().getContextClassLoader()
.loadClass(clazzName).newInstance();
} catch (InstantiationException | IllegalAccessException
| ClassNotFoundException e) {
logger.error(e.getMessage());
}
return clazz;
}
}
13.6.6.8
n
Es.uniovi.innova.eadministracion.tramites.swu.exceptio
13.6.6.8.1
GenericException.java
package es.uniovi.innova.eadministracion.tramites.swu.exception;
/**
* Excepción genérica para recogerla en las vistas del sitio web y mostrar
* mensajes personalizados de error
*
* @author danielmf
*
*/
public class GenericException extends RuntimeException {
private static final long serialVersionUID = 3408539344410962233L;
protected String msg;
public GenericException(String msg) {
this.msg = msg;
}
public String getMsg() {
return msg;
}
public void setMsg(String msg) {
this.msg = msg;
}
}
316
Daniel Machado Fernández | Máster en Ingeniería Web - Centro Internacional de
Postgrado - Universidad de Oviedo
