Centre universitaire - Salhi Ahmed - de Naâma

Institut des Sciences

Département d’Informatique
3ème Année Licence
Matière : Génie logiciel

Fiche TD (TP) 07 : Design patterns

Exercice 01 : Mettez en pratique les design patterns abordés au cours.

 langage de développement: java.

Exercice 02 :
1) Le design pattern MVC : Modèle-Vue-Contrôleur ou MVC est un motif (pattern)
d'architecture logicielle destiné aux interfaces graphiques, lancé en 1978 et très populaire
pour les applications web. Le motif est composé de trois types de modules ayant trois
responsabilités différentes : les modèles, les vues et les contrôleurs.
 Un modèle (Model) contient les données à afficher, et tout ce qui permet de les
modifier (getters, setters, etc.).
 Une vue (View) contient la présentation de l'interface graphique.
 Un contrôleur (Controller) traite les actions de l'utilisateur, modifie les données du
modèle et de la vue. C’est ici que sont la plupart des algorithmes, calculs, etc.
Le schéma suivant présente les interactions entre les différentes couches :

Interactions entre les couches

2) Exemple à suivre : Prenons un exemple simple d'une application de gestion de tâches (to-
do list) en utilisant le pattern MVC en Java.
Dans cet exemple, le modèle TaskModel gère la liste des tâches, la vue TaskView affiche
les tâches, et le contrôleur TaskController gère l'interaction entre le modèle et la vue.

1/4
a) Le modèle (Model) : TaskModel.java
package model;
import java.util.ArrayList;
import java.util.List;

public class TaskModel {

private List<String> tasks = new ArrayList<>();

public void addTask(String task) {

tasks.add(task);
}

public List<String> getTasks() {

return tasks;
}
}

b) La vue (View) : TaskView.java

package view;

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionListener;
import java.util.List;

public class TaskView {

private JFrame frame;
private JList<String> taskList;
private JTextField newTaskTextField;
private JButton addButton;

public TaskView() {
frame = new JFrame("To-Do List");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setSize(300, 200);

taskList = new JList<>();

newTaskTextField = new JTextField(15);
addButton = new JButton("Add Task");

frame.setLayout(new FlowLayout());
frame.add(taskList);
frame.add(newTaskTextField);
frame.add(addButton);

frame.setVisible(true);
}

public void displayTasks(List<String> tasks) {

taskList.setListData(tasks.toArray(new String[0]));
}

2/4
 public String getNewTask() {
return newTaskTextField.getText();
}

public void addButtonListener(ActionListener listener) {

addButton.addActionListener(listener);
}
}

c) Le contrôleur (Controller): TaskController.java

package controller;

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import model.TaskModel;
import view.TaskView;

public class TaskController {

private TaskModel model;
private TaskView view;

public TaskController(TaskModel model, TaskView view) {

this.model = model;
this.view = view;

// Ajout d'un ActionListener au bouton pour gérer l'ajout de tâches

view.addButtonListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
String newTask = view.getNewTask();
addTask(newTask);
}
});
}

public void addTask(String task) {

model.addTask(task);
updateView();
}

public void updateView() {

view.displayTasks(model.getTasks());
}
}

3/4
 d) La classe lanceur : On va maintenant créer la classe « main » de l'application.
package main;

import controller.TaskController;
import model.TaskModel;
import view.TaskView;

public class Main {

public static void main(String[] args) {
TaskModel model = new TaskModel();
TaskView view = new TaskView();
TaskController controller = new TaskController(model, view);

// Ajout de tâches
controller.addTask("Faire les courses");
controller.addTask("Répondre aux e-mails");

// Affichage initial des tâches

controller.updateView();
}
}

Voilà ce que donnera donc notre application finalement :

3) Travail à faire : Pour approfondir votre compréhension du principe, étendez l'application

pour inclure les fonctionnalités de suppression et de modification des tâches.

Remarques :
L'utilisation du pattern MVC permet une très bonne séparation des couches et facilite
l'ajout ou la modification de vues.
Par contre, elle nécessite un travail supplémentaire et augmente la quantité et la
complexité de code à écrire. Ce pattern n'est donc à conseiller que pour les moyennes et
grandes applications.

4/4