Está en la página 1de 93

Manual de Usuario Rational Rose

Ingeneria de Software 2011/2012

Nota: si se observan errores se ruega los comuniquéis par la mejora del manual, en lo referente a los
diagramas hay algunos que hay que son susceptibles de mejora y corrección, se está en proceso
de corrección.
Manual de Rational Rose
Índice

INDICE
1 DEFINICIÓN DEL PROBLEMA; FLORISTERÍA VIRTUAL .......................................................... 1

2 CREACIÓN DE CASOS DE USO .................................................................................................. 2


2.1 ACTORES .............................................................................................................................................. 2
2.1.1 Creación de Diagrama de Casos de Uso ........................................................................................ 2
2.1.2 Creación de Actores ........................................................................................................................ 6
2.2 CASOS DE USO .................................................................................................................................... 11
2.2.1 Creación de Casos de Uso. ........................................................................................................... 11
2.3 RELACIÓN ENTRE LOS CASOS DE USO ............................................................................................... 14
2.4 DIAGRAMAS DE CASOS DE USO ......................................................................................................... 14
2.4.1 Creación de Asociaciones de comunicaciones en Rational Rose. ................................................. 14
2.5 LOS ESTEREOTIPOS ............................................................................................................................. 14
2.5.1 Borrado de Elementos del Diagrama ............................................................................................ 15
2.5.2 Comentarios .................................................................................................................................. 16
3 CREACIÓN DE CLASES ............................................................................................................. 18
3.1 QUE ES UNA CLASE ............................................................................................................................. 18
3.1.1 Creación de una clase ................................................................................................................... 20
3.1.2 Añadir Atributos a una Clase ........................................................................................................ 22
3.1.3 Añadir Operaciones a una clase ................................................................................................... 24
3.2 CLASES ESPECIALES ........................................................................................................................... 27
3.2.1 Clases Plantilla (Templates) ......................................................................................................... 27
3.2.2 Clases Utilidad .............................................................................................................................. 30
3.3 LOS PAQUETES ................................................................................................................................... 32
3.3.1 Creación de paquetes .................................................................................................................... 32
3.3.2 Recolocado de Clases.................................................................................................................... 33
3.4 DIAGRAMAS DE CLASES ...................................................................................................................... 33
3.4.1 Creación de un diagrama de Clases ............................................................................................. 34
3.5 RELACIONES ENTRE CLASES ............................................................................................................... 35
3.5.1 Relación de asociación.................................................................................................................. 35
3.5.2 Creación de una relación de asociación ....................................................................................... 36
3.5.3 Creación de Una relación de Agregación ..................................................................................... 37
3.5.4 Añadir un nombre a una relación ................................................................................................. 37
3.5.5 Creación de nombres de roles en la relación. ............................................................................... 38
3.5.6 Indicadores de Multiplicidad ........................................................................................................ 38
3.5.7 Relaciones Recursivas ................................................................................................................... 39
3.5.8 Navegavilidad de las Relaciones ................................................................................................... 39
3.5.9 Relaciones cualificadas ................................................................................................................. 40
3.5.10 Clases Asociación..................................................................................................................... 41
3.5.11 Generalización (Herencia) ....................................................................................................... 42
4 DIAGRAMAS ................................................................................................................................ 44
4.1 DIAGRAMAS DE SECUENCIA ............................................................................................................... 44
4.1.1 Creación de un diagrama de secuencia ........................................................................................ 44
4.1.2 Creación de objetos y mensajes en el diagrama de secuencia ...................................................... 45
4.1.3 Asignación objetos en un diagrama de secuencia a las clases ..................................................... 46
4.1.4 Diagramas De Secuencias y Clases Interfaz ................................................................................. 46
4.1.5 Complejidad y Diagramas De Secuencia ...................................................................................... 47
4.2 DIAGRAMAS DE COLABORACIÓN ....................................................................................................... 47
4.2.1 Creación de diagramas de colaboración desde los diagramas de secuencia ............................... 47
4.3 ¿ POR QUÉ HAY DOS TIPOS DE DIAGRAMAS DIFERENTES? ................................................................... 48
4.4 COMPORTAMIENTO DINÁMICO (DIAGRAMAS DE ESTADO)................................................................. 49
4.4.1 Creación de diagramas de Estados ............................................................................................... 49
4.4.2 Estados .......................................................................................................................................... 49
4.4.3 Transiciones De Estado ................................................................................................................ 50
4.4.4 Estados Especiales ........................................................................................................................ 50
Manual de Rational Rose
Índice

4.4.5 Creación estados de inicio (start) y parada (Stop) ....................................................................... 51


4.4.6 Detalles De La Transición De Estados ......................................................................................... 52
4.4.7 Detalles Del Estado....................................................................................................................... 52
4.4.8 Creación de acciones entrantes, acciones salientes y actividades ................................................ 52
5 LA VISTA DE COMPONENTES .................................................................................................. 54
5.1.1 Creación de paquetes en la vista de componentes ........................................................................ 54
5.1.2 Creación de diagrama principal de componentes......................................................................... 55
5.2 COMPONENTES DE CÓDIGO FUENTE .................................................................................................... 56
5.3 ASIGNACIÓN DE CLASES A COMPONENTES ......................................................................................... 57
5.3.1 Creación de Componentes ............................................................................................................ 57
5.3.2 Asignación de Clases a un Componente ....................................................................................... 57
6 GENERACIÓN DE CÓDIGO EN C++ .......................................................................................... 59
6.1 CREACIÓN DE LA PLANTILLAS DE GENERACIÓN DE CÓDIGO .............................................................. 59
6.2 CREACIÓN DE COMPONENTES DE CÓDIGO FUENTE. ............................................................................ 61
6.2.1 Creación de Componentes de Implementación ............................................................................. 62
6.2.2 Asignación de Componentes a una clase ...................................................................................... 63
6.3 ENLACE DE LAS HOJAS DE PROPIEDADES A LAS CLASES. ..................................................................... 64
6.4 SELECCIONAR LOS COMPONENTES Y GENERAR EL CÓDIGO ................................................................. 66
7 INGENIERÍA INVERSA USANDO EL ANALIZADOR DE CÓDIGO C++ ................................... 68
7.1 CREACIÓN DE UN PROYECTO ............................................................................................................... 68
7.1.1 Creación de un proyecto en el analizador de C++ ....................................................................... 69
7.2 AÑADIR UN TITULO AL PROYECTO ...................................................................................................... 69
7.2.1 Añadir un Titulo en el analizador de C++.................................................................................... 70
7.3 AÑADIR DIRECTORIOS, LIBRERÍAS DE REFERENCIA O PROYECTOS BASE .............................................. 70
7.3.1 Creación de la lista de directorios en el analizador de C++ ....................................................... 70
7.3.2 Añadir proyectos base en el analizador de C++ .......................................................................... 72
7.4 AÑADIR LOS ARCHIVOS A ANALIZAR Y SUS TIPOS DE ARCHIVO .......................................................... 73
7.4.1 Añadir los archivos a analizar ...................................................................................................... 73
7.4.2 Cambiar el tipo de análisis en el analizador de C++ ................................................................... 74
7.4.3 Analizar archivos en el analizador de C++ .................................................................................. 75
7.5 EVALUACIÓN DE ERRORES .................................................................................................................. 76
7.6 SELECCIÓN DE LAS OPCIONES DE EXPORTACIÓN Y EXPORTAR EL MODELO ......................................... 77
7.6.1 Crear y exportar un modelo UML a partir del código C++ analizado. ....................................... 77
7.7 ACTUALIZACIÓN DEL UN MODELO ...................................................................................................... 78
7.7.1 Actualizando un modelo Rose ....................................................................................................... 78
8 GENERACIÓN DE CÓDIGO JAVA ............................................................................................. 80
8.1 CHEQUEO DE ERRORES DE SINTAXIS .................................................................................................. 80
8.2 FIJAR EL LENGUAJE DE GENERACIÓN DE CÓDIGO POR DEFECTO. ......................................................... 81
8.3 GENERACIÓN DE CÓDIGO DESDE EL DIAGRAMA. ................................................................................ 82
8.4 GENERACIÓN DE CÓDIGO JAVA DESDE EL DIAGRAMA DE COMPONENTES............................................ 83
8.5 MAPEO DE COMPONENTES PARA LA GENERACIÓN DE CÓDIGO ............................................................ 84
8.6 EDITOR DE CÓDIGO JAVA ................................................................................................................... 85
8.6.1 Cambiar el editor de código por defecto....................................................................................... 85
9 INGENIERÍA INVERSA DE CÓDIGO JAVA. .............................................................................. 87
9.1 ASIGNACIÓN DE NUEVOS DIRECTORIOS DE CLASSPATH. .................................................................... 87
9.2 ANALIZADOR DE CÓDIGO JAVA. ......................................................................................................... 88
9.3 CREACIÓN ACTUALIZACIÓN DEL MODELO. ......................................................................................... 89
Manual de Rational Rose Creación de Casos de Uso

1 Definición del Problema; Floristería virtual

En este ejemplo se pretende desarrollar una tienda de flores virtual. Para ello
una empresa decide montar una franquicia de reparto de flores y creará una página
Web que colocará en Internet; las floristerías se harán miembros de la franquicia y
serán las encargadas del reparto de las flores solicitadas por Internet.
Los usuarios se conectarán a la máquina Web y realizarán pedidos,
(encargarán ramos de flores) que serán enviados a otra tercera persona. Una vez
que el usuario ha realizado el pedido, la aplicación se encargará de buscar la
floristería más cercana al domicilio del destinatario, que se encuentre registrada en
el sistema y la notificará que debe realizar una entrega. Cuando esta floristería haya
realizado la entrega entrará en el sistema y registra la fecha y hora en que realizo la
entrega. La aplicación debe de llevar un registro de fechas tales como fecha en la
que se realiza el pedido, fecha en la que de debe entregar, la fecha de real de la
entrega, etc.
Cuando un cliente hace un pedido, se le proporciona un identificador único para
poder seguir el estado de su pedido. El usuario puede entrar en el sistema y seguir
el estado de su pedido así como anular la entrega si aun no se ha realizado.

1
Manual de Rational Rose Creación de Casos de Uso

2 Creación de Casos de Uso


2.1 Actores

Los actores no son parte del sistema ellos representan a una persona o cosa
que debe interactuar con el sistema. Lo único que un actor puede hacer es:

Introducir información al sistema


• Recibir información del sistema.

• Entrar y recibir información del sistema.

Los actores se deben de buscar y encontrar en la definición del problema.

En UML, un actor es representado por un muñeco de alambre como el mostrado en


la figura.

Figura 2.1 Icono de un Actor

Actores de la Floristería virtual serán:

• Las Personas de desean enviar flores.

• Las empresas o personas encargadas de enviar físicamente las flores a las


personas destino del pedido.

• El administrador que será el encargado de dar de alta las Tiendas en el sistema.

• El asignador, entendiéndose como un proceso encargado de asignar los pedidos


realizados por los clientes a la tienda que deberá hacer la entrega.

• Los destinatarios de los pedidos.

2.1.1 Creación de Diagrama de Casos de Uso

Un diagrama de casos de uso es la representación gráfica que relaciona los


actores con los casos de uso y sus relaciones dentro del sistema.

Cada sistema típicamente debe tener un diagrama de casos de uso.


Dependiendo la complejidad del sistema y el nivel de detalle que se quiera entrar el
sistema puede tener varios diagramas de casos de uso.

2
Manual de Rational Rose Creación de Casos de Uso

Comenzamos representando el comportamiento de los movimientos de las


actividades de la floristería por medio de casos de uso en Rational Rose.

- Se pincha con el botón derecho sobre la pestaña Use Case View


- Seguidamente se selecciona New, y a continuación Use Case Diagram

Figura 2.2.1.1 Selección diagrama de Casos de Uso

- Así tendremos creado el nuevo diagrama de casos de uso.

3
Manual de Rational Rose Creación de Casos de Uso

Figura 2.3.1.2 Obtención diagrama de Casos de Uso

- Al cual nombraremos, en este caso, como Floristeria. Y hacer doble clic


encima del diagrama para que nos muestre por pantalla el Toolbox de este
diagrama, y su ventana correspondiente.

4
Manual de Rational Rose Creación de Casos de Uso

Figura 2.4.1.3 Floristería

- Una vez abierta la ventana de Casos de uso es posible añadir casos de


uso y actores directamente en la ventana, a través de la barra de
herramientas.

Puntero de ratón normal, permite la selección de los elementos ya


existentes en el diagrama de casos de uso.

Anade un texto o etiqueta al diagrama de casos de uso

Añade una nota de texto al diagrama de casos de uso. La nota puede


estar asociada al diagrama o a un elemento en particular.

Establece una relación entre una nota de texto y un elemento. La nota y


el elemento con el que se establece la relación deben estar previamente
en el diagrama.

5
Manual de Rational Rose Creación de Casos de Uso

Añade un paquete al diagrama. Los paquetes son agrupaciones de


elementos. Se pueden definir paquetes de casos de uso, de clases de
componentes, etc.

Añade un nuevo caso de uso al Diagrama.

Añade un nuevo actor al diagrama.

Establece una relación entre un caso de uso y un actor.

Establece una relación o dependencia entre paquetes.

Establece una generalización entre casos de uso o actores.

- O bien como se detalla a continuación:

2.1.2 Creación de Actores

1. Se pulsa con el botón derecho en la pestaña del árbol marcada como Use Case
View, para que aparezca visible el menú contextual.

2. Se selecciona la opción New Actor. Un nuevo actor llamado New Class se


añadirá al árbol.

3. Cuando el nombre del actor se encuentra todavía seleccionado se introduce el


nombre correcto de este.

6
Manual de Rational Rose Creación de Casos de Uso

Figura 2.1.5.1 Creación de un Nuevo Actor

Repetir el proceso anterior para crear los usuarios de la aplicación

• Cliente.- Personas que desean enviar flores.

• Tienda.- Empresas o personas encargadas de enviar físicamente las flores a las


personas destino del pedido.

• Administrador.- Persona encargada en dar de alta las Tiendas en el sistema.

• Asignador.- Proceso encargado de leer los nuevos pedidos y asignárselos a la


tienda que realizará la entrega.

Hacer notar que los destinatarios no se han considerado como actores del
sistema, aunque en la vida real sean personas físicas, pero su papel no es relevante
en la aplicación. Por lo tanto, no siempre cualquier persona que aparezca en la
definición de un problema se debe considerar como actor del sistema.

Resaltar que se ha creado un actor con nombre Asignador, que sin ser una
persona física, sino un ente abstracto, se ha considerado como un actor del sistema,
al ser de vital importancia y tener unas tareas bien definidas (Asignar cada pedido a
la floristería más cercana al domicilio cliente).

7
Manual de Rational Rose Creación de Casos de Uso

Figura 2.1.6.2 Vista del árbol de Casos de Uso (actores)

Documentación de los Actores

Una vez creados los actores se debería comentar su papel en el sistema.

1. Se hace doble clic el icono de un actor.

Figura 2.1.7.3 Documentación de actores

8
Manual de Rational Rose Creación de Casos de Uso

2. Se selecciona la pestaña de General y se introduce la documentación asociada


al actor, en la ventana rotulada como Documentation.

Figura 2.1.8.4 Documentación de actores II

Si la documentación asociada al actor es demasiado extensa para introducirla en


la anterior ventana es posible añadir información externa al sistema en un archivo,
para ello:

1. Se hace doble clic el icono de un actor.

2. Se selecciona la pestaña Files y se pulsa en el interior de la ventana con el botón


derecho de ratón.

9
Manual de Rational Rose Creación de Casos de Uso

Figura 2.1.9.5 Documentación de actores por medio de fichero

3. En el menú contextual se selecciona Insert File.

4. Se abrirá un explorador que permitirá anexar un archivo.

Figura 2.1.10.5 Documentación de actores por medio de fichero II

10
Manual de Rational Rose Creación de Casos de Uso

2.2 Casos de Uso

Definen el diálogo entre el actor y el sistema. Definen los requisitos funcionales


del Sistema. Deben de ser intuitivos y sistemáticos.

En UML, un caso de uso se representa como un ovalo.

Figura 2.2 Icono de un Caso de Uso

2.2.1 Creación de Casos de Uso.

1. Se pulsa con el botón derecho en la pestaña del árbol marcada como Use Case
View, para que aparezca visible el menú contextual.

2. Se selecciona la opción New Use Case. Un nuevo Caso de Uso llamado New
Case se añadirá al árbol.

Figura 2.2.1 Creación de un Caso de Uso

11
Manual de Rational Rose Creación de Casos de Uso

3. Con el Caso de uso aun seleccionado se introduce el nombre del caso de uso.

Figura 2.2.2 Creación de un Caso de Uso II

Una vez creados los casos de uso del sistema se debería comentar su misión en el
sistema y su propósito funcional.

1. Se hace doble clic el icono del un actor.

2. Se selecciona la pestaña de General y entrar la documentación asociada al actor,


en la ventana rotulada como Documentation.

Casos de uso de la Floristería virtual.

1. Mantenimiento de tienda.

• Crear una nueva tienda.

• Modificar una existente.

• Borrar una tienda.

2. Hacer un pedido

• Crear un nuevo usuario

• Crear un nuevo destinatario

• Confirmar el pedido.

12
Manual de Rational Rose Creación de Casos de Uso

3. Hace el seguimiento del pedido

• Obtener nuevos pedidos

• Concertar cita con el destinatario.

• Informar de la entrega.

4. Asignar pedidos a Tiendas

Figura 2.2.3 Vista del Árbol de los Casos de Uso

Cada caso de uso se puede dividir a su vez en una serie de casos de uso,
llamados sus flujos, hasta completar la mínima acción que puede realizar el sistema.
En el ejemplo que nos ocupa se pueden definir cuatro casos de uso básicos, uno
para cada actor, a su vez cada caso de uso se puede dividir a su vez en múltiples
casos.

Asociación de documentos externos en un caso de uso.

Al igual que en los actores es posible la asignación de documentos externos para


documentar el funcionamiento de los casos de uso.

13
Manual de Rational Rose Creación de Casos de Uso

2.3 Relación Entre Los Casos De Uso

Debe existir una relación entre el actor y el caso de uso. Este tipo de relación
es con frecuencia referenciada como asociación. La asociación representa la
comunicación entre el actor y los casos de uso. En UML una asociación se
representa como una línea que une el actor con un caso de uso. Una asociación
puede ser navegable en ambos sentidos, aunque lo normal es que sea navegable en
sentido del actor al caso de uso. El sentido de navegabilidad esta representado por
una punta de flecha en la relación que uno el actor con el caso de uso. Si la relación
es navegable en ambos sentidos no existe punta de flecha en ningún sentido.

2.4 Diagramas De Casos De Uso

Una vez obtenidos los elementos necesarios para la creación de nuestro


diagrama, simplemente tenemos que seleccionar los elementos y arrastrarlos a la
ventana del diagrama (situada a la derecha) y colocarlos.

2.4.1 Creación de Asociaciones de comunicaciones en Rational Rose.

1. Se pulsa con el ratón en la barra de herramientas el botón marcado como una


flecha .

2. Se pulsa sobre el actor inicio de la relación y se arrastra el ratón hasta soltarlo


sobre el caso de uso objeto de la relación.

2.5 Los Estereotipos

Un estereotipo es una extensión del vocabulario de UML que permite crear


nuevos bloques de construcción derivados a partir de los existentes, pero
específicos a un problema concreto. De esta manera se pueden definir nuevas
clases a partir de las existentes, pero con características propias de tal forma que a
cada estereotipo puede proporcionar sus propias restricciones y notaciones. Cada
estereotipo puede proporcionar su propio icono.

Los estereotipos no son específicos de los casos de uso, estos también se


pueden aplicar a las clases y a las relaciones, tanto a las relaciones entre clases,
como a las relaciones entre los actores y los casos de uso.

Para modificar los estereotipos

1. Se hace doble clic sobre la relación, clase o caso de uso sobre al que se desea
cambiar el estereotipo.

14
Manual de Rational Rose Creación de Casos de Uso

2. En la pestaña General del dialogo se selecciona el estereotipo deseado de la


lista desplegable con nombre “Estereotype” o se introduce un nuevo valor.

Figura 2.5.1 Vista de la modificación de Estereotipos

2.5.1 Borrado de Elementos del Diagrama

El botón suprimir tan sólo elimina los elementos del diagrama, no del proyecto en
curso. Para eliminar un elemento del proyecto se deben seguir los siguientes pasos:

1. Se pulsa con el botón derecho del ratón sobre el elemento que se desea eliminar
en el árbol de la ventana izquierda.

2. Se selecciona Delete en el menú contextual.

3. Eliminar un elemento del árbol lo elimina de todos los diagramas donde se esta
utilizando, estén o no visible actualmente.

La combinación de teclas “Ctrol D” elimina el elemento actualmente seleccionado.

15
Manual de Rational Rose Creación de Casos de Uso

2.5.2 Comentarios

Si un elemento es utilizado en varios diagramas, la modificación de los


parámetros de uno de ellos se verá reflejado en todos, independientemente del
diagrama seleccionado actualmente.

Figura 2.5.2.1 Vista del Diagrama de Casos de Uso

Tenemos la posibilidad de añadir notas con el fin de aclarar la estructura o la


participación de algún componente el diagrama; para ello tendremos que seleccionar
de la caja de herramientas la nota, introducir el texto y colocarla donde sea
necesario.

16
Manual de Rational Rose Creación de Casos de Uso

Figura 2.5.2.2 Vista del Diagrama de Casos de Uso con nota aclaratoria.

17
Manual de Rational Rose Diagramas

3 Creación de Clases
3.1 Que es una clase

Se define una clase como un conjunto de Objetos que comparte una estructura
y comportamiento común.

En UML una clase se representa mediante un rectángulo dividido en tres


compartimentos que contienen de arriba abajo las siguientes informaciones:

ƒ El nombre de un estereotipo entre “<<>>”, en una línea por debajo el nombre de


la clase por un icono que puede representar el estereotipo de la misma.

ƒ En un segundo compartimento los atributos de la clase según la sintaxis:

visibilidad nombre_atributo:expesión_tipo=valor_inicial
{cadena_propiedades}

¾ visibilidad es un símbolo que puede ser:

Modo Modo Descripción


Icono Texto

+ Visibilidad Pública

# Visibilidad protegida

- Visibilidad privada

Visibilidad Implementación

La visibilidad puede abarcar un quinto símbolo ‘$’ que representa un atributo


estático, es decir un atributo cuyo valor es común a todas las instancias de la
clase. Este atributo estará a continuación de uno de los símbolos anteriormente
comentados.

La representación de la visibilidad de las operaciones y de los atributos en


modo icono o texto se modificar activando la opción Visibility as icons dentro de
la pestaña Notación del menú Tools-Options.

Después de hacer esto, las clases previamente diseñadas no cambiarán su


visualización, para mostrar los atributos u operaciones con su nueva notación,
actualizar el diagrama pulsando las opciones de menú Format AutosizeAll.

18
Manual de Rational Rose Diagramas

3 expresión_tipo representa un tipo de datos definido al que


pertenece el atributo. Los tipos de datos tipos son int, float,
char,... , aunque también es posible definir como tipo de dato
clases que se hayan diseñado previamente.

3 valor_inicial corresponde al valor inicial que el atributo adquiere


de forma automática al ser creado el objeto.

3 cadena_propiedades corresponde a un conjunto de


propiedades aplicables al atributo.

ƒ En el tercer compartimento se especifican las operaciones de la clase según la


sintaxis:
Visibilidad nombre_operación (lista_parámetros):
expresión_tipo_valor_retorno { cadena_propiedades }

3 visibilidad es similar a lo definido para los atributos.

3 expresión_tipo_valor_retorno representa el tipo de dato del


valor devuelto por la operación.

3 lista_parámetros es una secuencia de expresiones, separadas


por comas, con la siguientes sintaxis:

nombre_parametro:expresión_tipo=valor_por_defecto

expresión_tipo indica el tipo de dato al que pertenece el


parámetro.

3 valor_por_defecto corresponde al valor que se utilizará en el


caso de que la llamada a operación se realice sin especificar
dicho parámetro.

3 cadena_propiedades corresponde a un conjunto de


propiedades aplicables a la operación.

19
Manual de Rational Rose Diagramas

Figura 3.1 Representación de Unas clase

3.1.1 Creación de una clase

1. Se pulsa con el botón derecho en la pestaña del árbol marcada como Logical
View, para que aparezca visible el menú contextual.

2. Se selecciona la opción New Class. Una nueva Clase llamada New Class se
añadirá al árbol.

Figura 3.1.1 Creación de clases

20
Manual de Rational Rose Diagramas

3. Con la clase todavía seleccionada, se introduce el nombre correcto de la clase:

Una vez creados las nuevas clases del sistema se debería comentar su misión en el
sistema y su propósito funcional.

1. Se hace un doble clic en el icono de la clase.

2. Se selecciona la ventana de Documentación y introduce la documentación


asociada a la clase.

Figura 3.1.2 Documentación de clases

21
Manual de Rational Rose Diagramas

3.1.2 Añadir Atributos a una Clase

1. Se pulsa con el botón derecho en la clase a la que se quiere añadir un nuevo


atributo, para que aparezca visible el menú contextual.

2. Se selecciona la opción New / Attribute. Un nuevo atributo se añadirá a la clase.

Figura 3.1.2.1 Inserción de atributos de clases

3. Con el atributo todavía seleccionado, se introduce el nombre correcto, tipo de


dado y valor inicial de acuerdo a lo explicado al comienzo de este capitulo.

22
Manual de Rational Rose Diagramas

4. Para modificar la visibilidad, se hace doble click sobre el icono del atributo y se
cambia dentro de la pestaña General la visibilidad del atributo, marcando el botón
que se encuentra dentro del cuadro Export Control. En esta misma pestaña se
puede cambiar el nombre, el estereotipo, el tipo de atributo, el valor inicial, así
como añadir comentarios del significado del atributo.

Figura 3.1.2.2 Modificación de la visibilidad

5. En la pestaña Detail se podrá modificar si el atributo es contenido por valor o por


referencia, así como si el atributo es estático o no.

Una manera más fácil pero más lenta de añadir atributos es abriendo el dialogo
de especificaciones de la clase, haciendo doble clic sobre esta y pulsado sobre la
pestaña Attibutes. En esta pestaña del dialogo se pueden añadir todos los atributos
necesarios así como asignar la visibilidad, tipo de atributo y valor inicial de una
manera más visual.

23
Manual de Rational Rose Diagramas

Figura 3.1.2.3 Añadir nuevos atributos

3.1.3 Añadir Operaciones a una clase

1. Se pulsa con el botón derecho sobre la clase a la que se quiere añadir una nueva
Operación, para que aparezca visible el menú contextual.

2. Se selecciona la opción New / Operation. Una nueva operación se añadirá a la


clase.

3. Se modifica el nombre de la operación, tipo de valor retornado, atributos de


entrada de parámetros y sus valores iniciales de acuerdo a lo explicado al
comienzo de este capitulo.

4. Para modificar la visibilidad, se hace doble click sobre de la operación y se


cambia dentro de la pestaña General la visibilidad de la operación, marcando el
botón que se encuentra dentro del cuadro Export Control. En esta misma pestaña
se puede cambiar el nombre, el estereotipo, el tipo de atributo retornado, así
como añadir comentarios al funcionamiento de la operación.

24
Manual de Rational Rose Diagramas

Figura 3.1.3.1 Añadir nuevas operaciones

5. En la pestaña Detail se podrán modificar los atributos de entrada de la operación,


sus tipos y valores iniciales. Para añadir nuevos parámetros de entrada o
eliminar los existentes:

• Se pulsa con el botón derecho sobre la ventana arguments.

• Se selecciona Insert en el menú conextual.

• Se Modifica el nombre del argumento por defecto "argname", por el nombre


deseado.

25
Manual de Rational Rose Diagramas

Figura 3.1.3.2 Argumentos de las operaciones.

• Se seleccionan las especificaciones del argumento y ahí podemos incluir el


tipo de dato.

Figura 3.1.3.3 Argumentos de las operaciones (tipo)

26
Manual de Rational Rose Diagramas

• Se selecciona la columna Default y se introduce el valor de entrada por


defecto.

3.2 Clases Especiales

Existen dos tipos de clases, una se define como una extensión de concepto
básico de clase y otra como una clase cuyos atributos y operaciones reúnen una
propiedad especial. Estos tipos de clase son:

ƒ Clase Plantilla o patrón.

ƒ Clase Utilidad

3.2.1 Clases Plantilla (Templates)

Las clases plantilla se basan en un principio de genericidad dentro de las


distintas técnicas desarrollas en el campo de la ingeniería del software y se plantea
como una idea de parametrizar el desarrollo de módulos reutilizables. La idea se
basaba en la definición del modulo de software de forma genérica de modo que la
utilización del mismo en un caso concreto se realizaría dando valores a los
parámetros definidos a priori.

Generalmente el uso más frecuente de las clases plantilla se realizan en la


implementación de las llamadas clases contenedoras. Una clase contenedora tiene
por finalidad almacenar y permitir acceder a un conjunto, normalmente homogéneo
de objetos bajo unas determinadas condiciones. La finalidad de la clase es por lo
tanto independiente del objeto almacenado.

Los ejemplos más típicos de este tipo de clases son las clases vector de Java,
y vector de las STL (Stardar Template Library) de C++.

Una clase plantilla se representa en UML en base a la representación de una


clase normal modificada con un rectángulo situado en la esquina superior derecha
con líneas discontinua donde se indican lo parámetros de la clase separados por
comas.

Para crear una clase plantilla (Template ) se deben seguir los siguientes pasos:

1. Se pulsa con el botón derecho en la pestaña del árbol marcada como Logical
View, para que aparezca visible el menú contextual.

2. Se selecciona la opción New / Class. Una nueva Clase se añadirá al árbol.

27
Manual de Rational Rose Diagramas

3. Se hace un doble clic sobre la nueva clase, o se pulsa con el botón derecho y se
selecciona la opción Open Specificacion.

4. Se selecciona la Pestaña General.

5. Se selecciona en la lista desplegable Type el tipo de clase ParametrizedClass y


se validan los cambios pulsado el botón Apply

Figura 3.2.1 Clases Plantilla

6. Se selecciona la pestaña Detail (detalle).

7. Se pulsa con el botón derecho en el campo de Formal Arguments (argumentos


formales) para desplegar el menú.

8. Se selecciona el menú Insert (insertar), que insertará un nuevo argumento con un


nombre de argname y un tipo de argtype.

9. Con el argname seleccionado, se introduce el nombre del argumento.

10. Se pulsa para seleccionar el argtype y se introduce el tipo del argumento.

28
Manual de Rational Rose Diagramas

Figura 3.2.2 Argumentos.

11. Se repiten los pasos del 7 al 10 para cada argumento.

12. Se pulsa el botón OK para cerrar la Specification (Especificación).

Figura 3.2.3 Representación de una clase Plantilla

Se pueden crear clases parametrizables directamente desde la barra de


herramientas. Si este icono no se muestra en la barra de Herramientas, se puede
añadir con la opción Customize que aparece al pulsar con el botón derecho de sobre
la barra de herramientas, para su personalización.

29
Manual de Rational Rose Diagramas

Figura 3.2.4 Personalización de la barra de herramientas.

3.2.2 Clases Utilidad

Una clase utilidad aglutina un conjunto de atributos y operaciones que no son


propios de una clase especifica y son de definición global.

Según la especificación de UML una clase utilidad se representa mediante el


símbolo de una clase normal con un estereotipo <<utility>> Rational Rose suministra
un símbolo especifico heredado de la notación OMT, en el que se representa
mediante una clase con sombra.

Figura 3.2.2.1 Representación de una clase Utilidad

Para crear una clase utilidad, se deben seguir los siguientes pasos:

1. Se pulsa con el botón derecho en la pestaña del árbol marcada como Logical
View, para que aparezca visible el menú contextual.

2. Se selecciona la opción New / Class. Una nueva Clase se añadirá al árbol.

3. Se hace doble clic sobre la nueva clase, o pulsar con le botón derecho y
seleccionar la opción Open Specificacion.

4. Se selecciona la Pestaña General.

5. Se selecciona en la lista desplegable Type el tipo de clase ClassUtility.

30
Manual de Rational Rose Diagramas

Figura 3.2.2.2 Representación de una clase Utilidad II

6. Se pulsa el botón OK para cerrar la Specification (Especificación).

Tenemos la oportunidad de crear las Clases Utilidad directamente, haciendo clic


con el botón derecho del ratón en Logical View Ö New Ö Class Utility

Figura 3.2.2.3 Representación de una clase Utilidad III

31
Manual de Rational Rose Diagramas

3.3 Los Paquetes

Si un sistema contiene sólo unas pocas clases, estas se pueden manejar


fácilmente. La mayoría de los sistemas están compuestos de muchas clases, y se
necesita un mecanismo para agruparlas y facilitar su uso, mantenimiento
reutilización. Aquí es donde se usa el concepto de paquete. Un paquete en la vista
lógica (Logical View) de un modelo es una colección de paquetes y/o clases
relacionados. Un paquete se crea por el agrupamiento de clases u otros paquetes.
Un paquete se puede ver desde el nivel más alto del modelo o se puede entrar en él
para observar en más detalle su contenido.

Cada paquete contiene una interface que es implementado por sus clases
públicas. Estas clases, se encargan de la comunicación con los otros paquetes. El
resto de las clases de un paquete son clases de implementación y generalmente
privadas, por lo que no se comunican con las clases de otros paquetes.

Si el sistema es complejo, los paquetes se crearan en la Fase de


implementación para facilitar el desarrollo. Para sistemas más simples, las clases
que se encuentran en el análisis se suelen agrupar en un paquete. En los procesos
de análisis y diseño, el concepto de un paquete se usa para agrupar las clases que
son necesarias para llevar a cabo las decisiones arquitectónicas hechas en el
sistema.

En el UML, los paquetes son representados como carpetas (Folders).

Figura 3.3 Representación de una clase Utilidad

3.3.1 Creación de paquetes

1. Se pulsar con el botón derecho en el árbol de la ventana izquierda.

2. En el menú emergente se selecciona New Package (nuevo paquete).

32
Manual de Rational Rose Diagramas

Figura 3.3.1 Representación de una clase Utilidad (Paquete)

3. Mientras el paquete está todavía seleccionado, se introduce el nombre del


paquete.

Al introducir el nuevo paquete se deberían recolocar las clases previamente


creadas en el modelo.

3.3.2 Recolocado de Clases

1. Se pulsa con el botón derecho sobre la clase a recolocar.

2. Se arrastra la clase al paquete deseado.

3. Se repiten los pasos para cada una de las clases que se desea recolocar.

3.4 Diagramas de clases

Según vamos añadiendo clases al modelo, la presentación de las clases no es


suficiente, debido a que necesitamos tener una visión global de todas ellas y de sus
relaciones entre si. Los diagramas de clases se crean para tener una imagen de
algunas o todas las clases del modelo.

El diagrama de clases principal en la vista lógica del modelo es típicamente un


dibujo con los paquetes del sistema. Cada paquete contendrá sus diagramas de
clases. El cual también mostrará las clases del sistema.

33
Manual de Rational Rose Diagramas

3.4.1 Creación de un diagrama de Clases

1. Para crear el diagrama principal del sistema, se pulsa sobre el símbolo nombrado
como Main dentro del la carpeta Logical View en el árbol de la ventana izquierda.

2. Se pulsa sobre una de las clases previamente creadas y se arrastra a la ventana


derecha.

3. Se repite este último paso para todas las clases.

Una vez abierta la ventana del diagrama de Clases es posible añadir nuevas clases
directamente en la ventana, a través de la barra de herramientas.

Puntero de ratón normal, permite la selección de los elementos ya


existentes en el diagrama de casos de uso.

Anade un texto o etiqueta al diagrama de Clases.

Añade una nota de texto al diagrama de clases. La nota puede estar


asociada al diagrama o a un elemento en particular.

Establece una relación entre una nota de texto y un elemento. La nota y


el elemento con el que se establece la relación deben estar previamente
en el diagrama.

Añade un clase de tipo interface al diagrama.

Añade un clase al diagrama.

Añade una asociación unidireccional entre dos clases.

Establece una asociación entre una relación y una clase (por lo que crea
una clase relación).

Añade un paquete al diagrama. Los paquetes son agrupaciones de


objetos, se pueden definir paquete de casos de uso , de clases de
componentes, etc.

Establece una relación o dependencia entre paquetes.

Establece una generalización entre dos clases.

34
Manual de Rational Rose Diagramas

3.5 Relaciones entre clases

Del mismo modo que los objetos colaboran entre si a través de una conexión
establecida en las relaciones de enlace o agregación podemos establecer relaciones
entras las clases que nos permitan definir un jerarquía dentro del modelo.

En UML se han establecido los siguientes tres tipos básicos de relaciones entre
clases:
ƒ Asociación.
ƒ Herencia o Generalización.
ƒ Dependencia.

Basados en estos tres tipos básicos se derivan dos mas:


ƒ Agregación, es una especialización de la relación de asociación.
ƒ Instanciación es una especialización de la relación de dependencia.

3.5.1 Relación de asociación

La relación de asociación establece la existencia de una dependencia ente


dos clases sin establecer una direccionabilidad en la misma. Generalmente se
produce una cierta dualidad en la relación. Supongamos que nuestra empresa en la
encargada de suministrar las flores a todas la floristerías de la cadena, por lo tanto
cada vez que se hace un pedido, podemos establecer una relación con el nombre de
Suministro. Desde el punto de vista del suministrador la floristería tiene el rol de
cliente, mientras que desde el punto de vista de la floristería el suministrador tiene el
papel de proveedor o servidor.

En base a esta dualidad entre los elementos de una asociación se pueden


nombrar.

ƒ La relación en sí.

ƒ Los extremos de la asociación, lo que se denomina papel o rol, cada extremo


tiene un rol.

La importancia de la relación en una asociación lleva incluso a crear una clase


asociada lo que se denomina una clase asociación, nuestro ejemplo se puede crear
una clase asociación que reuniera el conjunto de facturas pendientes de pago por
una floristería.

35
Manual de Rational Rose Diagramas

Volviendo a los extremos de la asociación es necesario que definamos un nuevo


concepto, la cardinalidad de la asociación. Esta parte de la orientación a objetos a
sido heredada del modelo entidad relación. Hasta ahora hemos hablado de
asociaciones uno a uno, es decir por cada objeto de un extremo esta asociado a uno
del otro. Pero pueden existir combinaciones básicas:

ƒ Uno a uno

ƒ Uno a muchos

ƒ Muchos a muchos

Volviendo al ejemplo anterior el proveedor puede suministrar flores a muchas


floristerías. Por lo que se establece una relación de uno a muchos. Si en el sistema
existiesen varios suministradores, estos podrían también suministrar flores a todas
las floristerías, por lo que estas podrían tener varios suministradores, en
consecuencia se establecería una relación de muchos a muchos entre la clase
floristería y la clase suministrador.

A parte de la cardinalidad o multiplicidad del rol de una asociación se puede


completar la información asociada al rol con información adicional, estas son
condiciones o restricciones adicionales como por ejemplo en una asociación de uno
a muchos podemos decir si el conjunto de objetos son ordenados o no.

Cuando la relación de asociación la tenemos determinada de una forma unívoca


un valor a uno o a un conjunto de valores del extremo de cardinalidad mayor que
uno podemos hablar de una relación cualificada.

Indicar que aunque las relaciones de asociación se han planteado como


relaciones existentes entre clases de distintas también podríamos establecer
relaciones de una clase consigo misma. Estas son relaciones recursivas. La clase
persona establece relaciones recursivas para definir relaciones de parentesco,
relaciones de tipo, hermandad, paternidad, etc.

3.5.2 Creación de una relación de asociación

1. Se pulsa sobre el botón de relación de asociación en la barrar de herramientas.

2. Se pulsa sobre la clase origen de la relación.

3. Se arrastra el ratón y se suelta sobre la clase destino de la asociación

Figura 3.2 Representación de una Asociación

36
Manual de Rational Rose Diagramas

3.5.3 Creación de Una relación de Agregación

Una relación de agregación es una relación cualificada en la cual uno de los


objetos es parte integrante de otro objeto y sin el cual este no puede existir.
Supongamos que nuestro negocio es de reparación de vehículos, nosotros al
referirnos al objeto motor que siempre estará integrado en un coche y nunca podrá
existir un objeto motor sin su objeto contenedor, en este caso un coche. Si por el
contrario, fuéramos una fabrica de coches, todas las piezas del coche serian objetos
independientes que pueden combinarse para formar otro objeto, pero que pueden
existir libremente, cuando están en el almacén en espera de ser montadas.

En UML la relación de agregación es representada como un diamante en el


lado de la clase contenedora.

Para crear una clase de agregación se deben seguir los siguientes pasos.

1. Se pulsa con el botón derecho del ratón sobre una relación entre clases,
previamente existente en el extremo más próximo a la clase donde se desea
insertar el diamante (la clase contenedora).

2. Se selecciona Agragate en el menú contextual.

Un refinamiento de la asociación de agregación, se refiere a si el objeto esta


contenido por valor o por referencia. Si esta contenido por valor, implica una
propiedad en exclusiva del objeto contenedor, mientras que si es por referencia, el
objeto contenido puede estar compartido por varias clases contenedores.

Una relación de agregación por valor se representa con el diamante relleno,


mientras que si es por referencia, el diamante no estará relleno.

Figura 3.5.3 Representación de una Agragación por referencia

3.5.4 Añadir un nombre a una relación

1 Se hace doble clic sobre la relación a la que se desea asignar un nombre, o se


pulsa con el botón derecho sobre ella y se selecciona la opción Open
Specification.

2 Se asigna el nombre de la relación en la casilla Name.

37
Manual de Rational Rose Diagramas

3.5.5 Creación de nombres de roles en la relación.

1. Pulsar con el botón derecho ratón sobre una relación entre clases, previamente
existente en el extremo de la clase donde se desea insertar el rol.

2. Se selecciona Rol Name.

3. Esto creará un nombre de rol en el extremo de la relación y el cursor


permanecerá parpadeando en su interior.

4. Con el nombre de la relación todavía seleccionado introducir el nombre correcto


de la relación.

3.5.6 Indicadores de Multiplicidad

Aunque la multiplicidad esta definida para las clases, está define el número de
objetos que participan en una relación.

La cardinalidad o multiplicidad de una relación un UML aparece en los extremos


de la relación con la siguiente notación:

• Limite inferior .. Limite superior. Por ejemplo 1..6,0..6, 1..*

• Valor único, por ejemplo, 0,2

Para indicar la multiplicidad “ n “ es decir muchos, se puede sustituir tanto el valor


único como el límite superior por un asterisco.

1 Se pulsa con el botón derecho del ratón sobre una relación entre clases,
previamente existente, en el extremo de la clase donde se desea añadir la
multiplicidad.

2 Se selecciona Multiplicity, en el nuevo menú flotante se indica la multiplicidad.

3 Se repiten los pasos en el otro extremo de la relación.

Figura 3.5.6. Nombre, roles y Cardinalidad de la Relación

38
Manual de Rational Rose Diagramas

3.5.7 Relaciones Recursivas

1 Se selecciona el icono de relación de asociación en la barra de herramientas.

2 Se pulsa sobre la clase a la que se va añadir la relación recursiva y se arrastra el


ratón liberándolo fuera de la clase.

3 Se vuelve a pulsar con el ratón en el interior de la clase donde se desea crear la


relación recursiva.

Figura 3.5.7 Cardinalidad y Relación Recursiva

3.5.8 Navegabilidad de las Relaciones

Una relación recursiva es el ejemplo mas típico de una lista de objetos, de tal
manera que el primer objeto tendrá una referencia al segundo y este al tercero y así
sucesivamente hasta el final de la lista. Las listas suelen ser simplemente enlazadas
o doblemente enlazadas, de manera que la navegabilidad se pueda realizar en uno
o en otro sentido.

La navegabilidad se representa en UML como una punta de flecha en sentido


de la clase que pose la referencia a la otra. Si las dos clases poseen una referencia
entre si, en vez de aparecer una punta de flecha en cada extremo, como se podía
esperar, ningún extremo de la relación mostrará punta de flecha.

Para cambiar la navegabilidad a una relación se debe seguir la siguiente


secuencia de pasos:

1. Se pulsa con el botón derecho del ratón sobre una relación entre clases,
previamente existente en el extremo de la clase donde se desea modificar la
navegabilidad.

39
Manual de Rational Rose Diagramas

2. Pulsar sobre Navigable. Si la relación es Navegable estará marcada por el


símbolo√, en caso contrario no aparecerá ningún símbolo).

3.5.9 Relaciones cualificadas

Las relaciones cualificadas son aquellas que utilizan una clave de búsqueda
del objeto en el lado de la multiplicidad “muchos” de una asociación: El objeto fuente
junto con su valor cualificador se relacionan con sólo un objeto destino. (O conjunto
de objetos destino).

Supongamos que un objeto posee una relación a un conjunto de objetos de


otro tipo. Si las búsquedas en este conjunto de objetos se hacen siempre por un
valor concreto esto implica que se debe recorrer el conjunto de objetos hasta
encontrar el valor buscado. Si la relación estuviera cualificada por este valor, con
tener la clave de búsqueda nos permitiría acceder al objeto.

Como ejemplo si tenemos un objeto Tienda, que posee una serie de clientes,
estos pueden estar cualificados por su DNI, de tal manera que con conocer su clave
(DNI), nos permite acceder al resto de sus datos (Domicilio, nombre, apellidos, etc.).

Estas clases están implementadas en C++ por las clases map y multimap,
mientras en Java por la clase HasTable.

Si la relación esta cualificada, la clave o claves aparecen encerradas en un


rectángulo en el extremo que le corresponda.

Para crear una relación cualificada.

1 Se pulsa con el botón derecho del ratón sobre una relación entre clases,
previamente existente.

2 Se selecciona New Key/Qualifier.

3 Se modifica en el menú “Key Qualifier Specification for name” el parámetro


Name, introduciendo el nombre del parámetro.

4 Se modifica el menú “Key Qualifier Specification for name” el parámetro Type


indicando el tipo del parámetro contenido.

5 Se pulsa sobre el Botón OK para confirma los cambios

40
Manual de Rational Rose Diagramas

Figura 3.5.9 Relación Cualificada

3.5.10 Clases Asociación

Las clases asociación permiten modelar una asociación como una clase que
define las propiedades de la asociación. La clase asociación define atributos
descriptivos de la asociación de las clases que no pueden asignarse a una de las
clases de forma aislada. Representa con claridad el concepto de instancia de
asociación (Enlace).

Para crear una clase asociación se deben seguir los siguientes pasos:

1 Se añade al diagrama de clases la nueva clase asociación, como una clase


normal.

2 Se selecciona en la barra de herramientas el botón con una línea sólida


horizontal y una línea en diagonal a trazas .

3 Se pulsa con el botón derecho del ratón sobre una relación entre clases,
previamente existente.

4 Se arrastra el puntero del ratón y se libera sobre la clase relación.

Figura 3.5.10 Creación de una Clase Asociación

41
Manual de Rational Rose Diagramas

3.5.11 Generalización (Herencia)

La generalización es relación entre un elemento general (Llamado superclase


o Clase Padre) y un caso mas especifico de este elemento (Llamado clase hijo). La
generalización es con frecuencia llamada “Herencia”. La generalización significa que
los objetos hijos se pueden emplear en cualquier lugar donde se pueda emplear el
padre, pero no a la inversa, ya que los objetos hijos ofrecen más información que los
padres. Los objetos hijos heredan los atributos y métodos de su clase padre, a la la
que añade los propios, por eso se puede utilizar en el lugar de su clase padre pero
no a la inversa. Una operación de una clase hija con el mismo nombre que en la
clase padre redefine la operación del padre, esto se conoce como polimorfismo.

Para crear una relación de asociación se deben seguir los siguientes pasos:

1. Se pulsa con el ratón sobre el botón que representa un flecha con la punta con
un triángulo cerrado.

2. Se pulsa sobre la clase que es un caso particular de la clase mas general.

3. Se arrastra el ratón y se suelta sobre la clase general.

42
Manual de Rational Rose Diagramas

Para hacer que dos clases hereden de una misma clase padre y sólo se muestre
una línea de relación hacia la clase padre, (como en el siguiente dibujo) se debe
crear primero una relación y en la segunda relación se debe liberar el ratón dentro
del triángulo de la línea que define la generalización.

Figura 3.5.11 Representación de una generalización

43
Manual de Rational Rose Diagramas

4 Diagramas

4.1 Diagramas De Secuencia

Un diagrama de secuencia muestra interacciones de objetos dispuestos en


secuencia de tiempo. Se representan los objetos y las clases involucradas en el
escenario y la secuencia de mensajes intercambiados entre los objetos necesarios
para desarrollar la funcionalidad descrita en los caso de uso. Los diagramas de
secuencia están típicamente asociados con los casos de uso en el diseño del
sistema a desarrollar.

En el UML, un objeto en un diagrama de secuencia se dibuja como un


rectángulo que contiene el nombre del objeto, subrayado. Un objeto se puede
nombrar en uno de estos tres modos: el nombre del objeto, el nombre del objeto y su
clase o sólo el nombre de la clase (objeto anónimo).

Se pueden especificar los nombres de objetos (por ejemplo, los nombres de las
flores, Rosa, Tulipán, etc.) o pueden ser generales (por ejemplo, una flor sin
determinar). Lo normal es que los objetos anónimos se usen para representar un
objeto de la clase a la que pertenecen.

Cada objeto tiene su línea de tiempo representada por una línea trazada
debajo del objeto. Los mensajes entre objetos se representan por flechas desde el
objeto cliente (remitente del mensaje) al objetos servidor(destinatario del mensaje).

4.1.1 Creación de un diagrama de secuencia

1. Se pulsa con el botón derecho del ratón sobre el caso de uso al que se quiere
añadir el diagrama de secuencia para desplegar el menú contextual.

2. Se selecciona New: Sequence Diagram (diagrama nueva secuencia). Un nuevo


diagrama secuencia se añadirá árbol.

3. Con el nuevo diagrama de secuencia seleccionado, se introduce el nombre del


diagrama de secuencia.

44
Manual de Rational Rose Diagramas

Figura 4.1.1Creación de un diagrama de Secuencia

4.1.2 Creación de objetos y mensajes en el diagrama de secuencia

1. Se hace doble clic en el icono del diagrama de secuencia del árbol de la ventana
izquierda para abrir el diagrama.

2. Se pulsa sobre el icono de un nuevo objeto en la barra de herramientas.

3. Se pulsa sobre en la ventana el diagrama para colocar el nuevo objeto.

4. Mientras el objeto está todavía seleccionado se introduce el nombre del objeto.

5. Se repiten los pasos del 2 al 4 para tantos objetos como tenga el diagrama de
secuencia.

6. Se pulsa en la barra de Herramientas para seleccionar el icono de mensaje de


objeto (botón marcado como una flecha).

7. Pulsa sobre la línea de vida del objeto que envía el mensaje y arrastra la línea
del mensaje al de actor o objeto que reciba el mensaje.

8. Mientras la línea de mensaje está todavía seleccionada, introduce el nombre del


mensaje.

9. Repite los pasos 7 al 9 para cada mensaje del diagrama.

45
Manual de Rational Rose Diagramas

4.1.3 Asignación objetos en un diagrama de secuencia a las clases

1. Pulsa para seleccionar la clase a la que pertenece el objeto en el árbol.

2. Se arrastra la clase dentro del objeto en el diagrama de secuencia. Rose añadirá


el nombre de la clase precedido por “: “ al nombre del objeto. Si el objeto no
tiene nombre, el nombre será es “:nombre_clase”.

Figura 4.1.3 Representación de un Diagrama de Secuencia

4.1.4 Diagramas De Secuencias y Clases Interfaz

Las clases de interfaz se añaden a los diagramas de secuencia para mostrar


la interacción con el usuario o con otro sistema. En las primeras fases del análisis, el
propósito de mostrar las clases de interfaz en un diagrama de secuencia es para
capturar y documentar los requerimientos de las interfaces, no para mostrar como la
interface se va a implementar. Los mensajes desde el actor a la clase interfaz junto
con su información a intercambiar dependerá de la forma de implementación elegida
para el desarrollo.

46
Manual de Rational Rose Diagramas

4.1.5 Complejidad y Diagramas De Secuencia

Los diagramas de secuencia deben de ser simples, es más fácil ver los
objetos, las interacciones y los mensajes entre objetos y su funcionalidad obtenida
de los casos de uso.

En los diagrama de secuencia no se suele representar la lógica condicional


(toda la lógica if, then, else que existe en el mundo real). Si la lógica es simple, (que
represente sólo unos pocos mensajes) , se puede añadir al diagrama mediante
notas o aclaraciones para informar de las elecciones hechas, si por el contrario la
lógica es muy complicada o involucra a muchos mensajes, se deben dibujar varios
diagramas separados para cada una de las condiciones, de forma que los diagramas
sigan siendo simples.

4.2 Diagramas De Colaboración

Un diagrama de colaboración es un camino alternativo para mostrar un escenario


de un caso de uso. Este tipo de diagrama muestra las interacciones de objetos
organizadas alrededor de otros objetos y sus enlaces entre sí. Un diagrama de
colaboración contiene:

ƒ Objetos dibujados como rectángulos.

ƒ Enlaces entre objetos mostrados como líneas de conexión de los objetos unidos.

ƒ Mensajes mostrados como texto y una flecha que apunta desde el cliente al
suministrador.

4.2.1 Creación de diagramas de colaboración desde los diagramas de


secuencia

1. Se hace doble clic en el diagrama de secuencia para abrir la ventana.

2. Se elige pulsa la Opción de Menu Browse / Create Collaboration Diagram (crear


diagrama de colaboración) o se presiona F5.

3. Esto creará un nuevo diagrama de colaboración con los objetos existentes en el


diagrama de secuencia. Se colocan los objetos en el diagrama.

4. Se añaden nuevos objetos y mensajes en el diagrama, tantos como sean


necesarios.

Los diagramas de colaboración se pueden crear también desde el principio. En


este caso, el diagrama de secuencia se ha creado a partir del diagrama de
colaboración. Para crear un diagrama de colaboración desde el principio:

47
Manual de Rational Rose Diagramas

1. Se pulsa con el botón derecho del ratón sobre el Caso de uso al que se quiera
asociar el diagrama de colaboración para que se abra el menú contextual

2. Se selecciona la opción New / Collaboration Diagram (crear diagrama de


colaboración ).

3. Se hace doble clic en el diagrama colaboración para abrir la ventana.

4. Se añaden nuevos objetos y mensajes en el diagrama, tantos como sean


necesarios.

Figura 4.2.1 Representación de un Diagrama de Colaboración

4.3 ¿ Por qué hay dos tipos de Diagramas Diferentes?

Los diagramas de secuencia dan de un vistazo la secuencia de acciones que


transcurre en el tiempo, qué pasa primero, que pasa después. Los clientes pueden
leer fácilmente y entender este tipo de diagramas. Los diagramas de colaboración
tienden a dar una visión mayor de la colaboración entre los objetos, los enlaces y
relaciones entre estos.

48
Manual de Rational Rose Diagramas

4.4 Comportamiento Dinámico (Diagramas De Estado)

Los diagramas de casos de uso describen el comportamiento de los sistemas;


esto es, la interacción entre objetos en el sistema. Algunas veces es necesario
representar el comportamiento en el interior del objeto. Un diagrama de estados
muestra los estados de un objeto sencillo, los eventos o mensajes que causan una
transición desde un estado a otro, y las acciones que resultan de un cambio de
estado.

Los diagramas de estados no se deben crear para cada clase del sistema, sólo
se deben crear para las clases con un comportamiento dinámico significativo. Los
diagramas de interacción o de secuencia muestran el comportamiento dinámico del
sistema, los diagramas de estado el comportamiento dinámico de una sola clase.

4.4.1 Creación de diagramas de Estados

1. Se pulsa con el botón derecho sobre la clase a la que se desea agregar el


diagrama de estados y despliega el menú contextual.

2. Se selecciona el menú Statechar Diagram (diagrama de estado). Esto creará


automáticamente y abrirá el diagrama de estados.

4.4.2 Estados

Un estado es una condición durante la vida de un objeto cuando satisface


alguna condición, desarrolla alguna acción, o espera para un evento. El estado de
un objeto debería estar caracterizado por el valor de uno o más de los atributos de la
clase. Adicionalmente, un estado de un objeto puede ser caracterizado por la
existencia de un enlace a otro objeto. Así, los estados de un objeto se deben buscar
mediante el examen de los atributos y enlaces definidos para el objeto.

Figura 4.2.2 Representación de un Estado

Un diagrama de transición de estados abarca todos los mensajes que un objeto


puede enviar y recibir. El intervalo entre dos mensajes enviados por un objeto
representa un estado. Por esto, los diagramas de secuencia se deben estudiar para
descubrir los estados en los que puede estar un objeto.

4.4.2.1 Creación de estados

1. Se pulsa para seleccionar un estado de la barra de herramientas

2. Se pulsa sobre el diagrama de estados donde se desea colocar el estado.

49
Manual de Rational Rose Diagramas

3. Con el estado todavía seleccionado, se introduce el nombre del estado.

4.4.2.2 Transiciones De Estado

Una transición de estado representa un cambio desde un estado original a un


estado posterior (este podría ser el mismo que el estado original). Las transiciones
de estado suelen ser provocadas por Acciones.

Hay dos maneras para que se produzca una transición de estado; automático y no
automático. Una transición de estado automática ocurre cuando la actividad de un
estado se completa ( El evento no tiene un nombre asociado a la transición de
estado). Una transición de estado no automática es causada por la llegada de un
evento (desde otro objeto o desde fuera del sistema). Ambos tipos de transiciones
de estado se consideran que transcurren en un tiempo cero y no se pueden
interrumpir (Operación Atómica). Una transición de estado se representa por una
flecha que apunta desde el estado original al estado sucesor.

3.1.2 Creación de transiciones de estado

1. Se pulsa con el ratón sobre la barra de herramientas para seleccionar el icono de


transición ( un flecha).

2. Se pulsa con el ratón sobre el estado origen de la transición.

3. Arrastra el ratón hasta el estado final de la transición.

4. Si la transición de estado se produce por la llegada de un evento, se introduce el


nombre del evento mientras la flecha de transición de estado está todavía
seleccionada.

4.4.2.3 Estados Especiales

Hay dos tipos de estados especiales que se pueden añadir a un diagrama de


transición de estado. El primero es un estado de Inicio (start state). Cada diagrama
debe tener uno y sólo un estado de Inicio que debe ser un estado estable cuando se
crea el objeto. La notación UML para un estado de inicio es un circulo pequeño
relleno negro. El segundo estado especial es un estado de parada (stop state). La
notación UML para un estado de parada es un ojo de buey.

Figura 4.4.2.3 Representación de los Estados de Inicio y Parada

50
Manual de Rational Rose Diagramas

4.4.2.4 Creación estados de inicio (start) y parada (Stop)

1. Se pulsa con el ratón sobre el icono start (inicio) de la barra de herramientas.

2. Se pulsa con el ratón sobre diagrama estados para dibujar el icono start.

3. Se pulsa con el ratón sobre el icono de transición de estados de las herramientas


(Una flecha).

4. Pulsa en el icono start (inicio) y arrastra la flecha al estado deseado.

5. Se repite la misma secuencia de pasos con el icono stop. (En este caso el es un
estado final, por lo que será un estado destino de una transición)

Figura 4.4.2.4 Representación del Diagrama de Estados de un Pedido

51
Manual de Rational Rose Diagramas

4.4.3 Detalles De La Transición De Estados

Una transición de estado podría tener una acción y/o una condición de aviso
asociada a ella y sería también un disparador o evento. Una acción es el
comportamiento que se produce cuando sucede un cambio de estado. Un evento es
un mensaje que se envía a otro objeto en el sistema. Una condición de alerta es una
expresión booleana de valores atribuidos que permite la transición de estado sólo si
la condición es cierta. Ambas, acciones y alertas son comportamientos del objeto y
se suelen convertir en operaciones. A menudo estas operaciones son privadas (sólo
se pueden usar por el propio objeto).

Para introducir detalles a una transición de estado se deben seguir los siguientes
pasos:

1. Se pulsa con el botón derecho sobre la flecha de transición de estado para


desplegar el menú flotante.

2. Se selecciona la opción Specification (especificación).

3. Se selecciona la pestaña Detail (detalle).

4. Se introduce la acción, aviso y/o evento a enviar.

5. Se pulsar el botón OK para cerrar la especificación.

4.4.4 Detalles Del Estado

Las acciones que acompañan todas las transiciones de un estado a otro se


deben colocar como una acción entrante en el estado. Así mismo, las acciones que
producen una transición fuera del estado se deberían representar como acciones de
salida. El comportamiento que ocurre dentro del estado se llama actividad. La
actividad de un estado comienza cuando se produce el evento que da origen a la
transición al estado y finaliza al producirse un nuevo evento que produce el cambio
de estado. El comportamiento de una actividad debería ser una acción simple o
enviar un evento a otro objeto. Igual que las acciones y alertas este es
comportamiento es típico de las operaciones de un objeto.

4.4.5 Creación de acciones entrantes, acciones salientes y actividades

1. Se pulsa con el botón derecho en el estado para desplegar el menú contextual.

2. Se selecciona la opción de menú Specification (especificación).

52
Manual de Rational Rose Diagramas

3. Se selecciona la pestaña Detail (detalle).

4. Se pulsa con el botón en el campo (Action) para hacer visible el menú contextual.

5. Se selecciona el menú Insert (insertar). Este creará una acción llamada entry
(entrada).

6. Se hace doble clic en entry para hacer visible la especificación de la acción (


Action Specification ).

7. Se selecciona el tipo de acción (simple o enviar evento).

8. Se introduce la información de la acción o del evento a enviar.

9. Se selecciona cuando la acción debe ocurrir.

10. Se pulsa el botón OK para cerrar la Especificación de acción.

11. Se pulsa el botón OK para cerrar la Especificación de estado.

53
Manual de Rational Rose La Vista De Componentes

5 La Vista De Componentes

En esta vista se muestra la arquitectura actual de módulo software. En otras


palabras en que componentes se va a implementar cada una de las clases
representada en la vista Lógica. La vista de componentes o de arquitectura tiene por
misión facilitar el desarrollo, el manejo de los módulos software, la reutilización del
software y las restricciones impuestas por los lenguajes de programación y las
herramientas de desarrollo. Los elementos modelados en la vista de componentes o
arquitectura son paquetes y componentes junto con sus conexiones.

Un paquete en la vista de arquitectura representa una división física del sistema.


Los paquetes de la vista de componente son a menudo llamados subsistemas. Los
paquetes están organizados en una jerarquía de capas donde cada capa tiene una
interface bien definida.

La notación UML para un paquete en visión de componente es la misma que un


paquete en la Logical View (vista lógica).

Figura 5.1 Representación de una clase Utilidad

5.1.1 Creación de paquetes en la vista de componentes

1. Se pulsa el botón derecho para seleccionar la carpeta Component View (visión


de componente) en el árbol de la ventana izquierda y se despliega el submenú.

2. Selecciona el menú New: Package (nuevo: paquete). Esto añadirá un nuevo


paquete llamado NewPackage (nuevo paquete) en el árbol de la ventana
izquierda.

3. Con el New Package (nuevo paquete) todavía seleccionado, se introduce el


nombre del paquete.

El Diagrama principal de la vista de componente es una representación de los


paquetes (subsistemas) definidos para el sistema.

54
Manual de Rational Rose La Vista De Componentes

5.1.2 Creación de diagrama principal de componentes

1. Se hace doble clic en el Main Diagram (diagrama principal) en la carpeta


Component View (Vista de componentes) en el árbol de ventana izquierda para
abrir el diagrama.

2. Se pulsa sobre un paquete y se arrastra el paquete en el diagrama.

3. Se repita el paso 2 para cada paquete adicional.

4. Se establecen las relaciones entre los paquetes, Se pulsa con el ratón sobre el
botón para seleccionar el elemento.

5. Se pulsa sobre el paquete cliente, se arrastra el ratón y se libera sobre el


paquete servidor.

Dependiendo el tipo de leguaje que vallamos a implementar se suelen utilizar unos


símbolos para los componentes, estos son los más utilizados:

Puntero de ratón normal, permite la selección de los elementos ya


existentes en el diagrama de casos de uso.

Anade un texto o etiqueta al diagrama de Clases.

Añade una nota de texto al diagrama de clases. La nota puede estar


asociada al diagrama o a un elemento en particular.

Establece una relación entre una nota de texto y un elemento. La nota y


el elemento con el que se establece la relación deben estar previamente
en el diagrama.

Añade un paquete al diagrama. Los paquetes son agrupaciones de


objetos, se pueden definir paquete de casos de uso , de clases de
componentes, etc.

Establece una relación o dependencia entre paquetes o componentes.

Componente de declaración de una clase C++.

Componente de implementación de una clase C++.

Componente de implementación de una clase Java.

Componente de declaraciones de funciones globales.

55
Manual de Rational Rose La Vista De Componentes

Componente que implementa funciones globales.

Componente que implementa una función Main

Las relaciones de dependencia se añaden mediante la selección del icono


marcado como una flecha de líneas discontinuas en la barra de herramientas,
pulsando en el paquete que representa al cliente y arrastrando la flecha al paquete
que representa al servidor.

La información de la Logical View (Vista lógica) del modelo, por lo general


deber estar conectada a la información de la Component View del modelo mediante
un mapeo lógico entre los paquetes que componen cada una de las vistas. En
general, un paquete de la vista lógica se corresponde directamente a un paquete de
la vista de componentes. Sin embargo, hay algunas veces no es posible realizar un
mapeo de uno a uno entre los paquetes de la vista lógica y de componentes.
Algunas de las razones para esto son: un paquete lógico podría estar dividido en
varios (desarrollado por diferentes equipos de desarrollo); paquetes lógicos se
pueden unir para establecer una comunicación más directa entre sus objetos y
finalmente se pueden añadir paquetes para implantar funcionalidades de bajo nivel
no representadas durante el análisis (por ejemplo, comunicación para sistemas
distribuidos).

5.2 Componentes de código fuente

En la vista de componentes del modelo, un componente representa un archivo


software que pertenece a un paquete (subsistema). El tipo de archivo es
dependiente del lenguaje (por ejemplo, en C++, los componentes de software se
representan por archivos .h y .cpp, en Java se representan por archivos .java y en
PowerBuilder, por .pbl). Las clases en la vista lógica se mapean sobre los
componentes en la vista de componente. Normalmente este mapeo se realiza una
clase por componente, Sin embargo, hay veces que más que una clase estará
mapea a más de un componente. En Java es obligatorio que cada clase esté
implementada en un fichero con el mismo nombre que la clase, sin embargo en C++
esto no es necesario, pero normalmente el mapeo se hace de una clase sobre dos
componentes, el fichero de cabecera y el de implantación. Se pueden asociar varias
clases a un mismo componente cuando existe acoplamiento de clases o relaciones
de dependencia circulares.

56
Manual de Rational Rose La Vista De Componentes

5.3 Asignación de Clases a Componentes

5.3.1 Creación de Componentes

1. Se abre el diagrama de componentes.

2. Se pulsa sobre el icono del tipo de componente a generar.

3. Se pulsa en el diagrama para colocar el componente. El componente también se


añadirá al árbol de la ventana izquierda.

4. Mientras el componente está seleccionada, introduce el nombre del componente


(Se debe tener en cuenta el nombre de la implementación software).

5.3.2 Asignación de Clases a un Componente

1. Se pulsa con el botón derecho sobre el componente para que se muestre el


menú contextual.

2. Se selecciona el menú Open Specification (Abrir Especificación).

3. Se Selecciona la pestaña General.

4. Se seleccionar el lenguaje de programación de los que aparecen en la lista


desplegable (Language).

5. Se pulsa el botón Apply para validar lo cambios.

6. Se selecciona la pestaña Realizes.

7. Se pulsar con el botón derecho sobre la clase a asignar para que se despliegue
el submenú.

8. Se selecciona el menú Assign (asignación).

9. Se repinten los pasos 7 y 8 por cada clase a asignar al mismo componente.


Normalmente sólo se debe asignar una clase a un componente a no ser que
existan dependencias circulares o una muy estrecha relación.

10. Se pulsa el botón OK para cerrar la especificación.

57
Manual de Rational Rose La Vista De Componentes

Figura 5.3 Asignación de un componente a una clase

Si el lenguaje asignado es C++ se suelen asignar dos componentes software


a la misma clase, el archivo de cabecera y el de implementación (*.h, *.cpp). Por el
contrario si el lenguaje asignado es Java, tan sólo se suele asignar un componente.

Cuando el lenguaje asignado es Java, a partir del momento de la asignación el


dialogo de especificación por defecto habrá cambiado a uno particular para código
Java. Si se desea abrir el dialogo de Especificación Estándar abra que indicarlo
expresamente en el menú contextual.

58
Manual de Rational Rose Generación de Código en C++

6 Generación de Código en C++


En este capitulo se pretende dar unos conceptos generales para modificar y
configurar las propiedades de generación de código en C++ de Rational Rose, sin
entrar en detalles específicos debido a la infinidad de parámetros configurables
existente.

Pasos de generación de código:

1. Creación de las Plantillas de Propiedades del Código necesarias.

2. Creación de los Componentes a los que asignar el Código Fuente en el diagrama


de componentes o arquitectura.

3. Enlace de las Plantillas de Propiedades del código a las clases.

4. Selección de los Componentes y Generación del código.

5. Evaluación del Código generado (Errores y Warning en la generación de código)

6.1 Creación de la Plantillas de Generación de Código

Hay unas plantillas de propiedades de generación de código asociadas con el


proyecto, con las clases, con los roles, con los atributos y con operaciones. Las
plantillas de propiedades aplicadas al proyecto, se refieren a los nombres de
archivos, los nombre por defecto de las clases contenedoras, y colocación del
código generado. Las propiedades de las clases se refieren la generación de los
constructores, destructores, constructores copia, operadores de igualdad y diferencia
así como la generación de las funciones para obtener las variables el valor de las
variables de la clase (funciones get/set). Las propiedades de los roles tratan del
formato de generación de las funciones get/set la visibilidad de los métodos y las
clases contenedoras usadas. Las propiedades de las operaciones se refiere al tipo
de operación (normal, virtual, abstracta, estática, o friend). Las hojas de propiedades
estándar se pueden modificar así como crear nuevas hojas de propiedades para
especificar las características de C++ necesarias para el proyecto. Para cada clase
se generan dos tipos de archivos, un archivo de cabeceras (.h) y uno de
implementación (.cpp).

Para un proyecto típico, hay pocas personas encargadas de la creación de las


plantillas de generación de código que usarán el resto del equipo de desarrollo. Esto
permite que todos los desarrolladores generen el código con unas propiedades
comunes. Algunas plantillas de propiedades típicas son: Clase con Destructor Virtual
Clase Abstracta, funciones estáticas, la no generación de la las funciones get y set
para los atributos de la clase, retorno de parámetros por referencia.

59
Manual de Rational Rose Generación de Código en C++

Creación de plantillas de propiedades

1. Se selecciona en el menú Tools: Options (herramientas: opciones).

2. Se selecciona la pestaña del Lenguaje a Implementar (C++)

3. Se pulsa la flecha en el campo Type (tipo) para desplegar el submenú.

4. Se selecciona el tipo de plantillas de propiedades a modificar.

5. Se pulsa el botón Clone (Clonar) que mostrará la ventana Clone Property Set.

6. Se introduce el nombre de la nueva plantilla de propiedades, en la ventana


anterior

7. Se pulsa el botón OK para cerrar la ventana Clone Property Set.

8. Se pulsa sobre la propiedad a modificar, para seleccionarla.

1. Se modifica el valor de la propiedad al valor deseado de los que aparecen en la


lista desplegable, o se introduce un nuevo valor si el campo lo permite.

9. Se repiten los pasos 8 y 9 por cada propiedad a cambiar.

10. Se pulsa el botón Apply (aplicar) para validar los cambios.

11. Se repite los pasos precedentes para cada plantilla de propiedades a modificar o
clonar.

12. Se pulsa OK para cerrar la Ventana Options (opciones).

Un parámetro que suele ser muy conveniente cambiar en cualquier proyecto es


el valor del campo Directory, el cual indica el directorio base a partir del cual se
empezarán a generar los ficheros asociados a los componentes. Este aparece
mostrado en la siguiente figura. Este se puede asociar a su vez a una variable, de tal
manera que esta variable pueda estar definida con valores diferentes para cada
desarrollador que participe en el proyecto, sin embargo las plantilla de generación de
código siguen siendo comunes.

Las variables locales para el mapeo de los directorios de generación de código


se encuentran definidas en el diálogo que aparece en la opción de menú File / Edit
Map Path.

60
Manual de Rational Rose Generación de Código en C++

Figura 6.1 Ventana de Parámetros de Generación de Código

6.2 Creación de Componentes de Código Fuente.

Si una clase está mapeada a un componente, Rational Rose generará código


basado en el tipo presente en el diagrama. Si hay un solo componente que
representa el archivo de cabecera, Rose generará sólo un archivo .h que contendrá
la información definida para la clase. Si por el contrario sólo existe el componente
correspondiente al fichero de implementación, sólo se generará un archivo .cpp que
contendrá la el esqueleto de las funciones y métodos declarados en la clase. Si la
clase se encuentra mapeada a ambos componentes, se generarán ambos fichero,
pero no se generarán las relaciones entre ellos a no ser que se haya realizado
expresamente en el diagrama, es decir el componente de implementación tendrá
una relación al componente de especificación

61
Manual de Rational Rose Generación de Código en C++

Figura 6.2 Componentes de Código y Relaciones entre ficheros

6.2.1 Creación de Componentes de Implementación

1. Se hace doble clic en la carpeta del diagrama de componentes, para abrir el


diagrama.

2. Se pulsa sobre la barra de herramientas para seleccionar el componente del


fichero de implementación (Package Body).

3. Se pulsa para colocar el componente en el diagrama.

4. Mientras el componente está todavía seleccionado, se introduce el nombre del


componente, normalmente este debe ser el mismo nombre que el componente
(fichero) de cabecera, pero la aplicación mostrará un mensaje de aviso para
informando de que existe otro componente con el mimo nombre.

5. Se pulsa sobre la barra de herramientas para seleccionar el componente del


fichero de Cabeceras (NewPackageSpec).

6. Se repiten los pasos 3 y 4 para colocar el elemento en el diagrama.

62
Manual de Rational Rose Generación de Código en C++

7. Se pulsa para seleccionar el icono de dependencia en la barra de herramientas


.

8. Se pulsa sobre el componente de implementación en el diagrama y se arrastra la


en ratón hasta el componente de cabecera, para crear una dependencia entre
ambos.

6.2.2 Asignación de Componentes a una clase

Al igual que es posible la asignación de una clase a un componente es posible a


la inversa, es decir asignar un componente a una clase, en realidad existe una
dualidad que no puede ser ignorada, por lo que el mapeo puede hacerse en los dos
sentidos.

1. Se pulsa con el botón derecho sobre la clase para que se muestre el menú
contextual, o se hace doble clic sobre esta.

2. Se selecciona el menú Open Specification (Abrir Especificación).

3. Se Selecciona la pestaña General.

4. Se selecciona el lenguaje de programación (C++) de los que aparecen en la lista


desplegable (Language).

5. Se pulsa el botón Apply para validar lo cambios.

6. Se selecciona la pestaña Components.

7. Se pulsa con el botón derecho sobre el componente que se desea asignar a la


clase para que se despliegue el submenú.

8. Se selecciona la opción de menú Assign (asignación).

9. Se repiten los pasos 7 y 8 por cada componente a asignar a la clase.


(Normalmente los ficheros de cabecera e implementación)

10. Se pulsa el botón OK para cerrar la especificación.

63
Manual de Rational Rose Generación de Código en C++

Figura 6.3 Asignación de dos Componentes a una Clase

6.3 Enlace de las hojas de propiedades a las clases.

Se debe estudiar que tipo de plantilla de propiedades le corresponde a cada


clase. Si la plantilla se ajusta perfectamente a las necesidades de la clase, esta se
puede asignar sin modificaciones. De no ser cierto se deben crear nuevas plantillas
o modificar la propiedades particulares de la clase.

Enlace de una plantilla de propiedades a un elemento seleccionado en Rational


Rose

1. Se pulsa con el botón derecho para seleccionar la clase o el componente en el


árbol de la ventana izquierda o sobre el diagrama y despliega el submenú.

2. Se selecciona en el menú Open Specification (Abrir la especificación).

3. Si previamente no se ha asignado el lenguaje C++ se selecciona este de la lista


desplegable Languaje en la pestaña General.

64
Manual de Rational Rose Generación de Código en C++

4. Se pulsa el botón Apply, para validar los cambios. Esto creará una nueva
pestaña, con nombre C++, si no estaba creada al no tener lenguaje de
programación asignado.

5. Se selecciona la pestaña C++.

6. Se pulsa sobre la flecha en el campo Set para abrir la lista desplegable.

7. Se selecciona la plantilla de propiedades deseada.

8. Se pulsa OK para cerrar la especificación.

Si las propiedades de la clase no difieren en gran medida de la de la plantilla, no


es necesario crear una hoja de propiedades particular para la clase, las propiedades
de cada clase se pueden modificar de manera independiente, sin modificar los
parámetros generales de la plantilla y sin afectar a las demás clases que tengan esta
plantilla asignada.

Modificación de las propiedades de un Clase

1. Se pulsa con el botón derecho para seleccionar la clase en el árbol de la ventana


izquierda o en un diagrama y despliega el submenú.

2. Se selecciona la opción del menú Open Specification (Abrir especificación).

3. Selecciona la pestaña C++.

4. Se pulsa la flecha en el campo Set para desplegar la lista de plantillas existentes.

5. Se selecciona la plantilla de propiedades deseada.

6. Se pulsa sobre la propiedad a modificar, para seleccionarla.

7. Se modifica el valor de la propiedad al valor deseado de los que aparecen en la


lista desplegable, o se introduce un nuevo valor si el campo lo permite.

8. Se repiten los pasos 7 a 8 para cada propiedad a modificar.

9. Se pulsa el botón OK para cerrar la especificación de la clase.

65
Manual de Rational Rose Generación de Código en C++

Figura 6.4 Cambio de las propiedades de generación del Destructor

6.4 Seleccionar los componentes y generar el código

El código se puede generar para un paquete entero, para una clase, o un


conjunto de clases. Si una clase no está mapeada a un componente, el nombre de la
clase se utilizará para generar el nombre del archivo que contiene el código. El
código se generará en una estructura de directorios igual a los nombres de los
paquetes en la vista lógica. Si la clase se encuentra mapeada a un componente, el
nombre del componente se usará para generar el nombre del archivo que contiene
el código y el fichero con el código se crear en una estructura de directorios que se
corresponderá con los nombres de los paquetes en la vista de componentes.
Generación de código en Rational Rose
1. Se pulsa para seleccionar el paquete, la clase o conjunto de clases a generar.

2. Se pulsa menú Tools / C++ / Code Generation o pulsar con el botón derecho
sobre la clase y se selecciona C++ / Code Generation.

66
Manual de Rational Rose Generación de Código en C++

3. Se de desplegará la ventana Code Generation Status en la que mostrará la


información sobre los errores y avisos producidos durante la generación de
código.

4. Se evalúan y corrigen los errores producidos en la generación de código

Figura 6.5 Pantalla de la información del código Generado

Rose escribe todos los avisos y errores a la ventana Log. Si parte del diseño
de la clase no está completo, escribirá un mensaje de aviso y usará un valor por
defecto, y los defectos son tan graves que no puede asignar valores por defecto
generará mensajes de error.

Los avisos y errores más comunes en la generación de código son:

• La falta de asignación del tipo de dato en los atributos de la clase, por defecto
asigna de tipo void.

• La falta de asignación de la cardinalidad en las relaciones, por defecto asigna


cardinalidad 1.

• La falta del tipo de atributos retornado en las funciones, por defecto asigna tipo
void.

67
Ingeniería Inversa usando el
Manual de Rational Rose analizador de código C++

7 Ingeniería Inversa usando el analizador de código C++


7.1 Creación de un proyecto

Un proyecto del analizador de Código C++ contiene la información necesaria


para extraer y crear un diseño UML de los archivos de código fuente. Un proyecto
del analizador contiene la siguiente información:

• Caption: Titulo descriptivo del proyecto.

• Directories: Lista de los directorios usados por el analizador (Los directorios que
contienen el código fuente, y los directorios que contienen otros ficheros que
aunque no se vayan a analizar sean usados mediante directivas #include por los
ficheros de código a analizar).

• Extensions: Lista de las extensiones de los archivos reconocidas por el


analizador.

• Files: Lista de archivos a analizar.

• Defined Symbols and Undefined Symbols: Lista de símbolos definidos por el


preprocesador y sus extensiones.

• Categories: Lista de paquetes a los cuales se deben asignar las clases


generadas.

• Subsystems: Lista de paquetes a los cuales componentes y paquetes se


deberían asignar.

• Bases: Lista de proyectos base (Previamente analizados, equivalente a librerías


en código) que contienen la información necesaria para resolver los archivos
código fuente.

• Type 2 Context: Directrices del preprocesador necesarias por los archivos de


código fuente.

• Export Options: Lista de la información a exportar, para crear o actualizar el


modelo Rose, la posición de los comentarios, cabeceras, y demás parámetros sin
efecto en el código pero que se incluye en los ficheros.

68
Ingeniería Inversa usando el
Manual de Rational Rose analizador de código C++

Figura 7.1 Pantalla del Analizador de Código.

Si no están visibles todas las opciones, es porque se encuentra activado la


opción de visualización Simple, de forma que tan sólo se muestran las opciones más
importantes. Para hacer visible todos los parámetros pulsar la opción de menú View
/ Full.

7.1.1 Creación de un proyecto en el analizador de C++

1. Se selecciona el menú: Tools / C++ / Reverse Engineering. Esto abrirá un


módulo aparte de la aplicación Rational Rose. Este módulo se puede abrir fuera
de la aplicación de Rational (muy útil, cuando el equipo no dispone de suficientes
recursos) a través de los menús del sistema operativo Inicio / Programas
/Rational Rose 2000 / C ++ Analyzer.

2. Se selecciona el menú File / New (Archivo: Nuevo).

7.2 Añadir un Titulo al proyecto

Al igual que el código debe estar documentado para un uso futuro, los
proyectos del analizador también deberían estar documentados. Cada proyecto
deberá contener un Titulo. Este es una información descriptiva acerca del proyecto
(como su título y propósito). El tituló será usado por otros equipos de desarrollo para

69
Ingeniería Inversa usando el
Manual de Rational Rose analizador de código C++

determinar si el proyecto el potencialmente reutilizable, bien como un proyecto único


o como proyecto base de otros proyectos.

7.2.1 Añadir un Titulo en el analizador de C++

1. Se pulse el botón Caption para hacer visible la ventana de titulo.

2. Se introduce la información en la ventana Caption.

3. Se pulsa OK para cerrar la ventana Caption.

Figura 7.2 Pantalla de Creación del titulo de un proyecto.

7.3 Añadir directorios, librerías de referencia o proyectos base

La lista de directorios contiene una lista de los directorios usados por el


analizador C++. Si un directorio que contiene un archivo que se debe analizar, este
directorio debe estar en la lista de directorios. Además, el directorio de los ficheros
de include del proyecto a analizar también debe ser añadido a la lista de directorios.

7.3.1 Creación de la lista de directorios en el analizador de C++

1. Se pulsa el botón Directories (Directorios) para que se muestre la ventana Project


Directory List (Lista de directorios del proyecto).

2. Se navega por el árbol de la ventana titulado Directory Structure (Estructura de


directorio) para seleccionar el directorio a añadir.

3. Se pulsa el botón Add Current para añadir el directorio actual a la lista de


directorios.

4. Se Pulsa el botón Add Subdirs (Añadir subdirectorios) para añadir el directorio


actual y sus subdirectorios inmediatos en la lista de directorios.

5. Se pulsa el botón Add Hierarchy (Añadir jerarquía) para añadir el directorio actual
y todos sus subdirectorios en la lista de directorios.

70
Ingeniería Inversa usando el
Manual de Rational Rose analizador de código C++

6. Se repinten los pasos 2 al 5 para todos aquellos directorios que se desean añadir
al proyecto.

Figura 7.3 Añadir directorios de referencia a un proyecto.

Un proyecto del analizador podría usar información de otro proyecto, llamado


proyecto base. Los proyectos bases contienen información sobre otros archivos de
cabecera, librerías especificas del compilador o librerías de clases de otros
proveedores con las cuales se construyo el proyecto. Para no tener que realizar la
ingeniería inversa de estas librerías para todos los proyectos que utilicen estas
clases, una vez de analizada por primera vez esta información se debe crear un
proyecto base. El proyecto base podrá entonces ser usado por otros proyectos que
necesiten la información de los archivos del proyecto base, sin necesidad de repetir
el proceso.

Los proyectos base se identifican en la lista de proyectos base.

71
Ingeniería Inversa usando el
Manual de Rational Rose analizador de código C++

Si el analizador no puede encontrar un archivo en la lista de directorios del


proyecto lo buscará el archivo de un proyecto base. Los ficheros en los proyectos
base se buscan en el mismo orden en el que aparecen los proyectos base en la lista.

7.3.2 Añadir proyectos base en el analizador de C++

1. Se pulsa el botón Bases para que se muestre la ventana Base Projects.

2. Se navega por el árbol de la ventana titulado Directories hasta que el proyecto


deseado se muestre en la caja de texto File Name.

3. Se pulsa para seleccionar el proyecto.

4. Se pulsa el botón Add (añadir) para añadir un proyecto base.

Figura 7.4 Añadir un proyecto base (Microsoft Fundations Class 4.2) .

72
Ingeniería Inversa usando el
Manual de Rational Rose analizador de código C++

7.4 Añadir los Archivos a analizar y sus tipos de archivo

El analizador cataloga los archivos en tres diferentes tipos; Tipo 1, Tipo 2 y Tipo 3.

Tipo 1: Cuando se añade un archivo al proyecto, este se añadirá siempre de tipo


1. Este tipo de archivo es sintácticamente completo y de contexto
independiente; ósea, el archivo contiene su propia lista de declaraciones
en C++ o es capaz de obtener ellas de sus directivas #include.

Un archivo de tipo 1 es analizado cuando aparece en la lista de ficheros o


cuando este es incluido por otro fichero, siendo analizado cada vez que
aparece.

Tipo 2: Un archivo Tipo 2 es completo sintácticamente pero de contexto


dependiente; ósea, el archivo contiene una lista de declaraciones
completas en C++, pero el archivo contiene símbolos cuyas definiciones
están definidas en el contexto donde sean incluidas (otros ficheros).

Tipo 3: Un archivo Tipo 3 es sintácticamente incompleto.

7.4.1 Añadir los archivos a analizar

1. Se pulsa el botón Files (Archivos) para que se muestre la ventana Project Files
(Ficheros del proyecto).

2. Se navega por el árbol de la ventana titulado Directory Structure (Estructura de


directorio) para seleccionar el directorio donde se encuentran los ficheros

3. Se pulsa el botón Add All para añadir todos los ficheros del directorio al proyecto.

4. Se selecciona uno o varios ficheros y se pulsa el botón Add Selected (Añadir


seleccionado) para añadir los ficheros seleccionados.

73
Ingeniería Inversa usando el
Manual de Rational Rose analizador de código C++

Figura 7.5 Añadir Archivos a un proyecto.

7.4.2 Cambiar el tipo de análisis en el analizador de C++

1. Se pulsa para seleccionar el archivo en la lista de archivos.

2. Se pulsa para seleccionar el tipo apropiado desde el menú Action / Set Type.

3. Es posible cambiar el tipo de archivo utilizando los botones de la barra de


herramientas marcados como 1,2,3.

El analizador de C++ puede procesar un único archivo o un grupo de archivos. El


analizador crea y almacena información del análisis en un archivo de datos para
cada archivo que procesa. Este archivo de datos es utilizado la próxima vez que el
archivo es analizado. El estado de cada archivo se actualiza en la lista de archivos
cuando un archivo se procesa.

El estado de los archivos puede ser:

Analyzed: (Analizado) Análisis satisfactorio; este estado se aplica sólo a los


archivos código fuente Tipo 1 y Tipo 2.

CodeCycled: Análisis satisfactorio. Rational modifica el código original y añade los


comentarios y marchas para permitir la modificación y actualización
del modelo. Este estado sólo se aplica a archivos código Tipo 1 y

74
Ingeniería Inversa usando el
Manual de Rational Rose analizador de código C++

Tipo 2.

Excluded: (Excluido) Es un archivo Tipo 3, que es analizado cada vez que es


incluido por otro archivo.

Has errors: (Tiene errores) Encuentra errores en el archivo de código mientras lo


analiza. No ha sido analizado completamente.

No source: (No-fuente): No se ha podido encontrar el archivo a analizar en el


sistema.

Unanalyzed: (No Analizado): No se encuentra el fichero de datos para este


archivo.

Stale data: (Fichero desactualizado). Se ha encontrado un fichero de datos


desactualizado para este archivo. Este estado sólo se puede fijar
mediante el comando Update Status.

Unknown: (Desconocido) No se ha actualizado el fichero fuente desde que se


añadió al proyecto, o no se ha actualizado el fichero desde que se
abrió el proyecto.

7.4.3 Analizar archivos en el analizador de C++

1. Se establece el tipo de análisis para cada fichero a analizar. (Analysis Type).

2. Se pulsa con el ratón para seleccionar los ficheros a analizar. Si se mantiene


pulsada la tecla Control, se pueden seleccionar varios archivos a analizar. Si se
pulsa la tecla Mayúsculas, se seleccionan los archivos comprendidos entre el
anteriormente seleccionado y sobre el que se pulsa con el ratón.

3. Pulsa el menú Action / Analyze para analizar los archivos, o selecciona el menú
Action / Code Cycle para analizar el archivo y asegurar que Rational modifica los
archivos originales y añade los comentarios y marcas necesarias para permitir la
modificación y actualización del modelo.

75
Ingeniería Inversa usando el
Manual de Rational Rose analizador de código C++

Figura 7.6 Estado después del análisis.

7.5 Evaluación de errores

El analizador escribe todos los errores en la ventana Log. Los errores también
se pueden visualizar en la lista de archivos, haciendo un doble clic en el archivo que
indica que posee errores. Cada error se debe evaluar con la severidad que
corresponde, la existencia de errores no indica que no se haya realizado el análisis
del código tan sólo que no se ha extraído toda la información que el fichero contiene.

Algunos de los errores más comunes son:

Unresolved references: (referencias no resueltas): el analizador no puede


encontrar los archivos fuentes referenciados en los #include. Para resolver este tipo
de error, el directorio que contiene el archivo fuente se debe añadir a la lista de
directorios.

Context-sensitive source files: El código de otro directorio esta referenciados pero


no se ha incluido en el archivo. Se resuelve, cambiando el archivo al Tipo 2 o Tipo 3.

76
Ingeniería Inversa usando el
Manual de Rational Rose analizador de código C++

7.6 Selección de las opciones de exportación y exportar el Modelo

Las opciones de exportación especifican que elementos se deben modelar y dibujar


en el exportado. Por ejemplo, una clase puede ser modelada y dibujada, los
comentarios pueden ser añadidos, las asociaciones pueden ser modeladas y
dibujadas, y las relaciones de dependencia pueden ser modeladas. Si un elemento
es modelado y dibujado, será visible en el modelo Rose actualizado o creado. Si un
elemento es modelado, puede ser dibujado con Rose una vez que el modelo Rose
ha sido creado o actualizado. Si no es modelado, entonces nunca podrá ser dibujado
en Rose.

El analizador C++ tiene múltiples de opciones con las propiedades de exportación.


Estas son:

Round_trip: Esta opción de exportación se usa cuando se modifican clases,


funciones o métodos en la fase de implantación del código, que forma
al hacer la ingeniería inversa se que obtiene un nuevo modelo, con el
que actualizar el original. Esta opción genera ficheros con la extensión
.red.

First look: Genera un modelo de alto nivel. Esta opción genera ficheros con la
extensión .mdl.

Detailed Genera un modelo con más detalle que el anterior. También crea un
Análisis: modelo con extensión .mdl.

La opción del modelo a crear se encuentra en las hojas de las propiedades de


exportación de código, esto se hace modificando la original o creando una nueva.

7.6.1 Crear y exportar un modelo UML a partir del código C++ analizado.

1. Pulsar con el ratón para seleccionar los ficheros a exportar. Si se mantiene


pulsada la tecla Control, se pueden seleccionar varios archivos a analizar. Si se
pulsa la tecla Mayúsculas se seleccionan los archivos comprendidos entre el
anteriormente seleccionado y sobre el que se pulsa con el ratón.

2. Selecciona la Action de Menú: Action / Export to Rose.

3. Se pulsa la flecha del campo Option Set para abrir el menú desplegable.

4. Se selecciona la opción deseada.

5. Pulsa el botón OK o el botón Overwrite para exportar el modelo

77
Ingeniería Inversa usando el
Manual de Rational Rose analizador de código C++

Figura 7.6 Propiedades de exportación.

7.7 Actualización del un modelo

El fichero .red se usa para actualizar un modelo UML de Rational Rose una vez
que ha sido generado por el analizador. La actualización modificará los elementos
del modelo Rose con elementos extraídos desde el código fuente. Si algunos
elementos en el código no se encontraban en el modelo, estos se añadirán al
modelo.

7.7.1 Actualizando un modelo Rose

1. Se abre el modelo Rose a ser actualizado.

2. Se selecciona el menú File: Update (actualizar).

3. Se navega a través de la estructura de directorios para localizar el archivo .red.

4. Se pulsa para seleccionar el archivo .red.

5. Se pulsa el botón OK para cerrar el dialogo Merge Status, en el que mostrará el


estado de la actualización.

6. Se comprueban los errores o warning si, la actualización no se ha realizado


correctamente.

78
Ingeniería Inversa usando el
Manual de Rational Rose analizador de código C++

Figura 7.7 Estado de la actualización del modelo.

79
Manual de Rational Rose Generación de Código Java

8 Generación de Código Java


Rational tiene la capacidad de generar código en una gran variedad de
lenguajes, por supuesto no se describirá en detalle la generación de código en todos
los lenguajes que puede generar código, pero se añade un capitulo a la generación
de código Java debido a su gran crecimiento. Para la generación de código en otros
lenguajes puede deducirse por el lector en función de los apartados de este capitulo
y del titulado Generación de Código en C++.

8.1 Chequeo de Errores de Sintaxis

El diseño de clases pensadas en la generación de código Java tiene la ventaja


de que permite el chequeo de la sintaxis antes de la generación del código, para ello
seguir los siguientes pasos:

1. Se abre el modelo y se pulsa sobre el diagrama de componentes que contiene


los componentes de los que se desea generar el código.

2. Se selecciona uno o más paquetes y componentes en el diagrama que contiene


los componentes a los que se desea generar el código.

3. Se pulsa sobre la opción de menú Tools / Java / Systax Check para ejecutar un
rudimentario programa de sintaxis de comprobación de errores.

4. Comprobar el fichero de log, para ver los resultados del chequeo de sisntaxis. Si
existen errores no será posible compilar el código que desea generar.

5. Corregir los errores encontrados.

6. Repetir los pasos 3 al 5 hasta que no existan errores de sintaxis. Cuando todos
los errores de sintaxis se hayan corregido se puede proceder a generar el código.

Nota: Los errores y warning más comunes en la generación de código son:

• La falta de asignación del tipo de dato en los atributos de la clase, por defecto
asigna de tipo void.

• La falta de asignación de la cardinalidad en la relaciones, por defecto asigna


cardinalidad 1.

• La falta del tipo de atributos retornado en las funciones, por defecto asigna tipo
void.

80
Manual de Rational Rose Generación de Código Java

8.2 Fijar el lenguaje de generación de código por defecto.

Si la mayoría de las clases del modelo se van a generar en Java, se debería fijar
el lenguaje por defecto el lenguaje Java, para evitar asignar el lenguaje a cada una
de las clases generadas de forma independiente. Para fijar un lenguaje por defecto:

1. Se comprueba que Rational esta configurado para generar código Java. Se pulsa
la opción de menú Add-ins / Add-in Manager.

2. Se activa el lenguaje Java y todos aquellos que deseemos utilizar, sí aun no se


encontraban activados.

3. Se selecciona la opción de menú Tools / Options y se selecciona la pestaña


Notations.

4. Se pulsa sobre la flecha del cuadro Default Language para desplegar la lista de
desplazamiento, se selecciona el lenguaje por defecto para la generación de
código.

5. Se pulsa el botón OK para fijar el lenguaje por defecto para el modelo.

Figura 8.2 Selección de los Lenguajes de Generación.

81
Manual de Rational Rose Generación de Código Java

Figura 8.7.1 Selección del Lenguaje por defecto.

8.3 Generación de código desde el Diagrama.

1. Se abre el modelo y se muestra el diagrama de clases que contiene las clases y


paquetes del código a generar.

2. Se seleccionan una o más clases del diagrama.

3. Opcionalmente se puede usar la utilidad de comprobación de la sintaxis antes de


la generación de código.

4. Se pulsa sobre la opción de menú Tools / Java / Generate Java.

5. Si el paquete o los componentes no han sido mapeado a una entrada en el


Classpath (por ejemplo, es la primera vez que se genera código para un

82
Manual de Rational Rose Generación de Código Java

componente o paquete), se abrirá el dialogo Componet Mapping que permitirá


asociar el camino donde generar el código.

6. Comprobar la ventana del log, para ver si el código se ha generado


correctamente.

7. Corregir los errores y repetir el paso 4 hasta que no parezcan errores.

8. Ver y modificar el código generado.

Figura 8.8 Generación de Código Java.

8.4 Generación de código Java desde el diagrama de componentes.

1. Abrir el modelo y mostrar el diagrama de componentes que contiene los


componentes y paquetes para los cuales se desea generar el código.

2. Seleccionar uno o más componentes en el diagrama.

83
Manual de Rational Rose Generación de Código Java

3. Opcionalmente utilizar la utilidad de chequeo de sintaxis de código antes de


generar.

4. Se Pulsa sobre la opción de menú Tools / Java / Generate Java.

5. Si el paquete o los componentes no ha sido mapeado a una entrada en el


Classpath (por ejemplo es la primera vez que se genera código para un
componente o paquete), se abrirá el dialogo Componet Mapping que permitirá
asociar el camino donde generar el código.

6. Comprobar la ventana de log, para ver si el código se ha generado


correctamente.

7. Corregir los errores y repetir el paso 4 hasta que no parezcan errores.

8. Se edita y rellenan las funciones en el esqueleto del código generado.

8.5 Mapeo de componentes para la generación de código

En la lista de los directorios de Classpath, se selecciona el camino donde se


desea colocar los ficheros de código Java generados. Si el directorio donde
deseamos que se generen los ficheros no aparece en el diálogo se pueden añadir
nuevos directorios como se muestra en el apartado 9.1 Asignación de nuevos
Directorios de Classpath.

En la lista de paquetes y componentes se seleccionan uno más componentes a


generar en el Classpath. La lista de paquetes y componentes se mostrará al nivel
mas alto, es decir una vez que se ha asignado el nivel superior todos los
componentes se generarán siguiendo la jerarquía de paquetes creada en el modelo.

Se pulsa sobre el botón Map para seleccionar el paquete o componente en el


directorio seleccionado.

84
Manual de Rational Rose Generación de Código Java

Figura 8.9 Asignación de Directorio destino del código Generado.

8.6 Editor de Código Java

Se selecciona la clase o componente de cuyo código fuente se desea ver.

Se pulsa la opción de menú Tools / Java / Browse Java Source. El código se


visualizará utilizando la aplicación que se encuentre configurada como el editor por
defecto.

Figura 8.10 Editor de Código Java de Rational.

8.6.1 Cambiar el editor de código por defecto.

1. Se pulsa sobre el menú Tools / Java Proyect Specification.

2. Se selecciona la pestaña Detail.

3. Se selecciona uno de las opciones que aparecen en el cuadro de lista Editor


(Builtn o WindowShell).

4. Se pulsa el botón OK para guardar los cambios.

Si se ha seleccionado la opción WidowsShell, hay que estar seguro que Windows


tiene asignado una aplicación para abrir este tipo de ficheros. Se recomienda dejar
seleccionado opción por defecto “Builtn” y por tanto usar el editor de Rational.

85
Manual de Rational Rose Generación de Código Java

Figura 8.11 Cambio del Editor de Código Java de Rational.

86
Ingeniería Inversa de Código
Manual de Rational Rose Java.

9 Ingeniería Inversa de Código Java.


Al igual que es posible hacer ingeniería inversa del código C++, se puede hacer
del código Java, la ventaja de esta frente al C++ es que la herramienta de análisis no
es un módulo independiente del Rational, por lo que las clases y relaciones de los
ficheros analizadas actualizan y se añaden directamente al modelo actualmente
abierto.

Previamente a analizar un proyecto se debe añadir el directorio donde se


encuentra el código fuente como un directorio de Classpath.

9.1 Asignación de nuevos Directorios de Classpath.

1. Se pulsa sobre la opción de menú Tools / Java / Proyect Specifications.

2. Se selecciona la pestaña ClassPath.

3. Se pulsa sobre el botón Nuevo Directorio . Esto creará un nuevo botón en


la ventana Directorios.

4. Se pulsa sobre el nuevo botón creado para que aparezca la ventana del
explorador, en la que se selecciona el nuevo directorio de ClassPath.

Figura 9.1 Asignación de Nuevos Directorios de Classpath.

87
Ingeniería Inversa de Código
Manual de Rational Rose Java.

9.2 Analizador de Código Java.

1. Se selecciona sobre la opción de Menú Tools / Java / Reverse Ingineer Java.

2. Se selecciona en el árbol de la ventana Java Reverse Ingineer el directorio donde


se encuentran los ficheros a analizar.

3. Al seleccionar un directorio, aparecerán los ficheros con extensión .java que


contenga este directorio en la ventana superior derecha. En esta ventana se
seleccionan los ficheros a analizar.

4. Si se desea hacer la ingeniería Inversa de unos cuantos ficheros de debe pulsar


el Botón Add, para que añada los ficheros seleccionados, el botón Add All
añadirá todos los ficheros del cuadro estén o no seleccionados y Add Recursive
a parte de añadir todos los ficheros del directorio añadirá todos los ficheros que
posean los directorios de forma recursiva.

5. Se seleccionan en el cuadro inferior los ficheros a analizar, o se pulsa sobre el


botón Select All, para seleccionar todos los ficheros automáticamente.

6. Se pulsa sobre el botón Reverse para que comience el proceso de análisis. La


barra de indicación del proceso comenzará a desplazarse, hasta llegar al final de
la ventana.

7. Se pulsa el Botón Done para cerrar el diálogo, cuando el proceso de análisis


haya finalizado. Si han ocurrido errores durante el análisis mostrará un mensaje
de error.

8. Los errores ocurridos durante el proceso de análisis se registran en la ventana de


log.

9. Si existen errores, se asignan los nuevos Classpath y se repite el proceso


únicamente en las clases que no ha podido analizar.

88
Ingeniería Inversa de Código
Manual de Rational Rose Java.

Figura 9.2 Ingeniería Inversa en Java.

9.3 Creación actualización del Modelo.

Cuando se realiza la ingeniería inversa de un proyecto, todas las clases resultado


del análisis se añaden al árbol de la ventana izquierda de Rational dentro de la
carpeta del Logical View. Para crear un modelo con las clases analizadas se deben
seguir los siguientes pasos:

1. Se crea una nueva carpeta, con el nombre del proyecto.

2. Se arrastran todas las nuevas clases creadas dentro de la carpeta.

3. Se crea un nuevo diagrama de clases.

4. Se hace doble clic sobre el nuevo diagrama creado, para que se abra la ventana
de edición.

5. Se arrastran todas las clases creadas tras el proceso de análisis a la ventana de


edición. Las clases quedarán completamente desordenadas, y con el tamaño no
ajustado a sus propiedades.

89
Ingeniería Inversa de Código
Manual de Rational Rose Java.

6. Se pulsa sobre la opción de Menú Edit / Select All, para seleccionar todas las
clases de ventana de diseño.

7. Se pulsa sobre la opción de menú, Format / Autosize All, para ajustar el tamaño
de todas las clases seleccionadas.

8. Se pulsa sobre la opción de menú, Format / Layout Diagram, para que se


recoloquen todas las clases del diagrama.

Figura 9.3 Resultado Ingeniería Inversa.

90

También podría gustarte