Format
On-site at your office, fully remote, or in our course rooms. We adapt exercises and tooling to your environment.
Get a practical overview of Spring Modulith. This is a modern approach to structuring applications in a modular way without having to deal with the complexity of distributed architecture approaches.
Microservices are often considered the ideal solution for modularization – but they come with significant technical and organizational challenges. Moduliths offer a pragmatic alternative: a modular monolith that clearly structures technical aspects and remains maintainable in the long term. We apply the concepts in practice using an example application. We discuss how dependencies can be controlled, architecture rules can be checked automatically, documentation can be generated, and existing systems can be modernized step by step.
Concrete methods and best practices for designing Spring applications that are modular, maintainable, and free of unnecessary overhead. Develop future-proof systems that are easier to adapt, extend, and scale.
Understand the motivation behind moduliths and how they compare to microservices. Set up projects, define modules with package structures, named interfaces, and custom module detection, including simple, advanced, nested, and open modules.
Define dependency rules and enforce them with architecture tests. Integrate ArchUnit to automatically check your modular boundaries and customize verification options.
Learn the fundamentals of module testing with Spring Modulith's application module testing support. Handle dependencies, configure bootstrap modes, and leverage change-aware test execution.
Generate living architecture documentation automatically: Modulith diagrams in C4 and UML formats, and application module canvases that visualize your modular structure.
Communicate between modules using synchronous and asynchronous domain events. Use the event publication registry with persistence, repetition, and completion modes. Test event-driven interactions with the Scenario API and Passage of Time Events.
Integrate into CI/CD with fitness functions. Use the ApplicationModuleInitializer, Modulith actuator endpoints, observability with Micrometer and OpenTelemetry, module-specific Flyway migrations, and configurable Modulith properties.
Make DDD concepts explicit with jMolecules: aggregates, entities, value objects, domain events, repositories, and module annotations. Integrate into Modulith documentation, canvas, and ArchUnit rules.
Migrate legacy applications to a Modulith step by step. Design hybrid architectures combining moduliths and microservices. Externalize events via Kafka, AMQP, JMS, and Spring Messaging.
This training is designed for developers, architects, and teams who want to build or modernize Spring Boot applications with a clearly modular structure.
Software developers who work with Spring Boot and want to structure their applications in a clearly modular way, with clear boundaries, testable modules, and automated architecture checks.
Software architects who want to critically examine microservices or design hybrid architectures that combine the best of moduliths and distributed systems.
Teams that want to modernize existing monoliths and gradually convert them into modular systems, step by step, without a risky big-bang rewrite.
All sessions are hands-on with real code exercises using an example application. We tailor content and pace to your team's experience level.
On-site at your office, fully remote, or in our course rooms. We adapt exercises and tooling to your environment.
2 days. Individually adapted for in-house courses and can be split into focused modules.
Delivered in English or German. Italian available on request.
Spring Boot experience. Familiarity with domain-driven design concepts is helpful but not required.
Tell us about your team and goals. We'll design the right training for your context.