Spring Microservice - Event-driven Architecture - E-commerce Application

[akash-coded]

Creating a microservice architecture-based Spring Boot application for an e-commerce scenario involves a series of steps including creating individual services, implementing business logic, handling data storage, and ensuring asynchronous communication via events. Let's break down the steps for creating the Order Service, Inventory Service, Billing Service, and Shipping Service.

Technologies used:

• Spring Boot - For creating the microservices
• Kafka - For asynchronous communication via events
• MySQL - For data storage
• Docker - For containerization

1. Order Service

The Order Service is responsible for accepting customer orders and publishing events about these orders.

• Create a new Spring Boot application.
• Configure a MySQL database for storing order information.
• Create an Order model and a corresponding repository to handle CRUD operations.
• Create an OrderController with an endpoint for placing an order. This endpoint receives the order details, saves the order in the database, and publishes an "OrderPlaced" event.
• Configure a Kafka producer to publish the "OrderPlaced" event. The event contains relevant order details like OrderId, CustomerId, and Item details.

2. Inventory Service

The Inventory Service manages stock levels and listens for "OrderPlaced" events to update the inventory.

• Create a new Spring Boot application.
• Configure a MySQL database for storing inventory data.
• Create an Inventory model and a corresponding repository to handle CRUD operations.
• Configure a Kafka consumer to listen for "OrderPlaced" events. When an event is received, the service updates the inventory and publishes an "InventoryUpdated" event.

3. Billing Service

The Billing Service is responsible for charging customers and listens for "OrderPlaced" events to create bills.

• Create a new Spring Boot application.
• Configure a MySQL database for storing billing data.
• Create a Billing model and a corresponding repository to handle CRUD operations.
• Configure a Kafka consumer to listen for "OrderPlaced" events. When an event is received, the service generates a bill and publishes a "BillGenerated" event.

4. Shipping Service

The Shipping Service arranges delivery for orders and listens for "InventoryUpdated" and "BillGenerated" events to arrange shipment.

• Create a new Spring Boot application.
• Configure a MySQL database for storing shipping data.
• Create a Shipping model and a corresponding repository to handle CRUD operations.
• Configure a Kafka consumer to listen for "InventoryUpdated" and "BillGenerated" events. When both events are received for a particular order, the service arranges for the order to be delivered.

5. Error Handling and Synchronization

• Implement error handling in each service to deal with possible failures (like insufficient inventory, billing issues, etc).
• Keep track of the "InventoryUpdated" and "BillGenerated" events for each order in the Shipping Service to synchronize the operations.

6. Dockerization

• Dockerize each service to run them in isolated environments. Create a Dockerfile for each service, then build and run the docker containers.

Note: The above steps outline the design of the microservices and the flow of events between them. The actual implementation would involve writing the Spring Boot code for controllers, services, repositories, models, and the Kafka producer/consumer configurations. Also, security, logging, monitoring, testing, and other aspects would need to be addressed in a complete, production-ready application.

Let's consider four separate services: Order Service, Inventory Service, Billing Service, and Shipping Service.

1. Order Service

Folder Structure:

orderservice
├── src
│   ├── main
│   │   ├── java
│   │   │   ├── com
│   │   │   │   ├── ecommerce
│   │   │   │   │   ├── orderservice
│   │   │   │   │   │   ├── controller
│   │   │   │   │   │   │   ├── OrderController.java
│   │   │   │   │   │   ├── model
│   │   │   │   │   │   │   ├── Order.java
│   │   │   │   │   │   ├── repository
│   │   │   │   │   │   │   ├── OrderRepository.java
│   │   │   │   │   │   ├── service
│   │   │   │   │   │   │   ├── OrderService.java
│   │   │   │   │   │   ├── messaging
│   │   │   │   │   │   │   ├── OrderEventProducer.java
│   │   │   │   │   │   ├── OrderserviceApplication.java
│   │   ├── resources
│   │   │   ├── application.properties

2. Inventory Service

inventoryservice
├── src
│   ├── main
│   │   ├── java
│   │   │   ├── com
│   │   │   │   ├── ecommerce
│   │   │   │   │   ├── inventoryservice
│   │   │   │   │   │   ├── controller
│   │   │   │   │   │   │   ├── InventoryController.java
│   │   │   │   │   │   ├── model
│   │   │   │   │   │   │   ├── Product.java
│   │   │   │   │   │   ├── repository
│   │   │   │   │   │   │   ├── InventoryRepository.java
│   │   │   │   │   │   ├── service
│   │   │   │   │   │   │   ├── InventoryService.java
│   │   │   │   │   │   ├── messaging
│   │   │   │   │   │   │   ├── InventoryEventConsumer.java
│   │   │   │   │   │   ├── InventoryserviceApplication.java
│   │   ├── resources
│   │   │   ├── application.properties

3. Billing Service

billingservice
├── src
│   ├── main
│   │   ├── java
│   │   │   ├── com
│   │   │   │   ├── ecommerce
│   │   │   │   │   ├── billingservice
│   │   │   │   │   │   ├── controller
│   │   │   │   │   │   │   ├── BillingController.java
│   │   │   │   │   │   ├── model
│   │   │   │   │   │   │   ├── Billing.java
│   │   │   │   │   │   ├── repository

│ │ │ │ │ │ │ ├── BillingRepository.java
│ │ │ │ │ │ ├── service
│ │ │ │ │ │ │ ├── BillingService.java
│ │ │ │ │ │ ├── messaging
│ │ │ │ │ │ │ ├── BillingEventConsumer.java
│ │ │ │ │ │ ├── BillingserviceApplication.java
│ │ ├── resources
│ │ │ ├── application.properties

4. Shipping Service

shippingservice
├── src
│   ├── main
│   │   ├── java
│   │   │   ├── com
│   │   │   │   ├── ecommerce
│   │   │   │   │   ├── shippingservice
│   │   │   │   │   │   ├── controller
│   │   │   │   │   │   │   ├── ShippingController.java
│   │   │   │   │   │   ├── model
│   │   │   │   │   │   │   ├── Shipping.java
│   │   │   │   │   │   ├── repository
│   │   │   │   │   │   │   ├── ShippingRepository.java
│   │   │   │   │   │   ├── service
│   │   │   │   │   │   │   ├── ShippingService.java
│   │   │   │   │   │   ├── messaging
│   │   │   │   │   │   │   ├── ShippingEventConsumer.java
│   │   │   │   │   │   ├── ShippingserviceApplication.java
│   │   ├── resources
│   │   │   ├── application.properties

Spring Dependencies:

• spring-boot-starter-web
• spring-boot-starter-data-jpa
• spring-kafka or spring-rabbitmq based on your choice of message broker
• spring-boot-starter-validation

Kafka/RabbitMQ Configuration:
These would go inside application.properties for each service.

For Kafka:

spring.kafka.bootstrap-servers= localhost:9092
spring.kafka.consumer.group-id= group_id

For RabbitMQ:

spring.rabbitmq.host= localhost
spring.rabbitmq.port= 5672
spring.rabbitmq.username= guest
spring.rabbitmq.password= guest

You would also need to define Kafka/RabbitMQ templates and consumers in your service and messaging classes.

Note: While the above does provide a good outline, building microservices with Spring Boot and integrating with Kafka/RabbitMQ is a large topic and involves a detailed understanding of Spring Boot, JPA, Kafka/RabbitMQ, and how they all interact together. I would recommend referring to comprehensive resources or tutorials to guide you through building this application.

Dependencies for Microservices

Each microservice would need at least these dependencies:

1. Spring Boot Starter Web: To create web applications.
2. Spring Boot Starter Data JPA: To perform CRUD operations easily.
3. Spring Kafka: To use Apache Kafka with Spring.
4. Spring Boot Starter Validation: For bean validation.

Add these dependencies in the pom.xml file of each microservice:

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.kafka</groupId>
        <artifactId>spring-kafka</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-validation</artifactId>
    </dependency>
</dependencies>

Setting Up Apache Kafka From Scratch

You need to install and run Apache Kafka locally:

1. Download Apache Kafka from the official website. Unzip the downloaded file.

2. Start the Zookeeper server (Kafka uses Zookeeper to manage the cluster). Navigate to the Kafka directory in the terminal and run this command:

   bin/zookeeper-server-start.sh config/zookeeper.properties

3. Start the Kafka server. In a new terminal window, navigate to the Kafka directory again and run:

   bin/kafka-server-start.sh config/server.properties

4. Create a Kafka Topic. You can create a topic with the following command:

   bin/kafka-topics.sh --create --topic my_topic --bootstrap-server localhost:9092

Running Microservices Together

Once your microservices and Kafka are set up, you can start each microservice from the terminal by navigating to the root directory of each microservice project and running:

./mvnw spring-boot:run

Tips

• It's important to ensure your microservices and Kafka are all running and able to communicate with each other. Check application properties and logs to verify this.
• Understanding the basics of Spring Boot, JPA, REST API, and Kafka is very important before working on this setup.
• Using a tool like Postman can help in testing the microservices.
• Each microservice should have its own database. Never share databases between microservices.
• For beginners, focusing on one microservice at a time can make the process more manageable. Start with setting up a single service, ensuring that it runs correctly and communicates with Kafka. Then, gradually add more services into the mix.
• Consider using Docker to containerize your microservices and Kafka, which can make setting up and tearing down your environment much easier.

[ShriAbhi10]

Task3.zip

Hi Akash,

I have completed the Microservice for the ecommerce project. The last part of merging the two topics is pending. Not able to find the solution for the same.

Thanks,
Abhishek Shrivastava

[kuttiram]

E-Commerce Task 3.zip

Hi Akash,

I have completed the Microservice for e-com project. Please check and let me know your feedback.

1. Completed all for service with Kafka Broker
2. Global exception handling
3. Binding and validation completed with Lombok and validation
4. Topic will created by the code itself
5. Docker file config yet to start will complete it ASAP

Thanks & Regards,
Ramesh Kumar D

[DusaSuresh]

Hi Akash,

I have completed the ecommerce-order-service containing global exceptions, response value objects, response entities with proper http status code and docker file. Could you please let me know your feedback, I will complete rest of the services by tomorrow.

https://github.com/DusaSuresh/Ecommerce-order-service/tree/main

ecommerce-order-service.zip

[akash-coded]

Are all the services completed as of now?

[AnuragMishra58]

Hi @akash-coded ,

Name: Anurag Mishra
Emp Id: 550966

Implemented event driven messaging architecture using kafka between order and inventory service. It would update inventory quantity whenever new order is placed.

Please find zip below:-
event-driven-architecture-using-kafka.zip

[jay4tech]

Hi @akash-coded

Name: Jay Prakash Kumar

Implemented event-driven messaging architecture with RabbitMQ using order and inventory service. Inventory quantity will be updated whenever a new order gets placed.

Here are the repositories -
https://github.com/jay4tech/inventory-service-rabbitmq
https://github.com/jay4tech/order-service-rabbitmq

[elcenninan]

EDA-ecomm.zip
Elcen Zachariah([email protected])

[aathira-ps]

Session_7_eventdriven_Architecture.zip

Name: Aathira PS
Employee ID: 2077238

[singhRatan777]

task146.zip
Ratan Singh Dewada

[naikkushal]

kushal naik
Kushal Naik EDA.zip

[zafvirinchi]

Assignment_05092023.zip
Hi @akash-coded please find the attached project

[Chandrika1999]

Hi @akash-coded please find the attached project
Name:Chandrika Cheerla
eventdriven_Architecture_Task.zip

[Kiran-Ramesh1]

Hi @akash-coded ,

Name : Kiran Ramesh (1949256)
Event-driven Architecture.zip

Please find the assignment of [Event-driven Architecture]

[arghyagiri]

@akash-coded : https://github.com/arghyagiri/microservice-e2/tree/main/e-commerce-microservices-event-driven

[shriramram]

Hi @akash-coded
Name - Dattatraya Shriram
Description - Eventdriven architecture implementation
eventdriven_Architecture.zip

[Rajashree-Ravi]

@akash-coded
ecommerce-microservice-eda-pattern.zip

Please find attached EDA implementation with Kafka

[arulsudarvizhi1]

Hi Akash @akash-coded ,

Please find attached the event driven code with order service and inventory service
inventory-service - consumer with listener defined
order-service - producer
Topic: orderPlaced
Queue implementation: Kafka - kafka_2.12-2.1.0 [Install in order zookeeper and kafka server to start as pre-requisite]
Url tested: http://localhost:8083/order [Implementation to create order and reduce quantity in inventory through event driven approach]
Testing of the event driven approach between these two services worked
event_driven.zip

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

Adding reference to partial completed guided excercise 172 (Using this comment as placeholder for partial completed code upload)

Updated 26-Nov
guided_compound_ex.zip

[samik2023]

Hi Akash.

Here are the 3 services:-
https://github.com/samik2023/order-service
https://github.com/samik2023/inventory-service
https://github.com/samik2023/billing-service

Implemented using Kafka.
Order service : Published one Order event to kafka topic after a new order is created.
Billing Service and Inventory Service both listenning to same topic was able to retrieve the same message simultaneously.

Thanks
Samik -(TCS Nov 7th Morning 7.30 AM)

[HarshDPandya]

Hi @akash-coded , Sharing my code in zip file for Spring Microservice - Event-driven Architecture - E-commerce Application
Name: Harsh Pandya
TCS Emp Id: 2066481
microservice-ecommerce-event-driven-kafka-HarshPandya-2066481.zip

[vbhavana1]

Uploading bhavana_146.zip…