PDF de programación - Reingeniería con NetBeans

OpenStax-CNX module: m17590

1

Reingeniería con Netbeans*

Miguel-Angel Sicilia

This work is produced by OpenStax-CNX and licensed under the

Creative Commons Attribution License 2.0„

Descripción de cómo realizar Reingeniería con Netbeans.

Abstract

La ingeniería inversa se ha denido como el proceso de construir especicaciones de un mayor nivel de
abstracción partiendo del código fuente de un sistema software o cualquier otro producto (se puede utilizar
como punto de partida cualquier otro elemento de diseño, etc.).

A continuación se detalle cómo realizar Ingeniería Inversa a través de NetBeans, para ello primero hay

que tener instalado NetBeans 5.5.

1 Ejemplo práctico con Netbeans

1.1 Instalar NetBeans 5.5

En primer lugar tenemos que tener instalado NetBeans 5.5 (http://www.netbeans.org1 ). De esta Web se
puede descargar e instalar. Se puede instalar en diferentes idiomas.

A continuación debemos de comprobar si tenemos instalado o no el módulo UML Modelling2.
Para ello, primero hay que asegurarse de que no está ya instalado. Esto puede hacerse en la opción de

menú Herramientas|Gestor de módulos. . .:

*Version 1.5: Jan 14, 2009 11:32 am +0000
„http://creativecommons.org/licenses/by/2.0/
1http://www.netbeans.org/
2UML Modeling: Reverse Engineering Java Applications. Netbeans. Disponible en: http://www.netbeans.org/kb/55/uml-

re.html (<http://www.netbeans.org/kb/55/uml-re.html>).

http://cnx.org/content/m17590/1.5/

OpenStax-CNX module: m17590

2

Figure 1

Figura 1. Módulos del Gestor de Módulos a través de la opción Herramientas
Una vez comprobado que el módulo de UMl no está instalado, utilizando el botón Actualizar y se

podrán descargar actualizaciones disponibles.

http://cnx.org/content/m17590/1.5/

OpenStax-CNX module: m17590

3

Figure 2

Figura 2. Instalar manualmente UML Modelling
Lo podemos encontrar para descargarlo en la Web e instalarlo manualmente en la siguiente dirección:

http://www.linglom.com/downloads/uml-beta-nbms.zip3

Una vez descargado el chero, lo descomprimimos y tendríamos que agregarlos en la siguiente pantalla:

3http://www.linglom.com/downloads/uml-beta-nbms.zip

http://cnx.org/content/m17590/1.5/

OpenStax-CNX module: m17590

4

Figure 3

Figura 3. Visión de los módulos a instalar del chero zip descomprimido.

http://cnx.org/content/m17590/1.5/

OpenStax-CNX module: m17590

5

Figure 4

Figura 4. Instalación de los módulos y vericación de la rma digital.

http://cnx.org/content/m17590/1.5/

OpenStax-CNX module: m17590

6

Figure 5

Figura 5. Comprobación de los módulos instalados
Una vez instalado UML Modelling, volvemos a Herramientas-Gestor de módulos y lo comprobamos que

está bien instalado.

http://cnx.org/content/m17590/1.5/

OpenStax-CNX module: m17590

7

Figure 6

Figura 6. Comprobación de UML en el Gestor de módulos

1.2 Crear Diagrama de Uso con NetBeans 5.5

Creamos un nuevo proyecto, que denominamos UMLDemo. Para ello, vamos a: Archivo  Nuevo Proyecto:

http://cnx.org/content/m17590/1.5/

OpenStax-CNX module: m17590

8

Figura 7. Realizamos un nuevo proyecto

Figure 7

Figure 8

http://cnx.org/content/m17590/1.5/

OpenStax-CNX module: m17590

9

Figura 8. El proyecto se va a denominar UMLDemo

Figure 9

Figura 9. Seleccionamos el Diagrama de Caso de uso, cuyo nombre será UseCaseDiagram

http://cnx.org/content/m17590/1.5/

OpenStax-CNX module: m17590

10

Figure 10

Figura 10. Pantalla Inicial para crear nuestro Diagrama de Caso de Uso
A continuación realizamos el siguiente diagrama de caso de uso:

http://cnx.org/content/m17590/1.5/

OpenStax-CNX module: m17590

11

Figure 11

Figura 11. Ejemplo de un Diagrama de Caso de uso

1.3 Generar código con NetBeans 5.5

En nuestro ejemplo anterior (UMLDemo), vamos a realizar otro tipo de Diagrama, el Diagrama de clases.

http://cnx.org/content/m17590/1.5/

OpenStax-CNX module: m17590

12

Figure 12

Figura 12. Crear Diagrama de clases
Y realizamos el siguiente diagrama, añadimos los atributos y operaciones:

http://cnx.org/content/m17590/1.5/

OpenStax-CNX module: m17590

13

Figure 13

Figura 13. Ejemplo de Diagrama de clases
Creamos el proyecto, dónde vamos a generar el Código. A esto proyecto le vamos a llamar EjercicioCodigo:

http://cnx.org/content/m17590/1.5/

OpenStax-CNX module: m17590

14

Figure 14

Figura 14. Crear proyecto Java

http://cnx.org/content/m17590/1.5/

OpenStax-CNX module: m17590

15

Figure 15

Figura 15. Nombre del Proyecto
A continuación, en UMLDemo, botón derecho, Generamos Código (Generate Code. . .)

http://cnx.org/content/m17590/1.5/

OpenStax-CNX module: m17590

16

Figure 16

Figura 16. Nombre del Proyecto

http://cnx.org/content/m17590/1.5/

OpenStax-CNX module: m17590

17

Figure 17

Figura 17. Ubicación del Código que vamos a generar
Y el código que se genera en EjercicioCodigo es el siguiente:

Figure 18

http://cnx.org/content/m17590/1.5/

OpenStax-CNX module: m17590

18

Figura 18. Código generado

1.4 Ingeniería Inversa con NetBeans 5.5

Vamos a realizar Ingeniería Inversa con NetBeans. Para ello creamos el siguiente proyecto:

Figure 19

Figura 19. Creamos Proyecto para Ingeniería Inversa cuyo nombre será UMLIngenieriaInversa

http://cnx.org/content/m17590/1.5/

OpenStax-CNX module: m17590

19

Figure 20

Figura 20. En Java Project ponemos nuestro Código Java

http://cnx.org/content/m17590/1.5/

OpenStax-CNX module: m17590

20

Figure 21

Figura 21. Estructura de nuestras carpetas
Seleccionamos nuestra carpeta DicomImage y botón derecho Create Diagram From Selected Elements

http://cnx.org/content/m17590/1.5/

OpenStax-CNX module: m17590

21

Figure 22

Figura 22. Seleccionamos la opción

http://cnx.org/content/m17590/1.5/

OpenStax-CNX module: m17590

22

Figure 23

Figura 23. Elegimos el diagrama de Clases
Y obtenemos nuestro Diagrama de Clase.

http://cnx.org/content/m17590/1.5/

OpenStax-CNX module: m17590

23

Figure 24

Figura 24. Realización de la Ingeniería Inversa

2 Ejemplo práctico de Reingeniería del Software

Un ejemplo sencillo para poder dar un panorama de lo que se trata reingeniería de software sería un sistema
de un mini súper.

En este sistema se tienen:
• Bases de datos de los productos: en la cual viene toda la información de los productos en diferentes
campos como precio de compra, precio de venta, descripción (nombre, marca, tipo, etc.), descuentos,
inventario ,proveedor, clasicación, etc. Con 200 registros.
• Bases de datos de los trabajadores: aquí también existen diferentes campos por cada registro como
salario, horario, descripción (nombre, dirección, teléfono, antig¨uedad, etc.), puesto, etc, con 20 reg-
istros.

Al paso del tiempo este sistema se ha ido modicando debido a que las demandas de la tienda fueron
cambiando. Se modicaron elementos como:
la creación de una base de datos especial para proveedores
la cual tenía interacción con la de productos; se contrataron varias empresas de recursos humanos para la
reclutación de su personal, por lo tanto se creó un registro de estas y se hizo una interacción entre estas

http://cnx.org/content/m17590/1.5/

OpenStax-CNX module: m17590

24

con los trabajadores; como había descuentos especiales en los productos para los trabajadores se hizo una
interacción de la base de datos de trabajadores con la de productos. Aumentaron los trabajadores de 20 a
120, y los productos de 200 a 500.

Todas estas modicaciones se hicieron como se fue requiriendo, y por lo tanto solo se crearon parches en
el sistema, lo que hizo que el sistema: se fuera alentando cada vez más, no tuviera una buena presentación,
no fuera fácil su mantenimiento, etc.

Por lo tanto se tenía que modicar totalmente el sistema para una mejor manutención para lo cual
utilizamos la reingeniería de software, ya que con esto no tendríamos que reconstruir el software totalmente
sino que podíamos utilizarlo como base para la construcción de un software con reingeniería.

En primer lugar se decide traducir el código a una versión más actualizada del mismo lenguaje, esto
con el n de que nuestro programa sea más versátil, para esto se utilizo una herramienta para que la
traducción se hiciera de manera automática. Utilizamos las herramientas de ingeniería inversa para poder
extraer toda la información posible del software inicial para obtener el diseño del nuevo sistema, el cual
tiene que tener las mismas funciones del anterior con la misma interfaz. Con el nuevo diseño y el código
fuente, ya traducido a un lenguaje adecuado, se empezó a reestructurar el programa para que la rapidez en
sus funciones fuera óptima, para esto se necesitaba que existiera una buena modulación y así se empezó a
establecer módulos de los pequeños programas que se interrelacionaran, para conseguir tener varios módulos
con nes similares, ya estando bien la modulación sería más fácil poder implantar una estructura adecuada.
Finalmente se hizo la depuración de los datos, creando una base de datos general con apuntadores a datos,
con una buena clasicación e interacción entre estos. Al relacionar los programas con nuestra base de datos
generada tendremos como resultado un nuevo sistema creado con reingeniería el cual va a ser más rápido,
más mantenible, actualizado, y con capacidad de crecimiento sin estropear la arquitectura original.

Con esto tendremos una optimización de costes y eciencia.

http://cnx.org/content/m17590/1.5/