{"id":703,"date":"2026-06-27T23:34:10","date_gmt":"2026-06-27T22:34:10","guid":{"rendered":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/?p=703"},"modified":"2026-07-07T23:34:43","modified_gmt":"2026-07-07T22:34:43","slug":"spring-modulith-2-modul-architektur-mit-verifikation-und-event-getriebenen-modulen","status":"publish","type":"post","link":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/?p=703","title":{"rendered":"Spring Modulith 2 \u2013 Modul-Architektur mit Verifikation und Event-getriebenen Modulen"},"content":{"rendered":"\n

Je l\u00e4nger eine Spring-Boot-Anwendung lebt, desto gr\u00f6\u00dfer wird die Gefahr des \u201eBig Ball of Mud“: Services rufen wild andere Services auf, Zyklen entstehen, und aus dem sauberen Monolithen wird ein Wartungs-Albtraum. Spring Modulith 2 adressiert genau dieses Problem: Es strukturiert deine Anwendung in logische Module, erzwingt deren Grenzen und bereitet den Weg f\u00fcr eine eventuelle Microservice-Extraktion \u2014 alles ohne das Framework zu wechseln.<\/p>\n\n\n\n

Was ist Spring Modulith?<\/h2>\n\n\n\n

Spring Modulith (aktuell 2.1.0<\/strong>, f\u00fcr Spring Boot 4.1+) verpackt bew\u00e4hrte Architektur-Patterns in Spring-Boot-nativer Form:<\/p>\n\n\n\n

    \n
  1. Package-basierte Module<\/strong>\u00a0\u2014 Jedes Modul ist ein eigenes Package mit API (\u00f6ffentlich) und\u00a0internal<\/code>-Subpackage (privat)<\/li>\n\n\n\n
  2. Verifikations-Tests<\/strong>\u00a0\u2014 Pr\u00fcfen Einhaltung von Modulgrenzen zur Build-Zeit via ArchUnit<\/li>\n\n\n\n
  3. Event-Publikations-Registry<\/strong>\u00a0\u2014 Transaktionale Events mit Wiederholungslogik<\/li>\n\n\n\n
  4. Dokumentation<\/strong>\u00a0\u2014 Generiert C4- und UML-Diagramme automatisch<\/li>\n\n\n\n
  5. @ApplicationModuleTest<\/code><\/strong>\u00a0\u2014 Testet Module in Isolation mit dem Scenario-API<\/li>\n<\/ol>\n\n\n\n

    Projekt-Struktur<\/h2>\n\n\n\n

    Eine typische Modulith-Anwendung:<\/p>\n\n\n

    src\/main\/java\/com\/shop\/\n\u251c\u2500\u2500 Application.java               \/\/ @Modulithic<\/span>\n\u251c\u2500\u2500 order\/\n\u2502   \u251c\u2500\u2500 package-info.java          \/\/ @ApplicationModule<\/span>\n\u2502   \u251c\u2500\u2500 OrderManagement.java       \/\/ \u00f6ffentliche API<\/span>\n\u2502   \u251c\u2500\u2500 OrderCompleted.java        \/\/ Domain-Event<\/span>\n\u2502   \u2514\u2500\u2500 internal\/\n\u2502       \u2514\u2500\u2500 OrderInternal.java     \/\/ privat, nur im order-Modul nutzbar<\/span>\n\u2514\u2500\u2500 inventory\/\n    \u251c\u2500\u2500 package-info.java\n    \u2514\u2500\u2500 InventoryManagement.java   \/\/ h\u00f6rt auf OrderCompleted<\/span>\n<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
    Setup<\/h2>\n\n\n
    <dependencyManagement<\/span>><\/span>\n    <dependencies<\/span>><\/span>\n        <dependency<\/span>><\/span>\n            <groupId<\/span>><\/span>org.springframework.modulith<\/groupId<\/span>><\/span>\n            <artifactId<\/span>><\/span>spring-modulith-bom<\/artifactId<\/span>><\/span>\n            <version<\/span>><\/span>2.1.0<\/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.springframework.modulith<\/groupId<\/span>><\/span>\n        <artifactId<\/span>><\/span>spring-modulith-starter-core<\/artifactId<\/span>><\/span>\n    <\/dependency<\/span>><\/span>\n    <dependency<\/span>><\/span>\n        <groupId<\/span>><\/span>org.springframework.modulith<\/groupId<\/span>><\/span>\n        <artifactId<\/span>><\/span>spring-modulith-starter-jpa<\/artifactId<\/span>><\/span>\n    <\/dependency<\/span>><\/span>\n    <dependency<\/span>><\/span>\n        <groupId<\/span>><\/span>org.springframework.modulith<\/groupId<\/span>><\/span>\n        <artifactId<\/span>><\/span>spring-modulith-starter-test<\/artifactId<\/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
    Die @Modulithic<\/code>-Annotation auf der Application-Klasse aktiviert das Modulsystem:<\/p>\n\n\n
    import<\/span> org.springframework.modulith.Modulithic;\n\n@Modulithic\n@SpringBootApplication\npublic class<\/span> Application<\/span> <\/span>{\n    public static<\/span> void<\/span> main(String<\/span>[] args) {\n        SpringApplication.run(Application.class, args);\n    }\n}\n<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
    Module definieren und Abh\u00e4ngigkeiten deklarieren<\/h2>\n\n\n\n
    package-info.java<\/code> f\u00fcr jedes Modul:<\/p>\n\n\n
    <em>\/\/ com\/shop\/order\/package-info.java<\/em><\/span>\n@org.springframework.modulith.ApplicationModule(\n    displayName = \"Bestellungen\"<\/span>,\n    allowedDependencies = \"inventory\"<\/span>\n)\npackage com.shop.order;\n<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n
    <em<\/span>><\/span>\/\/ com\/shop\/inventory\/package-info.java<\/em<\/span>><\/span>\npackage com.shop.inventory;\n<em<\/span>><\/span>\/\/ keine allowedDependencies \u2192 darf auf alle exponierten APIs zugreifen<\/em<\/span>><\/span>\n<\/code><\/span>Code-Sprache:<\/span> HTML, XML<\/span> (<\/span>xml<\/span>)<\/span><\/small><\/pre>\n\n\n
    Events zwischen Modulen<\/h2>\n\n\n\n
    Module kommunizieren ausschlie\u00dflich via Spring Application Events:<\/p>\n\n\n
    <em>\/\/ Im order-Modul: Event publizieren<\/em><\/span>\npackage com.shop.order;\n\nimport org.springframework.context.ApplicationEventPublisher;\nimport org.springframework.stereotype.Service;\nimport org.springframework.transaction.annotation.Transactional;\n\n@Service\npublic<\/span> class<\/span> OrderManagement<\/span> <\/span>{\n    private<\/span> final<\/span> ApplicationEventPublisher events;\n    private<\/span> final<\/span> OrderRepository orders;\n\n    public<\/span> OrderManagement(ApplicationEventPublisher events,\n                           OrderRepository orders) {\n        this.events = events;\n        this.orders = orders;\n    }\n\n    @Transactional\n    public<\/span> void complete(Long orderId) {\n        Order order = orders.findById(orderId).orElseThrow();\n        order.markCompleted();\n        orders.save(order);\n        events.publishEvent(new<\/span> OrderCompleted(order.getId()));\n    }\n}\n\npublic<\/span> record OrderCompleted(Long orderId) {}\n<\/code><\/span>Code-Sprache:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n
    <em>\/\/ Im inventory-Modul: Event empfangen<\/em><\/span>\npackage com.shop.inventory;\n\nimport<\/span> com.shop.order.OrderCompleted;\nimport<\/span> org.springframework.modulith.ApplicationModuleListener;\nimport<\/span> org.springframework.stereotype.Component;\n\n@Component\npublic class<\/span> InventoryManagement<\/span> <\/span>{\n\n    @ApplicationModuleListener\n    void<\/span> on(OrderCompleted event) {\n        <em>\/\/ L\u00e4uft asynchron, in eigener Transaktion,<\/em><\/span>\n        <em<\/span>><\/span>\/\/ erst nachdem die Original-Transaktion committed wurde<\/em<\/span>><\/span><\/span>\n        updateStockForOrder(event.orderId());\n    }\n\n    private void<\/span> updateStockForOrder(Long orderId) {\n        <em>\/\/ Bestand reduzieren<\/em><\/span>\n    }\n}\n<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
    @ApplicationModuleListener<\/code> ist ein Shortcut f\u00fcr @Async<\/code> + @Transactional(propagation = REQUIRES_NEW)<\/code> + @TransactionalEventListener<\/code> \u2014 perfekt f\u00fcr lose gekoppelte Module.<\/p>\n\n\n\n
    Modul-Verifikationstests<\/h2>\n\n\n\n
    Spring Modulith generiert w\u00e4hrend des Builds automatisch Verifikationen. F\u00fcr eigene, explizite Tests:<\/p>\n\n\n
    import<\/span> org.junit.jupiter.api.Test;\nimport<\/span> org.springframework.modulith.core.ApplicationModules;\n\nclass<\/span> ModularityTests<\/span> <\/span>{\n\n    ApplicationModules modules = ApplicationModules.of(Application.class);\n\n    @Test\n    void<\/span> verifyModularity() {\n        modules.verify();\n    }\n\n    @Test\n    void<\/span> noCycles() {\n        modules.detectViolations().throwIfPresent();\n    }\n}\n<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
    Das erkennt:<\/p>\n\n\n\n
      \n
    • Zyklen zwischen Modulen<\/li>\n\n\n\n
    • Zugriffe auf\u00a0*.internal.*<\/code>-Packages von au\u00dfen<\/li>\n\n\n\n
    • Verst\u00f6\u00dfe gegen\u00a0allowedDependencies<\/code><\/li>\n<\/ul>\n\n\n\n
      Modul-Isolierte Integrationstests mit @ApplicationModuleTest<\/h2>\n\n\n
      package com.shop.order;\n\nimport<\/span> org.junit.jupiter.api.Test;\nimport<\/span> org.springframework.modulith.test.ApplicationModuleTest;\nimport<\/span> org.springframework.modulith.test.PublishedEvents;\nimport<\/span> org.springframework.modulith.test.Scenario;\nimport<\/span> org.springframework.beans.factory.annotation.Autowired;\n\n@ApplicationModuleTest  <em>\/\/ Bootet nur das order-Modul<\/em><\/span>\nclass<\/span> OrderIntegrationTests<\/span> <\/span>{\n\n    @Autowired OrderManagement orders;\n\n    @Test\n    void<\/span> completingOrderPublishesEvent(PublishedEvents events) {\n        orders.complete(1<\/span>L);\n\n        events.ofType(OrderCompleted.class)\n              .matching(e -> e.orderId().equals(1<\/span>L))\n              .hasSize(1<\/span>);\n    }\n\n    @Test\n    void<\/span> asyncScenarioExample(Scenario scenario) {\n        scenario.publish(new<\/span> OrderCompleted(42<\/span>L))\n                .andWaitForEventOfType(StockUpdated.class)\n                .matching(e -> e.orderId().equals(42<\/span>L))\n                .toArriveAndVerify(event -> {\n                    assertThat(event.newStockLevel()).isGreaterThan(0<\/span>);\n                });\n    }\n}\n<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
      Der Scenario<\/code>-API ist das Herzst\u00fcck asynchroner Modul-Tests: publish()<\/code>\/stimulate()<\/code> \u2192 Event erwarten \u2192 Zustands\u00e4nderung verifizieren.<\/p>\n\n\n\n
      Automatische Dokumentation<\/h2>\n\n\n
      import<\/span> org.junit.jupiter.api.Test;\nimport<\/span> org.springframework.modulith.docs.Documenter;\n\nclass<\/span> DocumentationTests<\/span> <\/span>{\n\n    ApplicationModules modules = ApplicationModules.of(Application.class);\n\n    @Test\n    void<\/span> generateDocs() {\n        new<\/span> Documenter(modules)\n            .writeModulesAsPlantUml()          <em>\/\/ System C4 Diagramm<\/em><\/span>\n            .writeIndividualModulesAsPlantUml() <em>\/\/ Pro-Modul Diagramm<\/em><\/span>\n            .writeModuleCanvases()              <em>\/\/ Tabellarische Modul-\u00dcbersichten<\/em><\/span>\n            .writeAggregatingDocument();        <em<\/span>><\/span>\/\/ Alles-in-einem AsciiDoc<\/em<\/span>><\/span><\/span>\n    }\n}\n<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
      Die Dateien landen in target\/spring-modulith-docs\/<\/code> und enthalten C4-Diagramme (PlantUML), Modul-Canvases (Spring Beans, Events, Properties) und ein aggregierendes AsciiDoc.<\/p>\n\n\n\n
      Der Weg zu Microservices<\/h2>\n\n\n\n
      Spring Modulith unterst\u00fctzt den schrittweisen \u00dcbergang zum Microservice:<\/p>\n\n\n\n
        \n
      1. Heute:<\/strong>\u00a0Monolith mit Modul-Grenzen und internen Events<\/li>\n\n\n\n
      2. Morgen:<\/strong>\u00a0Events mit\u00a0@Externalized<\/code>\u00a0annotieren \u2192 Kafka\/AMQP@Externalized(\"order-completed::#{#this.orderId()}\") public record OrderCompleted(Long orderId) {}<\/code><\/li>\n\n\n\n
      3. \u00dcbermorgen:<\/strong>\u00a0Modul als eigener Service extrahieren, Events vom Broker konsumieren<\/li>\n<\/ol>\n\n\n\n
        Keine Code-\u00c4nderung innerhalb des Moduls n\u00f6tig.<\/p>\n\n\n\n
        Fazit<\/h2>\n\n\n\n
        Spring Modulith 2 ist kein neues Framework \u2014 es ist ein Architektur-Werkzeugkasten f\u00fcr Spring Boot, der saubere Modulgrenzen zur Build-Zeit erzwingt und asynchrone Event-Kommunikation f\u00f6rdert. Die automatische C4-Dokumentation ist ein netter Bonus, der gerade in wachsenden Teams Gold wert ist.<\/p>\n\n\n\n
        F\u00fcr jedes Spring-Boot-Projekt mit mehr als 2 Modulen: Setzt Spring Modulith ein, bevor der Monolith unwartbar wird. Euer zuk\u00fcnftiges Ich wird es euch danken.<\/p>\n","protected":false},"excerpt":{"rendered":"
        Je l\u00e4nger eine Spring-Boot-Anwendung lebt, desto gr\u00f6\u00dfer wird die Gefahr des \u201eBig Ball of Mud“: Services rufen wild andere Services auf, Zyklen entstehen, und aus dem sauberen Monolithen wird ein Wartungs-Albtraum. Spring Modulith 2 adressiert genau dieses Problem: Es strukturiert deine Anwendung in logische Module, erzwingt deren Grenzen und bereitet den Weg f\u00fcr eine eventuelle […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[5],"tags":[],"class_list":["post-703","post","type-post","status-publish","format-standard","hentry","category-spring"],"_links":{"self":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts\/703","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=703"}],"version-history":[{"count":1,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts\/703\/revisions"}],"predecessor-version":[{"id":704,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts\/703\/revisions\/704"}],"wp:attachment":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=703"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=703"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=703"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}