Licence 3 Informatique – Génie Logiciel TP5: Patrons de conception 2

Ce TP explore les patrons de conception Observer et Décorateur à travers plusieurs exercices pratiques. Vous apprendrez à découpler des composants logiciels en respectant les principes SOLID, à utiliser les fonctionnalités d’Observable en Java 8, et à appliquer ces concepts dans un contexte concret, celui d’un concours de mangeurs de galettes. Pour réaliser ce TP, il est nécessaire de maîtriser les bases de la programmation orientée objet en Java et d’avoir des connaissances sur les tests unitaires, notamment avec Mockito.

Objectifs

• Manipuler les patrons de conception Observable et Décorateur
• Comprendre et appliquer les principes SOLID
• Utiliser les fonctionnalités d’Observable en Java 8
• Écrire des tests unitaires avec des objets Mock

Prérequis et mise en place

• Connaissances en programmation orientée objet en Java
• Environnement Java 8 ou supérieur
• Bibliothèque Mockito pour les tests unitaires
• Notions sur les patrons de conception Observer et Décorateur
• Accès à un IDE ou un terminal pour coder et exécuter les tests

Exercice 1 : Le patron de conception Observable

Dans cet exercice, vous allez implémenter la partie affichage d’une station météo, un exemple classique du patron Observer. La station météo (WeatherData) récupère des données de température, humidité et pression, et notifie plusieurs afficheurs qui doivent afficher ces données.

La spécification initiale est incomplète et ne respecte pas les principes SOLID car la classe WeatherData est fortement couplée aux afficheurs. L’objectif est donc de proposer un diagramme de classes basé sur le patron Observer pour découpler WeatherData des afficheurs.

À faire :

• Proposer un diagramme de classes respectant le patron Observer
• Implémenter cette solution en Java
• Utiliser des objets Mock pour écrire des tests unitaires validant le bon fonctionnement

Pourquoi : Cette étape permet de comprendre comment découpler les composants en respectant SOLID, en particulier le principe de responsabilité unique et le principe d’ouverture/fermeture.

Résultat attendu : Une classe WeatherData qui ne connaît pas directement les afficheurs, mais qui notifie des observateurs via une interface commune.

Exercice 2 : Utilisation d’Observable en Java 8

Depuis Java 8, le patron Observable est disponible dans le paquetage java.util. Vous devez reprendre l’exercice précédent en utilisant cette implémentation standard.

À faire :

• Modifier le code précédent pour que WeatherData étende ou utilise java.util.Observable
• Adapter les afficheurs pour qu’ils implémentent java.util.Observer
• Modifier les tests unitaires pour prendre en compte cette nouvelle architecture
• Réfléchir à l’utilisation de Mockito pour tester la partie observable

Pourquoi : Cela permet de comprendre comment utiliser les outils fournis par la JDK pour implémenter le patron Observer et comment adapter les tests en conséquence.

Résultat attendu : Une application fonctionnelle utilisant java.util.Observable et java.util.Observer, avec des tests unitaires adaptés.

Exercice 3 : Application du patron Observable au concours de galettes

Dans ce nouvel exercice, vous appliquez le patron Observable à un concours de mangeurs de galettes. Vous devez ajouter une classe Supporteur qui représente les spectateurs du concours. Ces supporteurs doivent applaudir à chaque élimination d’un concurrent.

À faire :

• Modifier le diagramme de classes pour intégrer la classe Supporteur
• Utiliser le patron Observable pour découpler les supporteurs du concours
• Écrire les tests unitaires associés pour valider cette interaction

Pourquoi : Cet exercice illustre l’utilisation du patron Observer dans un contexte différent, renforçant la compréhension de son utilité pour gérer des événements et notifications.

Résultat attendu : Une classe Supporteur observant le concours, recevant une notification à chaque élimination, avec des tests unitaires validant ce comportement.

Exercice 4 : Finalisation du concours avec le patron Décorateur

Le concours de galettes s’agrandit avec de nombreux concurrents proposant toujours plus d’ingrédients. La conception actuelle basée sur des fabriques devient difficile à maintenir. Vous devez donc reprendre la conception en introduisant le patron Décorateur pour gérer les ingrédients des galettes.

À faire :

• Modifier le diagramme de classes pour intégrer le patron Décorateur dans la gestion des ingrédients
• Modifier le code de l’application en conséquence
• Adapter les tests unitaires au fur et à mesure des modifications

Pourquoi : Le patron Décorateur permet d’ajouter dynamiquement des fonctionnalités (ici des ingrédients) sans modifier les classes existantes, améliorant la maintenabilité.

Résultat attendu : Une conception flexible où les galettes peuvent être décorées avec différents ingrédients, avec un code et des tests cohérents.

Résultats attendus

• Une implémentation du patron Observer qui découple WeatherData des afficheurs
• Une adaptation utilisant java.util.Observable et java.util.Observer en Java 8
• Une extension du concours de galettes avec une classe Supporteur observant les éliminations
• Une gestion des ingrédients des galettes basée sur le patron Décorateur
• Des tests unitaires utilisant des objets Mock pour valider chaque étape

Pièges courants

• Ne pas découpler correctement WeatherData des afficheurs, ce qui mène à un couplage fort et à une violation des principes SOLID
• Oublier d’adapter les tests unitaires lors de la migration vers java.util.Observable
• Ne pas utiliser d’interface commune pour les observateurs, rendant le code rigide
• Confondre le rôle du patron Décorateur avec celui d’une simple extension ou héritage
• Ne pas mettre à jour les tests lors de l’introduction du patron Décorateur, ce qui peut masquer des erreurs