Microservices: Clean Architecture, DDD, SAGA, Outbox & Kafka

Explore clean and hexagonal architectures, centering the domain layer to ensure a testable, independent software with ports and adapters, dependency inversion, and clearly defined entities and use cases.

Designs the order service with clean and hexagonal architecture, introducing domain and data layer interfaces. Illustrates dependency inversion with an API layer and REST controllers in a runtime-wired container.

Add an AI port and an AI layer adapter to the order service, enabling a remote LLM call via Spring AI with OpenAI, while preserving clean architecture and DDD.

Create a multi-module food ordering system using clean and hexagonal architecture: build an order service with domain, application, dataaccess, and messaging modules, plus order-container and order-domain-core wired to Kafka.

Define and connect order-service submodules using clean architecture, linking order-domain-core to the application service, managing versions in the base pom.xml, and verifying dependencies with a depgraph visualization.

Explore domain-driven design from strategic boundaries and ubiquitous language to tactical concepts such as entities, aggregates, value objects, domain events, and domain services, with kafka event logs guiding order-service.

Designs the order service domain using tactical domain-driven design patterns, building the order processing aggregate with value objects, entities, and domain events such as created, paid, and canceled.

Implement the order service domain logic by building the order aggregate with value objects and items, and enforce domain rules for initialize, pay, approve, and cancel.

Explore adding state changing methods to the order entity to form a simple state machine, transitioning from pending to paid, then approved, with cancel paths and saga-based rollback.

Implement domain events in the order service domain layer by creating order created, paid, and cancelled events, a shared domain event interface, and a domain service.

Implement the order application service module by adding dependencies and defining DTOs for create order command and response, track order query and response, and payment and restaurant approval messages.

Set up the OpenAI API key for Spring AI applications by logging into OpenAI, creating a project, generating the key, and configuring environment variables.

Update the order service domain to support ai integration by adding the orderPreferences value object, spice level enum, and an orderNoteInterpreter port, to be implemented by a future ai module.

Update and test the order service by mocking OrderNoteInterpreter, injecting via autowired, and converting raw notes to structured order preferences with a large language model.

Discover Apache Kafka basics: brokers, topics, partitions, replication, and offsets. Learn how producers, consumers, and consumer groups use append-only logs for resilient, scalable streaming with schema registry and K table.

Build a generic kafka producer and consumer in a new infrastructure module, with four sub-modules, a base pom, and config data mapped by kafka-config prefixes for confluent avro serializer.

Implement the Kafka model module by generating Avro Java classes from Avro schemas with the avro-maven-plugin, and configure Maven to create sources during install, including UUID, decimal, and timestamp-millis fields.

Implement a generic Kafka producer module with Spring configuration, producer config, factory, and template to send data to Kafka brokers using asynchronous callbacks and proper cleanup.

Implement a Spring global exception handler with controller advice and Slf4j, returning error DTOs for order domain and validation errors with 400, 404, and 500 responses.

Develop the data access adapter by adding JPA entities and repositories for orders, customers, and restaurants, with one-to-one and one-to-many mappings, address and order items, plus Lombok builders.

Create OrderJpaRepository extending JPA repository for OrderEntity with UUID and an OrderDataAccessMapper to convert between domain objects and entities, enabling findByTrackingId via Spring.

Develop the order messaging mapper to convert order created and canceled events into payment request Avro models, with pending or canceled statuses, and define configuration data for four Kafka topics.

Develop publisher implementations for create, cancel, and pay order events using Kafka, Avor models, and a generic callback helper within hexagonal architecture, with domain mappers and config-driven topics.

Implement payment and restaurant approval listeners, using PaymentResponseKafkaListener and RestaurantApprovalResponseKafkaListener to convert PaymentResponseAvroModel to PaymentResponse and ApprovalResponseAvroModel to approvalResponse via the messaging data mapper, triggering saga actions.

Implement the order container module by adding Spring Boot starter, building a jar and docker image, and configure multi-module support with scanBasePackages, entity scan, and JPA repositories, Postgres, and Kafka.

Configure a Kafka consumer with string key and Avro value deserialization, and tune consumer group id, auto offset reset, Avro reader, bench listener, and poll settings for optimal throughput.

Create the order service PostgreSQL schema with UUID support, including orders, order items, and address tables, cascade deletes, and enum order status values for testing.

Implements the order notes interpreter with OpenAI API, using a system prompt and prompt template to extract order preferences into OrderPreferences, with retry logic and AIOrderNotesInterpreterException for failures.

Upgrade Java to 25 and Spring Boot to 3.5.8, configure Lombok, migrate to Jakarta, and switch to KRaft mode Kafka without ZooKeeper for the order AI module.

Update the order service data access layer to persist LLM-populated order preferences as a JSONB column using JDBC type mapping; synchronize domain and JPA entities and prepare end-to-end AI testing.

Create a Spring Boot customer service module with a PostgreSQL schema, a materialized view of customer data for the order service, and run the end-to-end order workflow via Kafka.

Explore running a local LLM with Ollama for the order AI module, switching between local mistral 7B and OpenAI via spring AI, using an OpenAI-compatible Ollama API, with logging.

Develop the payment domain core by adding an aggregate root, payment entity, and value objects, including payment id, credit entry id, and credit history id, using money value objects.

Extend the domain exception framework with a payments domain exception and not found variant, then define abstract payment events (completed, canceled, failed) using a generic payment entity and super constructors.

Implement payment domain service with validate and initiate, and validate and cancel methods; enforce credit entry checks, update credit history, and emit payment completed or failed events using UTC time.

Implement the payment application service input port by building the payment request listener and persisting data via the data mapper, repositories, and domain events.

Refactor the fireEvent process by adding a domain event interface with a generic fire method and wiring domain event publishers to publish payment and order events.

Implement a complete payment data access module with adapters for payments, credit entry, and credit history, mapping between domain objects and JPA entities using repositories.

Implement a spring kafka listener for payment requests, wiring a payment request message listener and messaging data mapper to handle pending and cancel payments under the saga pattern.

Finish the restaurant domain core by adding exception classes and domain events for order approval and rejection, then implement the domain service and publish approved or rejected events.

Explore building the application service domain module by adding a mapper, DTOs, and ports, configuring dependencies, Kafka topics, domain events, and repository interfaces for restaurant approval.

Implement the application service input port for restaurant approval requests, using slf4j and spring annotations, and persist approvals transactionally via a data mapper and repositories.

Implement the restaurant service data access module by configuring dependencies, creating common data access components, and implementing JPA entities, repositories, and mappers for data access across services.

Implements the restaurant service container module by wiring domain core, application service, data access, and messaging with spring boot, and builds docker images and Kafka topics.

Explain and implement the order payment saga and order approval saga in a microservices architecture. Utilize transactional processing, domain events, and a shared saga helper for persisting orders.

Explore failure scenarios in a microservices food order system using saga and compensating transactions, with kafka-based communication across order, payment, and restaurant services, and introducing all sparks pattern for resilience.

update the order service to implement the outbox pattern by adding saga and outbox tables for payment and restaurant events, with json payloads, enums, indexes, and scheduler config.

Refactor the order domain to add outbox models and update ports, introducing order payments and approvals outbox messages with JSON payloads and saga status tracking via Kafka.

Refactor the order domain to add an outbox scheduler using spring scheduling. Implement a payment outbox scheduler with a helper and saga constants to publish messages and update outbox statuses.

Refactor the order domain to add approval outbox schedulers, including an approval outbox helper and restaurant scheduler, plus a daily outbox cleaner for completed and processing saga statuses.

Refactor the order domain layer to implement the outbox pattern by persisting events locally, removing direct publish calls, and using a payment outbox helper with transactional saves and json payloads.

Refactor the order payment saga to use the outbox pattern instead of direct event firing. Update saga steps and outbox handling for payment and approval to ensure idempotent processing.

Refactor the order payment saga by moving complete payments to a new private method, and apply optimistic locking on outbox messages to safely handle concurrent updates in Kafka.

Refactors the order domain to update the order approval saga, injects order data mapper and outbox helpers, and enables idempotent processing with optimistic locking and Kafka outbox flows.

Refactors the order messaging module to implement the outbox pattern for payment request events via a Kafka publisher, Avro model payloads, saga ID, and robust error handling.

Refactor the order messaging module to outbox-based Kafka publishing, introducing restaurant approval Avro payloads, saga tracing, and robust error handling for optimistic locking scenarios.

Develop and validate an integration test for the order payment saga using Spring Boot, SQL test data, and the outbox pattern, including concurrency and optimistic locking checks.

Refactors the payment domain to use an outbox pattern with schedulers, order outbox messages, saga integration, and read-only versus transactional operations for reliable event persistence.

Add the Outbox repository adapters to the payment data access module, implementing entity, mapper, and repository components for order outbox messages using the Outbox pattern.

Refactor the payment messaging module to the outbox pattern with a Kafka payment response publisher and Avro models. Log saga IDs, configure topics, and enable Spring managed components.

Test the payment request message listener in a Spring Boot context, ensuring outbox persistence and handling of double payments. Validate single- and multi-thread executions and log PostgreSQL unique constraint violations.

Refactor the restaurant service to implement the outbox pattern, adding order_outbox, status fields, data access, and mappers, with a scheduled 10-second delay to publish Kafka messages.