Classification

Classification automatique du domaine.
Du code source au modèle architectural.

HexaGlue lit votre code Java et attribue un rôle architectural à chaque classe : agrégat, entité, value object, port, service. Sans annotation, sans configuration obligatoire.

Concept

Un compilateur d'architecture

Un compilateur de code transforme du texte en instructions exécutables. HexaGlue fait la même chose pour l'architecture : il parse le code source de votre application, en extrait une représentation intermédiaire, puis la transforme en un modèle sémantique où chaque classe porte un rôle architectural précis.

Le résultat : une vision complète et fidèle de votre application. Classes, relations entre elles, arborescence des packages, signatures de méthodes, typage des attributs : HexaGlue sait exactement comment votre code est structuré.

Compatibilité

Lombok et annotation processors

HexaGlue s'intègre nativement avec les outils de génération de code les plus courants de l'écosystème Java.
Aucune configuration n'est nécessaire : la détection et l'adaptation sont automatiques.

Support Lombok automatique

HexaGlue détecte automatiquement Lombok dans les dépendances Maven et injecte un delombok transparent avant l'analyse. Le code analysé est le code expandé : @Data, @Builder, @Getter sont résolus en champs et méthodes réels.

Mode tolerant pour les annotation processors

Les projets utilisant MapStruct, Immutables ou d'autres processeurs d'annotations sont pris en charge grâce au mode tolerant (noClasspath). Le classpath d'analyse inclut automatiquement les classes compilées et les dépendances.

Zéro configuration

Ces fonctionnalités sont activées automatiquement. Pas de modification du pom.xml, pas de paramètre à ajouter. HexaGlue détecte le contexte du projet et s'adapte.

Le delombok s'exécute dans la phase initialize de Maven, avant l'analyse HexaGlue. Les sources générées sont placées dans un répertoire temporaire puis supprimées après l’analyse. Votre code source n’est jamais modifié.

Rôles détectés

11 rôles architecturaux identifiés automatiquement

HexaGlue analyse la structure de vos classes Java et leur attribue un rôle architectural. Voici les rôles détectés, regroupés par couche.

Couche	Rôle	Convention de détection
Domaine	Aggregate Root	Classe avec un champ d'identité typé (ex: `OrderId`)
Domaine	Entity	Classe membre d'un agrégat, sans identité propre
Domaine	Value Object	Record immuable, comportement sans identité
Domaine	Identifier	Record wrappant une valeur primitive (ex: `OrderId(Long value)`)
Domaine	Domain Event	Record avec suffixe `Event` ou interface marqueur
Domaine	Domain Service	Classe stateless dans le domaine, logique transverse
Ports	Driving Port	Interface dans un package `ports/in/` ou `api/`
Ports	Driven Port	Interface dans un package `ports/out/` ou `spi/`
Application	Application Service	Classe implémentant un driving port
Application	Command Handler	Classe traitant une commande spécifique
Application	Query Handler	Classe traitant une requête spécifique

Chaque classification est traçable : HexaGlue enregistre la règle qui a déclenché la décision et le niveau de confiance. Vous pouvez inspecter chaque choix dans le rapport d'audit ou la living documentation.

Inventaire architectural généré par HexaGlue : 11 cartes compteurs montrant les rôles classifiés (Aggregate Roots, Entities, Value Objects, Identifiers, Driving Ports, Driven Ports) — Extrait d'un rapport d'audit HexaGlue : exemple d'un inventaire architectural d'une application bancaire

Diagramme de l'agrégat Order généré par HexaGlue : Aggregate Root avec OrderId, OrderLine, OrderStatus et relations vers CustomerId et InventoryItem — Extrait d'une living documentation HexaGlue : le diagramme de classes d'un agrégat

Mécanisme

Trois niveaux de détection

HexaGlue combine trois stratégies de classification, du plus automatique au plus explicite.

Conventions de nommage et de packages

La position d'une classe dans l'arborescence des packages et ses suffixes orientent la classification. Une interface dans ports/out/ est un driven port. Un record nommé OrderId est un identifiant.

Heuristiques structurelles

La structure interne de la classe affine la détection. Une classe avec un champ d'identité typé est un agrégat. Un record immuable sans identité est un value object. Une interface avec des méthodes save/findById est un repository.

Configuration explicite

Quand les conventions ne suffisent pas, deux options : les annotations jMolecules directement dans le code, ou la surcharge dans hexaglue.yaml pour les réfractaires aux modèles enrichis (voir ci-dessous).

classification:
  # Exclure les classes utilitaires et de configuration
  exclude:
    - "com.acme.shop.config.*"
    - "com.acme.shop.util.*"

  # Surcharger une classification ambiguë
  explicit:
    com.acme.shop.domain.TaskService: DOMAIN_SERVICE
    com.acme.shop.domain.pricing.PricingEngine: DOMAIN_SERVICE

Domaine riche vs anémique

Quand le domaine est mis en défaut

Martin Fowler décrit le modèle de domaine anémiquecomme un anti-pattern où les objets métier ne contiennent que des données, sans comportement. La logique métier est déportée dans des services, et les classes se ressemblent toutes : getters, setters, types primitifs.

HexaGlue s'adapte aux deux situations :

Domaine riche : les conventions et heuristiques suffisent, aucune annotation nécessaire
Domaine anémique : les annotations jMoleculeslèvent l'ambiguïté là où la structure manque

Domaine riche

Le code porte sa propre sémantique. HexaGlue le classifie automatiquement.

Records pour les value objects et identifiants
Champs d'identité typés (OrderId)
Logique métier dans les agrégats, fabriques statiques
Interfaces dans ports/in/ et ports/out/

Domaine anémique

Le code manque de signaux structurels. Les annotations jMolecules expriment l'intention architecturale.

Types primitifs (Long, String) au lieu de value objects
Getters/setters sans logique métier
Classes qui se ressemblent toutes structurellement
@AggregateRoot, @Entity, @ValueObject pour lever l'ambiguïté

Annotations et interfaces jMolecules supportées

Couche	Annotation	Interface	Rôle attribué
Domaine	`@AggregateRoot`	`AggregateRoot`	Aggregate Root
Domaine	`@Entity`	`Entity`	Entity
Domaine	`@ValueObject`	`ValueObject`	Value Object
Domaine	`@Identity`	`Identifier`	Identifier
Événements	`@DomainEvent`	—	Domain Event
Événements	`@Externalized`	—	Externalized Event
Ports	`@PrimaryPort`	`PrimaryPort`	Driving Port
Ports	`@SecondaryPort`	`SecondaryPort`	Driven Port
Ports	`@Repository`	—	Repository (Driven)

jMolecules est une bibliothèque d'annotations purement sémantiques pour le DDD et l'architecture hexagonale. Contrairement à @Entity (JPA) ou @Service (Spring), les annotations jMolecules n'introduisent aucun couplage technique : pas de comportement au runtime, pas de dépendance vers un framework d'infrastructure. Elles expriment une intention architecturale, pas une contrainte technique.

C'est pourquoi les utiliser dans le domaine ne viole pas les principes de l'architecture hexagonale : le domaine reste pur, indépendant de l'infrastructure, et les annotations ne sont consommées qu'au compile-time par des outils comme HexaGlue.

Vous pouvez les adopter progressivement : annotez seulement les classes ambiguës, HexaGlue classifie le reste automatiquement.

Types non classifiés

Les zones grises de votre architecture

Toutes les classes ne correspondent pas à un rôle DDD ou hexagonal. HexaGlue les classe dans des catégories qui vous aident à comprendre pourquoi.

Catégorie	Signification	Exemple typique
`AMBIGUOUS`	Critères évalués, pas de match clair	Classe avec des traits de plusieurs rôles
`CONFLICTING`	Plusieurs règles en conflit	Entité qui ressemble aussi à un value object
`UTILITY`	Classe utilitaire détectée par suffixe	`StringUtils`, `DateHelper`
`TECHNICAL`	Classe d'infrastructure annotée	`@Configuration`, `@Component`
`OUT_OF_SCOPE`	Package de test ou mock	`com.acme.shop.test.*`

Les classes non classifiées ne sont pas un problème : elles signalent les zones grises de votre architecture. L'audit les comptabilise et propose des pistes de remédiation. Un projet legacy typique démarre avec 30 à 50% de classes non classifiées : c'est normal.

Voyez la classification en action.
50 classes classifiées au build.

Découvrez comment HexaGlue classifie un projet legacy de 50 classes, étape par étape.

Voir la classification en action Démarrer en 5 minutes

Classification automatique du domaine.Du code source au modèle architectural.