Extracción de titulares de periódicos on-line a partir de RSS para su posterior estudio

4 Universidad de Valladolid Escuela de Ingeniería Informática TRABAJO FIN DE GRADO Grado en Ingeniería Informática (Mención Computación) Extracción de titulares de periódicos on-line a partir de RSS para su posterior estudio Autor: D. Adrián Poncela Gómez Tutor: D. Quiliano Isaac Moro 2 3 Resumen: Este Trabajo de Fin de Grado tiene como objetivo el desarrollo de una aplicación de extracción y limpieza de titulares de prensa online, mediante el RSS para un posterior estudio estadístico. El usuario a través de una interfaz, podrá seleccionar en un menú los datos que quiere recoger, así como el tiempo de ejecución del programa. La herramienta mostrará unos resultados en tiempo real con gráficos de cómo va el proceso de obtención de los titulares. 4 5 Abstract: The objective of this Final Degree Project is the development of an online press headline extraction and cleaning application, using RSS for a subsequent statistical study. The user, through an interface, will be able to select from a menu the data he wants to collect, as well as the execution time of the program. The tool will show results with graphs of how the process of obtaining the headlines is going. 6 7 Índice general 1 Contextualización y objetivos ............................................................................................................ 13 1.1 Contextualización ...................................................................................................................... 13 1.2 Objetivos ................................................................................................................................... 13 1.3 Esquema general ....................................................................................................................... 14 1.4 Tecnología empleada................................................................................................................. 15 1.5 Metodología utilizada................................................................................................................ 15 1.6 Estructura de la memoria .......................................................................................................... 15 1.7 Contenido del CD ....................................................................................................................... 16 2 Planificación ...................................................................................................................................... 17 2.1 Proceso Unificado de desarrollo de software ............................................................................ 17 2.1.1 Características ..................................................................................................................................... 17 2.1.2 Fases ................................................................................................................................................... 18 2.2 Gestión de Riesgos .................................................................................................................... 19 2.3 Gestión de Recursos .................................................................................................................. 26 2.4 Planificación inicial .................................................................................................................... 27 2.5 Diagrama ................................................................................................................................... 28 2.6 Coste del proyecto ..................................................................................................................... 29 3 Análisis y especificación de requisitos ................................................................................................ 31 3.1 Requisitos funcionales ............................................................................................................... 31 3.2 Requisitos no funcionales .......................................................................................................... 32 3.3 Requisitos de información ......................................................................................................... 32 3.4 Casos de uso .............................................................................................................................. 32 3.4.1 Actores ................................................................................................................................................ 32 3.4.2 Diagrama de casos de uso .................................................................................................................... 33 3.4.3 Descripción de casos de usos ............................................................................................................... 33 3.5 Modelo de dominio ................................................................................................................... 36 3.6 Diagramas de secuencia ............................................................................................................ 37 4 Herramientas utilizadas ..................................................................................................................... 40 4.1 Lenguaje Java ............................................................................................................................ 40 4.2 NetBeans ................................................................................................................................... 40 4.3 Java Swing ................................................................................................................................. 41 4.4 MySQL ....................................................................................................................................... 42 4.5 MySQL WorkBench .................................................................................................................... 43 4.6 Astah UML ................................................................................................................................. 43 4.7 Git .............................................................................................................................................. 44 4.8 Microsoft Project ....................................................................................................................... 44 4.9 Lenguaje R ................................................................................................................................. 45 8 4.10 RStudio ...................................................................................................................................... 45 4.11 Power Bi Desktop ...................................................................................................................... 46 5 Diseño ................................................................................................................................................ 47 5.1 Arquitectura .............................................................................................................................. 47 5.2 Uso de MVC ............................................................................................................................... 48 5.2.1 Vista .................................................................................................................................................... 49 5.2.2 Controlador ......................................................................................................................................... 49 5.2.3 Modelo ................................................................................................................................................ 50 5.2.4 Principal ............................................................................................................................................... 51 5.2.5 Levenshtein ......................................................................................................................................... 52 5.3 Diseño base de datos relacional ................................................................................................ 52 5.3.1 Diagrama relacional ............................................................................................................................. 52 5.3.2 Interacciones con la base de datos ....................................................................................................... 52 5.3.3 Script SQL ............................................................................................................................................ 57 6 Implementación ................................................................................................................................. 59 6.1 RSS ............................................................................................................................................ 59 6.2 Redifusión Web ......................................................................................................................... 60 6.3 XML ........................................................................................................................................... 60 7 Pruebas .............................................................................................................................................. 73 8 Conclusiones ...................................................................................................................................... 79 8.1 Objetivos alcanzados ................................................................................................................. 79 8.2 Trabajo futuro ........................................................................................................................... 79 9 Bibliografía ........................................................................................................................................ 81 APÉNDICES ................................................................................................................................................ 83 A. Planificación real detallada............................................................................................................ 84 B. Conexión con Power BI .................................................................................................................. 97 C. Conexión con RStudio .................................................................................................................. 102 D. Manual de Usuario .................................................................................................................. 103 E. Manual de instalación: ................................................................................................................ 107 F. Anexos de código......................................................................................................................... 108 9 Índice de figuras Figura 1. Proceso Unificado ....................................................................................................................... 19 Figura 2. Gestión de riesgos ....................................................................................................................... 20 Figura 3. Matriz impacto/probabilidad ........................................................................................................ 21 Figura 4. Diagrama Gantt Planificación Inicial ........................................................................................... 28 Figura 5. Diagrama casos de uso ................................................................................................................ 33 Figura 6. Diagrama de secuencia Seleccionar información .......................................................................... 37 Figura 7. Diagrama de secuencia Importar palabras .................................................................................... 38 Figura 8. Diagrama de secuencia Ver gráficos ............................................................................................ 38 Figura 9. Diagrama de secuencia Ver titulares ............................................................................................ 39 Figura 10. Logo Java .................................................................................................................................. 40 Figura 12. Logo NetBeans .......................................................................................................................... 41 Figura 11. Logo MySQL ............................................................................................................................ 42 Figura 13. Logo MySQL WorkBench ......................................................................................................... 43 Figura 16. Logo Astah UML ...................................................................................................................... 44 Figura 17. Logo git..................................................................................................................................... 44 Figura 19. Logo Microsoft Project .............................................................................................................. 45 Figura 14. Logo lenguaje R ........................................................................................................................ 45 Figura 15. Logo RStudio ............................................................................................................................ 46 Figura 18. Logo Power BI .......................................................................................................................... 46 Figura 20. Modelo-Vista-Controlador ......................................................................................................... 48 Figura 21. Paquete Vista ............................................................................................................................ 49 Figura 22. Paquete Controlador .................................................................................................................. 49 Figura 23. Ejemplo Controlador ................................................................................................................. 49 Figura 24. Ejemplo captura de evento ......................................................................................................... 50 Figura 25. Paquete Modelo ......................................................................................................................... 50 Figura 26. Atributos FeedMessage ............................................................................................................. 50 Figura 27. Atributos Palabras ..................................................................................................................... 51 Figura 28. Atributos periódico .................................................................................................................... 51 Figura 29. Paquete Principal ....................................................................................................................... 51 Figura 30. Paquete Levenshtein .................................................................................................................. 52 Figura 31. Diagrama relacional de la base de datos. .................................................................................... 52 Figura 32. SQL Almacenar titulares ........................................................................................................... 52 Figura 33. SQL Guardados desde ahora ...................................................................................................... 53 Figura 34. SQL Número de titulares en cada periódico ............................................................................... 53 Figura 35. SQL Último titular almacenado ................................................................................................. 53 Figura 36. SQL Búsqueda de una palabra específica ................................................................................... 53 Figura 37. SQL Tabla titulares agrupados ................................................................................................... 54 Figura 38. SQL Tabla media de palabras agrupadas .................................................................................... 54 Figura 39. SQL Tabla media de caracteres agrupados ................................................................................. 54 Figura 40. SQL Titulares con una palabra de búsqueda ............................................................................... 54 Figura 41. SQL Titulares negativos ............................................................................................................ 55 Figura 42. SQL Titulares positivos ............................................................................................................. 55 Figura 43. SQL Actualizar uso de URL ...................................................................................................... 55 Figura 44. SQL Procesar palabra negativa .................................................................................................. 55 Figura 45. SQL Resetear uso de URL ......................................................................................................... 55 Figura 46. SQL Información de URL para utilizar ...................................................................................... 56 Figura 47. SQL Almacenar palabras ........................................................................................................... 56 Figura 48. SQL Frecuencia de cada palabra ................................................................................................ 56 Figura 49. SQL Importar CSV de palabras negativas .................................................................................. 56 Figura 50. SQL Obtener palabras distintas .................................................................................................. 56 Figura 51. Script SQL 1 ............................................................................................................................. 57 Figura 52. Script SQL 2 ............................................................................................................................. 57 Figura 53. Script SQL 3 ............................................................................................................................. 58 Figura 54. Script SQL 4 ............................................................................................................................. 58 Figura 55. RSS El País ............................................................................................................................... 59 16 • Capítulo 7. Pruebas: Pruebas realizadas durante el desarrollo de la herramienta implementada. • Capítulo 8. Conclusiones: En este último capítulo se expondrán los objetivos alcanzados, valoración personal del alumno. También se comentarán las posibles mejoras de este TFG, en lo que sería un trabajo futuro. • Bibliografía: Documentación utilizada y consultada a lo largo de la programación de la herramienta cómo en la realización de la memoria de este TFG. • Anexos: Incluye el manual de usuario, manual de instalación y mantenimiento, así como anexos de código. 1.7 Contenido del CD En el interior del CD se puede encontrar: • Documento con la memoria en PDF. • Carpeta con el proyecto exportado de NetBeans. • Carpeta con las bibliotecas necesarias para incluir en el proyecto, en formato JAR. • Carpeta con ejemplos de archivos de palabras negativas, positivas y de búsqueda. • Script SQL. 17 2 Planificación En este capítulo se explicará la planificación de este TFG. La planificación es una parte fundamental en el desarrollo de un proyecto. Conviene planificar y determinar en qué orden se van a realizar las tareas, así como la estimación de tiempo que va a suponer la realización de cada una de ellas. Es necesario realizar esta planificación, antes de comenzar con el análisis, el diseño y la implementación de la herramienta. Se explicará la metodología utilizada, la gestión de riesgos, la gestión de recursos y por último se realizará un cálculo sobre el coste del proyecto. Uso de Proceso Unificado Lo primero de todo en cuanto a la planificación del proyecto se refiere es qué tipo de metodología se va a seguir. En este punto se pueden analizar algunas metodologías y hacer una valoración de cuál se puede adaptar mejor. Se valoran la utilización de una metodología ágil, cascada o proceso unificado. Se descarta la utilización de un modelo de desarrollo en cascada debido a la más que posible necesidad de modificar los requisitos a medida que se avanza en el proyecto. La utilización de una metodología ágil cómo podría ser SCRUM, también se descarta, debido a que es necesario un equipo de desarrollo con experiencia, no siendo el caso de este TFG. Descartando el modelo de desarrollo en cascada y el uso de una metodología ágil, se decide utilizar el proceso unificado. La razón de esta decisión, se encuentra en que este método proporciona un enfoque iterativo e incremental. A diferencia de la metodología ágil no requiere personal con experiencia con este tipo de planificación. 2.1 Proceso Unificado de desarrollo de software En este apartado se procede a explicar en qué consiste el Proceso unificado (Wikipedia, 2019) de desarrollo de software. El Proceso Unificado es el marco de desarrollo de software que se caracteriza por estar dirigido por casos de uso, estar centrado en la arquitectura y ser iterativo e incremental. 2.1.1 Características • Iterativo e incremental El Proceso Unificado está formado por cuatro fases que se denominan: Inicio, Elaboración, Construcción y Transición. Cada uno de las fases, se divide en una serie de iteraciones. Las iteraciones tienen como finalidad, mostrar un incremento del producto desarrollado añadiendo una nueva funcionalidad o mejorando las funcionalidades ya existentes. • Dirigido por casos de uso En el Proceso Unificado los casos de uso son utilizados para establecer los requisitos funcionales. También se utilizan para definir los contenidos de cada una de las iteraciones. La idea es que cada iteración tome un conjunto de casos de uso y se desarrolle todo el proceso a través de las distintas disciplinas como pueden son la implementación, diseño y las pruebas. 18 • Centrado en la arquitectura Con el Proceso Unificado se asume que no hay un único modelo con el que se cubran todos los contenidos del sistema. Debido a este motivo existen varios modelos y vistas con la que se define la arquitectura de software de un sistema. Se parte de una visión global del sistema que se va refinando poco a poco hacia niveles inferiores para poder definir así cada uno de los componentes básicos que formarán el sistema. • Enfocado en los riesgos El Proceso Unificado necesita que el equipo de proyecto consiga identificar cada uno de los riesgos críticos en una etapa temprana del ciclo de vida. Se realiza con la finalidad de disminuir la probabilidad de que un riesgo ocurra, siendo estos tratados con la mayor prioridad. 2.1.2 Fases El Proceso Unificado se divide en cuatro fases: • Inicio: La fase de inicia tiene su importancia principalmente en nuevos desarrollos donde hay importantes riesgos que pueden ocurrir. A mayores existen una serie de requisitos que deben ser abordados antes de que el proyecto pueda continuar. Cuando la finalidad es una mejora de lo que ya existía, se trata de una fase más breve, centrándose principalmente en la viabilidad del proyecto. Objetivos y tareas importantes de esta fase: o Descripción del producto final. o Presentar análisis de negocio. o Identificar por mayores riesgos potenciales. o Establecimiento de las funcionalidades del sistema. o Identificar los casos de uso más importantes y dependientes. o Estimación del coste y presupuesto. o Cronograma de tareas. Con el hito de los objetivos de desarrollo, finaliza la fase de inicio. • Elaboración: En esta fase se obtiene una visión refinada de lo que va a resultar el proyecto. Se realiza la implementación del núcleo de la herramienta. Se resuelven aquellos riesgos más importantes que se pueden considerar críticos. Se pueden añadir nuevos requisitos. También se intentan ajustar las estimaciones. La mayor parte de los requisitos funcionales del sistema tienen que ser capturados en esta fase, además se tiene que diseñar la arquitectura inicial del programa. Todo esto tiene la finalidad de proporcionar una base estable, de cara afrontar las fases que requieren un mayor esfuerzo. Con el hito de la arquitectura del sistema, se da por finalizada la fase elaboración. • Construcción: Se trata de la fase más extensa dentro del desarrollo. 19 Se parte de la base de la arquitectura obtenida de la fase elaboración, con ella, en cada iteración se trata de evolucionarla hasta convertirse en un producto listo incluyendo requisitos mínimos. Con la finalización de cada iteración, se consigue una versión nueva ejecutable del producto, con funcionalidades añadidas o mejoradas, con respecto a las de la iteración anterior. Se tratan los riesgos de menor importancia Con el hito de la obtención de una aplicación con todas las funcionalidades, se da por completa la fase de construcción. • Transición: Se trata de la última fase, en la que el producto debe de estar preparado para ser probado y utilizado por el cliente sin problemas. Tras esto, se pensará en aumentar las funcionalidades para la mejora del producto. Durante esta fase se debe llevar a cabo la validación del sistema, así como resolver todos aquellos falos o errores identificados. La fase concluye con el producto final. (Researchgate, 2019) Figura 1. Proceso Unificado 2.2 Gestión de Riesgos Una de las partes más importantes a la hora de planificar el desarrollo de un proyecto es la gestión de los riesgos. No tener en cuenta los riesgos o darles menos importancia de la que realmente tienen, puede suponer un fracaso en el proyecto, así como el no cumplimiento de los objetivos establecidos. En este apartado se expondrán los riesgos que han sido detectados, acompañados de una descripción de los mismos, incluyendo su impacto y probabilidad. Junto con la matriz de exposición que se adjunta, se determina para cada uno de los riesgos, la exposición existente a dicho riesgo. 20 Lo primero de todo es determinar que se entiende por un riesgo: El PM-BOK proporciona la siguiente definición: “Un riesgo es un evento o una condición incierta que, si ocurren, tienen un efecto positivo o negativo sobre los objetivos del proyecto” Por tanto, el plan de gestión de riesgos tiene la finalidad de controlar, valorar y prevenir los principales riesgos que pueden ocurrir, afectando adversamente al proyecto. También incluye, para cada uno de los riegos un plan de acción para evitar o minimizar el impacto que pueda suponer. Etapas que componen el plan de riesgos: • Identificación de todos aquellos riesgos que puedan aparecer durante el desarrollo del proyecto, en cualquier etapa. • Análisis de cada uno de los riesgos que han sido identificados, asignándolos una probabilidad de ocurrencia, nivel de impacto. Se clasificarán en función de a qué parte o etapa del proyecto afectan. • Creación de un plan de acción para cada riesgo, aunque especialmente, para aquellos que sean más importantes, indicando que decisiones o acciones se debe tomar cuando sucedan. • Gestionar y supervisar los riesgos que afectaron al proyecto. (PDSC, 2019) Figura 2. Gestión de riesgos Hay que tener en cuenta, que durante la planificación inicial del proyecto se prevén una serie de riesgos y a medida que se avanza con el desarrollo del proyecto pueden ocurrir esos riesgos previstos, pero también pueden suceder algunos que no han sido valorados. Por tanto, en este plan de gestión de riesgos se incluirán, también todos aquellos riesgos descubiertos durante el desarrollo del proyecto. Esto se debe a la característica del Proceso Unificado, de en cada iteración revisar y actualizar la gestión de riesgos durante el desarrollo del proyecto. Se procederá a realizar una clasificación de los riesgos en tres categorías atendiendo a los siguientes criterios: • Riesgos de Proyecto: Restricciones de recursos, interfaces externas, relaciones con los proveedores, políticas internas, problemas de coordinación interna del equipo o del grupo, financiación no adecuada. • Riesgos de Proceso: Proceso software no documentado, falta de revisiones efectivas de colegas, no prevención de defectos, proceso de diseño pobre, gestión pobre de requisitos, planificación ineficaz. 21 • Riesgos de Producto: Falta de experiencia en el dominio, diseño complejo, interfaces definidas deficientemente, sistemas de legado poco comprendidos, requisitos vagos o incompletos. Probabilidades consideras en la valoración de los riesgos: • Muy baja. • Baja. • Media. • Alta. • Muy alta. Impactos considerados en la valoración de los riesgos: • Despreciable. • Marginal. • Crítico. • Catastrófico. Estrategias para la resolución y manejo de los riesgos: • Reducción del riesgo: Reduce la probabilidad y/o consecuencia del riesgo después de que ocurra. • Reserva del riesgo: Utilizar la planificación reservada previamente o la holgura del presupuesto, • Protección del riesgo: Reduce la probabilidad y/o consecuencia del riesgo antes de que ocurra. • Mitigación del riesgo: Aceptación de la ocurrencia de un riego, pero reduciendo al máximo su impacto. A continuación, se muestra la figura con la matriz de exposición utilizada y las tablas con los riesgos considerados en este TFG, así como la estrategia y plan de acción para cada uno de ellos. Figura 3. Matriz impacto/probabilidad 22 Tabla 1. Riesgo 1 Riesgo 1 Pérdida de datos. Detalle Pérdida de todo o de una parte del proyecto. Ya sea código, documentación, base de datos, bibliografía… Categoría Riesgo de Proyecto. Impacto Crítico. Probabilidad Baja. Exposición Baja. Estrategia Mitigación del riesgo. Plan de acción Utilización de gitlab.inf.uva para el control de versiones. (GitLab, 2019) Tabla 2. Riesgo 2 Riesgo 2 Enfermedad. Detalle Incapacidad de poder trabajar en el proyecto temporalmente debido a enfermedad. Categoría Riesgo de Proyecto. Impacto Marginal. Probabilidad Baja. Exposición Ninguna. Estrategia Mitigación del riesgo. Plan de acción Realizar una replanificación del proyecto según sea necesario en función del tiempo perdido por enfermedad. Tabla 3. Riesgo 3 Riesgo 3 Cambios en los requisitos. Detalle Modificación de los requisitos establecidos previamente en el inicio de la planificación del proyecto. Categoría Riesgo de producto. Impacto Crítico. Probabilidad Media. Exposición Moderada. Estrategia Reducción del riesgo. Reserva del riesgo. Plan de acción Uso de más recursos para minimizar las modificaciones producidas. Reserva de holgura de tiempo. 23 Tabla 4. Riesgo 4 Riesgo 4 Fallo en el diseño. Detalle Error a la hora de definir el diseño de toda o una parte de la herramienta. Categoría Riesgo de producto. Impacto Crítico. Probabilidad Media. Exposición Moderada. Estrategia Protección del riesgo. Reducción del riesgo. Plan de acción Corregir el error realizando una replanificación si fuese necesaria. Tabla 5. Riesgo 5 Riesgo 5 Fallo en la implementación. Detalle Error a la hora de implementar toda o una parte de la herramienta. Categoría Riesgo del producto. Impacto Crítico. Probabilidad Media. Exposición Moderada. Estrategia Protección del riesgo. Reducción del riesgo. Plan de acción Corregir el error realizando una replanificación si fuese necesaria. Tabla 6. Riesgo 6 Riesgo 6 Planificación no realista. Detalle Planificación de una herramienta que no va a ser posible ser ejecutada dentro de los límites de tiempo establecidos, por su complejidad. Categoría Reserva del riesgo. Impacto Crítico. Probabilidad Media. Exposición Moderada. Estrategia Protección del riesgo. Plan de acción Replanificación del proyecto ajustándose a los requisitos principales. 24 Tabla 7. Riesgo 7 Riesgo 7 Falta de conocimiento con herramientas/tecnologías. Detalle Tiempo empleado en adquirir los conocimientos necesarios para la utilización de las herramientas/tecnologías necesarias. Categoría Riesgo de producto. Impacto Marginal. Probabilidad Media. Exposición Baja. Estrategia Reducción del riesgo. Plan de acción Uso de tutoriales o preguntar a expertos en dichas herramientas/tecnologías. Tabla 8. Riesgo 8 Riesgo 8 Recursos no disponibles. Detalle Incapacidad de poder desarrollar, diseñar o implementar una parte de la herramienta por falta de algún recurso necesario para tal fin. Categoría Riesgo de Proyecto. Impacto Marginal. Probabilidad Baja. Exposición Baja. Estrategia Reserva del riesgo. Plan de acción Tener alternativas disponibles y preparadas para su utilización. Tabla 9. Riesgo 9 Riesgo 9 Asuntos personales. Detalle Incapacidad de poder trabajar en el proyecto temporalmente debido a asuntos personales. Categoría Riesgo de Proyecto. Impacto Marginal. Probabilidad Baja. Exposición Ninguna. Estrategia Mitigación del riesgo. Plan de acción Realizar una replanificación del proyecto según sea necesario en función del tiempo perdido por asuntos personales. 25 Tabla 10. Riesgo 10 Riesgo 10 Fallo conexión de Red. Detalle La conexión de red se interrumpe en el momento de consultar el archivo. Categoría Riesgos de proyecto. Impacto Crítico. Probabilidad Baja. Exposición Baja. Estrategia Mitigación del riesgo. Plan de acción Si la conexión con alguna página falla, continuar con la siguiente y volver a intentarlo después. Tabla 11. Riesgo 11 Riesgo 11 Fallo al proporcionar el XML. Detalle Fallo en la creación del archivo XML, por parte de la fuente online. Categoría Riesgos de proyecto. Impacto Crítico. Probabilidad Baja. Exposición Baja. Estrategia Mitigación del riesgo. Plan de acción Realizar una comprobación de que los campos son proporcionados correctamente, y si no es así, ignorarlo por el momento y volver a intentarlo después. Tabla 12. Riesgo12 Riesgo 12 Requisito mal especificado. Detalle Especificación errónea de un requisito. Categoría Riesgo de producto. Impacto Marginal. Probabilidad Baja. Exposición Ninguna. Estrategia Reducción del riesgo. Plan de acción Evaluación de los requisitos e identificación de la funcionalidad que supone dentro del producto para su modificación. 32 • RF-18 Creación de una base de datos con las tablas adecuadas para su posterior uso en otras aplicaciones de visualización. 3.2 Requisitos no funcionales Un requisito no funcional, especifica cómo debe funcionar el sistema. Pueden llegar a ser más importantes que los propios requisitos funcionales. Tratan sobre limitaciones que afectan a los servicio o funcionalidades del sistema. • RNF-01 El sistema permitirá interactuar con el programa de forma fiable, sencilla y rápida. • RNF-02 El sistema permitirá al usuario ejecutar el programa en distintos terminales. • RNF-03 El sistema realizará la importación de las palabras negativas se realizará mediante un archivo CSV. • RNF-04 El sistema realizará la importación de las palabras positivas se realizará mediante un archivo CSV. • RNF-05 El sistema realizará la importación desde un archivo en formato CSV de las palabras con las que realizar la búsqueda. • RNF-06 La interfaz de usuario del sistema deberá de ser simple, no requiriendo un gran tiempo de aprendizaje. 3.3 Requisitos de información • RI-01 El sistema deberá almacenar la información relativa a los nombres de periódicos disponibles para realizar la extracción de titulares. • RI-02 El sistema deberá almacenar la información relativa a los tipos de información disponibles para la extracción de los titulares. • RI-03 El sistema deberá almacenar la URL a utilizar para cada periódico y tipo de información disponible. • RI-04 El sistema deberá almacenar las palabras consideradas negativas por el usuario. • RI-05 El sistema deberá almacenar las palabras consideradas positivas por el usuario. • RI-06 El sistema deberá almacenar las palabras con las que realizar una búsqueda proporcionadas por el usuario. 3.4 Casos de uso 3.4.1 Actores Se considera un único actor, siendo cualquier persona que ejecute y utilice este programa. 33 3.4.2 Diagrama de casos de uso Figura 5. Diagrama casos de uso 3.4.3 Descripción de casos de usos Caso de uso 1 Seleccionar Información Descripción El sistema deberá permitir al usuario seleccionar la información con la que realizar el proceso de extracción de titulares. Precondición - Secuencia Normal Paso Acción 1 El usuario selecciona los periódicos, tipo de información, método de parada y valor correspondiente. 2 El sistema verifica que los datos introducidos son correctos y comienza el proceso de extracción. Excepciones Paso Acción 2 Si existen campos obligatorios sin introducir o no está en el formato deseado, el sistema informa al usuario y el caso de uso continúa en el paso 1. Postcondición • El sistema actualiza la base de datos conforme a las selecciones del usuario. Caso de uso 2 Salir de la herramienta Descripción El sistema deberá permitir al usuario salir de la herramienta antes, durante o después del proceso de extracción de titulares. Precondición - Secuencia Normal Paso Acción 1 En cualquier momento el usuario desea abandonar la ejecución de la herramienta pulsando el botón que corresponde. 2 El sistema permitirá al usuario abandonar y cerrar la herramienta. Excepciones Paso Acción 34 1 Si el usuario desea abandonar la herramienta durante el proceso de extracción de titulares, el sistema mostrará un mensaje de confirmación al usuario de si realmente quiere abandonar el programa. Si el usuario acepta, el caso de uso sigue en el paso 2. Si no lo acepta, continúa en el paso 1. Postcondición • El usuario finaliza la ejecución de programa, terminando todos los procesos activos. Caso de uso 3 Importar palabras positivas Descripción El sistema deberá permitir al usuario importar un archivo CSV que contenga una lista con las palabras positivas. Precondición • El usuario debe tener un archivo CSV, con el nombre apropiado en la ruta indicada en el manual de usuario. • El proceso de extracción de titulares ha finalizado. Secuencia Normal Paso Acción 1 El actor selecciona la opción de “Importar palabras positivas”. 2 El Sistema lee el archivo CSV proporcionado e informa al usuario de que la tabla correspondiente de la base de datos ha sido actualizada. Postcondición • El Sistema actualiza la tabla correspondiente de la base de datos con la lista de palabras positivas facilitada por el usuario. Caso de uso 4 Importar palabras negativas Descripción El sistema deberá permitir al usuario importar un archivo CSV que contenga una lista con las palabras negativas. Precondición • El usuario debe tener un archivo CSV, con el nombre apropiado en la ruta indicada en el manual de usuario. • El proceso de extracción de titulares ha finalizado. Secuencia Normal Paso Acción 1 El actor selecciona la opción de “Importar palabras negativas”. 2 El Sistema lee el archivo CSV proporcionado e informa al usuario de que la tabla correspondiente de la base de datos ha sido actualizada. Postcondición • El Sistema actualiza la tabla correspondiente de la base de datos con la lista de palabras negativas facilitada por el usuario. Caso de uso 5 Importar palabras de búsqueda Descripción El sistema deberá permitir al usuario importar un archivo CSV que contenga una lista con las palabras de búsqueda. Precondición • El usuario debe tener un archivo CSV, con el nombre apropiado en la ruta indicada en el manual de usuario. • El proceso de extracción de titulares ha finalizado. Secuencia Normal Paso Acción 1 El actor selecciona la opción de “Importar palabras de búsqueda”. 2 El Sistema lee el archivo CSV proporcionado e informa al usuario de que la tabla correspondiente de la base de datos ha sido actualizada. 35 Postcondición • El Sistema actualiza la tabla correspondiente de la base de datos con la lista de palabras de búsqueda facilitada por el usuario. Caso de uso 6 Ver gráficos Descripción El sistema deberá permitir al usuario la visualización de los gráficos con las estadísticas de la información almacenada en la base de datos hasta ese momento. Precondición • El proceso de extracción de titulares ha finalizado, es decir, la base de datos se encuentra actualizada. Secuencia Normal Paso Acción 1 El usuario selecciona la opción de “Ver Gráficos”. 2 El sistema muestra los gráficos con la información disponible en ese momento en la base de datos. Postcondición • El sistema mostrará los gráficos con las estadísticas de los titulares almacenados en la base de datos. Caso de uso 7 Ver titulares Descripción El sistema deberá permitir al usuario ver los titulares que contengan una palabra de búsqueda o hayan sido considerados negativos o positivos. Precondición • El proceso de extracción de titulares ha finalizado. • El procesamiento de palabras se ha realizado. Secuencia Normal Paso Acción 1 El usuario selecciona la opción de “Ver Titulares”. 2 El sistema muestra los titulares correspondientes, almacenados en ese momento en la base de datos. Postcondición El sistema mostrará una tabla con los titulares que contienen una palabra de búsqueda, o han sido considerados positivos y negativos Caso de uso 8 Procesar palabras Descripción El sistema deberá permitir al usuario realizar un procesamiento de palabras de búsqueda, positivas y negativas. Precondición El proceso de extracción de titulares ha finalizado. Se han importado los archivos CSV correspondientes, actualizando la base de datos. Secuencia Normal Paso Acción 1 El usuario selecciona la opción de “Procesamiento de palabras”. 2 El Sistema procesa las palabras de la base de datos e informa al usuario de que la base de datos ha sido actualizada. Postcondición • La base de datos se actualiza con la información proporcionada por el usuario. 36 3.5 Modelo de dominio En este proyecto, existen tres tipos de clases: • Periódico o nombre_periódico: Periódico del que se obtienen los titulares. Valores especificados en el <<enum>>. o tipo_información: Clase de noticia, dónde se incluye el titular. Valores especificados en el <<enum>>. o uso: Valor para especificar si el usuario lo ha seleccionado o no para la extracción de titulares. o link: URL del RSS • Titular o titulo: titular publicado obtenido del RSS o titulo_limpio: titular al que se le han eliminado las palabras con menor importancia o fecha: Fecha de publicación del titular o palabras: Número de palabras que forman el titular o caracteres: Número de caracteres que forman el titular o num: Identificador numérico de cada titular. • Palabra o palabra: Cada una de las palabras, que forman el titulo_limpio. o contador: Veces que aparece la palabra en un titular. o positiva: indicador de si la palabra es considerada positiva o negativa: indicador de si la palabra es considera negativa o búsqueda: indicador de se la palabra es de búsqueda 37 • Cardinalidad: o Un titular pertenecerá a un único periódico. o Un periódico puede tener varios titulares o ninguno. o Un titular puede tener una o varias palabras. o Una palabra puede estar en uno o varios titulares. 3.6 Diagramas de secuencia Diagramas de secuencia de los casos de uso más importantes de la herramienta. Figura 6. Diagrama de secuencia Seleccionar información 38 Figura 7. Diagrama de secuencia Importar palabras Figura 8. Diagrama de secuencia Ver gráficos 39 Figura 9. Diagrama de secuencia Ver titulares 40 4 Herramientas utilizadas 4.1 Lenguaje Java Java (Wikipedia, 2019) es un lenguaje de programación de propósito general, concurrente, orientado a objetos. Se diseñó con el fin de tener las mínimas dependencias de implementación posibles. Tiene la intención de permitir a los desarrolladores de aplicaciones que escriban el programa, y pueda ser ejecutado en cualquier dispositivo. Esto se conoce en inglés como WORA: “Write once, run anywhere”. Significa que el código que es ejecutado en una plataforma no tiene que ser recompilado para correr en otra. Java es uno de los lenguajes de programación más populares en uso, especialmente para aplicaciones clienteservidor de web. Java se creó con cinco objetivos principales: 1) Debería usar el paradigma de la programación orientada a objetos. 2) Debería permitir la ejecución de un mismo programa en múltiples sistemas operativos. 3) Debería incluir por defecto soporte para trabajo en red. 4) Debería diseñarse para ejecutar código en sistemas remotos de forma segura, 5) Debería ser fácil de usar y tomar lo mejor de otros lenguajes orientados a objetos como C++. Razones de utilización del lenguaje de programación Java: • Lenguaje de programación con el que el alumno tiene mayores conocimientos y experiencia. • Código base encontrado en este lenguaje de programación. • Capacidad para desarrollar una interfaz de usuario. Figura 10. Logo Java 4.2 NetBeans NetBeans (Wikipedia, 2019) es un entorno de desarrollo integrado libre, hecho principalmente para el lenguaje de programación Java. NetBeans IDE es un producto libre y gratuito sin restricciones de uso. La plataforma NetBeans permite que las aplicaciones sean desarrolladas a partir de un conjunto de componentes de software denominados módulos. Un módulo es un archivo Java que contiene clases de java escritas para interactuar con las APIs de NetBeans y un archivo especial “manifest file”, que lo identifica como módulo. 41 Las aplicaciones construidas a partir de módulos pueden ser extendidas agregándole nuevos módulos. Debido a que los módulos pueden ser desarrollados independientemente, las aplicaciones basadas en la plataforma NetBeans, pueden ser extendidas fácilmente por otros desarrolladores de software. Características de la aplicación: • Gestión de la interfaz de usuario (menús y barras de herramientas). • Gestión de configuración de usuario. • Gestión de almacenamiento (guardar o cargar algún tipo de dato). • Gestión de ventana. • Marco Asistente. • Librería visual. • Herramientas de desarrollo integrado. Razones de utilización de NetBeans: • Necesidad de utilización de un IDE, ya que proporciona muchas ventajas en cuanto a rapidez y facilidad para la programación. • IDE con el que el alumno tiene mayores conocimientos y experiencia. • No es necesario invertir tiempo en su aprendizaje. • Posee la capacidad de desarrollar una interfaz de usuario paso a paso. Figura 11. Logo NetBeans 4.3 Java Swing Java Swing (Wikipedia, 2019) es un framework MVC para desarrollar interfaces gráficas para Java con independencia de la plataforma. Sigue un simple modelo de programación por hilos, y posee las siguientes características principales: • Independencia de plataforma. • Extensibilidad: Arquitectura altamente particionada: los usuarios pueden proveer sus propias implementaciones modificadas para sobrescribir las implementaciones por defecto. • El control permite representar diferentes estilos de apariencia "look and feel" (desde apariencia Mac OS hasta apariencia Windows XP). Además, los usuarios pueden proveer su propia implementación de apariencia, que permitirá cambios uniformes en la apariencia existente en las aplicaciones Swing sin efectuar ningún cambio al código de aplicación. Razones de utilización de Java Swing: 48 (Codingornot, 2019) Figura 20. Modelo-Vista-Controlador Flujo de control que se sigue con el MVC: 1) El usuario interacciona con la interfaz. 2) El controlador recibe la notificación de la acción solicitada por el usuario. Se gestiona el evento. 3) El controlador accede al modelo, realizando las modificaciones necesarias en función de la petición del usuario. 4) El controlador delega en la vista la representación de la interfaz de usuario, con los cambios en el modelo y la información obtenida del mismo. 5) La interfaz de usuario espera nuevas interacciones del usuario para comenzar el ciclo de nuevo. En este TFG, se utiliza un Sistema de gestión de Base de Datos, el cuál gestiona los datos que debe utilizar la aplicación. Dentro del MVC, esta gestión se encuentra dentro del modelo. 5.2 Uso de MVC El desarrollo de este TFG consta de los siguientes 5 paquetes: 1) Vista. 2) Controlador. 3) Modelo. 4) Principal. 5) Levenshtein. A continuación, se procede a explicar el contenido de cada uno de los paquetes: 49 5.2.1 Vista Está formado por 5 clases java, uno por cada una de las 5 vistas que forman en proyecto. Figura 21. Paquete Vista Siguiendo el patrón MVC, en estas clases sólo se encuentra el contenido de los distintos componentes que forman la interfaz. No hay ninguna función ni procedimiento más allá de lo puramente visual. 5.2.2 Controlador Figura 22. Paquete Controlador Se encuentran las 5 clases javas que se corresponden con los 5 controladores de cada una de las vistas. La siguiente imagen, es un ejemplo de una de ellas: Figura 23. Ejemplo Controlador Se puede apreciar como la clase implementa la clase ActionListener para poder determinar cuando el usuario realiza una acción con un elemento de la vista correspondiente. Cuando el usuario interacciona con la vista, el controlador captura ese evento y en función de cuál sea realiza la acción correspondiente, como se puede ver a continuación: 50 Figura 24. Ejemplo captura de evento Se puede apreciar como dependiendo del evento que se capture se llama por ejemplo a un método o se muestra un texto en pantalla. 5.2.3 Modelo Figura 25. Paquete Modelo 5.2.3.1 Conexión Clase encargada de realizar la conexión de NetBeans con la base de datos local de MySQL. En esta clase es especifican todos lo datos necesarios para realizar la conexión como son el usuario, el nombre y la contraseña de la base de datos. Posee un método para realizar la conexión y otro para desconectarse. De esta forma se evita dejar la conexión abierta con la base de datos. 5.2.3.2 FeedMessage Clase que se encarga de almacenar la información de cada una de las instancias que se corresponden con los titulares. Sus atributos son los que posteriormente se guardarán en cada una de las columnas de la base de datos de la tabla Titulares. Se incluyen métodos getters() y setters() para la obtención y modificación de estos atributos según sea necesario. Figura 26. Atributos FeedMessage 51 5.2.3.3 Palabras Clase que se encarga de almacenar la información de cada una de las instancias que se corresponden con las palabras. Sus atributos son los que posteriormente se guardarán en cada una de las columnas de la base de datos de la tabla Palabras. Se incluyen métodos getters() y setters() para la obtención y modificación de estos atributos según sea necesario. Figura 27. Atributos Palabras 5.2.3.4 Periódico Figura 28. Atributos periódico Clase que se encarga de almacenar la información de cada una de las instancias que se corresponden con los periódicos. Sus atributos son los que posteriormente se guardarán en cada una de las columnas de la base de datos de la tabla Periódico. Se incluyen métodos getters() y setters() para la obtención y modificación de estos atributos según sea necesario. 5.2.3.5 UsoBD Clase que donde se realiza toda la funcionalidad relacionada con la base de datos. Esta funcionalidad incluye la realización de las consultas necesarias, la inserción de filas a la tabla de Titulares y la inserción de filas a la tabla de Palabras. 5.2.4 Principal Figura 29. Paquete Principal 52 Lo forman las clases necesarias para realizar el proceso de extracción de titulares, es decir, para conectarse a la URL proporcionada y leer el archivo XML. 5.2.5 Levenshtein Figura 30. Paquete Levenshtein Clase para calcular la similitud de dos cadenas de caracteres, mediante la distancia de Levenshtein. 5.3 Diseño base de datos relacional 5.3.1 Diagrama relacional Figura 31. Diagrama relacional de la base de datos. 5.3.2 Interacciones con la base de datos A lo largo de la ejecución de la herramienta se realizan una serie de interacciones con la base de datos. Estas interacciones son consultas a tablas determinadas de la base de datos, inserción de filas y actualización de filas. A continuación, se muestran las interacciones más importantes que se da a la base de datos, desde la herramienta. 1) Almacenar titulares: Figura 32. SQL Almacenar titulares Para insertar cada uno de los titulares con su información correspondiente en la tabla de Titulares. 53 2) Guardados desde ahora: Figura 33. SQL Guardados desde ahora Determina el número de titulares con fecha de publicación posterior a la fecha de inicio de la ejecución del programa. Se encarga de cumplir la condición de parada del programa con el número de titulares especificado por el usuario. 3) Numero de titulares en cada periódico: Figura 34. SQL Número de titulares en cada periódico Devuelve el número de titulares almacenados del periódico proporcionado. Sirve para poder conocer el número de periódicos almacenados en el resumen de resultados, tras la finalización del proceso de extracción de titulares. 4) Último titular almacenado: Figura 35. SQL Último titular almacenado Devuelve el último titular que ha sido almacenado proporcionando su identificador. El identificador del último titular almacenado es el número de titulares almacenados. Este titular es el que se mostrará en la vista de resultados en directo, actualizándose a medida que se almacena un nuevo titular. 5) Búsqueda de una palabra específica: Figura 36. SQL Búsqueda de una palabra específica Búsqueda de una palabra de un titular en concreto para ver si ya está almacenado en la tabla de datos o no. En los casos en que en un mismo titular aparezca repetida una misma palabra, esta búsqueda verá que ya está almacenada y hay que aumentar el contador de esa palabra, para ese titular. 54 6) Tabla titulares agrupados: Figura 37. SQL Tabla titulares agrupados Devuelve una tabla con el número de titulares almacenados para cada uno de los tres periódicos. 7) Tabla media de palabras agrupadas: Figura 38. SQL Tabla media de palabras agrupadas Devuelve una tabla con el promedio de palabras de los titulares almacenados para cada uno de los tres periódicos. 8) Tabla media de caracteres agrupados: Figura 39. SQL Tabla media de caracteres agrupados Devuelve una tabla con el promedio de caracteres de los titulares almacenados para cada uno de los tres periódicos. 9) Titulares con una palabra de búsqueda: Figura 40. SQL Titulares con una palabra de búsqueda Devuelve los titulares que contienen al menos una de las palabras consideradas como de búsqueda. 55 10) Titulares negativos: Figura 41. SQL Titulares negativos Devuelve los titulares que han sido considerados negativos. Contienen más palabras negativas que positivas. 11) Titulares positivos Figura 42. SQL Titulares positivos Devuelve los titulares que han sido considerados negativos. Contienen más palabras positivas que negativas. 12) Actualizar uso de URL: Figura 43. SQL Actualizar uso de URL Cambia el campo de uso a true, de la URL del periódico u tipo de información proporcionados. 13) Procesar palabra negativa: Figura 44. SQL Procesar palabra negativa Cambia el campo de negativa a true, de la palabra proporcionada. 14) Resetear uso de URL: Figura 45. SQL Resetear uso de URL Cambia los campos de uso de todas las URLs a false. Se realza antes de actualizar la nueva selección del usuario. 56 15) Información de URL para utilizar: Figura 46. SQL Información de URL para utilizar Devuelve aquellas URLs que tienen el campo de uso a true. Son los links que el usuario ha seleccionado para realizar la extracción de titulares. 16) Almacenar palabras: Figura 47. SQL Almacenar palabras Para insertar cada uno de las palabras con su información correspondiente en la tabla de Palabras. 17) Frecuencia de cada palabra: Figura 48. SQL Frecuencia de cada palabra Obtiene la frecuencia de cada una de las palabras almacenadas en la base de datos. Solo para las palabras que aparecen más de una vez. 18) Importar CSV de palabras negativas: Figura 49. SQL Importar CSV de palabras negativas Importa el archivo CSV de palabras negativas a la tabla correspondiente. 19) Palabras distintas: Figura 50. SQL Obtener palabras distintas Devuelve una lista con todas las palabras distintas. Esto se debe a que en la tabla de palabras se guardan palabras repetidas, ya que se almacenan todas las palabras de cada titular haciendo referencia al titular al que pertenecen. Con esta consulta se obtienen una lista de palabras que se correspondería a una especie de diccionario de palabras almacenadas. 57 5.3.3 Script SQL En este apartado se muestra el script utilizado para la creación de las tablas correspondientes de la tabla de datos. Figura 51. Script SQL 1 Figura 52. Script SQL 2 64 static final String LINK = "link"; static final String AUTHOR = "author"; static final String ITEM = "item"; static final String PUB_DATE = "pubDate"; static final String GUID = "guid"; final URL url; Estas variables se inicializan con el texto que hay que leer del archivo XML, es decir, el nombre de las etiquetas. Recibe como parámetro el URL del RSS para leer. Comprueba que es una URL correcta y no es errónea. Contiene 3 métodos: o public Feed readFeed() Guarda en unas variables el contenido que se encuentra en las etiquetas correspondientes del archivo XML. Realiza una lectura evento a evento, es decir etiqueta a etiqueta, distinguiendo entre, el evento de inicio y el evento del final. Crea una instancia de la clase Feed, y otra de la clase FeedMessage. Utiliza los Setters para dar valores, a los atributos de la clase correspondiente o private String getCharacterData(XMLEvent event, XMLEventReader eventReader) Crea un String, carácter a carácter y devuelve el resultado. o private InputStream read() Stream para la lectura. 4) ReadTest: (Anexo 4) Clase Principal, que contiene el método main(). Importa las otras 3 clases. Se crear un Parser y se le proporciona el link del RSS a leer Se crea una instancia de la clase Feed y se impriem su contenido. Se crean tantas instancias como titulare haya en el archivo XML y se imprime el contenido de cada una. Partiendo de este fragmento se ha realizado toda la implementación. La ejecución del programa empieza con la clase Main.java. En esta clase se crea una instancia de la clase “Periodico” y otra de la clase “UsoBD”. Por último, se crea la instancia de la primera vista (StartWindow) así como de su controlador (control_StartWindow). Dentro la vista StartWindow, se muestran 3 CheckBoxes para poder seleccionar los periódicos, en concreto se pueden seleccionar: • ABC. • El País. • La Vanguardia. 65 A mayores se muestran 5 CheckBoxes para poder seleccionar el tipo de información, son: • Último. • Opinión. • Economía. • Cultura. • Deportes. La información de estos periódicos se encuentra dentro de la tabla “Periódico” de la base de datos. Esta tabla se mantiene fija, no se puede modificar, es decir una vez insertadas las filas mediante el Script SQL, ya se encuentra toda la información que la herramienta utilizará. Se decide utilizar estos tres periódicos, ya que son 3 periódicos generales, es decir, tratan varios tipos de información. Por este motivo no se ha utilizado ningún periódico deportivo, por ejemplo, como podría ser “AS” o “Marca”. Para poder realizar el procesamiento de palabras, era necesario utilizar periódicos escritos en castellano, a sabiendas, de que un titular siempre puede incluir alguna que otra palabra en otro idioma. También hay que tener en cuenta, que no todos los RSS de los periódicos digitales poseen su información publicada por secciones tan especificas, por ejemplo, el RSS de “El día de Valladolid” no tiene sección de cultura, por lo que habría que buscar varios periódicos que tengan al menos un número mínimo de secciones iguales. A mayores, no todos los periódicos publican su información en el fichero XML de la misma forma, ya que cambian varios nombres de etiquetas. Teniendo en cuenta todo esto comentado, se ha decidido elegir los tres periódicos digitales ya enumerados. Los CheckBoxes del tipo de información aparecerán deshabilitados hasta que el usuario no seleccione un periódico. Además, si el usuario deselecciona los periódicos, se deseleccionarán los CheckBoxes de tipo e información y se deshabilitarán. Resumiendo, el usuario sólo podrá seleccionar el tipo de información, mientras tenga algún periódico seleccionado. En la vista, aparecerá un botón “Seleccionar todos”, con el que se seleccionan todos los CheckBoxes. De forma análoga, aparecerá un botón “Eliminar selecciones”, con el que se deseleccionan todos los CheckBoxes. Con estos dos conjuntos de selecciones el usuario ya puede seleccionar qué tipo de información y de dónde quiere obtener los titulares. El usuario también tiene la opción de seleccionar, cómo quiere que finalice el proceso de extracción de titulares. Existen dos opciones: • Número de horas. El usuario especificará en el campo de texto, el número de horas que el programa se ejecutará. Para determinar el fin de la ejecución, se almacena en el modelo la hora de inicio del programa y se realiza la suma de horas que el usuario ha especificado. De esta forma, también en el modelo se almacena la fecha de finalización de ejecución. Cada vez que se ejecute el código periódicamente se hace una comparación de la hora actual con la hora establecida para la finalización. Por tanto, si se supera la hora, el proceso de extracción de titulares finaliza, y se muestra el resumen de resultados. 66 • Número de titulares. El usuario especificará en el campo de texto, el número de titulares que el programa extraerá. Para ver el número de titulares al igual que el método anterior se guarda la fecha de inicio del programa y se hace una comparación con las horas de publicación de los titulares. Por lo tanto, cuando se hayan almacenado el número de titulares especificado, con una fecha de publicación superior a la de la hora de inicio, el proceso de extracción finaliza. Conviene aclarar que no siempre que se almacena un titular nuevo, se trata de un titular con una fecha de publicación posterior a la fecha de inicio. Esto se debe a que, en el RSS, a veces, no siempre, se publican titulares con una fecha de publicación anterior, por ejemplo, de hace una hora, por tanto, ese titular no contaría como titulares almacenados a partir de la fecha de inicio. También se dan casos del caso contrario, se publican titulares con una fecha de publicación que todavía no ha llegado, por ejemplo, un titular con una fecha de publicación de dentro de 5 horas. Una vez que el usuario ha seleccionado toda la información, pulsará el botón de Inicio. Es necesario que el usuario especifique todos los campos, es decir: 1) Al menos un periódico. 2) Al menos un tipo de información. 3) Seleccionado tipo de finalización del programa. 4) Especificado el número de horas o número de titulares. Si alguna de estas condiciones no se cumple, el programa mostrará un mensaje de error, indicándole al usuario qué condición no cumple, antes de dejarle continuar. Al pulsar el botón de Inicio, con todas las condiciones satisfechas, se mostrará la siguiente vista, la vista Results.java con los gráficos y tablas de los datos almacenados en la base de datos. En este punto, se realiza la conexión con la base de datos. La clase encargada de realizar dicha función se denomina Conexión.java (Anexo 5) y se encuentra dentro del Modelo. Es necesario añadir el siguiente archivo JAR al proyecto: mysql-connector-java-5.1.47 User mysql: root Password: bicicleta Nombre de base de datos: tfg Se crean dos métodos: 1) hazConexion() Conectarse con la base de datos 2) desconectar() Desconectarse de la base de datos La conexión se realiza con la siguiente línea: conectar =(Connection)DriverManager.getConnection("jdbc:mysql:// localhost:3306/tfg?autoReconnect=true&useSSL=false", "root","bicicleta"); Se especifica que la base de datos es local. Hay que proporcionar el nombre de la base de datos, así como el usuario y contraseña del usuario de MySQL, donde se encuentre dicha base de datos. Cada vez que se necesite acceder a la base de datos ya sea para insertar o eliminar una fila, se creará una conexión con la misma. Se ejecutarán las ordenes correspondientes y se cerrará la conexión. Lo mismo ocurre, cuando se quiera realizar una consulta a la misma. Al pulsar en el botón de Inicio, se actualiza la tabla Periódico en función de la selección de periódicos y de tipo de información que el usuario haya realizado para dicho experimento. Es necesario actualizar el campo uso de la tabla Periodico en función de la elección del usuario: 67 UPDATE Periodico SET uso=? WHERE nombre_periodico=? AND tipo_informacion=? Se marca el campo de uso a true de las URLs que el usuario ha decidido utilizar. Una vez, que la base de datos tiene la información de los enlaces que hay que consultar durante el proceso de extracción, se comienza la ejecución repetida del código. Para ello, se utiliza un Timer de Java que se procede a explicar. Para la realización de este TFG, surge la necesidad de realizar una tarea cada cierto tiempo, es decir, realizar una tarea periódicamente. Se trata de consultar los RSS de las fuentes de los periódicos de prensa online con el fin de encontrar los nuevos titulares publicados. Para solventar, esta necesidad me ayudé de las clase: java.util.Timer y java.util.TimerTask Resumiendo, la combinación de estas clases permite llamar a un método implementado, cada un cierto tiempo especificado en milisegundos. A continuación, se muestra un ejemplo de cómo funciona esta combinación de clases. Dentro del método run(), se encuentra el código necesario para la extracción de los titulares de prensa. (Chuidiang, 2019) Figura 58. Ejemplo Timer El tiempo, se especifica en milisegundos. Para este proyecto, un intervalo razonable para ejecutar el código es cada 30 minutos. Esto se debe a que, los periódicos no publican titulares constantemente. De la publicación del ultimo titular al siguiente pasa un tiempo variable de tiempo. Puede ser corto, de un minuto o menos, o pasar una hora sin que se publique ningún titular. Este último caso se da por las noches. Hay que tener en cuenta, que tampoco se puede poner un periodo de tiempo muy grande, ya que se podría correr el riesgo de perder algún titular. Este caso puede darse cuando, si se ejecuta el código por ejemplo cada 2 horas o más, y durante esas 2 horas se publican 25 titulares nuevos. Como se ha comentado ya en este documento, en el RSS de la fuente sólo se encuentran un número limitado de titulares, que se corresponden con los últimos publicados, por lo que, de una ejecución a otra, en un largo periodo de tiempo se ha podido renovar completamente ese archivo. Visto esto, se ha considerado que un intervalo de 30 minutos es un periodo razonable, para evitar este problema, El Timer se ha especificado en la clase ReadTest.java, donde se repite periódicamente el método run(). Lo primero de todo es obtener la información de la tabla Periódico de la base de datos, donde aparecerán con el campo en true, de aquellos links que hay que consultar. Para cada una las URLs se realiza una conexión a Internet para acceder a su archivo XML. Puede darse el caso de que haya un problema con la conexión, provocado por un fallo de red del usuario o por parte de la página web. 68 Si en algún momento esto ocurriera y el programa no pudiera acceder a una determinada dirección, la obviaría por el momento y pasaría ala siguiente. En la próxima iteración se volverá a intentar acceder a ella. Si no hay ningún error se guardan en un ArrayList de mensajes todos los titulares, junto con sus campos. Para añadir un nuevo titular a la base de datos, previamente se ha tenido que comprobar que ese titular no estaba ya añadido. Para cada uno de los titulares que se encuentran el ArrayList se realiza el siguiente proceso que. consta de dos pasos: el primero de una consulta y el segundo de una inserción: 1)Búsqueda. Consiste en un método booleano que dependiendo de si el titular está guardado devuelve un true y false en el caso contrario. Esta consulta se realiza para cada uno de los titulares leídos del RSS. SELECT * FROM Titulares WHERE titulo =?; 2)Inserción. Si se ha comprobado que el titular no está almacenado, es decir, el primer paso nos ha devuelto un false, se puede proceder a la creación de una nueva observación de la tabla Titulares, con los valores correspondientes para cada una de las columnas. INSERT INTO Titulares (titulo, titulo_limpio, dia_semana, dia, mes, hora, palabras, caracteres, nombre_periodico, tipo_informacion, num) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?,?) Este mismo proceso de dos pasos se realiza con la tabla de Palabras, con una pequeña diferencia, ya que para cada palabra se almacena el identificador del titular en el que aparece, por tanto, se almacenan varias apalabras iguales, que han aparecido por tanto en varios titulares. Puede darse el caso, que, en un mismo titular, una misma palabra aparezca repetida, por lo que se incluye un campo contador, que muestra la cantidad de veces que aparece esa palabra determinada en el titular. 1) Búsqueda. Al igual que para el caso de los titulares, consiste en un método booleano que devuelve true si la palabra de un mismo titular ya está almacenada o false si no lo está. Es decir, comprueba si en un mismo titular, la palabra aparece repetida. Se realiza únicamente con las palabras de los titulares nuevos, es decir, aquellos que van a ser insertados en la base de datos. No con cada una de las palabras leídas del RSS. SELECT * FROM Palabras WHERE palabra =? AND nombre_periodico= =? AND tipo_informacion = ? AND num =?; 2) Inserción Si la palabra está repetida en el titular, se realiza una actualización de dicha fila de la base de datos, modificando su contador al incrementarlo en una unidad. UPDATE Palabras SET contador=? WHERE palabra= ? AND nombre_periodico=? AND tipo_informacion=? Si la palabra no está repetida, se inserta en la base de datos, indicando el identificador del titular al que pertenece. 69 INSERT INTO Palabras(palabra,nombre_periodico,tipo_informacion, contador,num,negativa,busqueda) VALUES (?, ?, ?, ?, ?, ?, ?) Con este proceso, se han comprobado todos los titulares que aparecen en cada una de los ficheros XML. Este proceso se repite cada 30 minutos con la finalidad de extraer los nuevos titulares que han sido publicados durante este tiempo. Se realiza una consulta a la base de datos para comprobar si el titular ya ha sido almacenado. Esto mismo se podría realizar con una sola consulta que guarde en un ArrayList todos los titulares de la base de datos, y se busque en ese ArrayList cada uno de los titulares leídos del RSS. Esta última opción, pese a que sólo realiza una consulta a la base de datos, puesto que para cada titular leído de internet habría que recorrer el ArrayList que puede contener miles de titulares. Cuando se acaban de leer todas las URLs especificas se realiza la comparación para ver si el programa tiene que finalizar. Dependiendo de la opción elegida se evaluará si se ha cumplido el tiempo d ejecución o si ya se han almacenado el número de titulares proporcionado. Mientras se realiza el proceso de extracción el usuario se encontrará en la vista de Results, donde podrá ver en directo los gráficos actualizados con los datos que se encuentran en la base de datos. Por cada titular que se añade se modifica la vista actualizándose los gráficos y tabla. Conviene decir, que en esta vista el usuario tiene la capacidad de seleccionar de qué periódico de los tres disponibles, quiere ver los gráficos. Sin embargo, mientras se está actualizando la base de datos, el usuario no puede modificar esa selección. El programa indicará al usuario cuando se está actualizando la base de datos y cuándo puede consultar los gráficos modificando las selecciones. A continuación, se procede a explicar en qué consiste el proceso de limpieza de titulares: Durante el proceso de extracción de los titulares se realiza un proceso de limpieza de los mismos, es decir, eliminar aquellas palabras que no se consideran relevantes. Se realiza paso a paso eliminado aquellas partes del titular que no interesan: Se podrían resumir en: 1) Quitar signos: Creación de una lista de palabras con todos los signos de ortografía, interrogación, exclamación…, para su posterior eliminación. 2) Quitar preposiciones Creación de una lista de palabras con todas las preposiciones, para su posterior eliminación. 3) Quitar artículos: Creación de una lista de palabras con los artículos gramaticales, para su posterior eliminación. 4) Quitar conjunciones Creación de una lista de palabras con las conjunciones gramaticales, para su posterior eliminación. 5) Quitar otras palabras Creación de una lista de palabras formada por aquellas palabras, como pueden ser algunos determinantes posesivos, o verbos auxiliares entre otras, para su posterior eliminación. A continuación, se explica cómo se obtienen los campos de la tabla de Titulares: La tabla Titulares, tiene las siguientes columnas: 1) Titulo: Obtenido directamente del archivo XML del RSS. 70 2) Titulo limpio: Título tras el proceso de eliminación de las palabras con poca relevancia. Los cuatro próximos campos se obtienen del contenido de la etiqueta pubDate del archivo XML del RSS. Un ejemplo de lo que contiene dicho campo es el siguiente: Mon, 1 Apr 2019 17:47:33 +0200. Dividiéndolo por campos separados por espacios se obtienen los valores que almacenamos. 3) Día semana: Primer campo 4) Día: Segundo campo 5) Mes: Tercer campo 6) Hora: Quinto campo 7) Palabras: Número de palabras que contiene el título completo, todavía sin limpiar. 8) Caracteres: Número de caracteres que contiene el título completo, todavía sin limpiar. 9) Nombre periódico: Nombre del periódico, al que pertenece dicho titular que se obtiene de la tabla Periódico. 10) Tipo información: Tipo de información al que pertenece dicho titular que se obtiene de la tabla Periódico. 11) Num. Sirve de identificador, el primer titular almacenado es el 1 y a medida que se van almacenando titulares, se incrementa su valor. Sirve también para determinar el número de titulares almacenados. A continuación, se explica cómo se obtienen los campos de la tabla de Titulares: La tabla Palabras, tiene las siguientes columnas: 1) Palabra: Cada una de las palabras que forman el titular limpio. 2) Nombre Periódico: Nombre del periódico, donde ha sido publicado el titular al que pertenece la palabra, se obtiene de la tabla Periódico. 3) Tipo Información: Tipo de información, del titular al que pertenece la palabra, se obtiene de la tabla Periódico. 4) Contador: Veces que aparece la palabra en el titular. 5) Num: Identificador del titular al que pertenece la palabra. 6) Negativa: Booleano que indica si la palabra está considerada dentro de la lista de palabras que se han especificado como negativas. 7) Búsqueda: Booleano que indica si la palabra ha sido especificada como palabra a tener en cuenta en la búsqueda de titulares. Cuando ha finalizado el proceso de extracción de titulares, el usuario se encontrará en la vista de Final_Results.java, donde el usuario podrá ver un resumen del número de titulares almacenados en la base de datos. También tiene la opción de visualizar otra vez los gráficos. Se plantea la posibilidad, de que el usuario pueda proporcionar una lista de palabras positivas y otra lista de palabras negativas. La finalidad de esto, es poder identificar titulares positivos y titulares negativos. Está claro que es muy difícil poder conocer la verdadera intencionalidad o sensibilidad de un titular. Simplemente con esto, podemos hacer una clasificación entre los titulares de si son positivos, negativos y neutrales. 71 Si en el titular aparece al menos una palabra negativa, se considera un titular negativo. Si en el titular aparece al menos una palabra positiva, se considera un titular positivo. Puede darse el caso de que aparezca en el titular tanto una palabra positiva como una negativa, en ese caso se contará el número de palabras positivas y negativas, Si el numero coincide será considerado neutral. Como cabe esperar, si el titular no aparece ninguna palabra positiva ni negativa, también será considerado como un titular neutral. En esta vista el usuario puede realizar las siguientes acciones: • Importar palabras negativas. • Importar palabras positivas. • Importar palabras de búsqueda. • Procesar palabras. El proceso de importar palabras, ya sean positivas, negativas o de búsqueda se realiza de la misma forma. El usuario dispondrá de tres archivos CSV, uno para cada tipo de palabras. Estos archivos se deberán encontrar en la ruta especificada en el manual. Los archivos contendrán una lista de palabras que el usuario tendrá la capacidad de modificar cada uno de los archivos, eliminando o añadiendo las palabras deseadas. En cada archivo se mostrará una palabra por línea. Una vez que el usuario, ha modificado los archivos si es que asó lo ha deseado, en la vista del programa podrá pulsar los botones de importar palabras. De esta forma, se actualizará la tabla de la base de datos correspondientes a cada una de las tres listas de palabras. Se mostrará un mensaje al usuario indicando que el proceso de importar las palabras ya actualización de la base de datos se ha realizado correctamente. Por último, una vez que se han importado las palabras, el usuario puede Procesar las palabras con su botón correspondiente. Con esto se actualizarán los campos indicando si cada palabra es positiva, negativa o de búsqueda, comparando la lista de palabras totales almacenadas en la base de datos con cada una de las 3 listas de palabras. Al igual que al importar las palabras, se mostrará un mensaje al usuario indicando que el procesamiento de palabras se ha realizado correctamente. De esta forma, realizando el procesamiento de palabras al final de la extracción de titulares, da la capacidad al usuario de introducir palabras que no tenía pensado buscar antes de la extracción. Si el usuario, especificara las palabras antes del proceso de extracción, el procesamiento sería mucho menos flexible de como lo es ahora. El programa gana potencia y flexibilidad para las necesidades del usuario. A la hora de determinar si una palabra es negativa o positiva, se ha elaborado una lista, con alrededor de 50 palabras. Sin embargo, para que la comparación de las palabras no se realice exclusivamente con esa lista, se utiliza un método para determinar la similitud entre palabras. Si la similitud es grande, se considerará también como una palabra negativa. Este método, supone que se amplíen las posibilidades de encontrar una palabra negativa, sin embargo, se corre un riesgo, y es el considerar palabras como negativas cuando no lo son, por el simple hecho de ser muy parecida a una de la lista. Esto es un error asumible. Para determinar la similitud entre palabras se ha utilizado la distancia de Levenshtein (Wikipedia, 2019). La distancia de Levenshtein, también conocida como distancia entre palabras o distancia de edición, se considera el mínimo número de operaciones que se necesitan para transformar una palabra o cadena de caracteres en otra. Existen tres tipos de operaciones que son: inserción, eliminación y sustitución de un carácter. 72 Generaliza la distancia de Hamming que sólo es utilizada para palabras con la misma longitud y que sólo considera la operación de sustitución de un carácter. Para cada palabra del titular ya limpio, se calcula la afinidad mediante la distancia de Levenshtein (Censorcosmico, 2019)con las palabras de la lista creada a mano. Si la afinidad es mayor de un 75% se considera negativa, y si no lo es, no se considera negativa. Evidentemente si la palabra es una incluida, dentro de la lista, la afinidad será del 100% por lo que se añadirá como palabra negativa igualmente. Con esto se darán varios problemas, que se consideran asumibles y entendibles. 1) Considerar una palabra negativa no siéndolo realmente. 2) No considerar una palabra negativa, siéndolo realmente. Conviene destacar que el valor del 75%, se puede modificar en el código fuente, y establecerlo con mayor o menor afinidad. Una vez que se ha realizado el procesamiento de palabras, el usuario tiene la posibilidad de ver aquellos titulares que se han considerado negativos o positivos. Además, también puede ver aquellos titulares que contienen una palabra que el usuario ha considerado de búsqueda. Pulsando en el botón ver titulares, el programa mostrará al usuario una tabla con los titulares. El usuario tendrá la capacidad de seleccionar que titulares quieren ver, si los positivos, los negativos, o aquellos que contienen alguna palabra buscada. En este punto la ejecución del programa se podría considerar finalizada. El usuario podría utilizar otros programas para aprovechar los datos almacenados en la base de datos. Conectando estos programas de visualización de datos como son RStudio o Power BI con la base de datos, las posibilidades de representación y visualización de datos son enormes. 73 7 Pruebas En este capítulo se muestran todas aquellas pruebas realizadas sobre la herramienta desarrollada. Esas pruebas tienen la finalidad de certificar la fiabilidad de aquellas funcionalidades que presenta la herramienta, así como la detección de la gran parte de defectos. Las pruebas se han realizado a medida que el programa se ha ido desarrollando, periódicamente con la introducción de una nueva funcionalidad o modificación de una existente. La metodología empleada ha sido de caja negra, basándose en los requisitos y casos de uso especificados en su capítulo correspondiente. A continuación, se muestra un resumen de las pruebas realizadas, con los fallos más significativos e importantes. Tabla 15. Prueba 1 Prueba 1 Descripción El usuario inicia el programa. Resultado esperado La vista para seleccionar el tipo de información es mostrada. Resultado Resultado esperado. Tabla 16. Prueba 2 Prueba 2 Descripción El usuario selecciona uno o más periódicos con los CheckBoxes correspondientes. Resultado esperado Se habilitan las CheckBoxes para poder seleccionar el tipo de información. Resultado Resultado esperado. Tabla 17. Prueba 3 Prueba 3 Descripción El usuario deselecciona todos los periódicos que tenía marcados en los CheckBoxes correspondientes. Resultado esperado Se deshabilitan y se deseleccionan las CheckBoxes para poder seleccionar el tipo de información. Resultado Resultado esperado. Tabla 18. Prueba 4 Prueba 4 Descripción El usuario no puede comenzar el proceso de extracción de titulares sin al menos haber elegido un periódico. Resultado esperado Un mensaje de error será mostrado al usuario indicando que debe introducir al menos un periódico. Resultado Resultado esperado. 80 • Implementar un formulario para que el usuario pueda añadir nuevos periódicos y tipos de información con su correspondiente link del RSS. • Implementar una opción para importar archivos a la base de datos fuera de la ruta considerada segura por MySQL. Una ruta más accesible para el usuario. 81 9 Bibliografía ABC. (2019). Captura RSS ABC. Recuperado el 27 de Mayo de 2019, de https://www.abc.es/rss/feeds/abcPortada.xml Arquitecturajava. (2019). Override. Recuperado el 3 de Junio de 2019, de https://www.arquitecturajava.com/javaoverride-y-encapsulacion/ Astah. (2019). Logo Astah UML. Recuperado el 27 de Mayo de 2019, de http://astah.net/ Censorcosmico. (2019). Implementación distancia de Levenshtein. Recuperado el 10 de Junio de 2019, de https://censorcosmico.blogspot.com/2016/11/calculo-del-grado-de-similitud-o.html Chuidiang. (2019). Captura Ejemplo Timer. Obtenido de http://www.chuidiang.org/java/timer/timer.php Chuidiang. (2019). Ejemplos Timer Java. Recuperado el 3 de Junio de 2019, de http://www.chuidiang.org/java/timer/timer.php Codingornot. (2019). Esquema MVC. Recuperado el 27 de Mayo de 2019, de https://codingornot.com/mvcmodelo-vista-controlador-que-es-y-para-que-sirve Cotterell, B. H. (2002). Software Project Management. McGraw Hill. Obtenido de Bob Hughes and Mike Cotterell. Software Project Management. McGraw Hill, 2002. Dennysjymbo. (2019). XML Parser. Recuperado el 3 de Junio de 2019, de http://dennysjymbo.blogspot.com/ Dri. (2019). Logo MySQL. Recuperado el 27 de Mayo de 2019, de https://dri.es/album/blog/mysql-logo El País. (2016). Era digital. Recuperado el 6 de Mayo de 2019, de El País: https://elpais.com/elpais/2016/04/13/opinion/1460540302_620130.html El País. (2019). Captura El Pais RSS. Recuperado el 27 de Mayo de 2019, de https://servicios.elpais.com/rss/ El País. (2019). Captura RSS El País. Recuperado el 27 de Mayo de 2019, de http://ep00.epimg.net/rss/tags/ultimas_noticias.xml Elfuturodelosdatos. (2019). Power BI. Recuperado el 3 de Junio de 2019, de https://elfuturodelosdatos.com/power-bi-tutorial-espanol/ GitLab. (2019). Obtenido de https://gitlab.inf.uva.es Isaacfigueroa. (2019). Logo Power BI. Recuperado el 27 de Mayo de 2019, de https://isaacfigueroa.com/podcast/49-juntando-informacion-power-bi-desktop/ Java RSS Feed. (2019). Java RSS Feed. Recuperado el 3 de Junio de 2019, de https://www.vogella.com/tutorials/RSSFeed/article.html Macupdate. (2019). Logo MySQL WorkBench. Recuperado el 27 de Mayo de 2019, de https://www.macupdate.com/app/mac/31829/mysql-workbench Maximaformacion. (2019). Logo R. Recuperado el 27 de Mayo de 2019, de https://www.maximaformacion.es/blog-dat/que-es-r-software/ Microsoft. (2019). Power BI. Recuperado el 3 de Junio de 2019, de https://docs.microsoft.com/es-es/powerbi/desktop-getting-started Microsoft. (2019). Power BI Desktop. Recuperado el 20 de Mayo de 2019, de https://docs.microsoft.com/eses/power-bi/desktop-getting-started Mundolinux. (2019). XML. Recuperado el 20 de Mayo de 2019, de http://www.mundolinux.info/que-es-xml.htm Oracle. (2019). InputStream. Recuperado el 3 de Junio de 2019, de https://docs.oracle.com/javase/7/docs/api/java/io/InputStream.html Oracle. (2019). XMLEvent. Recuperado el 3 de Junio de 2019, de https://docs.oracle.com/javase/8/docs/api/index.html?javax/xml/stream/events/XMLEvent.html Palkotools. (2011). Importar datos RSS. Recuperado el 3 de Junio de 2019, de http://palkotools.blogspot.com/2011/06/tutorial-how-to-import-rss-feeds-into.html PDSC. (2019). Gestión de Riesgos. Recuperado el 20 de Mayo de 2019, de https://aulas.inf.uva.es/pluginfile.php/44263/mod_resource/content/5/PyDSC_riesgos_1819.pdf Poesiabinaria. (2019). Timer Java. Recuperado el 3 de Junio de 2019, de https://poesiabinaria.net/2014/01/introtimertask-java/ Programminghistorian. (2019). R con MySQL. Recuperado el 3 de Junio de 2019, de https://programminghistorian.org/en/lessons/getting-started-with-mysql-using-r Proyectosbeta. (2016). Logo RStudio. Recuperado el 27 de Mayo de 2019, de https://proyectosbeta.net/2016/10/rstudio-en-debian-jessie-de-64-bits/ Researchgate. (2019). Proceso Unificado. Recuperado el 20 de Mayo de 2019, de https://www.researchgate.net/figure/Flujos-de-trabajo-del-proceso-unificado_fig1_279751761 RSS.nom. (2019). RSS. Recuperado el 20 de Mayo de 2019, de https://www.rss.nom.es/ 82 Scribd. (2019). Astah UML. Recuperado el 13 de Mayo de 2019, de https://es.scribd.com/document/239437742/Tutorial-ASTAH Stackoverflow. (2019). Override. Recuperado el 3 de Junio de 2019, de https://es.stackoverflow.com/questions/156432/para-que-sirve-la-l%C3%ADnea-override-en-java Tutorials.jenkov. (2019). XMLEventReader. Recuperado el 3 de Junio de 2019, de http://tutorials.jenkov.com/java-xml/stax-xmleventreader.html Tutorials.jenkov. (2019). XMLInputFactory. Recuperado el 3 de Junio de 2019, de http://tutorials.jenkov.com/java-xml/stax-xmlinputfactory.html Vogella. (2019). Java XML Tutorial. Recuperado el 3 de Junio de 2019, de https://www.vogella.com/tutorials/JavaXML/article.html Wikiepdia. (2019). MVC. Recuperado el 27 de Mayo de 2019, de https://es.wikipedia.org/wiki/Modelo%E2%80%93vista%E2%80%93controlador Wikipedia. (2019). Arquitectura de Software. Recuperado el 27 de Mayo de 2019, de https://es.wikipedia.org/wiki/Arquitectura_de_software Wikipedia. (2019). Distancia de Levenshtein. Recuperado el 10 de Junio de 2019, de https://es.wikipedia.org/wiki/Distancia_de_Levenshtein Wikipedia. (2019). Git. Recuperado el 13 de Mayo de 2019, de https://es.wikipedia.org/wiki/Git Wikipedia. (2019). Java. Recuperado el 13 de Mayo de 2019, de https://es.wikipedia.org/wiki/Java_(lenguaje_de_programaci%C3%B3n) Wikipedia. (2019). Java Swing. Recuperado el 13 de Mayo de 2019, de https://es.wikipedia.org/wiki/Swing_(biblioteca_gr%C3%A1fica) Wikipedia. (2019). Lenguaje R. Recuperado el 13 de Mayo de 2019, de 2019: https://es.wikipedia.org/wiki/R_(lenguaje_de_programaci%C3%B3n) Wikipedia. (2019). Logo Git. Recuperado el 27 de Mayo de 2019, de https://es.m.wikipedia.org/wiki/Archivo:Gitlogo.svg Wikipedia. (2019). Logo Java. Recuperado el 27 de Mayo de 2019, de https://es.wikipedia.org/wiki/Java_(lenguaje_de_programaci%C3%B3n) Wikipedia. (2019). Logo Microsoft Project. Recuperado el 27 de Mayo de 2019, de https://es.wikipedia.org/wiki/Microsoft_Project WIkipedia. (2019). Microsoft Project. Recuperado el 20 de Mayo de 2019, de https://es.wikipedia.org/wiki/Microsoft_Project Wikipedia. (2019). MySQL. Recuperado el 13 de Mayo de 2019, de https://es.wikipedia.org/wiki/MySQL Wikipedia. (2019). MySQL Workbench. Recuperado el 13 de Mayo de 2019, de https://es.wikipedia.org/wiki/MySQL_Workbench Wikipedia. (2019). NetBeans. Recuperado el 13 de Mayo de 2019, de https://es.wikipedia.org/wiki/NetBeans Wikipedia. (2019). Proceso Unificado. Recuperado el 13 de Mayo de 2019, de https://es.wikipedia.org/wiki/Proceso_unificado Wikipedia. (2019). Redifusión Web. Recuperado el 20 de Mayo de 2019, de https://es.wikipedia.org/wiki/Redifusi%C3%B3n_web Wikipedia. (2019). RSS. Recuperado el 6 de Mayo de 2019, de https://es.wikipedia.org/wiki/RSS Wikipedia. (2019). RStudio. Recuperado el 13 de Mayo de 2019, de https://es.wikipedia.org/wiki/RStudio Wikipedia. (2019). XML. Recuperado el 20 de Mayo de 2019, de https://es.wikipedia.org/wiki/Extensible_Markup_Language 83 APÉNDICES 84 A. Planificación real detallada Este proyecto se puede dividir en los siguientes bloques: 1) Análisis. 2) Elección de las herramientas. 3) Extracción de titulares. 4) Limpieza. 5) Almacenamiento. 6) Visualización Estadísticas. La planificación, estará basada en el desarrollo de estos bloques uno por uno, en orden. Con la consecución de cada bloque, la aplicación debe de ser capaz de cumplir con unas funcionalidades mínimas que nos permitan avanzar al siguiente bloque. Lo primero de todo es construir una herramienta que sea un lector del archivo XML que nos proporciona el RSS del periódico digital online. Una vez que la herramienta funcione, se implementará la limpieza de los titulares, es decir, quedarse sólo con las palabras relevantes del titular. Tras esto se procederá al almacenamiento de dichos titulares en una base de datos. Por último, una vez que estén los titulares, guardados, sólo tenemos que utilizarlos para realizar unos gráficos estadísticos. A continuación, se describen cada una de las tareas realizadas a lo largo de este TFG. Cada tarea contiene una duración estimada por horas para su realización y el valor real para su desarrollo. La fecha que se indica la semana en la que se ha realizado. Actividades realizadas: Tabla 46. Tarea 1 Tarea 1 Análisis inicial. Fecha 25/02/19 – 01/03/19 Duración Estimada 4 horas. Duración Real 4 horas. Predecesoras 0 Detalle Fase inicial con la elección de la metodología de planificación, así como la gestión de riesgos, gestión de recursos, definición de actividades y calendarización. Tabla 47. Tarea 2 Tarea 2 Definición de requisitos. Fecha 25/02/19 – 01/03/19 Duración Estimada 4 horas. Duración Real 4 horas. Predecesoras 1 Detalle Obtención de los requisitos que tendrá el proyecto, tanto funcionales, no funcionales y de información; a partir de los datos que se tienen del proyecto. 85 Tabla 48. Tarea 3 Tarea 3 Definición de casos de uso Fecha 25/02/19 – 01/03/19 Duración Estimada 4 horas. Duración Real 4 horas. Predecesoras 2 Detalle A partir de la información que se tiene del proyecto y de los requisitos ya definidos, creación de los casos de uso, así como los primeros diagramas. Tabla 49. Tarea 4 Tarea 4 Definición de modelo de dominio Fecha 25/02/19 – 01/03/19 Duración Estimada 4 horas. Duración Real 4 horas. Predecesoras 3 Detalle Elaboración del modelo de dominio, en lenguaje UML, con los datos que se tienen acerca del proyecto. Tabla 50. Tarea 5 Tarea 5 Aprender funcionamiento XML Fecha 04/03/2019 - 08/03/2019 Duración Estimada 3 horas. Duración Real 3 horas. Predecesoras 4 Detalle Entender qué es un fichero XML. Sus partes, estructura y en definitivas las posibilidades que tiene este tipo de archivo. Aprendizaje a través de un tutorial disponible en Internet (Vogella, 2019). Ayudó a tener el conocimiento necesario para empezar a trabajar con este tipo de formato. El código encontrado en Internet, tomado como base para este proyecto, realizaba la lectura de un archivo XML, por lo que era necesario para poder entender en qué consiste ese código y que funciones realiza tener unos conocimientos básicos acerca de XML. Tabla 51. Tarea 6 Tarea 6 Valoración de lenguaje y herramientas a utilizar Fecha 04/03/2019 - 08/03/2019 Duración Estimada 10 horas. Duración Real 15 horas. Predecesoras 5 Detalle Tomar la decisión del lenguaje de programación con el que se va desarrollar el programa, así como las distintas herramientas a utilizar a lo largo de todo el proyecto. Se valoraron las siguientes opciones: - Utilización como lenguaje de programación Java. Lenguaje utilizado en la mayoría de prácticas y trabajos a lo largo del grado. Buen dominio. Ventaja en cuanto a 86 tiempo, no sería necesaria un excesivo aprendizaje, salvo algunas cosas puntuales. - Utilización de otro lenguaje de programación como puede ser C, Python… Son lenguajes de programación, menos utilizados a lo largo del grado. Podrían suponer una gran pérdida de tiempo en aprendizaje para la realización de ciertas funciones. - Utilizar Visual Studio. Herramienta, no utilizada nunca. Aprendizaje desde cero. Podría llegar a suponer pérdida de tiempo. - Utilizar IDE NetBeans. Herramienta con gran conocimiento, bastante utilizada a lo largo del grado. A mayores, herramienta ya utilizada para la creación de interfaces gráficas - Utilizar IDE Eclipse Herramienta con gran conocimiento, bastante utilizada a lo largo del grado. Sin experiencia de uso con interfaces gráficas. Además de la decisión de con qué herramienta se tienen mayores y mejores conocimientos, se valoró también, a la hora de tomar la decisión, cuál de ellas se podría acoplar mejor a lo que el proyecto en sí iba a necesitar, es decir, qué herramienta permite la extracción de titulares de prensa online. (Palkotools, 2011) y (Dennysjymbo, 2019) Varias páginas en internet mostraban distintas opciones de cómo realizar la lectura de un RSS (Java RSS Feed, 2019), tanto en lenguaje Java cómo C. Tras realizar una valoración de todas estas opciones, la decisión final fue realizar el trabajo, o al menos la parte que conlleva la extracción y limpieza de los titulares de prensa, con el lenguaje Java, ayudado del entorno de programación NetBeans. Tabla 52. Tarea 7 Tarea 7 Lectura y extracción de los titulares de una URL Fecha 04/03/2019 - 08/03/2019 Duración Estimada 1 hora. Duración Real 1 hora. Predecesoras 6 Detalle Utilización como base del programa el código encontrado en Internet de lectura de un archivo XML. Comprobación de que el código funcionaba y realizaba las funciones esperadas, proporcionando la URL de un archivo RSS de un periódico digital. El resultado fue el esperado, mostrando el resultado en pantalla, imprimiendo cada uno de los titulares que se encontraban el archivo XML del RSS proporcionado, en el momento de la ejecución. 87 Tabla 53. Tarea 8 Tarea 8 Lectura y extracción de los titulares de varias URL Fecha 11/03/2019 - 15/03/2019 Duración Estimada 1 hora. Duración Real 1 hora. Predecesoras 7 Detalle Tarea pequeña consistente en la modificación del código para que facilitando varias URLs, cada una de un periódico digital diferente, se impriman todos los titulares que se encuentren en el momento de ejecución en cada uno de los archivos RSS proporcionados. Tabla 54. Tarea 9 Tarea 9 Ejecución repetida cada cierto tiempo Fecha 11/03/2019 - 15/03/2019 Duración Estimada 3 horas. Duración Real 5 horas. Predecesoras 8 Detalle Valoración de las distintas posibilidades (Chuidiang, 2019) y (Poesiabinaria, 2019) de ejecutar el código de una manera periódica, cada un cierto tiempo establecido. Decisión por utilizar la clase Timer de Java, con la que básicamente se ejecuta una porción de código determinada, cada un cierto tiempo especificado en milisegundos. De esta forma, periódicamente, por ejemplo, cada 30 minutos, el programa imprime en pantalla los titulares de las fuentes especificadas. Tabla 55. Tarea 10 Tarea 10 Necesidad de almacenar Fecha 11/03/2019 - 15/03/2019 Duración Estimada 15 horas. Duración Real 15 horas. Predecesoras 9 Detalle Es necesario conseguir que, de una ejecución del código a la siguiente, sólo, se impriman los nuevos titulares. Es decir, los que han sido publicados, en el periodo de tiempo entre ejecuciones del programa. De esta forma, evitar que el programa imprima todos los titulares que se encuentran en el fichero cada vez, y que sólo sean imprimidos los nuevos. Al existir una limitación, en cuanto al número de titulares en el fichero XML de cada RSS, cada vez que se publica un titular, se añade al fichero, pero se elimina otro, manteniendo constante el número de titulares publicados en el archivo XML. Destacar que el número de titulares es variable para cada uno de los periódicos digitales. 88 Para poder llevar a cabo, lo comentado en esta tarea, es necesario un sistema de almacenamiento con el que poder almacenar los titulares. De esta manera, poder consultarlos y si hay algún titular nuevo que no está almacenado, añadirlo. Así se irá incrementando el número de titulares almacenados y cada vez que se publique uno nuevo, no se pierdan los titulares, como ocurría anteriormente. Tabla 56. Tarea 11 Tarea 11 Valorar almacenamiento de los titulares Fecha 11/03/2019 - 15/03/2019 Duración Estimada 1 hora. Duración Real 1 hora. Predecesoras 10 Detalle Las opciones valoradas, fueron dos. La primera de ellas fue un archivo de texto, en el que ir escribiendo los titulares uno a uno. La segunda es la creación de una base de datos. Debido a las grandes posibilidades que ofrece una base de datos, en cuanto a almacenamiento y consultas. A mayores, pensando en el objetivo final del proyecto, el tener que posteriormente acceder a los titulares almacenados en función de algunos parámetros o valores, lo más lógico era almacenar los titulares en una base de datos. Por tanto, la decisión fue decantarse por la segunda opción. Gracias a la base de datos, se abre un gran abanico de posibilidades, sobre todo a la hora de realizar una representación gráfica de los resultados estadísticos obtenidos. Tabla 57. Tarea 12 Tarea 12 Almacenamiento de los titulares Fecha 18/03/2019 - 22/03/2019 Duración Estimada 10 horas. Duración Real 25 horas. Predecesoras 11 Detalle Creación de un modelo de dominio en el que basarse para la elaboración de la base de datos. Creación de script SQL para la creación de las tablas necesarias de la base de datos. Valoración de opción de crear una base de datos remota con el servidor de la escuela o una base de datos local. Viendo los pros y contras de cada una de ellas, no obtenía ningún beneficio con la base de datos remota. Finalmente, creación de una base de datos local con MySQL. Conexión de la base de datos con NetBeans. Creación de métodos de inserción de filas a las tablas, necesarios para poder añadir los titulares leídos del RSS correspondiente a su tabla en la base de datos. 89 Tabla 58. Tarea 13 Tarea 13 No guardar repetidos Fecha 25/03/2019 - 29/03/2019 Duración Estimada 10 horas. Duración Real 25 horas. Predecesoras 12 Detalle Tras solventar el problema del almacenamiento de los titulares con la base de datos, hay que solucionar un nuevo impedimento. Cada vez que se ejecuta el código se van a almacenar los titulares en la base de datos. De ejecución a ejecución es muy frecuente que se lea un gran número de titulares que ya habían sido leídos alguna vez, por tanto, al intentar almacenarles en la base de datos, se va a producir un error de violación de clave primaria, puesto que se va a intentar añadir una instancia, que ya está almacenada. Esta tarea consiste, en idear un procedimiento a partir del cuál, ejecución tras ejecución, sólo se intente añadir a la base de datos aquellos titulares que no estén almacenados, es decir, los titulares que han sido publicados desde la última ejecución. Para ello, para cada titular leído se realiza una consulta a la base de datos, para ver si está almacenado dicho titular o no. Si no está, se almacena y si ya está se pasa al siguiente. A mayores, antes de almacenar el titular en la base de datos hay que comprobar si se ha llegado ya al número máximo de titulares especificado por el usuario. Si ya se ha llegado a ese límite, no se almacenará dicho titular. Tabla 59. Tarea 14 Tarea 14 Almacenamiento con más columnas Fecha 15/04/2019 - 19/04/2019 Duración Estimada 6 horas. Duración Real 6 horas. Predecesoras 13 Detalle Hasta este punto de TFG sólo se guardaba en la base de datos, para cada titular el título, el periódico dónde ha sido publicado y el campo contenido dentro de la etiqueta de <pubDate>. Dentro de este campo, se encontraban algunos valores, que podemos considerar relevantes y que se pueden guardar por separado como son: el día de la semana, el día del mes, el mes, y la hora de publicación exacta del titular. A mayores, también se añadieron algunos campos que median estadísticas básicas de los titulares de prensa leídos como son el número de caracteres y el número de palabras, para cada uno de los titulares almacenados en la base de datos. 96 Figura 61. Diagrama Gantt Planificación Real 3 97 B. Conexión con Power BI En este apartado se explicará como realizar la conexión de la base de datos con el programa de visualización de gráficos Power BI. Es necesario tener la base de datos creada en el servidor local, y con algunos datos guardados, es decir, para poder realizar los gráficos, la base de datos no puede estar vacía. En primer lugar, como es lógico, es descargar el programa de su página web https://powerbi.microsoft.com/eses/downloads/ eligiendo la versión gratuita. Figura 62. Descarga de Power BI Una vez descargado e instalado, sólo hay que abrir un proyecto nuevo. El usuario deberá elegir en la barra de herramientas la opción de “Obtener datos”. Figura 63. Obtener datos en Power BI 98 En la ventana que se despliega, hay que elegir la opción de Base de datos MySQL. Figura 64. MySQL en Power BI El programa pedirá que el usuario introduzca el servidor donde se encuentra la base de datos, así como el nombre de la misma. Se debe introducir “localhost” y “tfg” respectivamente. Figura 65. Seleccionar base de datos En este punto, se abrirá una nueva ventana en la que se debe seleccionar la pestaña de “Base de datos”, donde hay que especificar el nombre de usuario y la contraseña de la base de datos. En este caso, hay que introducir “root” y “bicicleta” respectivamente. Por último, antes de conectar hay que elegir el nivel donde aplicar la configuración dada. El usuario debe seleccionar la opción “locahost;tfg”. 99 Figura 66. Introducir usuario y contraseña Tras darle al conectar, se podrá ver una vista como la siguiente en la que ya aparecen las tablas que se encuentran en la base de datos. Este proceso tarda un poco, mientras realiza la conexión con la base de datos. Figura 67. Conexión con la base de datos Tras finalizar la conexión, se muestra la opción de elegir que tablas nos interesan y cuáles no. Para poder utilizar toda la información almacenada en la base de datos, se deben seleccionar las 6 tablas existentes. 100 Figura 68. Selección de tablas Tras realizar el proceso de carga de datos al programa, el usuario podrá ver en la parte derecha de la pantalla, una opción como la siguiente imagen donde aparece una lista con todas las tablas cargadas, así como sus columnas. Figura 69. Datos cargados En este momento, el usuario ya puede seleccionar aquellos datos que le interesen para la realización de gráficos. Para poder utilizar este programa conviene realizar un tutorial, para aprender sus funciones básicas para la visualización de gráficos. 101 Conviene tener en cuenta, que a medida que se actualiza la base de datos añadiendo nueva información es necesario actualizar los datos cargados en el programa Power BI. Por tanto, si se quiere tener la ultima información existente en la base de datos, es necesario actualizar la información. Para ello el usuario simplemente el usuario tendrá que pulsar en el botón de “Actualizar” en la barra de herramientas del programa. Figura 70. Actualizar datos Por ultimo, se muestra un ejemplo de visualización de gráficos. La siguiente imagen, muestra un pequeño dashboard interactivo formado por un gráfico de tarta y un gráfico de barras. El gráfico de tarta, muestra la proporción en cuanto a número de titulares por periódico. El gráfico de barras muestra el número de titulares, por tipo de información. El gráfico es interactivo, y se puede ver, por ejemplo, la proporción de numero de titulares de cada uno de los periódicos en el gráfico de barras, agrupado por tipo de información. Figura 71. Dashboard 102 C. Conexión con RStudio En este apartado se muestra el Script utilizado para utilizar los datos almacenados en la base de datos, desde otro programa de visualización de datos como es RStudio utilizando el lenguaje R. En este Script se realiza la conexión especificando el usuario, el servidor local por defecto, el nombre de la base de datos y la contraseña. A continuación, se muestra un ejemplo de como realizar una consulta y guardar los datos que devuelve esa consulta en una variable. Figura 72. Script RStudio El ejemplo que se muestra es el de un WordCloud, un gráfico muy intuitivo para ver la frecuencia con la que aparecen las palabras. Figura 73. WordCloud 103 D. Manual de Usuario Se incluye el manual de instrucciones para el usuario explicando las funcionalidades y opciones que presenta la herramienta desarrollada en este TFG. Se muestra la información, por apartados que se corresponden con las vistas disponibles en la interfaz de usuario del programa. Selección de información Figura 74. Vista para seleccionar la información En la parte izquierda se muestran 3 CheckBoxes para poder seleccionar, los periódicos. Es necesario seleccionar al menos uno, para poder comenzar el proceso de extracción de titulares. En la parte derecha, aparecen otros 5 CheckBoxes para seleccionar el tipo de información. Estos CheckBoxes aparecerán deshabilitados mientras no haya ningún periódico seleccionado. Cuando haya al menos un periódico, se habilitarán. Es necesario seleccionar al menos uno, para poder comenzar con el proceso de extracción de titulares. Debajo de los selectores del tipo de información se incluyen dos botones. Estos botones se han incluido para facilitar la experiencia de uso del usuario con la interfaz. El primero de ellos consiste en “Eliminar selecciones”. Cuando el usuario lo pulsa se deselecciona todas aquellas opciones previamente marcadas, tanto de tipo de información como de periódico. Este botón sólo se mostrará habilitado para su uso cuando al menos el usuario tenga alguna selección realizada. El segundo botón trata de “Seleccionar todos.” Cuando el usuario lo pulse, se seleccionarán todas las opciones posibles, es decir, todos los periódicos y todos los tipos de información. De esta forma se consigue que con un solo click el usuario pueda preparar el programa para la extracción de toda la información posible. En la parte inferior, en el centro se encuentran 2 RadioButtons, junto con un campo de texto. Esto sirve para que el usuario pueda seleccionar el modo de finalización del proceso de extracción. Se muestran 2 opciones la primera de ellas es con el “Número de titulares”. Cuando el usuario seleccione esta opción deberá introducir el número de titulares que, a partir de la hora de inicio de ejecución del programa, el usuario quiere que se almacenen. 104 La segunda opción es más simple, con el “Número de horas”, el usuario introduce en el campo de texto el número de horas que quiere que el programa almacene titulares. Cuando se cumpla el tiempo, el proceso de extracción finalizará. Por último, se encuentra el botón de Inicio, con el que el usuario puede dar comienzo al proceso de extracción de titulares. Es necesario que el usuario haya proporcionado toda la información necesaria, si no es así, el programa mostrará un mensaje indicando qué información falta de introducir. Resultados en directo Una vez que el usuario haya proporcionado toda la información necesaria y haya pulsado en el botón de Inicio se mostrará la siguiente vista. Figura 75. Vista con los resultados en directo En esta vista se muestra un Dashboard, compuesto por una tabla, un PieChart y 2 gráficos de barras. La tabla muestra dos selectores formados por tres RadioButtons cada uno. Con el primero de ellos el usuario puede seleccionar el periódico del que se visualizará la información almacenada en la base de datos. Con este selector se cambia el Dashboard entero. Con el segundo selector, se puede ver qué información se quiere visualizar en la tabla, para ver el valor numérico exacto que se representará en los gráficos. Destacar que estos selectores, sólo se podrá interactuar con ellos mientras no se está actualizando la base de datos. La actualización de la base de datos se realiza periódicamente, cada un cierto número de tiempo especificado. Durante unos segundos, el usuario verá en la interfaz un mensaje indicando que se está actualizando la base de datos. Una vez, se termine de actualizar la base de datos, el usuario tendrá la capacidad de modificar la información representada. En la parte superior se puede observar una barra de progresa con la que el usuario se puede hacer una idea del tiempo de ejecución que resta al programa ya sea por número de horas que han transcurrido o por nuevos titulares que se han almacenado en la base de datos. 105 En la parte inferior, se muestra el último titular que ha sido añadido a la base de datos, junto con la información del periódico y tipo, dónde ha sido publicado. Resultados Cuando finalice el proceso de extracción por cualquiera de los dos métodos límite de ejecución se mostrará la siguiente vista. Figura 76. Vista con resumen de resultados En esta vista se podrá ver un pequeño resumen, del número de titulares que se encuentran almacenados en ese momento en la base de datos y divididos por cada uno de los tres periódicos. En esta vista el usuario podrá realizar algunas acciones que son las siguientes: • Ver gráficos Al pulsar este botón el usuario podrá ver los gráficos que se mostraban mientras el proceso de extracción, con una vista muy similar. Figura 77. Vista para Ver Gráficos 112 Anexo 4: Clase Java denominada ReadTest utilizada como base para el desarrollo de este TFG. Se hace referencia a este anexo en el capítulo de Implementación. URL: https://www.vogella.com/tutorials/RSSFeed/article.html package de.vogella.rss.tests; import de.vogella.rss.model.Feed; import de.vogella.rss.model.FeedMessage; import de.vogella.rss.read.RSSFeedParser; public class ReadTest { public static void main(String[] args) { RSSFeedParser parser = new RSSFeedParser( "https://www.vogella.com/article.rss"); Feed feed = parser.readFeed(); System.out.println(feed); for (FeedMessage message : feed.getMessages()) { System.out.println(message); } } } Anexo 5: Clase Java Conexión con la que se junta la base de datos MySQL con el programa en NetBeans. package Conexion; import com.mysql.jdbc.Connection; import java.sql.DriverManager; import java.sql.SQLException; import javax.swing.JOptionPane; public class Conexion { private Connection conectar = null; public Connection hazConexion() { try { Class.forName("com.mysql.jdbc.Driver"); conectar = (Connection) DriverManager.getConnection("jdbc:mysql://localhost:3306/tfg?autoReconnect=true&useSSL=false", "root", "bicicleta"); } catch (ClassNotFoundException | SQLException error) { JOptionPane.showMessageDialog(null, "Error al Conectarse"+"\n"+error,"Mensaje Error",JOptionPane.ERROR_MESSAGE); } return conectar; } public void desconectar(){ try { conectar.close(); } catch (SQLException ex) { System.out.println("No se pudo desconectar"); } } }