Ingeniería de Software II Información obtenida de Internet UNIVERSIDAD DE SAN MARTIN DE PORRES...
-
Upload
nieve-tadeo -
Category
Documents
-
view
215 -
download
0
Transcript of Ingeniería de Software II Información obtenida de Internet UNIVERSIDAD DE SAN MARTIN DE PORRES...
Ingeniería de Software IIInformación obtenida de Internet
UNIVERSIDAD DE SAN MARTIN DE PORRESFACULTAD DE INGENIERIA Y ARQUITECTURA
Profesor: Ing. Luis Palacios Quichíz
Caso Práctico UML
Curso de UML para el Servicio de Informática
Universidad de Murcia
Julio de 2.000
Curso UML 3
Contenido
• Requisitos de la aplicación
• Casos de uso
• Modelo conceptual
• Modelo de Análisis y Diseño
• Aspectos Avanzados del Diseño
Curso UML 4
Requisitos de la aplicación
• Servicio de Tutorías Virtuales para la Universidad.
• Requisitos:– El alumno accederá a la aplicación a través del web.
– Los usuarios se identificarán en el sistema utilizando tarjetas inteligentes.
– Permitirá a los alumnos realizar consultas electrónicas.
– Sistema de consultas on-line.
– El alumno tendrá un buzón de nuevas respuestas.
– El profesor tendrá un buzón de nuevas consultas.
Curso UML 5
Requisitos de la aplicación
• Requisitos (continuación):– El alumno organizará las consultas por asignatura,
profesor y tema. – El profesor organizará las consultas por asignatura,
alumno y tema.– El profesor podrá determinar cuando desea establecer las
tutorías on-line para una asignatura.– La Universidad desea conocer para cada profesor:
• Cumplimiento horario tutorías.• Número de horas de tutorías on-line.• Número de horas de consultas on-line.• Número de consultas respondidas.
Curso UML 6
Reglas de Negocio
• Restricciones que afectan a las informaciones y acciones de la organización:– Horas de tutorías del profesor >= 6
– Un usuario no puede fallar durante el proceso de identificación más de 3 veces
Curso UML 7
Diagrama de Casos de Uso
Explorar Consultas Alumno Crear Tema Consulta
Realizar Consulta
Consultar Buzon Entrada Alumno
Explorar Consultas Profesor
Responser Consulta
Consulta en linea
Consultar Buzon Entrada Profesor
Establecer Tutorias
Alumno
(from Alumno)
Profesor
(from Profesor)
Identificacion Alumno Identificación Profesor
Identificación
<<extend>> <<extend>>
Universitario
Curso UML 8
Plantilla Casos de Uso
• Caso de uso: nombre del caso de uso• Objetivo: propósito del caso de uso• Actores: actores que intervienen• Precondiciones: condiciones que deben cumplirse
para poder comenzar el caso de uso• Pasos: secuencia normal de acciones• Variaciones: variaciones de la secuencia normal• Extensiones: extensiones del caso de uso
Curso UML 9
CDU: Realizar Consulta
• Objetivo: el alumno realiza una consulta electrónica al profesor de una asignatura
• Actores: Alumno • Pasos:
– 1. A: Selecciona el tema
– 2. A: Escribe la consulta y su título
– 3. S: Registrar consulta asociada al tema
Curso UML 10
CDU: Crear Tema Consulta
• Objetivo: establecer un nuevo tema de consulta para las tutorías con un profesor
• Actores: Alumno• Pasos:
– 1. A: Selecciona la asignatura y el profesor
– 2. A: Establece nuevo tema de consulta
– 3. S: Registrar el tema de consulta asociado al profesor y la asignatura
Curso UML 11
CDU: Crear Tema Consulta
• Variaciones:– 1.a. El tema de consulta existe
• 1.a.1: Indicar error
• 1.a.2: Finalizar cdu.
Curso UML 12
CDU: Consultar Buzón Entrada Alumno
• Objetivo: el alumno consulta las nuevas consultas contestadas por los profesores
• Actores: Alumno• Pasos:
– 1. S: Muestra todas las consultas recién contestadas por los profesores.
– 2. A: Lee las consultas del buzón.
Curso UML 13
CDU: Explorar Consultas Alumno
• Objetivo: el alumno explora las consultas, junto con sus respuestas, realizadas a los profesores
• Actores: Alumno• Pasos: *
– 1. S: Muestra las asignaturas para las que está matriculado el alumno
– 2. A: Selecciona Asignatura
– 3. S: Muestra los profesores de la asignatura seleccionada
– 4. A: Selecciona Profesor
Curso UML 14
CDU: Explorar Consultas Alumno
• Pasos (continuación):– 5. S: Muestra los temas para la Asignatura-Profesor-
Alumno
– 6. A: Selecciona Tema
– 7. S: Muestras las consultas para ese Tema
Curso UML 15
CDU: Consulta en Línea
• Objetivo: el alumno realiza una consulta en línea con el profesor.
• Actores: Alumno (iniciador), Profesor• Precondiciones: profesor está en línea y no
ocupado• Pasos:
– 1. A Alumno: Solicita la consulta al profesor.
– 2. S: Avisa al Profesor
– 3. A Profesor: Acepta la consulta.
– 4. S: Avisa al Alumno
Curso UML 16
CDU: Consulta en Línea
• Pasos (continuación):– 5. A Alumno-Profesor: Intercambian mensajes.
– 6. S: Envía mensajes al otro interlocutor
– 7. A Alumno-Profesor: Finaliza la consulta.
– 8. S: Notifica la finalización al otro interlocutor
– 9. S: Registrar periodo de tutoria asociado al Profesor y al Alumno
• Variaciones:– 2. a. El profesor no acepta la consulta
• 2.a.1: Finaliza cdu.
Curso UML 17
CDU: Responder Consulta
• Objetivo: el profesor responde una consulta electrónica de un alumno
• Actores: Profesor • Pasos:
– 1. A: Selecciona la consulta a responder
– 2. S: Muestra el contenido de la consulta para su edición
– 3. A: Escribe la respuesta dentro de la consulta
– 4. S: Registra la respuesta y la asocia a la consulta
Curso UML 18
CDU: Consultar Buzón Entrada Profesor
• Objetivo: el profesor examina las consultas no contestadas
• Actores: Profesor• Pasos:
– 1. S: Muestra todas las consultas no contestadas del profesor
– 2. A: Leer consultas del buzón.
Curso UML 19
CDU: Explorar Consultas Profesor
• Objetivo: el profesor explora las consultas, contestadas o no, de los alumnos
• Actores: Profesor• Pasos: *
– 1. A: Selecciona la Asignatura
– 2. S: Muestra los alumnos matriculados para la Asignatura
– 3. A: Selecciona el Alumno
– 4. S: Muestra los temas del Alumno para la Asignatura y el Profesor
Curso UML 20
CDU: Explorar Consultas Profesor
• Pasos: (continuación)– 5. A: Selecciona el Tema
– 6. S: Muestra las consultas de ese tema
Curso UML 21
CDU: Establecer Tutorías
• Objetivo: permite a un profesor establecer las asignaturas para las que estará en tutoría
• Actores: Profesor• Pasos:
– 1. A: Seleccionar asignatura y establecer estado (en línea o fuera de línea)
– 2. S: Registrar el cambio de tutorías y actualizar las estadísticas (cumplimiento horario tutorías y horas de tutorías)
Curso UML 22
CDU: Identificación
• Objetivo: obtener y validar la identidad de un usuario de la Universidad
• Actores: Universitario• Pasos:
– 1. S: Solicita tarjeta inteligente
– 2. A: Introduce tarjeta inteligente
– 3. S: Solicita el PIN
– 4. A: Introduce el PIN
– 5. S: Comprobar identidad
– 6. S: Devolver identidad
Curso UML 23
CDU: Identificación
• Variaciones:– 5. a. El PIN no es correcto
• 5.a.1: Solicitar el PIN hasta 3 veces
• Extensiones:– Tipo de usuario
Curso UML 24
CDU: Identificación Alumno
• Identificación Alumno extends Identificación• Objetivo: comprobar la identidad del alumno• Actores: Alumno• Precondiciones: • Pasos:
– 1: Pasos cdu Identificación
– 2: S: Obtener identidad alumno
Curso UML 25
CDU: Identificación Profesor
• Identificación Profesor extends Identificación• Objetivo: comprobar la identidad del profesor• Actores: Profesor• Precondiciones: • Pasos:
– 1: Pasos cdu Identificación
– 2: S: Obtener identidad profesor
Curso UML 26
Interfaces Gráficas (Pantallas)
• Una manera adecuada de validar los requisitos del usuario es construir las interfaces gráficas
• Nos ayudan a ver las conexiones entre casos de uso
• Permiten definir los llamados casos de uso reales: – Hacen referencia a los elementos de interacción actor-
sistema
– Ejemplo de elementos: cuadros de edición, botones, listbox, ...
Curso UML 27
Pantallas: Realizar Consulta
Curso UML 28
Pantallas: Crear Tema Consulta
Curso UML 29
Pantallas: Buzón de Entrada Alumno
Curso UML 30
Pantallas: Explorador Alumno
Curso UML 31
Pantallas: Consulta en Línea
Curso UML 32
Pantallas: Consulta en Línea
Curso UML 33
Pantallas: Consulta en Línea
Curso UML 34
Pantallas: Responder Consulta
Curso UML 35
Pantallas: Buzón de Entrada Profesor
Curso UML 36
Pantallas: Explorador Profesor
Curso UML 37
Pantallas: Establecer Tutorías
Curso UML 38
Pantallas: Identificación
Curso UML 39
Modelo Conceptual
• Conceptos y Atributos:– Alumno:
• DNI
• Nombre
– Profesor:• DNI
• Nombre
– Asignatura:• Código
• Nombre
Curso UML 40
Modelo Conceptual
• Conceptos y Atributos:– Consulta:
• Título
• Fecha
• Hora
• Mensaje
– Respuesta:• Fecha
• Hora
• Mensaje
– Tema:• Nombre
Curso UML 41
Modelo Conceptual
• Conceptos y atributos:– Horario Tutorías
– Franja Horaria:• hora de inicio
• hora de fin
• día de la semana
Curso UML 42
Modelo Conceptual
• Asociaciones entre conceptos:– Consulta tiene asociada Respuesta
– Alumno realiza Consulta
– Profesor responde Consulta
– Consulta realizada a Profesor
– Profesor tiene Horario Tutorías
– Horario Tutorías definido mediante Franja Horaria
– Consulta relacionada con Asignatura
– Alumno matriculado en Asignatura
– Profesor imparte Asignatura
Curso UML 43
Modelo Conceptual
• Asociaciones entre conceptos:– Alumno tutoría en línea Profesor
– Profesor establece tutoría Asignatura
– Tema tiene Consulta
– Tema organiza consultas Asignatura
– Tema organiza consultas Profesor
Curso UML 44
numeroHoras >= 6
FranjaHoraria
inicio : Timefin : Timedia : Day
(from Profesor)
HorarioTutorias
/ numeroHoras : Integer
(from Profesor)
11
definido mediante
Profesor
DNI : StringNombre : String
(from Profesor) 11
tiene
Respuesta
mensaje : String
fecha : Datehora : Time
(from Comun)
Profesor
(from Profesor)
Asignatura
codigo : Stringnombre : String
(from Universidad)
imparte
establece tutoría
Consulta
titulo : Stringfecha : Datehora : Timemensaje : String
estado : String
(from Comun)
responde
realizada a
relacionada con
0..11 0..11
tiene asociada
Asignatura(from Universidad)
Profesor
(from Profesor)
Alumno
DNI : StringNombre : String
(from Alumno)
tutoria en linea
1..*
1..*
1..*
1..*
matriculado enrealiza
Tema
nombre : String
(from Comun)
1
0..*
1
0..*
contiene
organiza consultas
organiza consultas
tema de consulta
Curso UML 45
Modelado de Análisis y Diseño
• Diagramas de Secuencia de Sistema
• Contratos de operaciones
• Diagramas de interacción
• Diagramas de clases
Curso UML 46
Diagramas de Secuencia del Sistema
• Describen los eventos que envía el actor al sistema• Conviene realizar un Diagrama de Secuencia de
Sistema (DSS) para cada caso de uso.• Ejemplo:
: Alumno : Sistema
seleccionarConsulta( )
marcarConsultaLeida( )
Curso UML 47
Contratos
• Los contratos nos permiten establecer las responsabilidades de cada operación.
• Definen explícitamente los cambios en el sistema después de finalizar la operación.
• Realizaremos contratos para todas las operaciones del sistema
• Para las operaciones del sistema debemos encontrar una clase Controlador (alternativas):– Clase que representa al Sistema.
– Clase que representa un manejador del caso de uso.
Curso UML 48
Plantilla Contratos
• Nombre: signatura de la operación• Responsabilidades: responsabilidades de la
operación • Tipo: clase que contiene la operación• Notas: notas• Excepciones: excepciones• Salida: salida que no sea por pantalla
Curso UML 49
Plantilla Contratos
• Precondiciones: condiciones que han de cumplirse antes de ejecutar la operación
• Postcondiciones: estado del sistema después de la ejecución del método.
Curso UML 50
Diagramas de Interacción
• Para cada operación del sistema construimos un Diagrama de Interacción (DI): – Diagrama de Colaboración
– Diagrama de Secuencia
• En los diagramas obviamos al acceso a los objetos controlador: – Se realiza a través de un objeto Singleton.
Equivalentes
objeto : GestorAlumno
G
1: getInstancia( )
instancia : GestorAlumno
2: getExplorador( )
Curso UML 51
DSS: Realizar Consulta
: Alumno
: Sistema
nuevaConsulta( )
Curso UML 52
Contratos: Realizar Consulta
• Nombre: nuevaConsulta (titulo: String; mensaje: String, tema: Tema)
• Responsabilidades: crea una nueva consulta y la asocia a un tema (asignatura-profesor)
• Tipo: GestorConsultas• Postcondiciones:
– Un objeto Consulta es creado
– Consulta.titulo = titulo y Consulta.mensaje = mensaje
– Una asociación tema-consulta es creada.
Curso UML 53
DI: nuevaConsulta
: Alumno :
GestorConsultasnuevaConsulta
: Consultatema : Tema
nuevaConsulta(String, String, Tema)
create( )
setTitulo(String)
setMensaje(String)
addConsulta(Consulta)
Curso UML 54
DSS: Crear Tema Consulta
: Alumno : Sistema
nuevoTema()
Curso UML 55
Contratos : Crear Tema Consulta
• Nombre: nuevoTema (tema: String, asignatura: Asignatura, profesor: Profesor)
• Responsabilidades: crear un nuevo tema de consulta asociandolo al alumno, al profesor y a la asignatura
• Notas: acceso al objeto Alumno a través de la clase Singleton
• Tipo: GestorConsultas• Excepciones: nombre del tema existe
Curso UML 56
Contratos : Crear Tema Consulta
• Postcondiciones:– Objeto Tema es creado
– Asociación Tema-Asignatura es creada
– Asociación Tema-Profesor es creada
– Asociación Alumno-Tema es creada
Curso UML 57
DI: nuevoTema
: Alumno : GestorConsultas nuevoTema :
Temaalumno : Alumno
nuevoTema(String, Profesor, Asignatura)create( )
setProfesor(Profesor)
setAsignatura(Asignatura)
addTema(Tema, Profesor, Asignatura)
Curso UML 58
DSS: Consultar Buzón Entrada Alumno
: Alumno : Sistema
seleccionarConsulta( )
marcarConsultaLeida( )
Curso UML 59
Contratos: Consultar Buzón Entrada Alumno
• Nombre: String seleccionarConsulta (consulta: Consulta)
• Responsabilidades: recordar la consulta seleccionada y devolver su contenido
• Tipo: BuzonAlumno• Postcondiciones:
– Asociación BuzonAlumno-Consulta es creada
Curso UML 60
DI: seleccionarConsulta
: Alumno :
BuzonAlumno : Consulta
seleccionarConsulta(Consulta)
setConsulta(Consulta)
getMensaje( )
Curso UML 61
Contratos: Consultar Buzón Entrada Alumno
• Nombre: marcarConsultaLeida()• Responsabilidades: cambiar el estado de la
consulta seleccionada• Tipo: BuzonAlumno• Precondiciones: consulta seleccionada
(seleccionarConsulta)• Postcondiciones:
– consulta.estado = “leída”
Curso UML 62
DI: marcarConsultaLeida
: Alumno :
BuzonAlumnoconsulta : Consulta
marcarConsultaLeida( )
setLeida( )
Curso UML 63
DSS: Explorar Consultas Alumno
: Alumno : Sistema
seleccionarAsignatura( )
seleccionarProfesor( )
seleccionarTema( )
seleccionarConsulta( )
nuevaConsulta( )
nuevoTema(String, Profesor, Asignatura)
cdu "Realizar Consulta"
cdu "Crear Tema Consulta"
Curso UML 64
Contratos: Explorar Consultas Alumno
• Nombre: List (Profesor) seleccionarAsignatura (asignatura: Asignatura)
• Responsabilidades: recordar la asignatura y devolver los profesores de la asignatura
• Tipo: ExploradorAlumno• Postcondiciones:
– Asociación ExploradorAlumno-asignatura es creada
Curso UML 65
DI: seleccionarAsignatura
: Alumno : ExploradorAlumno : Asignatura
seleccionarAsignatura(Asignatura)
getProfesores( )
setAsignatura( Asignatura)
Curso UML 66
Contratos: Explorar Consultas Alumno
• Nombre: List (Tema) seleccionarProfesor (profesor: Profesor)
• Responsabilidades: recordar el profesor seleccionado y mostrar los temas para la asignatura-profesor-alumno
• Tipo: ExploradorAlumno• Notas: acceso al Alumno a través del Singleton• Postcondiciones:
– Asociación ExploradorAlumno-profesor es creada
Curso UML 67
DI: seleccionarProfesor
: Alumno : ExploradorAlumno alumno : Alumno
seleccionarProfesor(Profesor)
setProfesor(Profesor)
getTemas(Asignatura, Profesor)
Curso UML 68
Contratos: Explorar Consultas Alumno
• Nombre: List(Consulta) seleccionarTema (tema: Tema)
• Responsabilidades: recordar el tema seleccionado y devolver todas las consultas para ese tema
• Tipo: ExploradorAlumno• Postcondiciones:
– Asociación ExploradorAlumno-tema es creada
Curso UML 69
DI: seleccionarTema
: Alumno :
ExploradorAlumno : Tema
seleccionarTema(Tema)
getConsultas( )
setTema(Tema)
Curso UML 70
Contratos: Explorar Consultas Alumno
• Nombre: String seleccionarConsulta (consulta: Consulta)
• Responsabilidades: recordar la consulta y devolver el contenido del mensaje
• Tipo: ExploradorAlumno• Postcondiciones:
– Asociación ExploradorAlumno-consulta es creada
Curso UML 71
DI: seleccionarConsulta
: Alumno :
ExploradorAlumno : Consulta
seleccionarConsulta(Consulta)
setConsulta(Consulta)
getMensaje( )
Curso UML 72
DSS: Consulta en Línea
: Alumno : Sistema
: Profesor
solicitarCosulta(Profesor)
solicitarConsulta(Alumno)
aceptarConsulta( )
enviarMensaje(String)
enviarMensaje(String)
terminarConsultaEnLinea( )
terminarConsultaEnLinea( )
rechazarConsulta( )
Curso UML 73
Contratos: Consulta en Línea
• Nombre: solicitarConsulta (profesor: Profesor)• Responsabilidades: solicita al profesor una
consulta en línea• Tipo: GestorConsultas• Notas: acceso al GestorCentral y al Alumno a
través del Singleton• Postcondiciones:
– Objeto ConsultaEnLinea es creado
– Asociación ConsultaEnLinea-Profesor es creada
Curso UML 74
Contratos: Consulta en Línea
• Postcondiciones (continuación):– Asociación ConsultaEnLinea-Alumno es creada
– Asociaciones entre ConsultaEnLinea y Gestores de Consultas (profesor y alumno) son creadas
– Asociación GestorConsultas-OyenteConsultasEnLinea es creada
Curso UML 75
DI: solicitarConsulta : Alumno
gestorAlumno : GestorConsultas
nuevaConsultaEnLinea : ConsultaEnLinea
: GestorCentral
gestorProfesor : GestorConsultas
solicitudConsultaEnLinea(Profesor, OyenteConsultaEnLinea)
solicitarConsultaEnLinea(Alumno, Profesor, GestorConsultas)
solicitudConsultaEnLinea(ConsultaEnLinea)
create( )
setAlumno(Alumno)
setProfesor(Profesor)
setGestores(GestorConsultas, GestorConsultas)
getGestorProfesor(Profesor)
getAlumno( )
setOyente(OyenteConsultaEnLinea)
Curso UML 76
Contratos: Consulta en Línea
• Nombre: aceptarConsulta ()• Responsabilidades: notificar al alumno que la
consulta ha sido aceptada por el profesor• Tipo: GestorConsultas• Postcondiciones:
– Objeto Periodo es creado
– Asociación GestorConsultas-OyenteGestorConsultas es creada
– Asociación ConsultaEnLinea-Periodo es creada
Curso UML 77
DI: aceptarConsulta
profesor : Profesor
gestorAlumno : GestorConsultasAlumno
nuevaConsultaEnLinea : ConsultaEnLinea
gestorProfesor : GestorConsultas
aceptarConsulta(OyenteConsultaEnLinea )
consultaAceptada( )
consultaAceptada(ConsultaEnLinea)
periodo : Periodo
create( )
setInicioPerido( )
setOyente(OyenteConsultaEnLinea)
Curso UML 78
Contratos: Consulta en Línea
• Nombre: rechazarConsulta ()• Responsabilidades: notificar al alumno que la
consulta ha sido rechazada por el profesor• Tipo: GestorConsultas• Postcondiciones:
– Objeto ConsultaEnLinea es destruido.
Curso UML 79
DI: rechazarConsulta
gestorAlumno : GestorConsultas
profesor : Profesor
nuevaConsultaEnLinea : ConsultaEnLinea
gestorProfesor : GestorConsultas
rechazarConsulta( )
consultaRechazada( )
consultaRechazada( )
destroy( )
Curso UML 80
Contratos: Consulta en Línea
• Nombre: enviarMensaje (mensaje: String)• Responsabilidades: envía un mensaje al otro
interlocutor• Tipo: GestorConsultas
Curso UML 81
DI: enviarMensaje
: Alumno
gestorAlumno : GestorConsultas
gestorProfesor : GestorConsultas
: OyenteConsultaEnLinea
consultaEnLinea : ConsultaEnLinea
enviarMensaje(String)
Este diagrama describe la secuencia de mensajes iniciada por el alumno. El diagrama para el profesor sería equivalente
Referencia al Gestor que realiza la llamada
enviarMensaje(String, GestorConsultas)
enviarMensaje(String)setMensaje(String)
Curso UML 82
Contratos: Consulta en Línea
• Nombre: terminarConsultaEnLinea ()• Responsabilidades: notifica al otro interlocutor
que la consulta ha finalizado y registra la consulta asociada al profesor
• Tipo: GestorConsultas• Postcondiciones:
– Asociación Profesor-ConsultaEnLinea es creada.
Curso UML 83
DI: terminarConsultaEnLinea
profesor : Profesor : Alumno
gestorAlumno : GestorConsultas
: GestorCentral
: ConsultaEnLinea
gestorProfesor : GestorConsultas
: OyenteConsultaEnLinea
periodo : Periodo
terminarConsultaEnLinea( )
terminarConsultaEnLinea(ConsultaEnLinea, GestorConsultas)
terminarConsultaEnLinea(GestorConsultas)
consultaEnLineaFinalizada( )
profesor := getProfesor( )
addConsultaEnLinea(ConsultaEnLinea)
setFinPeriodo( )
consultaFinalizada( )
Curso UML 84
DSS: Responder Consulta
: Profesor : Sistema
responderConsulta( )
Curso UML 85
Contratos: Responder Consulta
• Nombre: responderConsulta (consulta: Consulta, mensaje: String)
• Responsabilidades: crear una Respuesta y asociarla a la consulta
• Tipo: GestorConsultas• Postcondiciones:
– Objeto Respuesta es creado
– Asociación consulta-Respuesta es creada
– consulta.estado = “respondida”
Curso UML 86
DI: responderConsulta
: Profesor
: GestorConsultas
nuevaRespuesta : Respuesta
consulta : Consulta
responderConsulta(Consulta, String)create(String)
setRespuesta(Respuesta)
Curso UML 87
DSS: Consultar Buzón Entrada Profesor
: Profesor : Sistema
seleccionarConsulta( )
responderConsulta( )
CDU Responder Consulta
Curso UML 88
Contratos: Consultar Buzón Entrada Profesor
• Nombre: String seleccionarConsulta (consulta: Consulta)
• Responsabilidades: recordar la consulta seleccionada y devolver el contenido
• Tipo: BuzonProfesor• Postcondiciones:
– Asociación BuzonProfesor-consulta es creada
Curso UML 89
DI: seleccionarConsulta
: Profesor :
BuzonProfesor : Consulta
seleccionarConsulta(Consulta)
setConsulta(Consulta)
getMensaje( )
Curso UML 90
Contratos: Consultar Buzón Entrada Profesor
• Nombre: responderConsulta (respuesta: String)• Responsabilidades: crear una respuesta y
asociarla a la consulta• Tipo: BuzonProfesor• Notas: Ver CDU “Responder Consulta”• Precondiciones: una consulta ha sido
seleccionada (seleccionarConsulta)
Curso UML 91
Contratos: Consultar Buzón Entrada Profesor
• Postcondiciones:– Objeto Respuesta es creado
– Asociación consulta-Respuesta es creada
– consulta.estado = “respondida”
Curso UML 92
DI: responderConsulta
: Profesor :
BuzonProfesor :
GestorConsultas
responderConsulta(String)
responderConsulta(Consulta, String)
CDU "Responder Consultas"
Consulta es un atributo de BuzonProfesor
Curso UML 93
DSS: Explorar Consultas Profesor
: Profesor : Sistema
seleccionarAsignatura( )
seleccionarAlumno( )
seleccionarTema( )
seleccionarConsulta( )
responderConsulta( )
Curso UML 94
Contratos: Explorar Consultas Profesor
• Nombre: List(Alumno) seleccionarAsignatura (asignatura: Asignatura)
• Responsabilidades: recordar la asignatura y devolver los alumnos matriculados en ella
• Tipo: ExploradorProfesor• Postcondiciones:
– Asociación ExploradorProfesor-asignatura es creada
Curso UML 95
DI: seleccionarAsignatura
: ExploradorProfesor : Profesor
: Asignatura
seleccionarAsignatura(Asignatura)
getAlumnos( )
setAsignatura(Asignatura)
Curso UML 96
Contratos: Explorar Consultas Profesor
• Nombre: List(Tema) seleccionarAlumno (alumno: Alumno)
• Responsabilidades: recordar alumno seleccionado y mostrar sus temas de consulta
• Tipo: ExploradorProfesor• Postcondiciones:
– Asociación ExploradorProfesor-alumno es creada
Curso UML 97
DI: seleccionarAlumno
: Profesor :
ExploradorProfesor : Alumno
seleccionarAlumno(Alumno)
getTemas(Asignatura, Profesor)
setAlumno(Alumno)
Curso UML 98
Contratos: Explorar Consultas Profesor
• Nombre: List(Consulta) seleccionarTema (tema: Tema)
• Responsabilidades: recordar el tema seleccionado y devolver las consultas asociadas
• Tipo: ExploradorProfesor• Postcondiciones:
– Asociación ExploradorProfesor-tema es creada
Curso UML 99
DI: seleccionarTema
: Profesor :
ExploradorProfesor : Tema
seleccionarTema(Tema)
setTema(Tema)
getConsultas( )
Curso UML 100
Contratos: Explorar Consultas Profesor
• Nombre: String seleccionarConsulta (consulta: Consulta)
• Responsabilidades: recordar la consulta seleccionada y devolver su contenido
• Tipo: ExploradorProfesor• Postcondiciones:
– Asociación ExploradorProfesor-consulta es creada
Curso UML 101
DI: seleccionarConsulta
: Profesor :
ExploradorProfesor : Consulta
seleccionarConsulta(Consulta)
setConsulta(Consulta)
getMensaje( )
Curso UML 102
Contratos: Explorar Consultas Profesor
• Nombre: responderConsulta (respuesta: String)• Responsabilidades: crear una respuesta y
asociarla a la consulta• Tipo: ExploradorAlumno• Notas: ver CDU “Responder Consulta”• Precondiciones: una consulta ha sido
seleccionada (seleccionarConsulta)
Curso UML 103
Contratos: Explorar Consultas Profesor
• Postcondiciones:– Objeto Respuesta es creado
– Asociación consulta-Respuesta es creada
– consulta.estado = “respondida”
Curso UML 104
DI: responderConsulta
: Profesor :
ExploradorProfesor :
GestorConsultas
responderConsulta(Respuesta)
responderConsulta(Consulta, String)
CDU "Responder Consultas"
El Explorador posee una referencia a la consulta seleccionada
Curso UML 105
DSS: Establecer Tutorías
: Profesor : Sistema
seleccionarAsignatura( )
setAsignaturaEnTutoria( )
setAsignaturaSinTutoria( )
Curso UML 106
Contratos: Establecer Tutorías
• Nombre: seleccionarAsignatura (asignatura: TutoriaAsignatura)
• Responsabilidades: recordar la asignatura seleccionada
• Tipo: GestorTutorias• Postcondiciones:
– Asociación GestorTutorias-asignatura es creada
Curso UML 107
DI: seleccionarAsignatura
: Profesor :
GestorTutorias
seleccionarAsignatura(TutoriaAsignatura)
setAsignatura(TutoriaAsignatura)
Curso UML 108
Contratos: Establecer Tutorías
• Nombre: setAsignaturaEnTutoria (asignatura: TutoriaAsignatura)
• Responsabilidades: establecer que un profesor está en tutorías de una asignatura
• Tipo: GestorTutorías• Postcondiciones:
– Si no estaba en tutorías de la asignatura:• Objeto Perido es creado
• PeridoTutoria.horaInicio = horaActual
• Asociación TutoriaAsignatura-Periodo (periodoActual)
Curso UML 109
DI: setAsignaturaEnTutoria
asignatura : TutoriaAsignatura : Profesor
: GestorTutorias
nuevoPeriodoTutoria : Periodo
setAsignaturaEnTutoria( )
setEnTutoria( )
enTutoria := estaEnTutoria( )
[enTutoria]
create( )
setInicioPerido( )
setPeridoActual(PeriodoTutoria)
Curso UML 110
Contratos: Establecer Tutorías
• Nombre: setAsignaturaSinTutoria (asignatura: TutoriaAsignatura)
• Responsabilidades: establecer que un profesor no está en tutorías de una asignatura
• Tipo: GestorTutorías• Postcondiciones:
– Si estaba en tutorías de la asignatura:• TutoriaAsignatura.periodoActual.horaFin = horaActual
• Asociación TutoriaAsignatura-Periodo es creada (periodos)
Curso UML 111
DI: setAsignaturaSinTutoria
: Profesor :
GestorTutoriasasignatura :
TutoriaAsignaturaperiodoActual :
Periodo
setAsignaturaSinTutoria( )
setSinTutoria( )
enTutoria := estaEnTutoria( )
[not enTutoria]
setFinPeriodo( )
addPeriodoTutoria(PeriodoTutoria)
Curso UML 112
DSS: Identificación Alumno
: Alumno : Sistema
identificacionAlumno( )
Curso UML 113
Contratos: Identificación Alumno
• Nombre: Alumno identificacionAlumno (pin: PIN)
• Responsabilidades: validar y obtener la identificación del Alumno
• Tipo: GestorIdentificacion• Notas: acceso al gestor central utilizando el
Singleton• Excepciones: PINIncorrecto, AlumnoNoExiste
Curso UML 114
DI: identificacionAlumno
: Profesor :
GestorCentral : Tarjetero :
GestorIdentificacion
identificacionAlumno(PIN)
ok := comprobarPIN(PIN)
getAlumno(DNI)
dni := getDNI( )
[not ok]
Excepcion
Curso UML 115
DSS: Identificación Profesor
: Profesor : Sistema
identificacionProfesor( )
Curso UML 116
Contratos: Identificación Profesor
• Nombre: Profesor identificacionAlumno (pin: PIN)
• Responsabilidades: validar y obtener la identificación del Profesor
• Tipo: GestorIdentificacion• Notas: acceso al gestor central utilizando el
Singleton• Excepciones: PINIncorrecto, ProfesorNoExiste
Curso UML 117
DI: identificacionProfesor
: GestorIdentificacion : Profesor
: Tarjetero : GestorCentral
identificacionProfesor(PIN)
ok := comprobarPIN(PIN)
[not ok]
dni := getDNI( )
getProfesor(DNI)Excepción
Curso UML 118
Aplicación Patrones GRASP
• ¿Se ha violado algún patrón GRASP en los anteriores diagramas de interacción?
• Sí. La clase GestorConsultas no está cohesionada:– Incluye funcionalidad para el Alumno
– Incluye funcionalidad para el Profesor
• Solución: crear dos gestores de consultas:– GestorConsultasAlumno
– GestorConsultasProfesor
Curso UML 119
Visibilidad
• Visibilidad: capacidad de un objeto para hacer referencia a otro
• Tipos:– Visibilidad de atributos: declarada mediante
asociaciones
– Visibilidad de parámetros: utilizar dependencias
– Visibilidad local: declaración local• Durante el análisis/diseño es difícil identificarla
– Visibilidad global: utilizar dependencias• Clases Singleton y objetos que obtenemos a partir de ellas. En
nuestro ejemplo los objetos Controlador
Curso UML 120
Arranque del Sistema
• El arranque del sistema es un aspecto que hay que tener en cuenta.
• Durante el arranque se crean objetos y asociaciones entre ellos
• Nuestro sistema está dividido en 3 partes:– Aplicación Alumno
– Aplicación Profesor
– Servidor Central (Gestor Central)
Curso UML 121
Arranque del Sistema
• Las aplicaciones del alumno y profesor deben:– Validar la identidad del usuario.
– Obtener un objeto que los identifique.
• El objeto que identifica a los usuarios es conveniente que sea accesible de forma global (patrón Singleton).
• Ambas aplicaciones comenzaran validando a los usuarios. Si este proceso falla, no continuará la aplicación.
Curso UML 122
Arranque del Sistema
• También hay que tener en cuenta las operaciones que demandan las interfaces durante la creación:– Consultar Buzón Entrada Alumno:
• getConsultasNoLeidas
– Explorar Consultas Alumno:• getAsignaturasMatriculado
– Consulta en línea:• getProfesoresEnLinea
– Consultar Buzón Entrada Profesor:• getConsultasNoRespondidas
– Explorar Consultas Profesor:• getAsignaturasProfesor
Curso UML 123
Contrato: Consultar Buzón Entrada Alumno
• Nombre: List (Consulta) getConsultasNoLeidas()• Responsabilidades: obtener las consultas no
leídas para un determinado alumno• Tipo: BuzonAlumno• Notas: acceso al Alumno a través del Singleton
Curso UML 124
DI: getConsultasNoLeidas
: BuzonAlumno : Alumno alumno : Alumno
: Tema consulta : Consulta
getConsultasNoLeidas( )
getConsultasNoLeidas( )
Para cada Tema del Alumno:
consultas := getConsultas( )
Para cada consulta en consultas:
leida := estaLeida( )
if (not leida) resultado.add(consulta)
resultado
resultado := create Coleccion()
Curso UML 125
Contratos: Explorar Consultas Alumno
• Nombre: List (Asignatura) getAsignaturasMatriculado ()
• Responsabilidades: devolver las asignaturas en las que esta matriculado el alumno
• Tipo: ExploradorAlumno• Notas: acceso a Alumno a través del Singleton
Curso UML 126
DI: getAsignaturasMatriculado
: Alumno
: ExploradorAlumno
alumno : Alumno
getAsignaturasMatriculado( )
getAsignaturas( )
Curso UML 127
Contratos: Consulta En Línea
• Nombre: List (Profesores) getProfesoresEnLinea ()
• Responsabilidades: devolver una colección con los profesores que están disponibles para una consulta
• Tipo: GestorConsultasAlumno• Notas: acceso a Alumno a través del Singleton
Curso UML 128
DI: getProfesoresEnLinea
: GestorConsultasAlumno
: Alumno profesor : Profesor
asignatura : Asignaturaalumno : Alumno
getProfesoresEnLinea( )
asignaturas := getAsignaturas( )
Para cada asignatura en asignaturas:
profesoresEnLinea = create Coleccion()
profesores := getProfesores( )
Para cada profesor en profesores:
enLinea := estaEnLinea( )
if (enLinea) profesoresEnLinea.add(profesor)profesoresEnLinea
Curso UML 129
Contratos: Consultar Buzón Entradas Profesor
• Nombre: List (Consulta) getConsultasNoRespondidas()
• Responsabilidades: devolver una colección con las consultas no respondidas por el profesor
• Tipo: BuzonProfesor• Notas: acceso a Profesor a través del Singleton
Curso UML 130
DI: getConsultasNoRespondidas
: Profesor :
BuzonProfesor profesor : Profesor
asignatura : Asignatura
alumno : Alumnotema : Tema consulta :
Consulta
getConsultasNoRespondidas( )
asignaturas := getAsignaturas( )
alumnos := getAlumnos( )
temas := getTemas(Asignatura, Profesor)
consultas := getConsultas( )
consultasNoRespondidas := create Coleccion()
Para cada asignatura en Asignaturas:
Para cada alumno en Alumnos:
Para cada consulta en consultas:
Para cada tema en Temas:
respondida := estaRespondida( )
if (not respondida) consultasNoRespondidas.add(consulta)
consultasNoRespondidas
Curso UML 131
Contratos: Explorar Consultas Profesor
• Nombre: List (Asignatura) getAsignaturasProfesor()
• Responsabilidades: devolver las asignaturas que imparte el profesor
• Tipo: ExplorarProfesor• Notas: acceso a Profesor a través del Singleton
Curso UML 132
DI: getAsignaturasProfesor
: Profesor :
ExploradorProfesor profesor : Profesor
getAsignaturasProfesor( )
getAsignaturas( )
Curso UML 133
Organización en Paquetes
• Conviene organizar las clases en paquetes.• En nuestra aplicación, para las clases del modelo
creamos 4 paquetes:– Alumno
– Profesor
– Comun
– Universidad
• Creamos un paquete más para las interfaces gráficas, pantallas, que a su vez contiene los paquetes PAlumno, PProfesor y PComun.
Curso UML 134
Organización en Paquetes
• Paquetes del modelo: (incluye clases controlador)– Alumno: Alumno, GestorAlumno, BuzonAlumno,
ExploradorAlumno
– Profesor: Profesor, TutoriaAsignatura, HorarioTutorias, FranjaHoraria, GestorProfesor, BuzonProfesor, ExploradorProfesor, GestorTutorias
– Universidad: Asignatura, Tarjetero, GestorCentral, GestorIdentificacion
– Común: Consulta, Tema, Respuesta, ConsultaEnLinea, GestorConsultas, Periodo
Curso UML 135
Diagramas Controladores
• Creamos un diagrama de clases para mostrar las asociaciones y dependencias de las clases controlador.
• Dos diagramas:– Diagrama Controladores Alumno
– Diagrama Controladores Profesor
Curso UML 136
Alumno
GestorCentral(from Universidad)
ConsultaEnLinea(from Comun)
Tema(from Comun)
Profesor
(from Profesor)
Tarjetero
comprobarPIN()getDNI()getInstancia()
(from Universidad)
<<Singleton>>
0..1
-instancia
0..1
Consulta(from Comun)
Consulta(from Comun)
Asignatura(from Universidad)
Profesor
(from Profesor)
Tema(from Comun)
BuzonAlumno
marcarConsultaLeida()getConsultasNoLeidas()
<<controlador>>
0..1
-consulta
0..1
ExploradorAlumno
seleccionarAsignatura()seleccionarProfesor()setProfesor()getAsignaturasMatriculado()
<<controlador>>
0..1
-consulta
0..1
0..1-asignatura
0..1
0..1
-profesor
0..1
0..1
-tema
0..1
GestorCentral
terminarConsultaEnLinea()solicitarConsultaEnLinea()getGestorProfesor()asignaturaEnTutoria()getAlumno()getProfesor()GestorCentral()
(from Universidad)
GestorIdentificacion
identificacionAlumno()identificacionProfesor()
(from Universidad)
<<controlador>>
GestorConsultasAlumno
nuevaConsulta()nuevoTema()solicitudConsultaEnLinea()consultaAceptada()consultaRechazada()getProfesoresEnLinea()
<<controlador>>
GestorAlumno
getInstancia()getExplorador()getGestorConsultas()getBuzon()getGestorCentral()getGestorIdentificacion()getAlumno()
(from GestorConsultasAlumno)
<<Singleton>> 1
-buzon
1
1
-explorador
1
0..1
-instancia
0..1
1
-gestorCentral
1
0..1
-gestorIdentificacion
0..1
1-gestorConsultas
1
Alumno
Asignatura(from Universidad)
Profesor
(from Profesor)
Curso UML 137
TutoriaAsignatura
BuzonProfesor
responderConsulta()getConsultasNoRespondidas()
<<controlador>>
ExploradorProfesor
seleccionarAsignatura()seleccionarAlumno()setAlumno()getAsignaturasProfesor()
<<controlador>>
GestorCentral
terminarConsultaEnLinea()solicitarConsultaEnLinea()getGestorProfesor()asignaturaEnTutoria()getAlumno()getProfesor()GestorCentral()
(from Universidad)
GestorTutorias
seleccionarAsignatura()setAsignatura()setAsignaturaEnTutoria()setAsignaturaSinTutoria()
<<controlador>>
0..1
-asignatura
0..1
GestorConsultasProfesor
aceptarConsulta()rechazarConsulta()responderConsulta()
<<controlador>>
GestorProfesor
getGestorTutorias()getInstancia()getExplorador()getGestorConsultas()getBuzon()getGestorCentral()getGestorIdentificacion()getProfesor()
<<Singleton>>
1-buzon
1
1
-explorador
1
0..1
-instancia
0..1
1-gestorCentral
1
1
-gestorTutorias
1
1-gestorConsultas
1
ConsultaEnLinea(from Comun)
GestorConsultasProfesor
aceptarConsulta()rechazarConsulta()responderConsulta()
<<controlador>>
Alumno
(from Alumno)
Tema(from Comun)
Asignatura(from Universidad)
Consulta(from Comun)0..1
-consulta
0..1
0..1
-consulta
0..1
Alumno
(from Alumno)
0..1
-alumno
0..1
Tema(from Comun)
0..1
-tema
0..1
Asignatura(from Universidad)
0..1
-asignatura
0..1
Profesor
Curso UML 138
Diagrama de Clases
• En el diagrama de clases nos aparecen sólo los conceptos del modelo conceptual que hayan intervenido en los diagramas de interacción.
• Incluímos los métodos de las clases.• Añadimos a las asociaciones la navegabilidad,
cardinalidades, roles, agregación, ....
Curso UML 139
FranjaHoraria
inicio : Timefin : Timedia : Day
(from Profesor)
Profesor
(from Profesor)
HorarioTutorias
/ numeroHoras : Integer
(from Profesor)
1
-franjasHorarias
1
Asignatura
codigo : Stringnombre : String
getProfesores()getAlumnos()
(from Universidad)
1..*
1..*
-asignaturas 1..*
-profesores1..*
imparte
Profesor
addConsultaEnLinea()estaEnLinea()
getAsignaturas()
(from Profesor)
1-horarioTutorias
1
tiene
Alumno
addTema()getTemas()
getConsultasNoLeidas()getAsignaturas()
(from Alumno)1..*
1..*
-alumnos
1..*
-asignaturas
1..*
matriculado en
0..* 0..*
+alumno
0..*
+profesor
0..*tutoria en linea
Tema
nombre : String
addConsulta()create()setProfesor()setAsignatura()getConsultas()
(from Comun)
profesor : Profesorasignatura : Asignatura
1
0..*
1
profesor : Profesorasignatura : Asignatura
-temas 0..*
organiza consultas por
Consulta
titulo : Stringfecha : Datehora : Timemensaje : Stringestado : String
create()setTitulo()setMensaje()getMensaje()setLeido()setRespuesta()estaLeida()estaRespondida()
(from Comun)
0..*
1 -consultas
0..*
1
contiene
Respuesta
mensaje : Stringfecha : Datehora : Time
create()
(from Comun)
1 0..11
-respuesta
0..1
TutoriaAsignatura
estaEnTutoria()setEnTutoria()setPeridoActual()setSinTutoria()addPeriodoTutoria()
(from Profesor)
GestorConsultas(from Comun)
<<controlador>>
Periodo
inicio : Timefin : Time
create()setInicioPerido()setFinPeriodo()
(from Comun)
0..*
1
-periodos
0..*
1
ConsultaEnLinea
terminarConsultaEnLinea()getProfesor()create()setAlumno()setProfesor()setGestores()getAlumno()getGestorAlumno()enviarMensaje()destroy()consultaAceptada()consultaRechazada()
(from Comun)
1-gestorAlumno
1
1-gestorProfesor
10..1
-periodo
0..1
Curso UML 140
Herencia
• Hasta ahora no hemos tenido en cuenta la herencia.
• En nuestra aplicación surge la necesidad de la herencia con las clases controlador:– ExploradorAlumno-ExploradorProfesor
– BuzonAlumno-BuzonProfesor
– GestorConsultasAlumno-GestorConsultasProfesor
– GestorAlumno-GestorProfesor Factorizar comportamiento común
• También con Alumno y Profesor
Curso UML 141
Herencia
• Aparecen nuevas clases:– Explorador
– Buzon
– GestorConsultas
– Gestor
– Universitario
• Las clases que teníamos serán subtipos de estas últimas
Curso UML 142
Alumno
addTema()getTemas()
getConsultasNoLeidas()getAsignaturas()
(from Alumno)
GestorConsultas
enviarMensaje()terminarConsultaEnLinea()consultaEnLineaFinalizada()setOyente()
(from Comun)
<<controlador>>Explorador
seleccionarAsignatura()setAsignatura()seleccionarConsulta()setConsulta()seleccionarTema()setTema()
(from Comun)
<<controlador>>
Buzon
seleccionarConsulta()setConsulta()
(from Comun)
<<controlador>>
Gestor
getInstancia()getExplorador()getGestorConsultas()getBuzon()getGestorCentral()getGestorIdentificacion()
(from Comun)
BuzonProfesor
responderConsulta()getConsultasNoRespondidas()
(from Profesor)
<<controlador>>
GestorConsultasProfesor
aceptarConsulta()rechazarConsulta()responderConsulta()
(from Profesor)
<<controlador>>
GestorProfesor
getGestorTutorias()getInstancia()getExplorador()getGestorConsultas()getBuzon()getGestorCentral()getGestorIdentificacion()getProfesor()
(from Profesor)
<<Singleton>>BuzonAlumno
marcarConsultaLeida()getConsultasNoLeidas()
(from Alumno)
<<controlador>>
GestorConsultasAlumno
nuevaConsulta()nuevoTema()solicitudConsultaEnLinea()consultaAceptada()consultaRechazada()getProfesoresEnLinea()
(from Alumno)
<<controlador>>
GestorAlumno
getInstancia()getExplorador()getGestorConsultas()getBuzon()getGestorCentral()getGestorIdentificacion()getAlumno()
(from GestorConsultasAlumno)
<<Singleton>>
Universitario
DNI : StringNombre : String
(from Universidad)
ExploradorAlumno
seleccionarAsignatura()seleccionarProfesor()setProfesor()getAsignaturasMatriculado()
(from Alumno)
<<controlador>>ExploradorProfesor
seleccionarAsignatura()seleccionarAlumno()setAlumno()getAsignaturasProfesor()
(from Profesor)
<<controlador>>
Profesor
addConsultaEnLinea()estaEnLinea()
getAsignaturas()
(from Profesor)
Curso UML 143
Pantallas
• Las interfaces de usuario están relacionadas• Poseen una relación de creación• Las interfaces utilizan un controlador
(dependencia)• Es conveniente mostrar un diagrama que contenga
estas relaciones
Curso UML 144
Pantallas: Alumno
PBuzonAlumno
PSolicitudConsulta
PNuevoTema
PConsulta
PPrincipal
<<create>>
PExploradorAlumno
<<create>>
<<create>>
<<create>><<create>>
GestorConsultasAlumno(from Alumno)
<<controlador>>
ExploradorAlumno(from Alumno)
<<controlador>>
BuzonAlumno(from Alumno)
<<controlador>>
GestorAlumno(from Alumno)
<<Singleton>>
Todas las pantallas tienen una relación de dependencia con el Singleton
Curso UML 145
Pantallas Alumno
PExploradorProfesor
PEstablecerTutorias
PBuzonProfesor
PRespuesta
PPrincipal
BuzonProfesor(from Profesor)
<<controlador>>
ExploradorProfesor(from Profesor)
<<controlador>>
GestorTutorias(from Profesor)
<<controlador>>
GestorConsultasProfesor(from Profesor)
<<controlador>>
GestorProfesor(from Profesor)
<<Singleton>>
<<create>>
<<create>>
<<create>>
<<create>>
<<create>>
PAceptarConsulta
Todas las pantallas tienen una relación de dependencia con el Singleton
Curso UML 146
Distribución
• La mayor parte de los objetos de la aplicación necesitan ser distribuidos.
• Para conseguir la distribución de los objetos utilizaremos CORBA
• Necesitamos definir las interfaces CORBA para los objetos.
• Modificaciones: definir interfaces CORBA y las clases renombrarlas con el sufijo Impl.
Curso UML 147
Distribución
ConsultaEnLineaImpl
terminarConsultaEnLinea()getProfesor()create()
setAlumno()setProfesor()setGestores()getAlumno()getGestorAlumno()enviarMensaje()destroy()consultaAceptada()consultaRechazada()
(from Comun)
ConsultaEnLinea
terminarConsultaEnLinea()getProfesor()setAlumno()setProfesor()setGestores()getAlumno()
enviarMensaje()consultaAceptada()
consultaRechazada()
Curso UML 148
Codificación
• Con la herramienta Rational Rose podemos generar código a partir de los diagramas de clases. Lenguajes: Java, C++, Visual Basic, IDL,...
• Genera todo el código excepto la implementación de los métodos.
• Permite conectar la herramienta con cualquier IDE del lenguaje de programación utilizado.
• Ingeniería Inversa: cualquier modificación en el código se verá reflejada en el modelo
• Round Trip Engineering.
Curso UML 149
Fin Primer Ciclo Desarrollo
• Es recomendable realizar un proceso de desarrollo iterativo e incremental
• Al final de cada fase obtenemos un producto totalmente funcional (con simplificaciones)
• Temas pendientes:– Realizar los cálculos necesarios para la universidad:
porcentaje de cumplimiento de tutorías, consultas respondidas, etc.
– Distribución– Persistencia– ...
Curso UML 150
Persistencia
• La mayor parte de los objetos de la aplicación deben ser persistentes.– Los controladores no deben ser persistentes
• Alternativas:– Utilizar un servidor de aplicaciones Enterprise
JavaBeans.• La mayor parte de los objetos serían EJB Entity (persistentes)
• Modificaciones en el diseño:– Creación, localización y destrucción de los objetos utilizando las
interfaces home.
– Framework de persistencia basado en CORBA
Curso UML 151
Persistencia
• Framework de persistencia basado en CORBA:– En nuestro sistema existe un servidor CORBA
– Definimos interfaces home para los objetos CORBA
– Modificación en el diseño:• Creación, localización y destrucción de los objetos utilizando
las interfaces home.
Curso UML 152
Diagrama de Despliegue
Ordenador Alumno
Ordenador Profesor
Servidor Central
<<CORBA>>
InternetInternet
Internet
<<ORB>>
<<ORB>><<ORB>>
Curso UML 153
Componentes
• Cuando modelemos una aplicación debemos pensar en los componentes.
• En nuestra aplicación podemos identificar algunos componentes reutilizables. Por ejemplo, el Buzón.
• Lo ideal sería desarrollar un componente gráfico Buzón que fuera reutilizable.– En nuestra aplicación los buzones tienen un Director
que indicará los elementos a listar.
– Los elementos de la lista deben tener un Descriptor y un Contenido.
Curso UML 154
Componentes
• Definimos dos interfaces (en Java):– IDirectorBuzon
• String [] etiquetas ()
• IElementoBuzon [] elementos ()
– IElementoBuzon• String [] descriptor ()
• String contenido ()
• Nuestro componente tendrá la siguiente interface:– void setDirector (IDirectorBuzon)
– IElementoBuzon getElementoSeleccionado ()
Curso UML 155
Componentes
• Desarrollaremos un interfaz gráfico basado en los componentes Swing de Java:
IBuzon
setDirector()getElementoSeleccionado()
IElementoBuzon
descriptor()contenido()
IDirectorBuzon
etiquetas()elementos()
JScrollPane(from Swing)
JPane(from Swing)
JTable(from Swing)
JTextArea(from Swing)
BuzonGrafico
0..*1
11
1
1
-elementos
0..*-director
1
-contenido
1
-descriptores
1-scrollpane1
-panel
1
BuzonGrafico
IBuzon