Guided Exercise - Microservices - Design Patterns - Aggregator Pattern

[akash-coded]

Aggregator Pattern in Spring Microservices

The Aggregator is a Microservices pattern where one service (the Aggregator) calls multiple services to perform some task. The Aggregator will then compile the results and send a unified response back to the consumer. This pattern simplifies the consumer code, centralizes some request-handling aspects, and makes it possible to optimize calls for better performance.

Prerequisites

• Java Development Kit (JDK 8 or above)
• Maven
• IDE like IntelliJ IDEA or Eclipse
• Docker (for running services)

Architecture Overview

We will create 3 services:

1. OrderService - Manages orders
2. PaymentService - Manages payments
3. AggregatorService - Aggregates data from the Order and Payment services and provides a unified API to the client

Step 1: Create Microservices

Create three separate Spring Boot projects (either via Spring Initializr or your preferred method).

Step 2: Add Dependencies

For all three projects, you will need the following dependencies:

<!-- Web -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!-- Actuator for monitoring -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

For the AggregatorService, add Spring Cloud OpenFeign for declarative REST calls:

<!-- Feign -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>

Step 3: Business Logic

1. OrderService: Create a REST API to get an order by ID.
2. PaymentService: Create a REST API to get payment details by order ID.
3. AggregatorService: Use Feign clients to call the above services and aggregate the data.

Here's a simple Feign client in AggregatorService:

@FeignClient("order-service")
public interface OrderClient {
    @GetMapping("/order/{id}")
    Order getOrderById(@PathVariable("id") String id);
}

@FeignClient("payment-service")
public interface PaymentClient {
    @GetMapping("/payment/{orderId}")
    Payment getPaymentByOrderId(@PathVariable("orderId") String orderId);
}

Step 4: Aggregation Logic

In the AggregatorService, use the Feign clients to aggregate data.

@RestController
public class AggregatorController {
    @Autowired
    private OrderClient orderClient;
    @Autowired
    private PaymentClient paymentClient;

    @GetMapping("/aggregate/{id}")
    public AggregateData aggregate(@PathVariable String id) {
        Order order = orderClient.getOrderById(id);
        Payment payment = paymentClient.getPaymentByOrderId(id);
        return new AggregateData(order, payment);
    }
}

Step 5: Run Services

1. Run the OrderService and PaymentService locally or package them and run as Docker containers.
2. Run the AggregatorService.

Step 6: Test Aggregator

Test by calling http://localhost:8080/aggregate/1.

Internal Details

The Aggregator pattern can add an extra layer for request/response management, enabling optimizations like response caching, parallel calls, and more. It also decouples consumers from the details of internal microservices, making the architecture more flexible.

Best Practices, Dos and Don'ts, Optimization Strategies

1. Caching: Cache common queries in the aggregator.
2. Asynchronous Calls: Use async mechanisms for calling services to reduce the overall time.
3. Bulk API: Where possible, use bulk APIs to retrieve data.
4. Error Handling: Handle errors gracefully; a failure in one service should not lead to a complete failure in the aggregator.
5. Monitoring: Monitor aggregators carefully as they are a common point of failure.
6. Rate Limiting: Implement rate limiting to prevent misuse.
7. Decoupling: Keep the aggregator decoupled from business logic; it should only be responsible for data gathering.

Code Repository Structure

Your code structure might look something like this for the three services:

• OrderService

  • src
    • main
      • java
        • com
          • example
            • OrderServiceApplication.java
            • controller
              • OrderController.java
            • model
              • Order.java
      • resources
        • application.properties

• PaymentService

  • src
    • main
      • java
        • com
          • example
            • PaymentServiceApplication.java
            • controller
              • PaymentController.java
            • model
              • Payment.java
      • resources
        • application.properties

• AggregatorService

  • src
    • main
      • java
        • com
          • example
            • AggregatorServiceApplication.java
            • controller
              • AggregatorController.java
            • feignclient
              • OrderClient.java
              • PaymentClient.java
            • model
              • AggregateData.java
      • resources
        • application.properties

Sample Code for Controllers and Models

OrderService

@RestController
public class OrderController {
    @GetMapping("/order/{id}")
    public Order getOrderById(@PathVariable String id) {
        return new Order(id, "Product_" + id, 10);
    }
}

public class Order {
    private String id;
    private String name;
    private double price;
    // Getters and Setters
}

PaymentService

@RestController
public class PaymentController {
    @GetMapping("/payment/{orderId}")
    public Payment getPaymentByOrderId(@PathVariable String orderId) {
        return new Payment(orderId, "PAID");
    }
}

public class Payment {
    private String orderId;
    private String status;
    // Getters and Setters
}

AggregatorService

@RestController
public class AggregatorController {
    @Autowired
    private OrderClient orderClient;
    @Autowired
    private PaymentClient paymentClient;

    @GetMapping("/aggregate/{id}")
    public AggregateData aggregate(@PathVariable String id) {
        Order order = orderClient.getOrderById(id);
        Payment payment = paymentClient.getPaymentByOrderId(id);
        return new AggregateData(order, payment);
    }
}

public class AggregateData {
    private Order order;
    private Payment payment;
    // Getters and Setters
}

Further Considerations

Performance

• Aggregator services can be prone to performance bottlenecks and can add latency if not properly designed.

Fault Tolerance

• Use patterns like Circuit Breaker to make the aggregator service more resilient.

Authentication & Authorization

• The aggregator may need to handle security aspects, both for incoming requests and for the service-to-service calls it makes. Spring Security can be used here.

Monitoring & Logging

• Aggregator services can be crucial in terms of observability. Integrate them with centralized logging and monitoring solutions.

Versioning

• Be cautious with versioning. When one of the internal services changes its API, the aggregator must be updated accordingly.

API Documentation

• Use tools like Swagger to document the aggregator API to make it easier for clients to understand what is being offered.

Testing

• Include unit tests for the individual services and integration tests that include the aggregator.

[HarshDPandya]

Hi Akash, Sharing my code in zip file for Microservices - Design Patterns - Aggregator Pattern using OpenFeign
Name: Harsh Pandya
TCS Emp Id: 2066481
microservice-aggregator-with-openfeign-Harsh-2066481.zip

[singhRatan777]

Aggregate-pattern.zip
Ratan Singh Dewada

[elcenninan]

Aggregator microservice.zip
Elcen Zachariah

[jay4tech]

Hi @akash-coded
Name: Jay Prakash Kumar [2075419]

Assignment of Microservices - Aggregator Desing Pattern using OpenFeign -

https://github.com/jay4tech/order-service
https://github.com/jay4tech/aggregator-service
https://github.com/jay4tech/aggregator-service

[zafvirinchi]

Hi @akash-coded

Please find the
https://github.com/zafvirinchi/E_Commerce_Dicussion156

[Chandrika1999]

Hi @akash-coded
Name: Chandrika Cheerla[2255969]

Assignment: Microservices - Aggregator
MicroServices-Aggregator-Project.zip

[arupmukherjee38]

Aggregator_Patternpoc.zip
Arup Mukherjee(TCS Emp Id:1524555)

[naikkushal]

AggregatorServices156.zip
Kushal Naik

[Devipadala]

Hi @akash-coded
Name: Devi Padala[2269823]

Assi
MicroServices-Aggregator.zip
gnment: Microservices - Aggregator

[AnuragMishra58]

Hi @akash-coded
Name: Anurag Mishra
Emp Id: 550966
Please find below aggregation pattern assignment using feign client.
aggregation.zip

[Prasadpoojary]

Hi
Aggregator pattern assignment using spring-feign
name : Prasad
spring-aggregator.zip

Thanks

[esubshaik1610]

hi akash PFA,
name: Esub Shaik[2268851]
session5-aggregator.zip

[arunsankar172]

Hi Akash,
Arunsankar R
aggregator.zip

[aathira-ps]

Session_5_Aathira PS.zip

[Kiran-Ramesh1]

Hi @akash-coded ,
Uploading Aggregator.zip…

Name : Kiran Ramesh (1949256)

[sushmoyr]

What if we use GRPC instead of rest client for service to service communication? The aggregator service will be a rest api server and the rest of the services will be a GRPC server. What are your thoughts on this?

[Sdey0907]

**

Task -Microservices - Design Patterns - Aggregator Pattern_Sayan Dey_Completed

**
Uploading MicroServices-Aggregator-Project.zip…

[prasetha21-max]

PRASETHA N
services.zip