Mid-Assessment - Building Spring Monolithic and Microservices Applications - Library Management System

[akash-coded]

Exercise

Part 1: Monolithic Spring Boot App

Domain: Library Management System

The application should handle books, authors, and borrowing records.

Entities:

• Book: id, title, ISBN, author, status (available, borrowed)
• Author: id, name, country, list of books
• Borrowing Record: id, book, borrowing date, return date, user

Requirements:

1. CRUD operations for books and authors.
2. Borrow a book (mark it as borrowed).
3. Return a book (mark it as available and update the borrowing record).
4. Find all books by an author.
5. Find all borrowed books by a user.

Part 2: Microservices Architecture

Splitting the Monolithic App:

1. Author Service

   • Maintains details about authors.
   • Provides an endpoint to retrieve all books by an author.

2. Book Service

   • Maintains the book catalog.
   • Allows borrowing and returning of books. However, when a book is borrowed or returned, it sends a request to the Borrowing Service to create/update the borrowing record.

3. Borrowing Service

   • Maintains borrowing records.
   • Provides an endpoint to retrieve all borrowed books by a user.

Requirements:

1. Each service should have its own database.
2. Services should communicate using REST templates.
3. Implement proper error handling. For instance, if the Borrowing Service is down, the Book Service should not allow borrowing a book.
4. Handle scenarios where a book is added or removed. The corresponding author's list of books should be updated.
5. Implement an endpoint in the Borrowing Service to find all overdue books.

Bonus (for candidates to show extra effort):

• Implement service discovery using Spring Eureka.
• Add client-side load balancing with Ribbon.
• Implement API Gateway using Spring Cloud Gateway or Zuul.

Guidelines:

1. Each service should be a separate Spring Boot application.
2. All inter-service communication should be handled via REST calls.
3. Ensure transactional consistency across services. For example, if the Borrowing Service fails to create a record, the Book Service should mark the book as available.
4. Use H2 or an embedded database for simplicity.

Assessment Points:

1. Proper division of responsibilities among services.
2. Adherence to RESTful principles.
3. Proper error handling and transaction management across services.
4. Quality and clarity of the code, including meaningful variable names, modularity, and inclusion of comments.
5. Proper implementation of the bonus features, if attempted.

This assessment exercise should give you a good chance to showcase their deep understanding of both monolithic and microservices architectures in Spring Boot. Given your vast experiences, the challenge should be approachable while still allowing room for them to exhibit advanced skills and best practices.

Implementation Guidelines

Part 1: Monolithic Spring Boot Application - Library Management System

1. Setup Spring Boot Project

Visit Spring Initializr and choose:

• Maven Project
• Java
• Spring Boot version: Latest Stable
• Project Metadata: com.tcs.library, library-management
• Dependencies: Spring Web, Spring Data JPA, H2 Database, Lombok, Springfox Swagger UI

Click Generate and extract the zip.

2. Configuration

src/main/resources/application.properties

spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.driver-class-name=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=
spring.jpa.database-platform=org.hibernate.dialect.H2Dialect
spring.h2.console.enabled=true

logging.level.org.hibernate.SQL=DEBUG
logging.level.org.hibernate.type.descriptor.sql.BasicBinder=TRACE

# Swagger properties
springfox.documentation.swagger.v2.path=/api-docs

3. Entity Creation

Book.java

@Entity
@Data
public class Book {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String title;
    private String ISBN;
    @ManyToOne
    private Author author;
    @Enumerated(EnumType.STRING)
    private BookStatus status;
}

enum BookStatus {
    AVAILABLE,
    BORROWED
}

Author.java

@Entity
@Data
public class Author {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    private String country;
    @OneToMany(mappedBy = "author")
    private List<Book> books;
}

BorrowingRecord.java

@Entity
@Data
public class BorrowingRecord {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    @OneToOne
    private Book book;
    private LocalDate borrowingDate;
    private LocalDate returnDate;
    private String user;
}

4. Repositories

Create JPA Repositories for each entity.

5. Services

Implement services to manage business logic.

6. Controllers

Implement REST controllers for CRUD operations and business operations.

7. Logging

logback-spring.xml

<!-- configure your logging here -->

8. Swagger

Setup Swagger for API documentation.

Part 2: Microservices Architecture

1. Setup three Spring Boot Projects with the same dependencies as above but named author-service, book-service, and borrowing-service.

2. Configuration for Microservices

Similar to the monolithic configuration, adjust the database and server ports so they don't collide.

3. Entity Creation and Operations

Follow similar steps to the monolithic approach, but each microservice focuses on its domain.

For instance, the book-service will be responsible for books and will only have references to author ids and not the whole author entity. This keeps our services decoupled.

4. Service Communication

Use RestTemplate for microservices to communicate. For instance, when a book is borrowed in the book-service, a call will be made to the borrowing-service to record the borrowing.

5. Advanced Features

Implement service discovery, client-side load balancing, and an API Gateway if required.

---

This is a high-level guide. I've kept it concise for readability. Each step involves nuances, especially when partitioning monolithic apps into microservices. Proper error handling, data consistency, transaction management, and more are crucial. Given the experience level of the TCS learners, this exercise should provide a comprehensive understanding of both architectural patterns.

Migrating the Monolith to Microservices

Let's dig deeper into the microservices part:

Part 2: Microservices Architecture

1. Setup for author-service

1.1. Configuration

application.properties for author-service

server.port=8081

spring.datasource.url=jdbc:h2:mem:authordb
spring.datasource.driver-class-name=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=
spring.jpa.database-platform=org.hibernate.dialect.H2Dialect
spring.h2.console.enabled=true

1.2. Entity Creation

Author.java

@Entity
@Data
public class Author {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    private String country;
}

1.3. Repository

AuthorRepository.java

public interface AuthorRepository extends JpaRepository<Author, Long> {}

1.4. Controller

AuthorController.java

@RestController
@RequestMapping("/authors")
public class AuthorController {
    @Autowired
    private AuthorRepository authorRepository;

    @GetMapping
    public List<Author> getAllAuthors() {
        return authorRepository.findAll();
    }

    @PostMapping
    public Author createAuthor(@RequestBody Author author) {
        return authorRepository.save(author);
    }
}

2. Setup for book-service

2.1. Configuration

application.properties for book-service

server.port=8082

spring.datasource.url=jdbc:h2:mem:bookdb
...

2.2. Entity Creation

Book.java

@Entity
@Data
public class Book {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String title;
    private String ISBN;
    private Long authorId; // Instead of the whole author object, we're storing authorId
    @Enumerated(EnumType.STRING)
    private BookStatus status;
}

2.3. Service Communication

BookService.java

@Service
public class BookService {

    @Autowired
    private RestTemplate restTemplate;

    public Author getAuthorById(Long authorId) {
        return restTemplate.getForObject("http://localhost:8081/authors/" + authorId, Author.class);
    }
}

3. Setup for borrowing-service

Following similar lines, borrowing-service will have its own entity, repository, and controller. When a book is borrowed, you'd register it in borrowing-service.

---

Expanding the exercise:

Once the three services are created, operational, and talking to each other, here are potential expansion points:

1. Service Discovery: Incorporate tools like Eureka Server. Each microservice will then be a Eureka client. It helps in dynamic discovery without hardcoding service URLs.

2. Centralized Configuration: Integrate Spring Cloud Config server. Store configurations of all services in a central place.

3. Resilience and Latency: Use Hystrix or Resilience4J for circuit breaking. When one service fails or is slow, you can provide fallbacks.

4. API Gateway: Instead of direct communication between client and services, introduce an API Gateway (like Zuul) that routes requests to appropriate services.

5. Tracing and Logging: Use tools like Sleuth and Zipkin for distributed tracing. Centralize logs with the ELK stack.

6. Data Consistency: Add mechanisms for eventual consistency. For instance, when an author is deleted, ensure that related books are also addressed (either deleted or updated). This is where patterns like Saga can play a role.

7. Testing: Focus on writing unit tests with Mocks and integration tests for service interaction.

8. Continuous Deployment/Integration: Incorporate Jenkins or GitHub Actions to automate the deployment of services.

---

By breaking the monolithic application into microservices and incorporating the above-mentioned tools, you will not only understand the intricacies of microservice architecture but will also appreciate the advantages (and challenges) it brings in terms of scalability, maintainability, and resilience.

Reflection:

While diving deep into microservices with Spring Boot, it's vital to notice that while we add functionality, the complexity also rises. But each tool and pattern addresses a real-world problem in microservices:

• Hystrix ensures one service failure doesn't bring down other dependent services.
• Eureka allows smooth inter-service communication.
• Ribbon provides load balancing to distribute traffic and prevent overloading a single service instance.

For the developers, remember, it's not about using all these tools; it's about understanding their purpose and applying them judiciously. Always relate to real-world problems, like how Netflix uses Hystrix to ensure users always get recommendations, even if the primary recommendation service fails, a fallback provides generic recommendations. Understanding the "why" behind each tool is as crucial as the "how."

[HarshDPandya]

Hi Akash, Sharing my code in zip file for Part 1: Monolithic Spring Boot App
Name: Harsh Pandya
TCS Emp Id: 2066481
library-project-HarshPandya-2066481.zip

Thanks.

[esubshaik1610]

Hi @akash-coded , Sharing my zip file for Part 1 here
Name: Esub Shaik
TCS Emp Id: [2268851]
library-management.zip

[zafvirinchi]

Hi
Please find the gitHub url
Name:- Zafrul Islam
EmpId:- 1974878

[zafvirinchi]

https://github.com/zafvirinchi/LMSProject

[elcenninan]

management.zip
hi please find the project in the zip file. my tcs id is elcen.z@tcs.com

[naikkushal]

Hi please find my zip file my tcs id is kushal.naik@tcs.com
Part1 kushal naik.zip

[arunsankar172]

Hi @akash-coded
Name: ARUNSANKAR R (r.arunsankar@tcs.com)
Library-Management-Project.zip

[jay4tech]

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

library-management.zip

[AnuragMishra58]

Hi @akash-coded
Name: Anurag Mishra [550966]
Please find below zip for part 1 pre-assessment
library-management-part-1.zip

[arfaz9030]

I am Arfaz and my employee ID is 2354634 I am getting an issue that is not able to create borrowing records I tried multiple times after noon until now

[arupmukherjee38]

Hi @akash-coded
Name: Arup Mukherjee [1524555]
Please find below for part 1 pre-assessment

https://github.com/arupmukherjee38/LMS

[Prasadpoojary]

Hi @akash-coded
Name: Prasad [1844193]
Please find below for part 1 pre-assessm
library-management.zip
ent

[Nagaraj2610]

Hi Akash,
Name: Nagaraj - 930145
Please find below download URL for pre-assessment
library-management-upload.zip

[Hemaruban]

Hi @akash-coded
Name: Hemalatha (1085177)
Hemalatha.library-management.zip

[dhanusha444]

Hi @akash-coded
Name Dhanusha Kotte (dhanusha.kotte1@tcs.com)
library-management.zip

[singhRatan777]

library-management.zip
Ratan Singh Dewada

[ssagarwala]

Hello @akash-coded
This is Fatima

please check this one https://github.com/ssagarwala/MidAssessment
I will add two more pending small functionality soon.

thanks very much.

[samik2023]

Hi Aakash,

Please find attached the 3 independent microservices (Book , Author , Borrower). I have added RestTemplate by invoking BorrowRecord service insertion whenever Book service is invoked. Please review.

Name: Samik
Org: TCS
Batch: Nov 7th Batch morning 7.30
3Microservices.zip

Thanks
Samik

[bijumedayil]

Hi @akash-coded
2255107
Bijumon Habeeb

author-service.zip
book-service.zip
borrowing-service.zip
library-manager.zip

Please Find Below Details

Monolithic

library-manager port: 8080 Swagger : http://localhost:8080/api/swagger-ui/index.html#/br-controller

Microservice

book-service port:8080 Swagger : http://localhost:8080/api/swagger-ui/index.html#
author-service port:8081 Swagger : http://localhost:8081/api/swagger-ui/index.html#
borrowing-service port :8082 Swagger : http://localhost:8082/api/swagger-ui/index.html#

[HarshDPandya]

Hi @akash-coded, please find attached zip file for Microservice Architecture in Library Management System API.
Name : Harsh Pandya
library-management-microservice-HarshPandya-2066481.zip

[jayakumarvinayagam2023]

Hi @akash-coded ,
I have created librarymanagment using microservice
https://github.com/jayakumarvinayagam2023/MicroservicesLibraryManagementSystem

Technology:
Author: .Net Core, MySql
Book: .Net Core, SQL Server - in progress
Borrowing: .Net core, MySql - in progress

[sathyakulandhaivel]

Uploading LibMgmt_SathyaK_563920.zip…

Hi Akash ,
I have created library management system using microservice

[ssagarwala]

Hello Akash, @akash-coded
This is Fatima.

please check the mid assessment here
https://github.com/ssagarwala/MidAssessment

and provide feedback. thanks.

[Abhrajit-7]

Hi @akash-coded,
This is Abhrajit

Please find the link mid-assessment below.
library-management 2.zip
library-manage.zip

[Manogaran-Coded]

Hi @akash-coded

I have completed Mid Assessment Part-2. Please find the Screenshot Document and attached Code.

Library Management System Project-Rest APIs.docx
LibraryMgmt.zip

Please find below the GIT Hub Link as well

https://github.com/Manogaran-Coded/Library-Managment-System

[himarou]

Hi @akash-coded ,

Please find completed Mid Assessment ZIP. It has 3 micro services, Eureka service registry and API Gateway.

Thanks,
Himansu Rout(334368)
library-Microservice-Eureka-Gateway-Himansu.zip

[jyothi241868]

Hi Akash,

Please find the zip file for the mid assessment.
MicroServices.zip

[dilipdmane]

Added Assignment 1
Assignement_1_Dilip_M2.zip
Mane

[raghavan-tcs]

@akash-coded Hi Aakash, Please find attached microservices created for mid-assessment for Batch April 17-2024
book-service
author-service
borrowing-service

Thanks
Raghavan S
mid-assessment.zip

[Aditi-12092024]

Hi Akash,
Please find attached zip file for mid assessment , 22 April 2024
Library_Management_MS.zip

Thanks

[akash-coded]

Uvais_Beg-MidAssesment.zip
FYR Uvais.

[venom-xd]

Hi Akash,
Please find attached microservices created for mid-assessment for Batch April 17-2024

Mid Assesment Library Management.zip

Thanks
Aditya Kumar