1 Ingeniería de Software II Información obtenida de Internet UNIVERSIDAD DE SAN MARTIN DE PORRES FACULTAD DE INGENIERIA Y ARQUITECTURA Profesor: Ing. Luis Palacios Quichíz

2 Caso Práctico UML Curso de UML para el Servicio de Informática Universidad de Murcia Julio de 2.000

3 Curso UML3 Contenido Requisitos de la aplicación Casos de uso Modelo conceptual Modelo de Análisis y Diseño Aspectos Avanzados del Diseño

4 Curso UML4 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.

5 Curso UML5 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.

6 Curso UML6 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

7 Curso UML7 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 AlumnoIdentificación Profesor Identificación > Universitario

8 Curso UML8 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

9 Curso UML9 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

10 Curso UML10 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

11 Curso UML11 CDU: Crear Tema Consulta Variaciones: –1.a. El tema de consulta existe 1.a.1: Indicar error 1.a.2: Finalizar cdu.

12 Curso UML12 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.

13 Curso UML13 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

14 Curso UML14 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

15 Curso UML15 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

16 Curso UML16 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.

17 Curso UML17 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

18 Curso UML18 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.

19 Curso UML19 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

20 Curso UML20 CDU: Explorar Consultas Profesor Pasos: (continuación) –5. A: Selecciona el Tema –6. S: Muestra las consultas de ese tema

21 Curso UML21 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)

22 Curso UML22 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

23 Curso UML23 CDU: Identificación Variaciones: –5. a. El PIN no es correcto 5.a.1: Solicitar el PIN hasta 3 veces Extensiones: –Tipo de usuario

24 Curso UML24 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

25 Curso UML25 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

26 Curso UML26 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,...

27 Curso UML27 Pantallas: Realizar Consulta

28 Curso UML28 Pantallas: Crear Tema Consulta

29 Curso UML29 Pantallas: Buzón de Entrada Alumno

30 Curso UML30 Pantallas: Explorador Alumno

31 Curso UML31 Pantallas: Consulta en Línea

32 Curso UML32 Pantallas: Consulta en Línea

33 Curso UML33 Pantallas: Consulta en Línea

34 Curso UML34 Pantallas: Responder Consulta

35 Curso UML35 Pantallas: Buzón de Entrada Profesor

36 Curso UML36 Pantallas: Explorador Profesor

37 Curso UML37 Pantallas: Establecer Tutorías

38 Curso UML38 Pantallas: Identificación

39 Curso UML39 Modelo Conceptual Conceptos y Atributos: –Alumno: DNI Nombre –Profesor: DNI Nombre –Asignatura: Código Nombre

40 Curso UML40 Modelo Conceptual Conceptos y Atributos: –Consulta: Título Fecha Hora Mensaje –Respuesta: Fecha Hora Mensaje –Tema: Nombre

41 Curso UML41 Modelo Conceptual Conceptos y atributos: –Horario Tutorías –Franja Horaria: hora de inicio hora de fin día de la semana

42 Curso UML42 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

43 Curso UML43 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

44 Curso UML44 1 0..* 1 contiene organiza consultas tema de consulta

45 Curso UML45 Modelado de Análisis y Diseño Diagramas de Secuencia de Sistema Contratos de operaciones Diagramas de interacción Diagramas de clases

46 Curso UML46 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( )

47 Curso UML47 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.

48 Curso UML48 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

49 Curso UML49 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.

50 Curso UML50 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( )

51 Curso UML51 DSS: Realizar Consulta

52 Curso UML52 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.

53 Curso UML53 DI: nuevaConsulta : Alumno : GestorConsultas nuevaConsulta : Consulta tema : Tema nuevaConsulta(String, String, Tema) create( ) setTitulo(String) setMensaje(String) addConsulta(Consulta)

54 Curso UML54 DSS: Crear Tema Consulta

55 Curso UML55 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

56 Curso UML56 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

57 Curso UML57 DI: nuevoTema : Alumno : GestorConsultasnuevoTema : Tema alumno : Alumno nuevoTema(String, Profesor, Asignatura) create( ) setProfesor(Profesor) setAsignatura(Asignatura) addTema(Tema, Profesor, Asignatura)

58 Curso UML58 DSS: Consultar Buzón Entrada Alumno

59 Curso UML59 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

60 Curso UML60 DI: seleccionarConsulta : Alumno : BuzonAlumno : Consulta seleccionarConsulta(Consulta) setConsulta(Consulta) getMensaje( )

61 Curso UML61 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”

62 Curso UML62 DI: marcarConsultaLeida : Alumno : BuzonAlumno consulta : Consulta marcarConsultaLeida( ) setLeida( )

63 Curso UML63 DSS: Explorar Consultas Alumno : Alumno : Sistema seleccionarAsignatura( ) seleccionarProfesor( ) seleccionarTema( ) seleccionarConsulta( ) nuevaConsulta( ) nuevoTema(String, Profesor, Asignatura) cdu "Realizar Consulta" cdu "Crear Tema Consulta"

64 Curso UML64 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

65 Curso UML65 DI: seleccionarAsignatura : Alumno : ExploradorAlumno : Asignatura seleccionarAsignatura(Asignatura) getProfesores( ) setAsignatura( Asignatura)

66 Curso UML66 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

67 Curso UML67 DI: seleccionarProfesor : Alumno : ExploradorAlumno alumno : Alumno seleccionarProfesor(Profesor) setProfesor(Profesor) getTemas(Asignatura, Profesor)

68 Curso UML68 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

69 Curso UML69 DI: seleccionarTema : Alumno : ExploradorAlumno : Tema seleccionarTema(Tema) getConsultas( ) setTema(Tema)

70 Curso UML70 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

71 Curso UML71 DI: seleccionarConsulta : Alumno : ExploradorAlumno : Consulta seleccionarConsulta(Consulta) setConsulta(Consulta) getMensaje( )

72 Curso UML72 DSS: Consulta en Línea : Alumno : Sistema : Profesor solicitarCosulta(Profesor) solicitarConsulta(Alumno) aceptarConsulta( ) enviarMensaje(String) terminarConsultaEnLinea( ) rechazarConsulta( )

73 Curso UML73 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

74 Curso UML74 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

75 Curso UML75 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)

76 Curso UML76 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

77 Curso UML77 DI: aceptarConsulta profesor : Profesor gestorAlumno : GestorConsultasAlumno nuevaConsultaEnLinea : ConsultaEnLinea gestorProfesor : GestorConsultas aceptarConsulta(OyenteConsultaEnLinea ) consultaAceptada( ) consultaAceptada(ConsultaEnLinea) periodo : Periodo create( ) setInicioPerido( ) setOyente(OyenteConsultaEnLinea)

78 Curso UML78 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.

79 Curso UML79 DI: rechazarConsulta gestorAlumno : GestorConsultas profesor : Profesor nuevaConsultaEnLinea : ConsultaEnLinea gestorProfesor : GestorConsultas rechazarConsulta( ) consultaRechazada( ) destroy( )

80 Curso UML80 Contratos: Consulta en Línea Nombre: enviarMensaje (mensaje: String) Responsabilidades: envía un mensaje al otro interlocutor Tipo: GestorConsultas

81 Curso UML81 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)

82 Curso UML82 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.

83 Curso UML83 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( )

84 Curso UML84 DSS: Responder Consulta

85 Curso UML85 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”

86 Curso UML86 DI: responderConsulta : Profesor : GestorConsultas nuevaRespuesta : Respuesta consulta : Consulta responderConsulta(Consulta, String) create(String) setRespuesta(Respuesta)

87 Curso UML87 DSS: Consultar Buzón Entrada Profesor

88 Curso UML88 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

89 Curso UML89 DI: seleccionarConsulta : Profesor : BuzonProfesor : Consulta seleccionarConsulta(Consulta) setConsulta(Consulta) getMensaje( )

90 Curso UML90 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)

91 Curso UML91 Contratos: Consultar Buzón Entrada Profesor Postcondiciones: –Objeto Respuesta es creado –Asociación consulta-Respuesta es creada –consulta.estado = “respondida”

92 Curso UML92 DI: responderConsulta : Profesor : BuzonProfesor : GestorConsultas responderConsulta(String) responderConsulta(Consulta, String) CDU "Responder Consultas" Consulta es un atributo de BuzonProfesor

93 Curso UML93 DSS: Explorar Consultas Profesor : Profesor : Sistema seleccionarAsignatura( ) seleccionarAlumno( ) seleccionarTema( ) seleccionarConsulta( ) responderConsulta( )

94 Curso UML94 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

95 Curso UML95 DI: seleccionarAsignatura : ExploradorProfesor : Profesor : Asignatura seleccionarAsignatura(Asignatura) getAlumnos( ) setAsignatura(Asignatura)

96 Curso UML96 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

97 Curso UML97 DI: seleccionarAlumno : Profesor : ExploradorProfesor : Alumno seleccionarAlumno(Alumno) getTemas(Asignatura, Profesor) setAlumno(Alumno)

98 Curso UML98 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

99 Curso UML99 DI: seleccionarTema : Profesor : ExploradorProfesor : Tema seleccionarTema(Tema) setTema(Tema) getConsultas( )

100 Curso UML100 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

101 Curso UML101 DI: seleccionarConsulta : Profesor : ExploradorProfesor : Consulta seleccionarConsulta(Consulta) setConsulta(Consulta) getMensaje( )

102 Curso UML102 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)

103 Curso UML103 Contratos: Explorar Consultas Profesor Postcondiciones: –Objeto Respuesta es creado –Asociación consulta-Respuesta es creada –consulta.estado = “respondida”

104 Curso UML104 DI: responderConsulta : Profesor : ExploradorProfesor : GestorConsultas responderConsulta(Respuesta) responderConsulta(Consulta, String) CDU "Responder Consultas" El Explorador posee una referencia a la consulta seleccionada

105 Curso UML105 DSS: Establecer Tutorías : Profesor : Sistema seleccionarAsignatura( ) setAsignaturaEnTutoria( ) setAsignaturaSinTutoria( )

106 Curso UML106 Contratos: Establecer Tutorías Nombre: seleccionarAsignatura (asignatura: TutoriaAsignatura) Responsabilidades: recordar la asignatura seleccionada Tipo: GestorTutorias Postcondiciones: –Asociación GestorTutorias-asignatura es creada

107 Curso UML107 DI: seleccionarAsignatura : Profesor : GestorTutorias seleccionarAsignatura(TutoriaAsignatura) setAsignatura(TutoriaAsignatura)

108 Curso UML108 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)

109 Curso UML109 DI: setAsignaturaEnTutoria asignatura : TutoriaAsignatura : Profesor : GestorTutorias nuevoPeriodoTutoria : Periodo setAsignaturaEnTutoria( ) setEnTutoria( ) enTutoria := estaEnTutoria( ) [enTutoria] create( ) setInicioPerido( ) setPeridoActual(PeriodoTutoria)

110 Curso UML110 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)

111 Curso UML111 DI: setAsignaturaSinTutoria : Profesor : GestorTutorias asignatura : TutoriaAsignatura periodoActual : Periodo setAsignaturaSinTutoria( ) setSinTutoria( ) enTutoria := estaEnTutoria( ) [not enTutoria] setFinPeriodo( ) addPeriodoTutoria(PeriodoTutoria)

112 Curso UML112 DSS: Identificación Alumno

113 Curso UML113 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

114 Curso UML114 DI: identificacionAlumno : Profesor : GestorCentral : Tarjetero : GestorIdentificacion identificacionAlumno(PIN) ok := comprobarPIN(PIN) getAlumno(DNI) dni := getDNI( ) [not ok] Excepcion

115 Curso UML115 DSS: Identificación Profesor

116 Curso UML116 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

117 Curso UML117 DI: identificacionProfesor : GestorIdentificacion : Profesor : Tarjetero : GestorCentral identificacionProfesor(PIN) ok := comprobarPIN(PIN) [not ok] dni := getDNI( ) getProfesor(DNI) Excepción

118 Curso UML118 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

119 Curso UML119 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

120 Curso UML120 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)

121 Curso UML121 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.

122 Curso UML122 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

123 Curso UML123 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

124 Curso UML124 DI: getConsultasNoLeidas : BuzonAlumno : Alumno alumno : Alumno : Temaconsulta : Consulta 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()

125 Curso UML125 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

126 Curso UML126 DI: getAsignaturasMatriculado : Alumno : ExploradorAlumno alumno : Alumno getAsignaturasMatriculado( ) getAsignaturas( )

127 Curso UML127 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

128 Curso UML128 DI: getProfesoresEnLinea : GestorConsultasAlumno : Alumnoprofesor : Profesor asignatura : Asignatura alumno : 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

129 Curso UML129 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

130 Curso UML130 DI: getConsultasNoRespondidas : Profesor : BuzonProfesor profesor : Profesor asignatura : Asignatura alumno : Alumno tema : Temaconsulta : 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

131 Curso UML131 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

132 Curso UML132 DI: getAsignaturasProfesor : Profesor : ExploradorProfesor profesor : Profesor getAsignaturasProfesor( ) getAsignaturas( )

133 Curso UML133 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.

134 Curso UML134 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

135 Curso UML135 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

136 Curso UML136

137 Curso UML137

138 Curso UML138 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,....

139 Curso UML139 FranjaHoraria inicio : Time fin : Time dia : Day (from Profesor) Profesor (from Profesor) HorarioTutorias / numeroHoras : Integer (from Profesor) 1 -franjasHorarias 1 Asignatura codigo : String nombre : String getProfesores() getAlumnos() (from Universidad) 1..* -asignaturas 1..* -profesores 1..* imparte Profesor addConsultaEnLinea() estaEnLinea() getAsignaturas() (from Profesor) 1 -horarioTutorias 1 tiene Alumno addTema() getTemas() getConsultasNoLeidas() getAsignaturas() (from Alumno) 1..* -alumnos 1..* -asignaturas 1..* matriculado en 0..* +alumno 0..* +profesor 0..* tutoria en linea Tema nombre : String addConsulta() create() setProfesor() setAsignatura() getConsultas() (from Comun) profesor : Profesor asignatura : Asignatura 1 0..* 1 profesor : Profesor asignatura : Asignatura -temas 0..* organiza consultas por Consulta titulo : String fecha : Date hora : Time mensaje : String estado : String create() setTitulo() setMensaje() getMensaje() setLeido() setRespuesta() estaLeida() estaRespondida() (from Comun) 0..* 1 -consultas 0..* 1 contiene Respuesta mensaje : String fecha : Date hora : Time create() (from Comun) 10..11 -respuesta 0..1 TutoriaAsignatura estaEnTutoria() setEnTutoria() setPeridoActual() setSinTutoria() addPeriodoTutoria() (from Profesor) GestorConsultas (from Comun) > Periodo inicio : Time fin : 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 1 0..1 -periodo 0..1

140 Curso UML140 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

141 Curso UML141 Herencia Aparecen nuevas clases: –Explorador –Buzon –GestorConsultas –Gestor –Universitario Las clases que teníamos serán subtipos de estas últimas

142 Curso UML142

143 Curso UML143 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

144 Curso UML144 Pantallas: Alumno PBuzonAlumno PSolicitudConsulta PNuevoTema PConsulta PPrincipal > PExploradorAlumno > GestorConsultasAlumno (from Alumno) > ExploradorAlumno (from Alumno) > BuzonAlumno (from Alumno) > GestorAlumno (from Alumno) > Todas las pantallas tienen una relación de dependencia con el Singleton

145 Curso UML145 Pantallas Alumno PExploradorProfesor PEstablecerTutorias PBuzonProfesor PRespuesta PPrincipal BuzonProfesor (from Profesor) > ExploradorProfesor (from Profesor) > GestorTutorias (from Profesor) > GestorConsultasProfesor (from Profesor) > GestorProfesor (from Profesor) > PAceptarConsulta Todas las pantallas tienen una relación de dependencia con el Singleton

146 Curso UML146 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.

147 Curso UML147 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()

148 Curso UML148 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.

149 Curso UML149 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 –...

150 Curso UML150 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

151 Curso UML151 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.

152 Curso UML152 Diagrama de Despliegue Ordenador Alumno Ordenador Profesor Servidor Central > Internet >

153 Curso UML153 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.

154 Curso UML154 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 ()

155 Curso UML155 Componentes Desarrollaremos un interfaz gráfico basado en los componentes Swing de Java: IBuzon setDirector() getElementoSeleccionado() IElementoBuz on descriptor() contenido() IDirectorBuzon etiquetas() elementos() JScrollPane (from Swing) JPane (from Swing) JTable (from Swing) JTextArea (from Swing) BuzonGrafico 0..* 1 1 1 1 1 -elementos 0..* -director 1 -contenido 1 -descriptores 1 -scrollpane 1 -panel 1 BuzonGrafico IBuzon