• Transparents de cours :
  • Introduction (pdf)
  • JDBC (1/2) (pdf)
  • JDBC (2/2) (pdf)
  • Tests (pdf)
  • Interfaces graphiques (pdf)
  • Architecture logicielle (pdf)
• Planches de TP :
  • TP 1 (pdf)
  • TP 2 (pdf)
  • TP 3 (pdf)
  • TP 4 (pdf)
  • TP 5 (pdf)
  • TP 6 (pdf)

Gestion de notes (2/6)

Introduction

Il y a deux objectifs pour cette séance de TP :

1. Modifier le dépôt du projet pour permettre de stocker de manière persistante les données de notre serveur de gestion de notes en utilisant un système de gestion de bases relationnelles. Vous allez utiliser la base de données embarquée HyperSQL que vous allez configurer via un fichier stockant des properties.
2. Décomposer le code de la partie contrôleur de votre projet afin de bien séparer les fonctionnalités d’affichage (la vue) des fonctionnalités de modification et d’accès du modèle.

Stockage persistant

Ressources utiles

SQL

• SQL Statements documentation
• SQLSTATE Messages documentation

JDBC

• Les transparents du cours ;
• Le Guide JDBC d’Oracle ;
• Le cours de base chez Oracle ;
• JavaDoc du module java.sql contenant les packages java.sql et javax.sql.

HyperSQL

• Home page HyperSQL
• Documentation HyperSQL

Properties

• Documentation classe Properties ;
• Tutoriel properties.

Gestion des Exceptions

• Cours Exception Oracle
• Explication try with ressources

Créer un DAO utilisant JDBC

Votre tâche pour cette semaine est donc de mettre en place le stockage et l’accès aux données via JDBC. Pour cela, vous devrez :

• Créer des classes DAO permettant d’accéder à des données dans une base de données relationnelles. Ces classes devront initialiser les données de la table. Les trois classes DAO à créer sont :
  • JDBCStudentDAO implémentant l’interface DAO<Integer, StudentDTO> ;
  • JDBCCourseDAO implémentant l’interface DAO<Integer, CourseDTO> ;
  • JDBCTeacherDAO implémentant l’interface DAO<Integer, TeacherDTO>.
• Mettre en place un système de configuration via un fichier configuration.properties (dans le répertoire src/main/ressources) stockant des properties comme l’adresse du serveur SQL et les identifiants d’accès.

Une première version du fichier pourra être la suivante :

db_url=jdbc:hsqldb:mem:mymemdb
db_username=SA
db_password=
dao_type=memoryWithInit

Refactorisation de la vue et du contrôleur

Comme demandé pour le TP précédent, vous devez également refactoriser le code de votre projet pour bien séparer les responsabilités entre la vue et le contrôleur. L’objectif est de faire en sorte que le contrôleur ne gère que les interactions avec le modèle alors que la vue s’occupera de l’affichage y compris de la gestion des routes. La partie contrôleur de l’application ne doit pas être dépendantes des détails de la vue et donc des choix de bibliothèques pour la gestion du serveur (Javalin) ou la gestion des templates (JTE). Un changement de la bibliothèque de gestion du serveur ou des templates ne devrait pas impacter le code du contrôleur de l’application.

Pour réaliser cette séparation, vous devez créer une interface AppController qui contiendra les méthodes nécessaires pour gérer les différentes actions de l’application (ajout, suppression, modification, affichage des étudiants, cours, enseignants, ...). Ensuite, vous devez créer une classe ConcreteAppController qui implémente cette interface en interagissant avec la partie modèle (le package model) et persistance (package storage) de votre application. Enfin, vous devez modifier la partie vue de votre application pour qu’elle utilise l’interface AppController pour effectuer les différentes actions. La vue devra être responsable de la gestion des routes et de l’affichage des données, mais elle devra déléguer les opérations de modification et d’accès aux données du modèle au contrôleur. Pour cela, vous pouvez créer une interface WebView et une classe ConcreteWebView qui gèrera les routes et utilisera une instance de AppController pour effectuer les opérations nécessaires. Afin d’encore mieux séparer les responsabilités, vous pouvez également créer des classes spécifiques pour gérer les routes liées aux différentes fonctionnalités de votre application, chacune utilisant l’interface AppController pour effectuer les opérations nécessaires. Il faudra donc mettre en place un mécanisme afin que des instances de classes dans la vue (implémentant l’interface WebView) puissent s’enregistrer au près d’une instance d’AppController.