Chapitre 6: Architecture Logicielle

Ce matériel couvre les principes fondamentaux de l'architecture logicielle, en s'appuyant sur un exemple simple de calculatrice. Il s'adresse aux étudiants en informatique ou en génie logiciel souhaitant comprendre comment structurer un projet logiciel, séparer les responsabilités et appliquer des architectures classiques comme le modèle MVC.

Comment structurer un projet logiciel ?

Structurer un projet logiciel consiste à définir son architecture, c’est-à-dire la manière dont les composants sont organisés, leurs relations entre eux et avec l’environnement logiciel. Cette étape est cruciale car elle influence directement la conception et le développement du code.

Par exemple, une calculatrice simple peut être modélisée avec des classes telles que Calculatrice, FrameCalculatrice, OperationButton et NumericButton. Ces classes interagissent entre elles, mais un seul diagramme de classes pour un projet complexe devient rapidement insuffisant.

Il est donc recommandé de séparer clairement les concepts, notamment :

• Un modèle pour l'interface homme-machine (IHM)
• Un modèle pour le cœur métier, ici la calculatrice elle-même

Cette séparation facilite la maintenance, la compréhension et l’évolution du projet.

Séparation en deux paquetages

Une bonne pratique consiste à découper le projet en deux paquetages distincts :

• ModèleCalculatrice : contient tous les éléments liés à la logique métier de la calculatrice (ex : opérations, stockage de la valeur, etc.)
• IHMCalculatrice : contient tous les éléments liés à l’interface utilisateur (ex : affichage, boutons, gestion des événements)

Ces deux paquetages sont liés par des dépendances, où l’IHM peut utiliser les éléments du modèle métier. Il est important d’éviter les dépendances circulaires entre ces paquetages pour ne pas complexifier la structure.

Exemple de diagramme simplifié

Dans le paquetage ModèleCalculatrice, on trouve la classe Calculatrice avec les méthodes :

• ajouter(nombre: integer)
• soustraire(nombre: integer)
• intialiser()
• toString(): String

La classe Calculatrice possède un attribut valeur: integer initialisé à 0.

Dans le paquetage IHMCalculatrice, la classe FrameCalculatrice gère l’affichage et les interactions utilisateur, avec des méthodes comme :

• refreshDisplay()
• intialiser()
• AddCible(calculatrice: Calculatrice)

Les architectures n-tiers

Pour des projets plus complexes, la décomposition en plusieurs niveaux (ou tiers) est utilisée. Cette décomposition peut être horizontale ou verticale et vise à mieux organiser les responsabilités.

Architecture 3-tiers : le modèle MVC

Le modèle MVC (Model-View-Controller) est un patron de conception très utilisé, notamment dans le développement web, qui sépare clairement les responsabilités en trois couches :

• Model (Modèle) : représente la logique métier et les données spécifiques à l’application. Par exemple, la classe Calculatrice qui gère les opérations.
• View (Vue) : concerne la représentation des données, c’est-à-dire l’affichage à l’écran ou sur un autre périphérique. Il peut y avoir plusieurs vues pour un même modèle.
• Controller (Contrôleur) : gère les interactions avec l’utilisateur, détermine les traitements à effectuer et fait le lien entre le modèle et la vue.

Exemple simplifié MVC pour la calculatrice

• Modèle : la classe Calculatrice avec ses méthodes d’ajout et de soustraction.
• Vue : la classe FrameCalculatrice qui affiche la valeur courante et les boutons.
• Contrôleur : un composant qui capte les clics sur les boutons, appelle les méthodes du modèle et met à jour la vue.

Diagramme de paquetage

Le diagramme de paquetage permet de représenter l’organisation structurelle et modulaire d’un projet logiciel. Chaque paquetage est un espace de noms contenant des diagrammes ou d’autres paquetages. Les dépendances entre paquetages sont indiquées par des relations « use ».

Quelques règles importantes :

• Pas de transitivité automatique des dépendances : si A dépend de B et B dépend de C, A ne dépend pas nécessairement de C.
• Différents stéréotypes de dépendance existent :
• import : utilisation des éléments importés sans préfixe
• access : les éléments sont accessibles
• merge : fusion de deux paquetages en un seul

Glossaire des termes clés

• Architecture logicielle : structure d’un logiciel en termes de composants, relations entre eux et avec l’environnement.
• Paquetage : regroupement logique d’éléments (classes, diagrammes) formant un espace de noms.
• Dépendance : relation où un élément utilise ou dépend d’un autre.
• Modèle (Model) : couche représentant la logique métier et les données.
• Vue (View) : couche représentant la présentation des données à l’utilisateur.
• Contrôleur (Controller) : couche gérant les interactions utilisateur et coordonnant modèle et vue.
• Paquetage ModèleCalculatrice : contient la logique métier de la calculatrice.
• Paquetage IHMCalculatrice : contient les éléments liés à l’interface utilisateur.
• Architecture n-tiers : décomposition d’un système en plusieurs couches ou niveaux.
• Patron MVC : modèle architectural séparant modèle, vue et contrôleur.

Points clés à retenir

• La structuration d’un projet logiciel passe par la définition de son architecture.
• Il est essentiel de séparer clairement le cœur métier (modèle) de l’interface utilisateur (IHM).
• La séparation en paquetages évite les dépendances circulaires et facilite la maintenance.
• L’architecture 3-tiers, notamment le modèle MVC, permet une meilleure organisation et évolutivité.
• Le diagramme de paquetage UML aide à visualiser la structure modulaire et les dépendances.