Guided Compound Exercise - Spring Microservice Design Patterns - Banking System

[akash-coded]

Let’s choose a banking domain focusing on a few primary operations:

Scenario Overview:

Imagine a banking system with 3 microservices:

1. AccountService: Handles account management, including balance management.
2. TransactionService: Handles transactions between accounts.
3. NotificationService: Manages and sends notifications to users.

Main Functionality Workflow:

1. A user initiates a transaction.
2. If the transaction is successful, both account balances are updated, and notifications are sent to both users.
3. If the transaction fails at any point, the transaction is rolled back and a failure notification is sent to the initiating user.

Part 1: API Gateway, Proxy Pattern & Synchronous Communication

1. API Gateway using Spring Cloud Gateway:

Include dependencies in pom.xml:

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-gateway</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

application.yml for API Gateway:

spring:
  cloud:
    gateway:
      routes:
      - id: accountService
        uri: http://localhost:8081
        predicates:
        - Path=/api/accounts/**
      - id: transactionService
        uri: http://localhost:8082
        predicates:
        - Path=/api/transactions/**
      - id: notificationService
        uri: http://localhost:8083
        predicates:
        - Path=/api/notifications/**

2. Proxy Pattern:

Implement Feign Clients in services for synchronous communications.

Part 2: Event-Driven Architecture (EDA) & Asynchronous Communication

3. Asynchronous Communication:

• Using @Async annotations and ThreadPoolTaskExecutor to execute methods in the background.
• This is utilized within services to communicate with other services asynchronously after state updates.

Part 3: Implementing Saga Pattern

4. Saga Pattern:

a. TransactionService:

• Initiate Transaction: Commits a pending transaction and emits an event for AccountService.
• Handle Failures: Listens for failure events and compensates the transaction.

b. AccountService:

• Update Account: Updates account balances and emits success/failure events.
• Handle Failures: Listens for failure events to revert any performed changes.

c. NotificationService:

• Send Notifications: Listens for success/failure events and sends notifications accordingly.

Implementation Snippets:

TransactionService:

Initiate transaction and emit an event:

@PostMapping("/initiate")
public Transaction initiateTransaction(@RequestBody Transaction transaction) {
    transaction.setStatus(Status.PENDING);
    transactionRepository.save(transaction);
    eventPublisher.publishStartTransactionEvent(new StartTransactionEvent(transaction.getId()));
    return transaction;
}

AccountService:

Handle transaction events, update account balance, and emit events:

@EventListener
public void handleStartTransactionEvent(StartTransactionEvent event) {
    try {
        Transaction transaction = fetchTransactionDetails(event.getTransactionId());
        processTransaction(transaction);
        eventPublisher.publishTransactionSuccessEvent(new TransactionSuccessEvent(transaction.getId()));
    } catch (AccountException e) {
        eventPublisher.publishTransactionFailureEvent(new TransactionFailureEvent(event.getTransactionId(), e.getMessage()));
    }
}

NotificationService:

Listen for transaction success/failure events and send notifications:

@EventListener
public void handleTransactionSuccessEvent(TransactionSuccessEvent event) {
    Notification notification = createSuccessNotification(event.getTransactionId());
    sendNotification(notification);
}

@EventListener
public void handleTransactionFailureEvent(TransactionFailureEvent event) {
    Notification notification = createFailureNotification(event.getTransactionId(), event.getFailureReason());
    sendNotification(notification);
}

Part 4: Detailed Microservice Implementation

4.1 AccountService

Dependencies:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<!-- other necessary dependencies -->

application.properties:

spring.datasource.url=jdbc:your_database_url
spring.datasource.username=your_username
spring.datasource.password=your_password
# other database configurations

Model: Account

@Entity
public class Account {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private Double balance;
    // Getters and Setters
}

Repository: AccountRepository

public interface AccountRepository extends JpaRepository<Account, Long> {
}

4.2 TransactionService

Model: Transaction

@Entity
public class Transaction {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private Long senderId;
    private Long receiverId;
    private Double amount;
    private Status status;  // Enum: PENDING, SUCCESS, FAILURE
    // Getters and Setters
}

Repository: TransactionRepository

public interface TransactionRepository extends JpaRepository<Transaction, Long> {
}

4.3 NotificationService

Model: Notification

public class Notification {
    private Long userId;
    private String message;
    // Getters and Setters
}

Part 5: SAGA Pattern & Asynchronous Communication

To manage data consistency across services in a microservices architecture, the SAGA Pattern is employed. In this context:

• When a transaction is initiated, the TransactionService creates a PENDING transaction and sends a StartTransactionEvent.
• The AccountService listens for this event, processes the transaction, and sends either a TransactionSuccessEvent or TransactionFailureEvent.
• NotificationService listens for these events and sends appropriate notifications.

Event Publishing & Listening:

EventPublisher (Common to all services):

@Component
public class EventPublisher {
    @Autowired
    private ApplicationEventPublisher applicationEventPublisher;
    
    public void publishStartTransactionEvent(StartTransactionEvent event) {
        applicationEventPublisher.publishEvent(event);
    }
    
    // Other publish methods for various events
}

EventListeners:

@Component
public class TransactionEventListener {
    @EventListener
    public void handleStartTransactionEvent(StartTransactionEvent event) {
        // Logic to handle the event
    }
}

Part 6: Asynchronous Communication

Methods annotated with @Async must be declared in beans, and Spring’s @EnableAsync annotation should be enabled:

@Configuration
@EnableAsync
public class AsyncConfiguration {
    @Bean(name = "taskExecutor")
    public Executor taskExecutor() {
        return new ThreadPoolTaskExecutor();
    }
}

Using @Async("taskExecutor") on methods will execute them in a separate thread:

@Async("taskExecutor")
public void processTransaction(Transaction transaction) {
    // Processing logic
}

Part 7: Building, Testing, and Deploying the Services

Each microservice should be tested independently, ensuring unit tests validate business logic and integration tests validate inter-service communication.

Testing can involve using TestContainers to create isolated database instances, using MockMvc for API testing, and employing @Mock and @Spy for unit testing.

Repository Structure:

Each microservice will have its dedicated repository with a similar structure:

/microservice-name
    /src
        /main
            /java/com/tcs/microservicename
                /config
                /controller
                /model
                /repository
                /service
                /listener
            /resources
        /test
    /target
    pom.xml

Part 8: Proxy Pattern and API Gateway Integration

8.1 Proxy Pattern Implementation

In the banking scenario, let's implement a LoggingProxy to manage and log the transaction flow within services without intruding into business logic.

In TransactionService, a proxy can log transaction statuses and parameters:

public class TransactionLoggingProxy {
    
    private final TransactionService transactionService;
    
    public TransactionLoggingProxy(TransactionService transactionService) {
        this.transactionService = transactionService;
    }
    
    public Transaction initiateTransaction(Long senderId, Long receiverId, Double amount) {
        log.info("Transaction Initiated: SenderId=" + senderId + ", ReceiverId=" + receiverId + ", Amount=" + amount);
        Transaction transaction = transactionService.initiateTransaction(senderId, receiverId, amount);
        log.info("Transaction Status: " + transaction.getStatus());
        return transaction;
    }
}

In real-world scenarios, we'd implement a dynamic proxy instead of a static one to manage multiple methods without creating a specific proxy method for each original method.

8.2 API Gateway

We will use Spring Cloud Gateway to implement the API Gateway pattern.

Dependencies:

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-gateway</artifactId>
</dependency>

application.yaml

spring:
  cloud:
    gateway:
      routes:
        - id: transaction_route
          uri: lb://transaction-service
          predicates:
            - Path=/api/transaction/**
        - id: account_route
          uri: lb://account-service
          predicates:
            - Path=/api/account/**
        - id: notification_route
          uri: lb://notification-service
          predicates:
            - Path=/api/notification/**

In the configuration above, requests to /api/transaction will be routed to the TransactionService, /api/account will route to the AccountService, and /api/notification will route to the NotificationService.

Part 9: Securing Microservices

Security is paramount, particularly in a domain like banking. We could secure our services using OAuth2.0 and OpenID Connect for Authentication and Authorization.

Implementing a robust security mechanism ensures safe, secure communication and data transfer between microservices, and protects sensitive user data.

Part 10: Handling Data Consistency and Compensation Transactions

When working with SAGA Patterns, particularly in scenarios like banking, where consistency is crucial, compensation transactions should be in place in case a process fails mid-transaction.

For instance:

• Upon transaction failure, an event should be emitted, compensating for the original transaction to preserve data consistency across services.
• If money is debited from an account and the transaction fails before reaching the recipient's account, a compensation transaction should be triggered to refund the debited amount.

Part 11: Monitoring and Observability

Incorporate Spring Boot Actuator, Prometheus, and Grafana to create a monitoring system for microservices.

Dependencies:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
<dependency>
    <groupId>io.micrometer</groupId>
    <artifactId>micrometer-registry-prometheus</artifactId>
</dependency>

application.properties:

management.endpoints.web.exposure.include=*
management.endpoint.health.show-details=always
management.metrics.export.prometheus.enabled=true

By integrating Prometheus and Grafana with Spring Boot, developers gain insights into microservices' health, performance, and errors, ensuring immediate attention to potential issues.

Conclusion

The integration of various patterns and technologies like the Proxy pattern, API Gateway, SAGA, EDA, and Asynchronous Communication within a complex banking domain demonstrates a powerful, resilient, and scalable microservices architecture using Spring Boot.

Each step is essential to understand how to build scalable, maintainable, and observable systems. Test each part thoroughly to understand the interactions and ensure system reliability and consistency.

[sowmyagardas]

Hi Akash,

Attaching the compound exercise assignment. I'm facing compilation issues. Could you please check and help me out to resolve the issue.

Error: main java class file is non-project file

Thanks,
Sowmya.
Project172.zip

[arulsudarvizhi1]

Hi Akash,

Please find attached the code base:

1. account-service - Logic to persist account, find all accounts, find account by id, event for updating account balance http://localhost:8081/account
2. notification service - Logic to persist notification through event, finding all notification http://localhost:8083/notification
3. Transaction-service - Logic to create transaction - Checks account balance using feign client / make credit and debit of account balances using event driven approach / send success notification for both debitor and creator and if failure only to initiator http://localhost:8082/transaction
4. Gateway application - Configuration of API gateway : 8090 port number

Code Base:

guided_compound_ex.zip

Name: Arul
Batch: Nov 7th to Dec 6th 7.30 am batch

[samik2023]

Hi Akash.

Here are the 4 services:-
https://github.com/samik2023/gateway-service
https://github.com/samik2023/account-service
https://github.com/samik2023/transaction-service
https://github.com/samik2023/notification-service

Gateway url to start :
http://localhost:9999/api/transactions/updateSyncCall
http://localhost:9999/api/transactions/updateAsyncTransaction

Using swagger:
http://localhost:8082/swagger-ui/index.html

The details of test can be found under README.md of transaction-service.
This has been done using kafka as messaging platform.

Thanks
Samik
TCS- 7th Nov Batch morning 7.30

[misriya-git]

Hi Akash,

Please find the codebase below:

Misriya-172.zip

Swagger URLs:
http://localhost:8081/swagger-ui/index.html (account-service)
http://localhost:8082/swagger-ui/index.html (transaction-service)
http://localhost:8083/swagger-ui/index.html (notification-service)
http://localhost:8088/api/transaction/1 (API Gateway)

Thanks,
Misriya

[HarshDPandya]

Hi @akash-coded , Sharing my code in zip file for Guided Compound Exercise - Spring Microservice Design Patterns - Banking System
Name: Harsh Pandya
TCS Emp Id: 2066481
microservice-compound-ex-banking-system-HarshPandya-2066481.zip

Thanks,
Harsh Pandya

[samik2023]

Hi Akash,

Here is the saga orchestrator pattern demo. Orchestrator will be connecting via feign and gettin response on topic.
For the time being, am not using inventory as separate service to make it simple but taking care inside order service and updating quantity.

https://github.com/samik2023/saga-orc-orchestrator-service
https://github.com/samik2023/saga-orc-order-service
https://github.com/samik2023/saga-orc-payment-service
https://github.com/samik2023/saga-orc-shipping-service

Iniiating order
http://localhost:8081/swagger-ui/index.html

Regards
Samik (TCS 7th Nov morning 7.30 batch)

[obulix]

Hi @akash-coded ,

Here is the saga implementation.

https://github.com/obulix/MicSrv-Saga
Name : Dinakaran.

[jyothi241868]

Hi Akash,

Please find the attached project

CompoundExercise.zip

Thanks,
Jyothi K

[pradnyakinge]

hi @akash-coded , please find attached compound exercise solution .
compound_exercise.zip

Please let me know if anything else is missing in it . I will update the code.