Learn Spring Modulith: Monolith to Microservices Seamlessly

Configure Spring Modulith dependencies via Maven in IntelliJ or STS, including Web, JPA with Hibernate, Lombok, and Docker Compose for Postgres, using Start.spring.io and Spring Boot 3.3.0+.

Explore spring boot docker compose with postgres, focusing on volume mapping to persist data locally. Fix a password mismatch and run the setup via docker compose for testing before production.

Explore modulith dependency management as you wire in spring modules. Inspect external dependencies in IntelliJ and explore API and event publication patterns in the spring monolith.

Define entities in a spring modulith by modeling inventory and order with strong decoupling, custom repositories, and a status converter for enum persistence, enabling monolith to microservice transition.

Define the payment entity in the Modulith, implement a payment status enum (incomplete, completed, failed) with an attribute converter to string, and enable lookups by order ID in the repository.

Limit repository access levels by restricting interface visibility to prevent modules from accessing internals, hide repositories, and reduce cross‑module coupling as you design moduliths.

wire a dev environment to prepopulate inventory data in a spring modulith app by running sql scripts via docker compose and validating the pre-populated items.

Set up base and integration tests for Spring Modulith, explain application model tests, configure Docker Compose data sources and application YAML resources, and manage environment variables for reliable integration testing.

Explore Modulith integration testing by configuring base and application model tests, wiring environment variables, and choosing docker compose or direct data sources for seamless monolith to microservices testing.

Explore modulith integration tests by wiring a service and inventory repository, and running tests to reveal unsatisfied dependencies. Learn you can't inject beans across modules without cross‑module wiring rules.

Migrate the Modulith order service from Lombok to Java 21 records, refactor inventory and order data transfer objects, and wire the initial create order workflow with inventory lookup and persistence.

Build and persist an order with linked inventory using JPA, mapping inventory details through DTOs and resolving inventories by name for proper linkage.

Demonstrates building an order service with a rest controller and post mappings using a response entity. Tests with HTTP client, persists orders, and links inventory items to compute totals.

Learn to use Spring Modulith events to transmit data between models, by building an order event service that publishes events to the payments module and a listener to process them.

Publish events in a modular Spring application and listen with an asynchronous transactional listener in Modulith. The lecture demonstrates wiring the event pipeline, transaction propagation, and verifying listener reception.

Explore how Modulith simulates a failed event, publishes events asynchronously, and uses the event publication table to distinguish completed from failed deliveries in a monolith-to-microservices context.

Learn to create an order integration test for a modulith setup by wiring services, simulating events, and asserting outcomes in the database.

Explore scenario-based tests in spring modulith by publishing an order payments dto, waiting for a 5000 amount event, and verifying results.

Model and mirror an event publication table in a modulith via JPA, define a UUID id and timestamps, and implement repository and service to fetch completed and uncompleted publications.

Learn modulith patterns for turning a monolith into microservices by building an event action system that maps event types to canonical names and supports completed and incomplete publications.

Create a custom setup with an application runner to scan for a custom event marker, map annotated attributes to actions, and persist event actions in the repository.

Republish incomplete events in a Modulith project by implementing a republish action that uses the event action repository and environment settings to reprocess uncompleted events.

Test event actions in a Modulith setup by creating an action, indexing it, and wiring a listener to verify incomplete and completed events.

Explore modulith patterns by wiring payment events to an email listener using an email DTO and event publishing. Build a dedicated email service module to handle notifications.

Fix a payment error by changing the payment service state from on to complete order, and align database records with the listener id and package name for correct event handling.

Implement a complete payments workflow in a modulith, including a complete order controller, DTO updates, and event-driven email notifications and listeners.

Track a modulith payments fix as the speaker debugs registration and transactional issues, ensures proper publication, and previews validation concepts in the next videos.

Explore open models and a custom model exception within Modulith, then implement spring boot validation and a global exception handler to surface method argument errors.

Master global exception handling and Jakarta validation in a modulith, using not blank and @Valid for lists, then test with docker compose and debugging to verify errors.

Learn how to generate diagrams that illustrate module interactions in Spring Modulith, using PlantUML and model canvases to document dependencies and event flows.

Explore modulith documentation by comparing diagram options such as UML, Cypher, and C4, and see how the chosen diagrams connect to the model documentation and runtime support.

Add runtime support and actuator to a spring boot project to enable production readiness, expose health endpoints, and integrate observability with micrometer and Prometheus and Grafana.

Explore three ways to dockerize a Spring Boot app: use Spring Boot's built-in image, create a Dockerfile, or apply Layer Tools for granular layer builds.

Configure docker compose with a bridge network to connect Modulith services to Postgres, then test endpoints, actuators, and event listeners end-to-end.

Transition a dockerized, stateless Spring Modulith to Kubernetes by externalizing configuration with production properties and Spring profiles. Learn how to prepare deployments and manage Kubernetes-specific settings for production readiness.

Explore testing externalized properties by building and pushing a docker image, running docker compose with Postgres, and validating spring profiles for Kubernetes readiness.