iluwatar
diff --git a/‎microservices-messaging/README.md‎
Lines changed: 247 additions & 0 deletions b/‎microservices-messaging/README.md‎
Lines changed: 247 additions & 0 deletions
diff --git a/‎microservices-messaging/docker-compose.yml‎
Lines changed: 53 additions & 0 deletions b/‎microservices-messaging/docker-compose.yml‎
Lines changed: 53 additions & 0 deletions
diff --git a/‎microservices-messaging/etc/microservices-messaging-flowchart.png‎
113 KB b/‎microservices-messaging/etc/microservices-messaging-flowchart.png‎
113 KB
diff --git a/‎microservices-messaging/etc/microservices-messaging-sequence-diagram.png‎
186 KB b/‎microservices-messaging/etc/microservices-messaging-sequence-diagram.png‎
186 KB
@@ -0,0 +1,247 @@
+---
+title: "Microservices Messaging Pattern in Java: Enabling Asynchronous Communication Between Services"
+shortTitle: Microservices Messaging
+description: "Learn about the Microservices Messaging pattern, a method for enabling asynchronous communication between services through message brokers to enhance decoupling, scalability, and fault tolerance in distributed systems."
+category: Integration
+language: en
+tag:
+  - API design
+  - Asynchronous
+  - Cloud distributed
+  - Decoupling
+  - Enterprise patterns
+  - Event-driven
+  - Messaging
+  - Microservices
+  - Scalability
+---
+## Also known as
+
+* Asynchronous Messaging
+* Event-Driven Communication
+* Message-Oriented Middleware (MOM)
+
+## Intent of Microservices Messaging Design Pattern
+
+The Microservices Messaging pattern enables asynchronous communication between microservices through message passing, allowing for better decoupling, scalability, and fault tolerance. Services communicate by exchanging messages over messaging channels managed by a message broker.
+
+## Detailed Explanation of Microservices Messaging Pattern with Real-World Examples
+
+Real-world example
+
+> Imagine an e-commerce platform where a customer places an order. The Order Service publishes an "Order Created" message to a message broker. Multiple services listen to this message: the Inventory Service updates stock levels, the Payment Service processes payment, and the Notification Service sends confirmation emails. Each service operates independently, processing messages at its own pace without blocking others. If the Payment Service is temporarily down, the message broker holds the message until it recovers, ensuring no data is lost.
+
+In plain words
+
+> The Microservices Messaging pattern allows services to communicate asynchronously through a message broker, enabling them to work independently without waiting for each other.
+
+Wikipedia says
+
+> Message-oriented middleware is software or hardware infrastructure supporting sending and receiving messages between distributed systems. MOM allows application modules to be distributed over heterogeneous platforms and reduces the complexity of developing applications that span multiple operating systems and network protocols.
+
+Flowchart
+
+![Microservices Messaging flowchart](./etc/microservices-messaging-flowchart.png)
+
+
+
+## Programmatic Example of Microservices Messaging Pattern in Java
+
+
+The Microservices Messaging pattern demonstrates how services communicate through a message broker without direct coupling. In this example, we show an order processing system where services exchange messages asynchronously.
+
+The `Message` class represents the data exchanged between services.
+
+```java
+public class Message {
+  private final String id;
+  private final String content;
+  private final LocalDateTime timestamp;
+
+  public Message(String content) {
+    this.id = UUID.randomUUID().toString();
+    this.content = content;
+    this.timestamp = LocalDateTime.now();
+  }
+
+  // Getters
+}
+```
+
+The `MessageBroker` acts as the intermediary that routes messages between producers and consumers.
+
+```java
+public class MessageBroker {
+  private final Map subscribers = new ConcurrentHashMap<>();
+
+  public void subscribe(String topic, Consumer handler) {
+    subscribers.computeIfAbsent(topic, k -> new ArrayList<>()).add(handler);
+  }
+
+  public void publish(String topic, Message message) {
+    List<Consumer> handlers = subscribers.get(topic);
+    if (handlers != null) {
+      handlers.forEach(handler -> handler.accept(message));
+    }
+  }
+}
+```
+
+The `OrderService` is a message producer that publishes order messages.
+
+```java
+public class OrderService {
+  private static final Logger LOGGER = LoggerFactory.getLogger(OrderService.class);
+  private final MessageBroker broker;
+
+  public OrderService(MessageBroker broker) {
+    this.broker = broker;
+  }
+
+  public void createOrder(String orderId) {
+    Message message = new Message("Order Created: " + orderId);
+    broker.publish("order-topic", message);
+    LOGGER.info("Published order message: {}", orderId);
+  }
+}
+```
+
+The `InventoryService` is a message consumer that processes inventory updates.
+
+```java
+public class InventoryService {
+  private static final Logger LOGGER = LoggerFactory.getLogger(InventoryService.class);
+
+  public void handleMessage(Message message) {
+    LOGGER.info("Inventory Service received: {}", message.getContent());
+    LOGGER.info("Updating inventory...");
+  }
+}
+```
+
+The `PaymentService` handles payment processing messages.
+
+```java
+public class PaymentService {
+  private static final Logger LOGGER = LoggerFactory.getLogger(PaymentService.class);
+
+  public void handleMessage(Message message) {
+    LOGGER.info("Payment Service received: {}", message.getContent());
+    LOGGER.info("Processing payment...");
+  }
+}
+```
+
+The `main` application demonstrates the messaging pattern in action.
+
+```java
+public class App {
+  private static final Logger LOGGER = LoggerFactory.getLogger(App.class);
+
+  public static void main(String[] args) throws InterruptedException {
+    final MessageBroker broker = new MessageBroker();
+
+    final InventoryService inventoryService = new InventoryService();
+    final PaymentService paymentService = new PaymentService();
+
+    broker.subscribe("order-topic", inventoryService::handleMessage);
+    broker.subscribe("order-topic", paymentService::handleMessage);
+
+    final OrderService orderService = new OrderService(broker);
+
+    orderService.createOrder("ORDER-123");
+
+    Thread.sleep(1000);
+  }
+}
+```
+
+Console output:
+
+```
+Published order message: ORDER-123
+Inventory Service received: Order Created: ORDER-123
+Updating inventory...
+Payment Service received: Order Created: ORDER-123
+Processing payment...
+```
+
+Sequence Diagram
+
+![Microservices Messaging sequence_diagram](./etc/microservices-messaging-sequence-diagram.png)
+
+## How to Run the Application
+
+### Option 1: Automated Script (Recommended)
+
+Run the helper script from the module directory, which automatically starts Kafka via Docker Compose (if Docker is installed and Kafka is not already running) and launches the application:
+
+* **Windows (PowerShell)**:
+  ```powershell
+  powershell -ExecutionPolicy Bypass -File .\run-app.ps1
+  ```
+* **Linux / macOS**:
+  ```bash
+  ./run-app.sh
+  ```
+
+### Option 2: Docker Compose
+
+Start the Kafka container manually via Docker Compose and run the application:
+
+```bash
+# Start Kafka container on port 9092
+docker compose up -d
+
+# Run the application
+../mvnw compile exec:java -Dexec.mainClass="com.iluwatar.messaging.App"
+
+# Stop Kafka container when finished
+docker compose down
+```
+
+## When to Use the Microservices Messaging Pattern in Java
+
+* When services need to communicate without blocking each other.
+* In systems requiring loose coupling between components.
+* For event-driven architectures where multiple services react to events.
+* When you need to handle traffic spikes by buffering messages.
+* In distributed systems where services may be temporarily unavailable.
+
+## Real-World Applications of Microservices Messaging Pattern in Java
+
+* Java applications using Apache Kafka, RabbitMQ, or ActiveMQ for service communication.
+* E-commerce platforms for order processing and inventory management.
+* Financial services for transaction processing and notifications.
+* IoT systems for sensor data processing and event handling.
+
+## Benefits and Trade-offs of Microservices Messaging Pattern
+
+* Services are loosely coupled and can be developed and deployed independently.
+* Message buffering improves system resilience when services are temporarily unavailable.
+* Supports multiple communication patterns like publish/subscribe and request/reply.
+* Enhances scalability by allowing parallel message processing.
+* Natural support for event-driven architectures.
+
+Trade-offs:
+
+* Introduces additional complexity with the message broker infrastructure.
+* Requires high availability setup for the message broker.
+* Eventual consistency instead of immediate consistency.
+* Debugging asynchronous flows is more complex than synchronous calls.
+* Need to handle message duplication and ensure idempotent consumers.
+
+## Related Java Design Patterns
+
+* [Saga Pattern](https://java-design-patterns.com/patterns/saga/): Uses messaging to coordinate distributed transactions.
+* [CQRS Pattern](https://java-design-patterns.com/patterns/cqrs/): Often uses messaging to separate read and write operations.
+* [Event Sourcing](https://java-design-patterns.com/patterns/event-sourcing/): Stores state changes as messages.
+* [API Gateway](https://java-design-patterns.com/patterns/microservices-api-gateway/): Complements messaging for synchronous requests.
+
+## References and Credits
+
+* [Enterprise Integration Patterns: Designing, Building, and Deploying Messaging Solutions](https://amzn.to/3vLKqET)
+* [Microservices Patterns: With examples in Java](https://amzn.to/3UyWD5O)
+* [Building Event-Driven Microservices: Leveraging Organizational Data at Scale](https://amzn.to/3PihS9R)
+* [Pattern: Messaging (microservices.io)](https://microservices.io/patterns/communication-style/messaging.html)
+* [Apache Kafka Documentation](https://kafka.apache.org/documentation/)
@@ -0,0 +1,53 @@
+#
+# This project is licensed under the MIT license. Module model-view-viewmodel is using ZK framework licensed under LGPL (see lgpl-3.0.txt).
+#
+# The MIT License
+# Copyright © 2014-2022 Ilkka Seppälä
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+#
+
+version: '3.8'
+
+services:
+  kafka:
+    image: confluentinc/cp-kafka:7.5.0
+    container_name: kafka-messaging-demo
+    ports:
+      - "9092:9092"
+    environment:
+      KAFKA_NODE_ID: 1
+      KAFKA_LISTENER_SECURITY_PROTOCOL_MAP: 'CONTROLLER:PLAINTEXT,PLAINTEXT:PLAINTEXT,PLAINTEXT_HOST:PLAINTEXT'
+      KAFKA_ADVERTISED_LISTENERS: 'PLAINTEXT://kafka:29092,PLAINTEXT_HOST://localhost:9092'
+      KAFKA_OFFSETS_TOPIC_REPLICATION_FACTOR: 1
+      KAFKA_GROUP_INITIAL_REBALANCE_DELAY_MS: 0
+      KAFKA_TRANSACTION_STATE_LOG_MIN_ISR: 1
+      KAFKA_TRANSACTION_STATE_LOG_REPLICATION_FACTOR: 1
+      KAFKA_PROCESS_ROLES: 'broker,controller'
+      KAFKA_CONTROLLER_QUORUM_VOTERS: '1@kafka:29093'
+      KAFKA_LISTENERS: 'PLAINTEXT://kafka:29092,CONTROLLER://kafka:29093,PLAINTEXT_HOST://0.0.0.0:9092'
+      KAFKA_INTER_BROKER_LISTENER_NAME: 'PLAINTEXT'
+      KAFKA_CONTROLLER_LISTENER_NAMES: 'CONTROLLER'
+      KAFKA_LOG_DIRS: '/tmp/kraft-combined-logs'
+      CLUSTER_ID: 'MkU3OEVBNTcwNTJENDM2Qk'
+    healthcheck:
+      test: ["CMD-SHELL", "kafka-topics --bootstrap-server localhost:9092 --list"]
+      interval: 5s
+      timeout: 10s
+      retries: 5