TP8 - jMolecules et ArchUnit

1. Résumé

jMolecules est un ensemble d’annotations Java qui permettent l’expression explicite de concepts architecturaux, améliorant ainsi la clarté et la maintenabilité du code.

jMolecules aide à préserver le code du domaine de toute dépendance technique et exprime ces concepts techniques à travers des annotations et des interfaces basées.

En fonction de l’approche et de la conception choisies, on peut importer le module jMolecules pertinent pour exprimer les concepts techniques spécifiques à ce style.
Voici, par exemple, quelques styles de conception pris en charge et les annotations associées que l’on peut utiliser :

Conception pilotée par le domaine (DDD)

@Entity, @ValueObject, @Repository et @AggregateRoot

Architecture CQRS

@Command, @CommandHandler et @QueryModel

Architecture en couches

@DomainLayer`, @ApplicationLayer et @InfrastructureLayer

Tableau 1. Résumé des annotations jMolecules

Concept

Annotation

Cible

Entité

@Entity

Types

Objet-Valeur

@ValueObject

Types

Dépôt

@Repository

Types

Service

@Service

Types

Fabrique

@Factory

Types

Identité

@Identity

Champs et méthodes (accesseurs)

ArchUnit est une bibliothèque de tests qui nous permet de vérifier qu’une application respecte un ensemble donné de règles architecturales. Mais qu’est-ce qu’une règle architecturale ? Et surtout, qu’est-ce que ArcUnit entend par architecture ?

Il s’agit de la Vue du développement, qui est un des aspects de l’architecture d’un logiciel. Cette vue s’intéresse à la manière dont on organise les différentes classes de notre application en paquets.

La vue du développement définit également la manière dont les paquets ou groupes de paquets, également appelés couches, interagissent. En termes plus pratiques, elle définit si le code d’un paquet donné peut appeler une méthode d’une classe appartenant à un autre paquet. Supposons, par exemple, que l’architecture d’une application comporte trois couches : présentation, service et persistance.

Une façon de visualiser l’interaction entre ces couches consiste à utiliser un diagramme de paquets UML avec un paquet représentant chaque couche :

svg

Ce diagramme nous permet d’extraire certaines règles :

  • Les classes du paquet Présentation ne doivent dépendre que des classes du paquet Service.

  • Les classes du paquet Service ne doivent dépendre que des classes du paquet Persistance.

  • Les classes du paquet Persistance ne doivent dépendre d’aucune autre.

Grâce à ces règles, nous pouvons maintenant revenir à notre question initiale. Dans ce contexte, une règle architecturale est une affirmation sur la manière dont les classes de notre application interagissent entre elles.

Maintenant, comment vérifier que notre implémentation respecte ces règles{nbsp? C’est là qu'ArchUnit entre en jeu. Il permet d’exprimer nos contraintes architecturales à l’aide d’une API fluide et de les valider parallèlement à d’autres tests automatiques.

ArchUnit et jMolecules s’intègrent parfaitement. En effet, le projet jMolecules propose un ensemble de règles architecturales prêtes à l’emploi.

2. Instructions

  1. Utilisez les annotations jMolecules pour identifier les Services, les Dépôts, les Entités, les Identités, les Objets-Valeur et les Agrégats du code source.

  2. Utilisez ArchUnit pour vérifier que le code respecte bien les règles architecturales de la conception pilotée par le domaine.