Merge branch 'iluwatar:master' into actor-model

Author: ssrijan-007-sys

microservices-distributed-tracing/README.md

@@ -1,27 +1,32 @@
 ---
-title: "Microservices Distributed Tracing Pattern: Enhancing Visibility in Service Communication"
-shortTitle: Distributed Tracing in Microservices
+title: "Microservices Distributed Tracing Pattern In Java: Enhancing Visibility in Service Communication"
+shortTitle: Microservices Distributed Tracing
 description: "Learn how the Distributed Tracing pattern enhances visibility into service communication across microservices. Discover its benefits, implementation examples, and best practices."
-category: Structural
+category: Architectural
 language: en
 tag:
-  - Scalability
+    - Cloud distributed
+    - Microservices
+    - Resilience
+    - Observability
+    - Scalability
+    - System health
 ---
 
 ## Intent of Microservices Distributed Tracing Design Pattern
 
-Distributed tracing aims to monitor and track requests as they flow through different services in a microservices architecture, providing insights into performance, dependencies, and failures.
+Provide a mechanism to trace and correlate requests as they traverse multiple microservices in a distributed system, enabling end-to-end visibility and easier troubleshooting.
 
 ## Also known as
 
 * Distributed Request Tracing
-* End-to-End Tracing
+* End-to-End Microservice Tracing
 
 ## Detailed Explanation of Microservices Distributed Tracing Pattern with Real-World Examples
 
 Real-world example
 
-> In an e-commerce platform, distributed tracing is used to track a customer's request from the moment they add an item to the cart until the order is processed and shipped. This helps in identifying bottlenecks, errors, and latency issues across different services.
+> Imagine an online food delivery platform where one microservice handles user orders, another manages restaurant menus, and yet another coordinates courier assignments. When a user places an order, the request travels through all three services in sequence. By implementing distributed tracing, each service attaches a trace identifier to its logs. This allows the operations team to follow the journey of a single order across the entire pipeline, identify any delays along the way, and quickly pinpoint which service is causing the bottleneck or experiencing an error.
 
 In plain words
 
@@ -31,10 +36,13 @@ Wikipedia says
 
 > Tracing in software engineering refers to the process of capturing and recording information about the execution of a software program. This information is typically used by programmers for debugging purposes, and additionally, depending on the type and detail of information contained in a trace log, by experienced system administrators or technical-support personnel and by software monitoring tools to diagnose common problems with software.
 
-## Programmatic Example of Microservices Distributed Tracing in Java
+Sequence diagram
+
+![Microservices Distributed Tracing Sequence Diagram](./etc/microservices-distributed-tracing-sequence-diagram.png)
 
+## Programmatic Example of Microservices Distributed Tracing in Java
 
-This implementation shows how an e-commerce platform's `OrderService` interacts with both `PaymentService` and `ProductService`. When a customer places an order, the `OrderService` calls the `PaymentService` to process the payment and the `ProductService` to check the product inventory. Distributed tracing logs are generated for each of these interactions and can be viewed in the Zipkin interface to monitor the flow and performance of requests across these services.
+This implementation shows how an e-commerce platform's `OrderService` interacts with both `PaymentService` and `ProductService`. When a customer places an order, the `OrderService` calls the `PaymentService` to process the payment and the `ProductService` to check the product inventory. By adding distributed trace instrumentation (usually via libraries like Spring Cloud Sleuth or OpenTelemetry), each service attaches trace context to outgoing requests and logs. These logs can then be viewed in the Zipkin interface (or other tracing tools, such as Jaeger) to observe the entire flow of the request and quickly identify any performance bottlenecks or failures across multiple services.
 
 Here's the `Order microservice` implementation.
 
@@ -150,25 +158,32 @@ public class ProductController {
 }
 ```
 
-## When to Use the Microservices Distributed Tracing Pattern in Java
+In this example, each microservice would typically be configured with tracing libraries (like Sleuth or OpenTelemetry). The trace context is propagated via HTTP headers, enabling the logs and metrics for each service call to be grouped together and visualized in Zipkin or another compatible tool. This ensures complete end-to-end visibility into each request’s journey.
 
-* When you have a microservices architecture and need to monitor the flow of requests across multiple services.
-* When troubleshooting performance issues or errors in a distributed system.
-* When you need to gain insights into system bottlenecks and optimize overall performance.
+## When to Use the Microservices Distributed Tracing Pattern in Java
 
+* When multiple services form a single user request path and debugging failures requires visibility across service boundaries.
+* When monitoring or diagnosing performance bottlenecks is critical in a multi-service environment.
+* When correlation of logs and metrics from independent services is needed to understand overall system health.
 
 ## Microservices Distributed Tracing Pattern Java Tutorials
 
 * [Spring Boot - Tracing (Spring)](https://docs.spring.io/spring-boot/reference/actuator/tracing.html)
 * [Reactive Observability (Spring Academy)](https://spring.academy/guides/microservices-observability-reactive-spring-boot-3)
 * [Spring Cloud – Tracing Services with Zipkin (Baeldung)](https://dzone.com/articles/getting-started-with-spring-cloud-gateway)
 
+## Real-World Applications of Microservices Distributed Tracing Pattern in Java
+
+* OpenTelemetry for tracing instrumentation in Java services.
+* Spring Cloud Sleuth for automatic tracing in Spring Boot microservices.
+* Jaeger and Zipkin for collecting and visualizing distributed traces in Java-based systems.
+
 ## Benefits and Trade-offs of Microservices Distributed Tracing Pattern
 
 Benefits:
 
-* Provides end-to-end visibility into requests.
-* Helps in identifying performance bottlenecks.
+* Centralized insight into request paths across services, reducing time to diagnose issues.
+* Improved observability enables proactive identification of system bottlenecks.
 * Aids in debugging and troubleshooting complex systems.
 
 Trade-offs:
@@ -177,20 +192,17 @@ Trade-offs:
 * Requires additional infrastructure (e.g., Zipkin, Jaeger) for collecting and visualizing traces.
 * Can become complex to manage in large-scale systems.
 
-## Real-World Applications of Microservices Distributed Tracing Pattern in Java
-
-* Monitoring and troubleshooting e-commerce platforms.
-*  Performance monitoring in financial transaction systems.
-*  Observability in large-scale SaaS applications.
-
 ## Related Java Design Patterns
 
-* [Log Aggregation Microservice](https://java-design-patterns.com/patterns/microservices-log-aggregation/) - Distributed tracing works well in conjunction with log aggregation to provide comprehensive observability and troubleshooting capabilities.
-* [Circuit Breaker](https://java-design-patterns.com/patterns/circuit-breaker/) - Distributed tracing can be used alongside the Circuit Breaker pattern to monitor and handle failures gracefully, preventing cascading failures in microservices.
-* [API Gateway Microservice](https://java-design-patterns.com/patterns/microservices-api-gateway/) - The API Gateway pattern can be integrated with distributed tracing to provide a single entry point for tracing requests across multiple microservices.
+* [API Gateway Microservice](https://java-design-patterns.com/patterns/microservices-api-gateway/): Acts as an entry point to microservices and can propagate trace information to downstream services.
+* [Circuit Breaker](https://java-design-patterns.com/patterns/circuit-breaker/): Distributed tracing can be used alongside the Circuit Breaker pattern to monitor and handle failures gracefully, preventing cascading failures in microservices.
+* [Log Aggregation Microservice](https://java-design-patterns.com/patterns/microservices-log-aggregation/): Distributed tracing works well in conjunction with log aggregation to provide comprehensive observability and troubleshooting capabilities.
+* [Saga](https://java-design-patterns.com/patterns/saga/): Orchestrates distributed transactions, which benefit from trace identifiers to correlate steps across services.
 
 ## References and Credits
 
 * [Building Microservices](https://amzn.to/3UACtrU)
-* [OpenTelemetry Documentation](https://opentelemetry.io/docs/)
 * [Distributed tracing (microservices.io)](https://microservices.io/patterns/observability/distributed-tracing.html)
+* [Microservices Patterns: With examples in Java](https://amzn.to/3UyWD5O)
+* [OpenTelemetry Documentation](https://opentelemetry.io/docs/)
+* [Release It! Design and Deploy Production-Ready Software](https://amzn.to/3Uul4kF)

microservices-distributed-tracing/etc/microservices-distributed-tracing-sequence-diagram.png

@@ -36,7 +36,7 @@ class ProductControllerTest {
   private ProductController productController;
 
   @BeforeEach
-  public void setUp() {
+  void setUp() {
     productController = new ProductController();
   }
 

microservices-distributed-tracing/product-microservice/src/test/java/com/iluwatar/product/microservice/ProductControllerTest.java

@@ -1,53 +1,56 @@
 ---
-title: "Idempotent Consumer Pattern in Java: Ensuring Reliable Message Processing"
-shortTitle: Idempotent Consumer
+title: "Microservices Idempotent Consumer Pattern in Java: Ensuring Reliable Message Processing"
+shortTitle: Microservices Idempotent Consumer
 description: "Learn about the Idempotent Consumer pattern in Java. Discover how it ensures reliable and consistent message processing, even in cases of duplicate messages."
-category: Structural
+category: Messaging
 language: en
 tag:
+    - Asynchronous
+    - Decoupling
     - Event-driven
+    - Messaging
+    - Microservices
+    - Resilience
+    - Retry
 ---
 
 ## Also known as
 
-* Idempotency Pattern
+* Idempotent Subscriber
+* Repeatable Message Consumer
+* Safe Consumer
 
 ## Intent of Idempotent Consumer Pattern
 
-The Idempotent Consumer pattern is used to handle duplicate messages in distributed systems, ensuring that multiple processing of the same message does not cause undesired side effects. This pattern guarantees that the same message can be processed repeatedly with the same outcome, which is critical in ensuring reliable communication and data consistency in systems where message duplicates are possible.
+Ensure that consuming the same message multiple times does not cause unintended side effects in a microservices-based architecture.
 
 ## Detailed Explanation of Idempotent Consumer Pattern with Real-World Examples
 
-### Real-world Example
+Real-world example
 
 > In a payment processing system, ensuring that payment messages are idempotent prevents duplicate transactions. For example, if a user’s payment message is accidentally processed twice, the system should recognize the second message as a duplicate and prevent it from executing a second time. By storing unique identifiers for each processed message, such as a transaction ID, the system can skip any duplicate messages. This ensures that a user is not charged twice for the same transaction, maintaining system integrity and customer satisfaction.
 
-### In Plain Words
+In plain words
 
 > The Idempotent Consumer pattern prevents duplicate messages from causing unintended side effects by ensuring that processing the same message multiple times results in the same outcome. This makes message processing safe in distributed systems where duplicates may occur.
 
-### Wikipedia says
 
-> In computing, idempotence is the property of certain operations in mathematics and computer science whereby they can be applied multiple times without changing the result beyond the initial application.
+Wikipedia says
 
-## When to Use the Idempotent Consumer Pattern
+> In computing, idempotence is the property of certain operations in mathematics and computer science whereby they can be applied multiple times without changing the result beyond the initial application.
 
-The Idempotent Consumer pattern is particularly useful in scenarios:
+Flowchart
 
-* When messages can be duplicated due to network retries or communication issues.
-* In distributed systems where message ordering is not guaranteed, making deduplication necessary to avoid repeated processing.
-* In financial or critical systems, where duplicate processing would have significant side effects.
+![Microservices Idempotent Consumer flowchart](./etc/microservices-idempotent-consumer-flowchart.png)
 
-## Real-World Applications of Idempotent Consumer Pattern
+## Programmatic example of Idempotent Consumer Pattern
 
-* Payment processing systems that avoid duplicate transactions.
-* E-commerce systems to prevent multiple entries of the same order.
-* Inventory management systems to prevent multiple entries when updating stock levels.
+In this Java example, we have an idempotent service that creates and updates orders. The `create` method is idempotent, meaning multiple calls with the same order ID return the same result without duplicates. For state changes (like starting or completing an order), the service checks whether the transition is valid and throws an exception if it’s not allowed. The `RequestStateMachine` ensures that order statuses move forward in a valid sequence (e.g., PENDING → STARTED → COMPLETED).
 
-## Programmatic example of Idempotent Consumer Pattern
-In this Java example, we have an idempotent service that offers functionality to create and update (start, complete, etc.) orders. The service ensures that the **create order** operation is idempotent, meaning that performing it multiple times with the same order ID will lead to the same result without creating duplicates. For state transitions (such as starting or completing an order), the service enforces valid state changes and throws exceptions if an invalid transition is attempted. The state machine governs the valid order status transitions, ensuring that statuses progress in a defined and consistent sequence.
 ### RequestService - Managing Idempotent Order Operations
-The `RequestService` class is responsible for handling the creation and state transitions of orders. The `create` method is designed to be idempotent, ensuring that it either returns an existing order or creates a new one without any side effects if invoked multiple times with the same order ID.
+
+The `RequestService` class provides methods to create and transition an order. The `create` method returns an existing order if it already exists, making it idempotent.
+
 ```java
 public class RequestService {
     // Idempotent: ensures that the same request is returned if it already exists
@@ -76,8 +79,11 @@ public class RequestService {
     }
 }
 ```
+
 ### RequestStateMachine - Managing Order Transitions
-The `RequestStateMachine` ensures that state transitions occur in a valid order. It handles the progression of an order's status, ensuring the correct sequence (e.g., from `PENDING` to `STARTED` to `COMPLETED`).
+
+The `RequestStateMachine` enforces valid state changes. If a requested transition is not allowed based on the current status, an exception is thrown.
+
 ```java
 public class RequestStateMachine {
 
@@ -102,9 +108,10 @@ public class RequestStateMachine {
   }
 }
 ```
+
 ### Main Application - Running the Idempotent Consumer Example
 
-In the main application, we demonstrate how the `RequestService` can be used to perform idempotent operations. Whether the order creation or state transition is invoked once or multiple times, the result is consistent and does not produce unexpected side effects.
+Here, we demonstrate how `RequestService` can be called multiple times without creating duplicate orders. We also show how invalid transitions (like trying to start an order twice) result in exceptions, while valid transitions proceed normally.
 
 ```java
 Request req = requestService.create(UUID.randomUUID());
@@ -127,32 +134,49 @@ req = requestService.complete(req.getUuid());
 // Log the final status of the Request to confirm it's been completed
 LOGGER.info("Request: {}", req);
 ```
+
 Program output:
+
 ```
 19:01:54.382  INFO [main] com.iluwatar.idempotentconsumer.App      : Nb of requests : 1
 19:01:54.395 ERROR [main] com.iluwatar.idempotentconsumer.App      : Cannot start request twice!
 19:01:54.399  INFO [main] com.iluwatar.idempotentconsumer.App      : Request: Request(uuid=2d5521ef-6b6b-4003-9ade-81e381fe9a63, status=COMPLETED)
 ```
+
+## When to Use the Idempotent Consumer Pattern
+
+* When messages can arrive more than once due to network glitches or retries
+* When microservices must guarantee consistent state changes regardless of duplicates
+* When fault-tolerant event-driven communication is critical to system reliability
+* When horizontal scaling requires stateless consumer operations
+
+## Real-World Applications of Idempotent Consumer Pattern
+
+* Payment processing systems that receive duplicate charge events
+* E-commerce order services that handle duplicate purchase requests
+* Notification services that retry failed message deliveries
+* Distributed transaction systems where duplicated events are common
+
 ## Benefits and Trade-offs of the Idempotent Consumer Pattern
 
-### Benefits
+Benefits
 
-* **Reliability**: Ensures that messages can be processed without unwanted side effects from duplicates.
-* **Consistency**: Maintains data integrity by ensuring that duplicate messages do not cause redundant updates or actions.
-* **Fault Tolerance**: Handles message retries gracefully, preventing them from causing errors.
+* Prevents duplicate side effects
+* Increases reliability under repeated or delayed messages
+* Simplifies error handling and retry logic
 
-### Trade-offs
+Trade-offs
 
-* **State Management**: Requires storing processed message IDs, which can add memory overhead.
-* **Complexity**: Implementing deduplication mechanisms can increase the complexity of the system.
-* **Scalability**: In high-throughput systems, maintaining a large set of processed messages can impact performance and resource usage.
+* Requires careful design to track processed messages
+* Can add overhead for maintaining idempotency tokens or state
+* May require additional storage or database transactions
 
 ## Related Patterns in Java
 
-* [Retry Pattern](https://java-design-patterns.com/patterns/retry/): Works well with the Idempotent Consumer pattern to handle failed messages.
-* [Circuit Breaker Pattern](https://java-design-patterns.com/patterns/circuitbreaker/): Often used alongside idempotent consumers to prevent repeated failures from causing overload.
+* Outbox Pattern: Uses a dedicated table or storage to reliably publish events and handle deduplication at the source.
 
 ## References and Credits
 
+* [Building Microservices](https://amzn.to/3UACtrU)
 * [Enterprise Integration Patterns: Designing, Building, and Deploying Messaging Solutions](https://amzn.to/4dznP2Y)
-* [Designing Data-Intensive Applications](https://amzn.to/3UADv7Q)
+* [Microservices Patterns: With examples in Java](https://amzn.to/3UyWD5O)

microservices-idempotent-consumer/README.md

@@ -44,18 +44,15 @@ public RequestService(
   }
 
   /**
-   * Creates a new Request or returns an existing one by it's UUID. This operation is idempotent:
+   * Creates a new Request or returns an existing one by its UUID. This operation is idempotent:
    * performing it once or several times successively leads to an equivalent result.
    *
    * @param uuid The unique identifier for the Request.
    * @return Return existing Request or save and return a new Request.
    */
   public Request create(UUID uuid) {
     Optional<Request> optReq = requestRepository.findById(uuid);
-    if (!optReq.isEmpty()) {
-      return optReq.get();
-    }
-    return requestRepository.save(new Request(uuid));
+    return optReq.orElseGet(() -> requestRepository.save(new Request(uuid)));
   }
 
   /**

microservices-idempotent-consumer/etc/microservices-idempotent-consumer-flowchart.png

@@ -39,12 +39,12 @@
 class AppTest {
 
   @Test
-  void main() {
+  void testMain() {
     assertDoesNotThrow(() -> App.main(new String[] {}));
   }
 
   @Test
-  void run() throws Exception {
+  void testRun() throws Exception {
     RequestService requestService = Mockito.mock(RequestService.class);
     RequestRepository requestRepository = Mockito.mock(RequestRepository.class);
     UUID uuid = UUID.randomUUID();

microservices-idempotent-consumer/src/main/java/com/iluwatar/idempotentconsumer/RequestService.java

@@ -43,11 +43,10 @@
 class RequestServiceTests {
   private RequestService requestService;
   @Mock private RequestRepository requestRepository;
-  private RequestStateMachine requestStateMachine;
 
   @BeforeEach
   void setUp() {
-    requestStateMachine = new RequestStateMachine();
+    RequestStateMachine requestStateMachine = new RequestStateMachine();
     requestService = new RequestService(requestRepository, requestStateMachine);
   }
 

microservices-idempotent-consumer/src/test/java/com/iluwatar/idempotentconsumer/AppTest.java

@@ -35,7 +35,7 @@ class RequestStateMachineTests {
   private RequestStateMachine requestStateMachine;
 
   @BeforeEach
-  public void setUp() {
+  void setUp() {
     requestStateMachine = new RequestStateMachine();
   }
 

microservices-idempotent-consumer/src/test/java/com/iluwatar/idempotentconsumer/RequestServiceTests.java

@@ -2,10 +2,13 @@
 title: "Money Pattern in Java: Encapsulating Monetary Values with Currency Consistency"
 shortTitle: Money
 description: "Learn how the Money design pattern in Java ensures currency safety, precision handling, and maintainable financial operations. Explore examples, applicability, and benefits of the pattern."
-category: Behavioral
+category: Structural
 language: en
 tag:
-  - Encapsulation
+    - Business
+    - Domain
+    - Encapsulation
+    - Immutable
 ---
 
 ## Also known as
@@ -14,147 +17,115 @@ tag:
 
 ## Intent of Money Design Pattern
 
-The Money design pattern provides a robust way to encapsulate monetary values and their associated currencies. It ensures precise calculations, currency consistency, and maintainability of financial logic in Java applications.
+Encapsulate monetary values and their associated currency in a domain-specific object.
 
 ## Detailed Explanation of Money Pattern with Real-World Examples
 
-### Real-world example
+Real-world example
 
-> Imagine an e-commerce platform where customers shop in their local currencies. The platform needs to calculate order totals, taxes, and discounts accurately while handling multiple currencies seamlessly.
+> Imagine an online gift card system, where each gift card holds a specific balance in a particular currency. Instead of just using a floating-point value for the balance, the system uses a Money object to precisely track the amount and currency. Whenever someone uses the gift card, it updates the balance with accurate calculations that avoid floating-point rounding errors, ensuring the domain logic stays consistent and accurate.
 
-In this example:
-- Each monetary value (like a product price or tax amount) is encapsulated in a `Money` object.
-- The `Money` class ensures that only values in the same currency are combined and supports safe currency conversion for global operations.
-
-### In plain words
+In plain words
 
 > The Money pattern encapsulates both an amount and its currency, ensuring financial operations are precise, consistent, and maintainable.
 
-### Wikipedia says
+Wikipedia says
+
+> The Money design pattern encapsulates a monetary value and its currency, allowing for safe arithmetic operations and conversions while preserving accuracy and consistency in financial calculations.
+
+Mind map
 
-> "The Money design pattern encapsulates a monetary value and its currency, allowing for safe arithmetic operations and conversions while preserving accuracy and consistency in financial calculations."
+![Money Pattern Mind Map](./etc/money-mind-map.png)
+
+Flowchart
+
+![Money Pattern Flowchart](./etc/money-flowchart.png)
 
 ## Programmatic Example of Money Pattern in Java
 
-### Money Class
+In this example, we're creating a `Money` class to demonstrate how monetary values can be encapsulated along with their currency. This approach helps avoid floating-point inaccuracies, ensures arithmetic operations are handled consistently, and provides a clear domain-centric way of working with money.
 
 ```java
-
-/**
- * Represents a monetary value with an associated currency.
- * Provides operations for basic arithmetic (addition, subtraction, multiplication),
- * as well as currency conversion while ensuring proper rounding.
- */
+@AllArgsConstructor
 @Getter
 public class Money {
-  private @Getter double amount;
-  private @Getter String currency;
+    private double amount;
+    private String currency;
 
-  public Money(double amnt, String curr) {
-    this.amount = amnt;
-    this.currency = curr;
-  }
+    public Money(double amnt, String curr) {
+        this.amount = amnt;
+        this.currency = curr;
+    }
 
-  private double roundToTwoDecimals(double value) {
-    return Math.round(value * 100.0) / 100.0;
-  }
+    private double roundToTwoDecimals(double value) {
+        return Math.round(value * 100.0) / 100.0;
+    }
 
-  public void addMoney(Money moneyToBeAdded) throws CannotAddTwoCurrienciesException {
-    if (!moneyToBeAdded.getCurrency().equals(this.currency)) {
-      throw new CannotAddTwoCurrienciesException("You are trying to add two different currencies");
+    public void addMoney(Money moneyToBeAdded) throws CannotAddTwoCurrienciesException {
+        if (!moneyToBeAdded.getCurrency().equals(this.currency)) {
+            throw new CannotAddTwoCurrienciesException("You are trying to add two different currencies");
+        }
+        this.amount = roundToTwoDecimals(this.amount + moneyToBeAdded.getAmount());
     }
-    this.amount = roundToTwoDecimals(this.amount + moneyToBeAdded.getAmount());
-  }
-
-  public void subtractMoney(Money moneyToBeSubtracted) throws CannotSubtractException {
-    if (!moneyToBeSubtracted.getCurrency().equals(this.currency)) {
-      throw new CannotSubtractException("You are trying to subtract two different currencies");
-    } else if (moneyToBeSubtracted.getAmount() > this.amount) {
-      throw new CannotSubtractException("The amount you are trying to subtract is larger than the amount you have");
+
+    public void subtractMoney(Money moneyToBeSubtracted) throws CannotSubtractException {
+        if (!moneyToBeSubtracted.getCurrency().equals(this.currency)) {
+            throw new CannotSubtractException("You are trying to subtract two different currencies");
+        } else if (moneyToBeSubtracted.getAmount() > this.amount) {
+            throw new CannotSubtractException("The amount you are trying to subtract is larger than the amount you have");
+        }
+        this.amount = roundToTwoDecimals(this.amount - moneyToBeSubtracted.getAmount());
     }
-    this.amount = roundToTwoDecimals(this.amount - moneyToBeSubtracted.getAmount());
-  }
 
-  public void multiply(int factor) {
-    if (factor < 0) {
-      throw new IllegalArgumentException("Factor must be non-negative");
+    public void multiply(int factor) {
+        if (factor < 0) {
+            throw new IllegalArgumentException("Factor must be non-negative");
+        }
+        this.amount = roundToTwoDecimals(this.amount * factor);
     }
-    this.amount = roundToTwoDecimals(this.amount * factor);
-  }
 
-  public void exchangeCurrency(String currencyToChangeTo, double exchangeRate) {
-    if (exchangeRate < 0) {
-      throw new IllegalArgumentException("Exchange rate must be non-negative");
+    public void exchangeCurrency(String currencyToChangeTo, double exchangeRate) {
+        if (exchangeRate < 0) {
+            throw new IllegalArgumentException("Exchange rate must be non-negative");
+        }
+        this.amount = roundToTwoDecimals(this.amount * exchangeRate);
+        this.currency = currencyToChangeTo;
     }
-    this.amount = roundToTwoDecimals(this.amount * exchangeRate);
-    this.currency = currencyToChangeTo;
-  }
 }
+```
 
-## When to Use the Money Pattern
-
-The Money pattern should be used in scenarios where:
+By encapsulating all money-related logic in a single class, we reduce the risk of mixing different currencies, improve clarity of the codebase, and facilitate future modifications such as adding new currencies or refining rounding rules. This pattern ultimately strengthens the domain model by treating money as a distinct concept rather than just another numeric value.
 
-1. **Currency-safe arithmetic operations**  
-   To ensure that arithmetic operations like addition, subtraction, and multiplication are performed only between amounts in the same currency, preventing inconsistencies or errors in calculations.
-
-2. **Accurate rounding for financial calculations**  
-   Precise rounding to two decimal places is critical to maintain accuracy and consistency in financial systems.
-
-3. **Consistent currency conversion**  
-   When handling international transactions or displaying monetary values in different currencies, the Money pattern facilitates easy and reliable conversion using exchange rates.
+## When to Use the Money Pattern
 
-4. **Encapsulation of monetary logic**  
-   By encapsulating all monetary operations within a dedicated class, the Money pattern improves maintainability and reduces the likelihood of errors.
+* When financial calculations or money manipulations are part of the business logic
+* When precise handling of currency amounts is required to avoid floating-point inaccuracies
+* When domain-driven design principles and strong typing are desired
 
-5. **Preventing errors in financial operations**  
-   Strict validation ensures that operations like subtraction or multiplication are only performed when conditions are met, safeguarding against misuse or logical errors.
+## Real-World Applications of Monad Pattern in Java
 
-6. **Handling diverse scenarios in financial systems**  
-   Useful in complex systems like e-commerce, banking, and payroll applications where precise and consistent monetary value handling is crucial.
+* JSR 354 (Java Money and Currency) library in Java
+* Custom domain models in e-commerce and accounting systems
 
----
 ## Benefits and Trade-offs of Money Pattern
 
-### Benefits
-1. **Precision and Accuracy**  
-   The Money pattern ensures precise handling of monetary values, reducing the risk of rounding errors.
-
-2. **Encapsulation of Business Logic**  
-   By encapsulating monetary operations, the pattern enhances maintainability and reduces redundancy in financial systems.
-
-3. **Currency Safety**  
-   It ensures operations are performed only between amounts of the same currency, avoiding logical errors.
+Benefits
 
-4. **Improved Readability**  
-   By abstracting monetary logic into a dedicated class, the code becomes easier to read and maintain.
+* Provides a single, type-safe representation of monetary amounts and currency
+* Encourages encapsulation of related operations such as addition, subtraction, and formatting
+* Avoids floating-point errors by using integers or specialized decimal libraries
 
-5. **Ease of Extension**  
-   Adding new operations, handling different currencies, or incorporating additional business rules is straightforward.
+Trade-offs
 
-### Trade-offs
-1. **Increased Complexity**  
-   Introducing a dedicated `Money` class can add some overhead, especially for small or simple projects.
-
-2. **Potential for Misuse**  
-   Without proper validation and handling, incorrect usage of the Money pattern may introduce subtle bugs.
-
-3. **Performance Overhead**  
-   Precision and encapsulation might slightly affect performance in systems with extremely high transaction volumes.
-
----
+* Requires additional classes and infrastructure to handle currency conversions and formatting
+* Might introduce performance overhead when performing large numbers of money operations
 
 ## Related Design Patterns
 
-1. **Value Object**  
-   Money is a classic example of the Value Object pattern, where objects are immutable and define equality based on their value.
-   Link:https://martinfowler.com/bliki/ValueObject.html
-2. **Factory Method**  
-   Factories can be employed to handle creation logic, such as applying default exchange rates or rounding rules.
-    Link:https://www.geeksforgeeks.org/factory-method-for-designing-pattern/
----
+* [Value Object](https://java-design-patterns.com/patterns/value-object/): Money is typically a prime example of a domain-driven design value object.
 
 ## References and Credits
 
-- [Patterns of Enterprise Application Architecture](https://martinfowler.com/eaaCatalog/money.html) by Martin Fowler  
-- [Design Patterns: Elements of Reusable Object-Oriented Software](https://amzn.to/3w0pvKI)  
+* [Domain-Driven Design: Tackling Complexity in the Heart of Software](https://amzn.to/3wlDrze)
+* [Implementing Domain-Driven Design](https://amzn.to/4dmBjrB)
+* [Patterns of Enterprise Application Architecture](https://amzn.to/3WfKBPR)

microservices-idempotent-consumer/src/test/java/com/iluwatar/idempotentconsumer/RequestStateMachineTests.java

@@ -24,28 +24,19 @@
  */
 package com.iluwatar;
 
+import lombok.AllArgsConstructor;
 import lombok.Getter;
 
 /**
  * Represents a monetary value with an associated currency. Provides operations for basic arithmetic
  * (addition, subtraction, multiplication), as well as currency conversion while ensuring proper
  * rounding.
  */
+@AllArgsConstructor
 @Getter
 public class Money {
-  private @Getter double amount;
-  private @Getter String currency;
-
-  /**
-   * Constructs a Money object with the specified amount and currency.
-   *
-   * @param amnt the amount of money (as a double).
-   * @param curr the currency code (e.g., "USD", "EUR").
-   */
-  public Money(double amnt, String curr) {
-    this.amount = amnt;
-    this.currency = curr;
-  }
+  private double amount;
+  private String currency;
 
   /**
    * Rounds the given value to two decimal places.

money/README.md

@@ -59,11 +59,7 @@ void testAddMoney_DifferentCurrency() {
     Money money1 = new Money(100.00, "USD");
     Money money2 = new Money(50.25, "EUR");
 
-    assertThrows(
-        CannotAddTwoCurrienciesException.class,
-        () -> {
-          money1.addMoney(money2);
-        });
+    assertThrows(CannotAddTwoCurrienciesException.class, () -> money1.addMoney(money2));
   }
 
   @Test
@@ -83,11 +79,7 @@ void testSubtractMoney_DifferentCurrency() {
     Money money1 = new Money(100.00, "USD");
     Money money2 = new Money(50.25, "EUR");
 
-    assertThrows(
-        CannotSubtractException.class,
-        () -> {
-          money1.subtractMoney(money2);
-        });
+    assertThrows(CannotSubtractException.class, () -> money1.subtractMoney(money2));
   }
 
   @Test
@@ -96,11 +88,7 @@ void testSubtractMoney_AmountTooLarge() {
     Money money1 = new Money(50.00, "USD");
     Money money2 = new Money(60.00, "USD");
 
-    assertThrows(
-        CannotSubtractException.class,
-        () -> {
-          money1.subtractMoney(money2);
-        });
+    assertThrows(CannotSubtractException.class, () -> money1.subtractMoney(money2));
   }
 
   @Test
@@ -118,11 +106,7 @@ void testMultiply_NegativeFactor() {
     // Test multiplying by a negative factor
     Money money = new Money(100.00, "USD");
 
-    assertThrows(
-        IllegalArgumentException.class,
-        () -> {
-          money.multiply(-2);
-        });
+    assertThrows(IllegalArgumentException.class, () -> money.multiply(-2));
   }
 
   @Test
@@ -141,19 +125,12 @@ void testExchangeCurrency_NegativeExchangeRate() {
     // Test converting currency with a negative exchange rate
     Money money = new Money(100.00, "USD");
 
-    assertThrows(
-        IllegalArgumentException.class,
-        () -> {
-          money.exchangeCurrency("EUR", -0.85);
-        });
+    assertThrows(IllegalArgumentException.class, () -> money.exchangeCurrency("EUR", -0.85));
   }
 
   @Test
   void testAppExecution() {
     assertDoesNotThrow(
-        () -> {
-          App.main(new String[] {});
-        },
-        "App execution should not throw any exceptions");
+        () -> App.main(new String[] {}), "App execution should not throw any exceptions");
   }
 }