jmolecules
1.10
Un ensemble de bibliothèques pour aider les développeurs à implémenter des modèles de domaine dans un vieux Java simple et sans distraction.
Exprimez explicitement les concepts architecturaux pour faciliter la lecture et l’écriture de code.
Gardez le code spécifique au domaine exempt de dépendances techniques. Réduisez le code passe-partout.
Générez automatiquement de la documentation et validez les structures de mise en œuvre et votre architecture.
Facilitez la vie des développeurs.
Exprimer qu'un morceau de code (un package, une classe ou une méthode) implémente un concept architectural.
Permettez au lecteur humain de déterminer facilement à quel type de concepts architecturaux correspond un morceau de code donné.
Autoriser l'intégration d'outils :
Augmentation du code. (Exemples d'outils : ByteBuddy avec intégrations Spring et JPA).
Vérifiez les règles architecturales. (Exemples d'outils : jQAssistant, ArchUnit).
Exemple : Un domaine bancaire.
import org . jmolecules . ddd . annotation .*;
@ Entity
class BankAccount {
@ Identity
final IBAN iban ;
/* ... */
}
@ ValueObject
class IBAN { /* ... */ }
@ ValueObject
record Currency { /* ... */ }
@ Repository
class Accounts { /* ... */ } Lorsque nous prenons le langage omniprésent au sérieux, nous voulons des noms (pour les classes, les méthodes, etc.) qui contiennent uniquement des mots du langage du domaine. Cela signifie que les titres des éléments constitutifs ne doivent pas faire partie des noms. Ainsi, dans un domaine bancaire, nous ne voulons pas BankAccountEntity , CurrencyVO ou même AccountRepository comme types. Au lieu de cela, nous voulons BankAccount , Currency et Accounts – comme dans l’exemple ci-dessus.
Néanmoins, nous voulons exprimer qu'une classe donnée (ou un autre élément architectural) est un élément de construction spécial ; c'est-à-dire utilise un modèle de conception. jMolecules fournit un ensemble d'annotations standard pour les éléments de base connus de DDD.
Comme alternative aux annotations mentionnées ci-dessus, jMolecules fournit également un ensemble d'interfaces, largement basées sur les idées présentées dans la série "Advancing Enterprise DDD" de John Sullivan. Ils permettent d'exprimer les relations entre les éléments constitutifs directement au sein du système de types, de sorte que le compilateur puisse aider à vérifier l'exactitude du modèle et que les informations puissent également être traitées plus facilement par la réflexion Java.
Identifier — Un type pour représenter les types censés agir comme identifiants.
Identifiable<ID> — Tout ce qui expose un identifiant.
Entity<T extends AggregateRoot<T, ?>, ID> extends Identifiable<ID> — Une entité, déclarant à quel AggregateRoot elle appartient et quel identifiant elle expose.
AggregateRoot<T extends AggregateRoot<T, ID>, ID extends Identifier> extends Entity<T, ID> — une racine agrégée étant une Entity lui appartenant exposant un Identifier dédié
Association<T extends AggregateRoot<T, ID>, ID extends Identifier> extends Identifiable<ID> — une association explicite à une cible AggregateRoot .
Cette disposition donne des orientations à la modélisation et permet de vérifier facilement les règles suivantes, potentiellement par réflexion :
Types d’identifiants dédiés et appliqués par agrégat pour éviter la confusion des identifiants de différents agrégats.
AggregateRoot ne doit faire référence qu'aux instances Entity qui ont été déclarées comme lui appartenant.
AggregateRoot et Entity ne doivent faire référence qu'à d'autres AggregateRoots via des instances Association .
Pour la vérification automatisée et l'intégration de la technologie d'exécution, voir Intégrations jMolecules.
jmolecules-ddd — annotations et interfaces pour exprimer les blocs de construction DDD (objets de valeur, entités, racines agrégées, etc.) dans le code.
jmolecules-events — annotations et interfaces pour exprimer le concept d'événements dans le code.
kmolecules-ddd — Version basée sur Kotlin de jmolecules-ddd pour atténuer les problèmes d'interopérabilité Kotlin/Java pour le modèle basé sur le type.
jMolecules fournit des annotations pour décrire les concepts architecturaux de niveau supérieur suivant les styles des architectures en couches, en oignon et hexagonale. Ils vous permettent de marquer un package entier comme une couche, un anneau ou une couche contenant des ports et des adaptateurs. Ceux-ci apparaîtront dans le fichier package-info.java pour chaque package que vous souhaitez annoter, par exemple :
package-info.java pour la couche de domaine : @ DomainLayer
package org . acmebank . domain ;
import org . jmolecules . architecture . layered .*;package-info.java pour la couche Application : @ ApplicationLayer
package org . acmebank . application ;
import org . jmolecules . architecture . layered .*;De cette façon, toutes les classes du package respectif sont considérées comme faisant partie de la couche annotée, de l'anneau ou comme un port/adaptateur.
Alternativement, les classes peuvent être annotées directement :
import org . jmolecules . architecture . layered .*;
@ DomainLayer
@ Entity
public class BankAccount { /* ... */ }
@ ApplicationLayer
@ Service
public class TransferMoney { /* ... */ }Actuellement, des annotations pour les architectures en couches, en oignon et hexagonales existent.
jmolecules-architecture — annotations pour exprimer les styles architecturaux dans le code.
jmolecules-cqrs-architecture — Architecture CQRS
@Command
@CommandDispatcher
@CommandHandler
@QueryModel
jmolecules-layered-architecture — Architecture en couches
@DomainLayer
@ApplicationLayer
@InfrastructureLayer
@InterfaceLayer
jmolecules-onion-architecture — Architecture d'oignon
Classique
@DomainModelRing
@DomainServiceRing
@ApplicationServiceRing
@InfrastructureRing
Simplifié (ne sépare pas le modèle de domaine et les services)
@DomainRing
@ApplicationRing
@InfrastructureRing
jmolecules-hexagonal-architecture — Architecture hexagonale
@Application
@(Primary|Secondary)Adapter
@(Primary|Secondary)Port
Les annotations et interfaces jMolecules peuvent être utilisées pour générer le code technique nécessaire pour exprimer le concept dans une certaine technologie cible.
Intégration Spring, Data JPA, Data MongoDB, Data JDBC et Jackson – pour que le code utilisant les annotations jMolecules fonctionne immédiatement dans ces technologies.
Les concepts jMolecules exprimés dans le code peuvent être utilisés pour vérifier les règles issues des définitions des concepts et générer de la documentation.
Plugin jQAssistant — pour vérifier les règles s'appliquant aux différents styles architecturaux, blocs de construction DDD, CQRS et événements. Crée également des diagrammes PlantUML à partir des informations disponibles dans la base de code.
Règles ArchUnit — permettent de vérifier les relations entre les blocs de construction DDD.
Spring Modulith — prend en charge la détection des composants jMolecules, des blocs de construction DDD et des événements à des fins de modèle de module et de documentation (voir la documentation Spring Modulith pour plus d'informations).
Pour utiliser jMolecules dans votre projet, déclarez simplement une dépendance. Les binaires de version sont disponibles dans le référentiel central Maven. Pour éviter d'avoir à déclarer explicitement toutes les versions, nous vous recommandons d'utiliser le jmolecules-bom dans votre section de gestion des dépendances.
< dependency >
< groupId >org.jmolecules</ groupId >
< artifactId >jmolecules-ddd</ artifactId >
< version >1.9.0</ version >
</ dependency >repositories {
mavenCentral()
}
dependencies {
implementation( " org.jmolecules:jmolecules-ddd:1.9.0 " )
} mvn release:prepare -DscmReleaseCommitComment="$ticketId - Release version $version." -DscmDevelopmentCommitComment="$ticketId - Prepare next development iteration."
mvn release:perform -Dgpg.keyname=$keyname
