{"id":708,"date":"2026-07-02T23:38:16","date_gmt":"2026-07-02T22:38:16","guid":{"rendered":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/?p=708"},"modified":"2026-07-07T23:38:55","modified_gmt":"2026-07-07T22:38:55","slug":"domain-driven-design-im-code-erzwingen-mit-jmolecules-archunit","status":"publish","type":"post","link":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/?p=708","title":{"rendered":"Domain-Driven Design im Code erzwingen mit jMolecules & ArchUnit"},"content":{"rendered":"\n

Domain-Driven Design (DDD) verspricht bessere Software durch eine gemeinsame Sprache und klare Architekturmuster. In der Praxis scheitert DDD oft an einem: Der Code verletzt die Regeln, die das Design vorschreibt. Repositories geben keine Aggregates zur\u00fcck, Value Objects sind nicht immutable, und Entities werden direkt statt \u00fcber ihre Aggregate Root angesprochen.<\/p>\n\n\n\n

jMolecules l\u00f6st dieses Problem, indem es DDD-Konzepte als Java-Annotationen und Typsystem ausdr\u00fcckt \u2014 und ArchUnit erzwingt deren Einhaltung zur Build-Zeit.<\/p>\n\n\n\n

jMolecules 2.0: DDD im Typsystem verankern<\/h2>\n\n\n\n

jMolecules (aktuell 2.0.1<\/strong>) unterscheidet sich fundamental von anderen DDD-Bibliotheken: Es geht nicht um Code-Generierung, sondern um die Abbildung fachlicher Konzepte im Code<\/strong> \u2014 ohne Suffixe wie CustomerEntity<\/code> oder MoneyVO<\/code>.<\/p>\n\n\n\n

Die Annotationen<\/h3>\n\n\n
import org.jmolecules.ddd.annotation.*;\nimport java.util.UUID;\n\n@AggregateRoot\npublic<\/span> class<\/span> Bestellung<\/span> <\/span>{\n\n    private<\/span> @Identity BestellId id;\n    private<\/span> List<\/span><Bestellposten> posten = new<\/span> ArrayList<>();\n    private<\/span> Geld gesamtbetrag = Geld.EURO(0<\/span>);\n\n    private<\/span> Bestellung() {}\n\n    public<\/span> Bestellung(BestellId id) { this.id = id; }\n\n    public<\/span> void postenHinzufuegen(BestellpostenId id, String beschreibung,\n                                   Geld preis, Menge menge) {\n        Bestellposten p = new<\/span> Bestellposten(id, beschreibung, preis, menge);\n        this.posten.add(p);\n        this.gesamtbetrag = this.gesamtbetrag.add(p.positionssumme());\n    }\n\n    public<\/span> BestellId getId() { return<\/span> id; }\n    public<\/span> List<\/span><Bestellposten> getPosten() { return<\/span> List<\/span>.copyOf(posten); }\n    public<\/span> Geld getGesamtbetrag() { return<\/span> gesamtbetrag; }\n}\n\n@Entity\npublic<\/span> class<\/span> Bestellposten<\/span> <\/span>{\n\n    private<\/span> @Identity BestellpostenId id;\n    private<\/span> String beschreibung;\n    private<\/span> Geld preis;\n    private<\/span> Menge menge;\n\n    private<\/span> Bestellposten() {}\n\n    public<\/span> Bestellposten(BestellpostenId id, String beschreibung,\n                          Geld preis, Menge menge) {\n        this.id = id;\n        this.beschreibung = beschreibung;\n        this.preis = preis;\n        this.menge = menge;\n    }\n\n    Geld positionssumme() {\n        return<\/span> preis.multiplizieren(menge.wert());\n    }\n}\n<\/code><\/span>Code-Sprache:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
Die @Identity<\/code>-Annotation markiert das ID-Feld innerhalb von @Entity<\/code> oder @AggregateRoot<\/code> \u2014 essenziell f\u00fcr JPA-Mapping und Konsistenzpr\u00fcfungen.<\/p>\n\n\n\n
Value Objects \u2014 unver\u00e4nderlich per Design<\/h3>\n\n\n
<em>\/\/ Records sind der nat\u00fcrliche Value-Object-Typ in modernem Java<\/em><\/span>\n@ValueObject\npublic<\/span> record BestellId(UUID wert) {\n    public<\/span> static<\/span> BestellId neu() { return<\/span> new<\/span> BestellId(UUID.randomUUID()); }\n}\n\n@ValueObject\npublic<\/span> record Geld(long betragInCent, String waehrung) {\n    public<\/span> static<\/span> Geld EURO(long betragInCent) {\n        return<\/span> new<\/span> Geld(betragInCent, \"EUR\"<\/span>);\n    }\n\n    public<\/span> Geld add(Geld other) {\n        if<\/span> (!waehrung.equals(other.waehrung))\n            throw<\/span> new<\/span> IllegalArgumentException(\"W\u00e4hrungen stimmen nicht \u00fcberein\"<\/span>);\n        return<\/span> new<\/span> Geld(betragInCent + other.betragInCent, waehrung);\n    }\n\n    public<\/span> Geld multiplizieren(int faktor) {\n        return<\/span> new<\/span> Geld(betragInCent * faktor, waehrung);\n    }\n}\n\n@ValueObject\npublic<\/span> record Menge(int wert) {\n    public<\/span> Menge {\n        if<\/span> (wert < 1<\/span>)\n            throw<\/span> new<\/span> IllegalArgumentException(\"Menge muss positiv sein\"<\/span>);\n    }\n}\n<\/code><\/span>Code-Sprache:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
Repository \u2014 das Tor zum Aggregate<\/h3>\n\n\n
@Repository\npublic<\/span> interface<\/span> Bestellungen<\/span> <\/span>{\n    Bestellung speichern(Bestellung bestellung);\n    Optional<Bestellung> findeNachId(BestellId id);\n    List<\/span><Bestellung> findeAlle();\n}\n<\/code><\/span>Code-Sprache:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
ArchUnit: DDD-Regeln automatisch pr\u00fcfen<\/h2>\n\n\n\n
Das jMolecules-ArchUnit-Modul (jmolecules-archunit<\/code>) liefert vier eingebaute Regeln:<\/p>\n\n\n
import<\/span> com<\/span>.tngtech<\/span>.archunit<\/span>.junit<\/span>.AnalyzeClasses<\/span>;\nimport<\/span> com<\/span>.tngtech<\/span>.archunit<\/span>.junit<\/span>.ArchTest<\/span>;\nimport<\/span> com<\/span>.tngtech<\/span>.archunit<\/span>.lang<\/span>.ArchRule<\/span>;\nimport<\/span> org<\/span>.jmolecules<\/span>.archunit<\/span>.JMoleculesDddRules<\/span>;\n\n@AnalyzeClasses<\/span>(packages = \"com.meinefirma.shop\"<\/span>)\npublic class DddRegelnTest {\n\n    @ArchTest<\/span>\n    ArchRule dddRegeln = JMoleculesDddRules.all();\n}\n<\/code><\/span>Code-Sprache:<\/span> CSS<\/span> (<\/span>css<\/span>)<\/span><\/small><\/pre>\n\n\n
Diese vier Regeln werden gepr\u00fcft:<\/p>\n\n\n\n
    \n
  1. Entities nur innerhalb ihres Aggregates verwenden<\/strong>\u00a0\u2014 Ein\u00a0Bestellposten<\/code>, der\u00a0Bestellung<\/code>\u00a0als Owner deklariert, darf nicht in einem anderen Aggregate referenziert werden<\/li>\n\n\n\n
  2. Aggregate-Referenzen nur per ID oder\u00a0Association<\/code><\/strong>\u00a0\u2014 Keine direkten Objektreferenzen auf andere Aggregate Roots<\/li>\n\n\n\n
  3. @Identity<\/code>-Feld ist Pflicht<\/strong>\u00a0\u2014 Jedes\u00a0@Entity<\/code>\u00a0und\u00a0@AggregateRoot<\/code>\u00a0muss ein\u00a0@Identity<\/code>-Feld haben<\/li>\n\n\n\n
  4. Value Objects enthalten keine Entities<\/strong>\u00a0\u2014 Value Objects d\u00fcrfen weder Entities noch Aggregate Roots referenzieren<\/li>\n<\/ol>\n\n\n\n
    Eigene Regeln definieren<\/h2>\n\n\n\n
    Neben den Built-in-Regeln kannst du eigene, dom\u00e4nenspezifische Constraints formulieren:<\/p>\n\n\n
    import<\/span> static<\/span> com<\/span>.tngtech<\/span>.archunit<\/span>.lang<\/span>.syntax<\/span>.ArchRuleDefinition<\/span>.*;\nimport<\/span> org<\/span>.jmolecules<\/span>.ddd<\/span>.annotation<\/span>.*;\nimport<\/span> org<\/span>.jmolecules<\/span>.architecture<\/span>.annotation<\/span>.*;\n\n@AnalyzeClasses<\/span>(packages = \"com.meinefirma.shop\"<\/span>)\npublic class EigeneDddRegeln {\n\n    @ArchTest<\/span>\n    ArchRule repositoriesNurAggregates = methods()\n        .that().areDeclaredInClassesThat()\n            .areAnnotatedWith(Repository.class)\n        .and<\/span>().arePublic()\n        .should().haveRawReturnType(classes().that()\n            .areAnnotatedWith(AggregateRoot.class));\n\n    @ArchTest<\/span>\n    ArchRule valueObjectsSindRecords = classes()\n        .that().areAnnotatedWith(ValueObject.class)\n        .should().beRecords();\n\n    @ArchTest<\/span>\n    ArchRule servicesOhneZustand = fields()\n        .that().areDeclaredInClassesThat()\n            .areAnnotatedWith(Service.class)\n        .should().beFinal();\n\n    @ArchTest<\/span>\n    ArchRule factoriesNurImDomainLayer = classes()\n        .that().areAnnotatedWith(Factory.class)\n        .should().resideInAnyPackage(\"..domain..\"<\/span>);\n}\n<\/code><\/span>Code-Sprache:<\/span> CSS<\/span> (<\/span>css<\/span>)<\/span><\/small><\/pre>\n\n\n
    Layered- und Onion-Architecture erzwingen<\/h2>\n\n\n\n
    jMolecules unterst\u00fctzt auch Architekturstile:<\/p>\n\n\n
    <em<\/span>><\/span>\/\/ package-info.java im Domain-Package<\/em<\/span>><\/span>\n@DomainLayer\npackage com.meinefirma.shop.domain;\n\n<em<\/span>><\/span>\/\/ package-info.java im Application-Package<\/em<\/span>><\/span>\n@ApplicationLayer\npackage com.meinefirma.shop.application;\n\n<em<\/span>><\/span>\/\/ package-info.java im Infrastructure-Package<\/em<\/span>><\/span>\n@InfrastructureLayer\npackage com.meinefirma.shop.infrastructure;\n<\/code><\/span>Code-Sprache:<\/span> HTML, XML<\/span> (<\/span>xml<\/span>)<\/span><\/small><\/pre>\n\n\n
    Die ArchUnit-Regel JMoleculesArchitectureRules.ensureLayering()<\/code> pr\u00fcft dann, dass die Infrastructure-Schicht nicht direkt vom Application-Layer abh\u00e4ngt, dass Domain keine \u00e4u\u00dferen Schichten kennt, usw.<\/p>\n\n\n\n
    F\u00fcr Onion-Architektur:<\/p>\n\n\n
    @ArchTest\nArchRule onion = JMoleculesArchitectureRules.ensureOnionSimple();\n<em<\/span>><\/span>\/\/ Domain \u2282 Application \u2282 Infrastructure<\/em<\/span>><\/span>\n<em<\/span>><\/span>\/\/ Keine Ring-\u00dcberspringungen, keine Abh\u00e4ngigkeiten von au\u00dfen nach innen<\/em<\/span>><\/span>\n<\/code><\/span>Code-Sprache:<\/span> HTML, XML<\/span> (<\/span>xml<\/span>)<\/span><\/small><\/pre>\n\n\n
    ByteBuddy: DDD-Annotationen zu JPA\/Spring mappen<\/h2>\n\n\n\n
    Das jmolecules-bytebuddy<\/code>-Plugin \u00fcbersetzt jMolecules-Annotationen automatisch in Framework-Annotationen:<\/p>\n\n\n
    @AggregateRoot<\/span>         \u2192  @javax.persistence.Entity + implements Persistable\n@Identity              \u2192  @javax.persistence.EmbeddedId oder @Id\n@ValueObject (record)  \u2192  @javax.persistence.Embeddable + implements Serializable\n@Repository            \u2192  @org.springframework.stereotype.Repository\n@Service               \u2192  @org.springframework.stereotype.Service\n<\/code><\/span>Code-Sprache:<\/span> CSS<\/span> (<\/span>css<\/span>)<\/span><\/small><\/pre>\n\n\n
    Maven-Konfiguration:<\/p>\n\n\n
    <plugin<\/span>><\/span>\n    <groupId<\/span>><\/span>net.bytebuddy<\/groupId<\/span>><\/span>\n    <artifactId<\/span>><\/span>byte-buddy-maven-plugin<\/artifactId<\/span>><\/span>\n    <version<\/span>><\/span>1.17.5<\/version<\/span>><\/span>\n    <executions<\/span>><\/span>\n        <execution<\/span>><\/span>\n            <goals<\/span>><\/span><goal<\/span>><\/span>transform-extended<\/goal<\/span>><\/span><\/goals<\/span>><\/span>\n        <\/execution<\/span>><\/span>\n    <\/executions<\/span>><\/span>\n    <configuration<\/span>><\/span>\n        <classPathDiscovery<\/span>><\/span>true<\/classPathDiscovery<\/span>><\/span>\n    <\/configuration<\/span>><\/span>\n<\/plugin<\/span>><\/span>\n<\/code><\/span>Code-Sprache:<\/span> HTML, XML<\/span> (<\/span>xml<\/span>)<\/span><\/small><\/pre>\n\n\n
    Damit bleiben deine Domain-Klassen frei von JPA\/Spring-Imports \u2014 die Framework-Integration passiert transparent zur Compile-Zeit.<\/p>\n\n\n\n
    Dependencies<\/h2>\n\n\n
    <dependencyManagement<\/span>><\/span>\n    <dependencies<\/span>><\/span>\n        <dependency<\/span>><\/span>\n            <groupId<\/span>><\/span>org.jmolecules<\/groupId<\/span>><\/span>\n            <artifactId<\/span>><\/span>jmolecules-bom<\/artifactId<\/span>><\/span>\n            <version<\/span>><\/span>2025.0.2<\/version<\/span>><\/span>\n            <type<\/span>><\/span>pom<\/type<\/span>><\/span>\n            <scope<\/span>><\/span>import<\/scope<\/span>><\/span>\n        <\/dependency<\/span>><\/span>\n    <\/dependencies<\/span>><\/span>\n<\/dependencyManagement<\/span>><\/span>\n\n<dependencies<\/span>><\/span>\n    <dependency<\/span>><\/span>\n        <groupId<\/span>><\/span>org.jmolecules<\/groupId<\/span>><\/span>\n        <artifactId<\/span>><\/span>jmolecules-ddd<\/artifactId<\/span>><\/span>\n    <\/dependency<\/span>><\/span>\n    <dependency<\/span>><\/span>\n        <groupId<\/span>><\/span>org.jmolecules.integrations<\/groupId<\/span>><\/span>\n        <artifactId<\/span>><\/span>jmolecules-archunit<\/artifactId<\/span>><\/span>\n        <scope<\/span>><\/span>test<\/scope<\/span>><\/span>\n    <\/dependency<\/span>><\/span>\n    <dependency<\/span>><\/span>\n        <groupId<\/span>><\/span>org.jmolecules.integrations<\/groupId<\/span>><\/span>\n        <artifactId<\/span>><\/span>jmolecules-spring<\/artifactId<\/span>><\/span>\n        <scope<\/span>><\/span>runtime<\/scope<\/span>><\/span>\n    <\/dependency<\/span>><\/span>\n    <dependency<\/span>><\/span>\n        <groupId<\/span>><\/span>com.tngtech.archunit<\/groupId<\/span>><\/span>\n        <artifactId<\/span>><\/span>archunit-junit5<\/artifactId<\/span>><\/span>\n        <version<\/span>><\/span>1.4.2<\/version<\/span>><\/span>\n        <scope<\/span>><\/span>test<\/scope<\/span>><\/span>\n    <\/dependency<\/span>><\/span>\n<\/dependencies<\/span>><\/span>\n<\/code><\/span>Code-Sprache:<\/span> HTML, XML<\/span> (<\/span>xml<\/span>)<\/span><\/small><\/pre>\n\n\n
    Fazit<\/h2>\n\n\n\n
    DDD scheitert nicht am Design, sondern an der mangelnden Durchsetzung im Code. jMolecules und ArchUnit schlie\u00dfen diese L\u00fccke: jMolecules dr\u00fcckt DDD-Konzepte im Typsystem aus (ohne Framework-Abh\u00e4ngigkeiten), ArchUnit pr\u00fcft deren Einhaltung bei jedem Build, und ByteBuddy \u00fcbersetzt sie nahtlos in JPA\/Spring.<\/p>\n\n\n\n
    Das Ergebnis ist selbstdokumentierender Code, der beweist<\/em>, dass er DDD-konform ist \u2014 nicht nur behauptet. F\u00fcr jedes Projekt mit nicht-trivialer Dom\u00e4ne ein klares Plus.<\/p>\n","protected":false},"excerpt":{"rendered":"
    Domain-Driven Design (DDD) verspricht bessere Software durch eine gemeinsame Sprache und klare Architekturmuster. In der Praxis scheitert DDD oft an einem: Der Code verletzt die Regeln, die das Design vorschreibt. Repositories geben keine Aggregates zur\u00fcck, Value Objects sind nicht immutable, und Entities werden direkt statt \u00fcber ihre Aggregate Root angesprochen. jMolecules l\u00f6st dieses Problem, indem […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[4],"tags":[],"class_list":["post-708","post","type-post","status-publish","format-standard","hentry","category-plain_java"],"_links":{"self":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts\/708","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=708"}],"version-history":[{"count":1,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts\/708\/revisions"}],"predecessor-version":[{"id":709,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts\/708\/revisions\/709"}],"wp:attachment":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=708"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=708"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=708"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}