Capstone Project - Spring Microservices - Reservation System

[akash-coded]

Project Title: Hotel Reservation System

Project Documentation Manual

Introduction

The Hotel Reservation System aims to offer a seamless hotel booking experience by leveraging microservices architecture, encapsulating specific functionalities and domains within independent services. This documentation aims to provide a detailed manual for implementing each service, with a focus on advanced developers.

Code Quality Metrics & Standards

• Make sure to adhere to clean code principles.
• Code comments should explain 'why' instead of 'what'.
• Implement SonarQube checks in your CI/CD pipeline for static code analysis.

Architecture Overview

The system consists of:

• Customer Service: Handles customer profiles and preferences.
• Reservation Service: Manages reservation logic.
• Payment Service: Handles payment transactions.
• Hotel Management Service: Manages room inventories.
• Notification Service: Sends out notifications.

Key Microservice Patterns in the Workflows

1. Saga Pattern: Primarily used in the refund process to ensure that a series of local transactions are all executed or compensated. Each step is an individual local transaction and has a compensating transaction.

   Example: If the refund is not processed, the reservation is not cancelled, and the user is notified.

2. API Gateway Pattern: All client requests go through an API Gateway (Zuul/Spring Cloud Gateway), which routes requests to appropriate services.

   Example: A user makes a reservation. The API gateway routes this request to the Reservation Service, which then talks to Payment Service and Hotel Management Service.

3. Proxy Pattern: When you have to interact with an external service or library, wrap it within a Proxy Service. The Proxy pattern will help you control access, logging, and security features for accessing the third-party or costly resources.

   Example: For sending SMS and Email notifications, instead of calling third-party services directly, they could be routed through a Notification Proxy that batches requests or caches repeated requests to the same number/email to reduce costs.

Business Workflows:

User Signup Workflow

• Trigger: A new user signs up.
• Actors: Customer Service, Notification Service.
• Flow:
  1. User sign-up form is submitted to Customer Service.
  2. Customer Service validates the data and creates a new record in its database.
  3. Notification Service is invoked to send a welcome email.

Room Reservation Workflow

• Trigger: Customer books a room.
• Actors: Customer Service, Reservation Service, Payment Service, Hotel Management Service, Notification Service.
• Flow:
  1. Customer submits reservation request to Reservation Service.
  2. Reservation Service first checks room availability with Hotel Management Service.
  3. If available, Reservation Service reserves the room and sends a payment request to Payment Service.
  4. Payment Service processes the transaction and sends the status back to Reservation Service.
  5. Reservation Service confirms the reservation, and Notification Service sends a confirmation message.

Room Cancellation and Refund

• Trigger: Customer cancels a room.
• Actors: Customer Service, Reservation Service, Payment Service, Hotel Management Service, Notification Service.
• Flow:
  1. Cancellation request received by Reservation Service.
  2. Reservation Service confirms the cancellation and initiates a refund via Payment Service.
  3. Payment Service processes the refund and notifies Reservation Service.
  4. Reservation Service releases the room back to inventory via Hotel Management Service.
  5. Notification Service sends out cancellation and refund notifications.

Implement Saga patterns to maintain data consistency across these operations.

This manual serves as a comprehensive guide to implementing the Hotel Reservation System as a robust, fault-tolerant, and highly scalable system. By adhering to these guidelines and workflows, the development team can facilitate a smooth development, deployment, and maintenance process.

Objective

The objective of this project is to build a hotel reservation system using Spring Boot microservices, following microservices principles, patterns, testing strategies, and DevOps practices.

Project Modules:

1. Customer Service
2. Reservation Service
3. Payment Service
4. Hotel Management Service
5. Notification Service

Steps for Implementation

Below are the detailed steps for implementing this project:

Step 1: Set Up Development Environment

• Install Java JDK (version 11 or above).
• Install a suitable IDE like IntelliJ IDEA or Eclipse.
• Install Docker and Kubernetes for containerization and orchestration.
• Install Maven or Gradle for building your project.
• Set up a Git repository for version control.

Step 2: Create Spring Boot Applications

• For each service (Customer, Reservation, Payment, Hotel Management, Notification), create a separate Spring Boot project. You can use Spring Initializr (https://start.spring.io/) to bootstrap your projects.
• Include necessary dependencies like Web, JPA, and the appropriate SQL database.

Step 3: Define Business Logic for Each Service

• Implement the business domain logic for each service. This includes creating necessary entities, repositories, services, and controllers.

Step 4: Containerize Services

• Create a Dockerfile for each service, defining how the Docker image for each service should be built.
• Build and test the Docker image for each service locally.

Step 5: Create Kubernetes Configurations

• Create Kubernetes Deployment and Service configurations for each service.
• Test the deployment and scaling of each service locally using minikube or similar.

Step 6: Implement API Gateway

• Use Spring Cloud Gateway or Netflix Zuul to create an API gateway, providing a single entry point for all client requests and routing requests to the appropriate service.

Step 7: Implement Service Discovery

• Use Netflix Eureka or Kubernetes' native service discovery.
• Each service will register with the service discovery component on startup and use it to discover other services.

Step 8: Implement Circuit Breaker

• Use Netflix Hystrix to implement the Circuit Breaker pattern. This will prevent a single service failure from cascading to other services.

Step 9: Implement Database Per Service Pattern

• Ensure each service has its own private database to maintain loose coupling.

Step 10: Implement Asynchronous Communication

• Use message brokers such as RabbitMQ, ActiveMQ, or Kafka for event-driven, asynchronous operations. For example, sending notifications when a reservation is made or cancelled.

Step 11: Implement Testing (Optional)

• Unit Testing: Use JUnit and Mockito.
• Integration Testing: Use Spring Boot Test.
• End-to-End Testing: Use tools like Selenium or Cucumber.

Step 12: Implement DevOps Practices (Optional)

• Set up a Jenkins server for continuous integration and delivery.
• Create Jenkins pipelines that build your project, run tests, build Docker images, and deploy to Kubernetes.

Step 13: Implement Observability (Optional)

• Set up ELK (Elasticsearch, Logstash, Kibana) stack for centralized logging.
• Set up Prometheus and Grafana for monitoring and alerting.
• Use Zipkin or Jaeger for distributed tracing.

Remember to keep in mind the principles of microservices as you implement this project: model around business domain, culture of automation, hide implementation details, decentralize all things, deploy independently, consumer first, isolate failures, and be highly observable.

---

Project Implementation: Hotel Reservation System Using Spring Microservices

Introduction

This implementation manual provides detailed guidance on building a Hotel Reservation System utilizing Spring Boot microservices. The system leverages microservices architecture principles, incorporating various design patterns and best practices for robust, scalable, and fault-tolerant applications.

Code Quality Metrics & Standards

• Adhere to clean code principles.
• Code comments should focus on explaining 'why'.
• Integrate SonarQube in the CI/CD pipeline for static code analysis.

Architecture Overview

1. Customer Service: Manages customer profiles and preferences.
2. Reservation Service: Handles room booking logic.
3. Payment Service: Manages payment transactions.
4. Hotel Management Service: Oversees room inventories.
5. Notification Service: Sends notifications (email, SMS).

---

Customer Service

Functionalities & Purpose:

• Handles user registration, login, and profile management.
• Stores customer preferences and booking history.

Key Events and Actions:

• UserRegistered: When a new user signs up.
  • Action: Store user data and trigger SendWelcomeEmail event.
• UserUpdated: When user updates profile.
  • Action: Update user information in the database.

---

Reservation Service

Functionalities & Purpose:

• Manages room booking, availability checks, and reservation records.
• Interacts with the Hotel Management Service to reserve rooms.

Key Events and Actions:

• RoomRequested: When a customer requests a room.
  • Action: Check availability and reserve if possible, then publish RoomReserved event.
• ReservationCancelled: When a booking is canceled.
  • Action: Release room reservation and initiate a refund process.

---

Payment Service

Functionalities & Purpose:

• Processes all payment transactions.
• Handles refunds and payment confirmations.

Key Events and Actions:

• PaymentProcessed: When a payment is successfully processed.
  • Action: Notify Reservation Service to confirm booking.
• RefundInitiated: When a refund process starts.
  • Action: Process the refund and publish RefundProcessed.

---

Hotel Management Service

Functionalities & Purpose:

• Manages room inventory and status updates.
• Provides information about room types, availability, and pricing.

Key Events and Actions:

• RoomInventoryUpdated: When room availability changes.
  • Action: Update the inventory records accordingly.
• RoomPricingUpdated: When pricing for rooms is updated.
  • Action: Reflect these changes in the system for new reservations.

---

Notification Service

Functionalities & Purpose:

• Sends out email and SMS notifications to users.
• Handles communication for various system activities.

Key Events and Actions:

• SendWelcomeEmail: Triggered after a user is registered.
  • Action: Send a welcome email to the new user.
• ReservationConfirmationSent: When a reservation is confirmed.
  • Action: Send a booking confirmation notification.

---

Implementing Saga Pattern for Compensating Transactions

Scenario 1: Failed Payment During Reservation

• Flow: Reservation → Payment Failure → Cancel Reservation
• Compensating Transaction: If payment fails, the Reservation Service receives a failure event and cancels the reservation, releasing the room and notifying the customer.

Scenario 2: Room Unavailability After Payment

• Flow: Payment Success → Room Unavailable → Refund
• Compensating Transaction: If a room becomes unavailable after payment (due to a race condition), the system initiates a refund and informs the customer of the unavailability.

Scenario 3: Customer Cancels Reservation Post Payment

• Flow: Customer Cancels → Reservation Cancelled → Initiate Refund
• Compensating Transaction: On customer cancellation, trigger a refund process and update the room inventory.

---

Circuit Breaker Scenarios

Scenario 1: Hotel Management Service Overload

• Circuit Breaker Implementation: In Reservation Service when querying room availability.
• Action on Trip: Provide a default response indicating temporary unavailability, log the incident, and retry after a brief delay.

Scenario 2: External Payment Gateway Timeout

• Circuit Breaker Implementation: In Payment Service during transaction processing.
• Action on Trip: Queue the payment request and process it once the gateway is responsive.

---

Flow of Events for CQRS

• Command Side: Services like Reservation and Payment Services handle the business logic and emit events post transactions.
• Query Side: Services like Customer Service and Hotel Management Service consume these events to update their query models.

---

Industry Best Practices & Inter-Service Communication Strategies

1. API Gateway (Zuul/Spring Cloud Gateway):

   • Routes client requests to appropriate services.
   • Example Use-Case: Directing booking requests to Reservation Service.

2. Proxy Pattern:

   • Use for interacting with external services like SMS/Email providers.
   • Example

Use-Case: Notification Service acting as a proxy for third-party communication services.

3. Event-Driven Communication (Kafka):
   • Facilitates asynchronous communication between microservices.
   • Example Use-Case: Updating customer profiles in Customer Service based on booking events.

Saga Choreography and Compensating Transactions

Scenario 4: Notification Failure Post Reservation

• Flow: Successful Reservation → Notification Service Down
• Compensating Transaction: Queue the notification message. Once the Notification Service is back, process the queued messages.
• CQRS Impact: The failure doesn't impact the command side (Reservation), but the query side (Customer Service) might have a delay in reflecting the updated status until the notification is sent.

Scenario 5: Concurrent Room Booking

• Flow: Multiple Concurrent Bookings → Overbooking
• Compensating Transaction: If an overbooking situation is detected, one of the transactions is rolled back, the payment is refunded, and the customer is notified of the issue.
• CQRS Impact: The command side handles the overbooking logic, while the query side might temporarily show inconsistent data until the compensating transaction is completed.

---

Circuit Breaker Usage Scenarios

Scenario 3: Slow Customer Profile Updates

• Circuit Breaker Implementation: In Reservation Service when accessing Customer Service for profile details.
• Action on Trip: Use cached customer data if available, or provide a default guest profile, and retry fetching the profile after a delay.

Scenario 4: Hotel Management Service Database Maintenance

• Circuit Breaker Implementation: In Reservation Service for querying room availability.
• Action on Trip: Inform the user about temporary unavailability of the reservation function, log the incident, and enable a read-only mode based on cached data if available.

Event Sourcing and Event-Driven Architecture (EDA)

• Event Sourcing:

  • Every change to the application state is stored as a sequence of events.
  • This is particularly useful in Reservation and Payment Services where every transaction and its outcome (success/failure) are crucial.
  • Implement event sourcing in these services to ensure you can reconstruct the system state, useful for debugging and auditing.

• Event-Driven Architecture:

  • Services communicate primarily through events, using Kafka.
  • For instance, ReservationService publishes an event after a room booking which CustomerService and HotelManagementService listen to.
  • This approach ensures loose coupling and high resilience.

Synchronous vs. Asynchronous Communication

• Synchronous Communication (RestTemplate, Feign):

  • Use when real-time responses are necessary. For example, ReservationService might synchronously call PaymentService to process payments immediately.
  • Implement Feign for inter-service communication where declarative REST client logic is required.

• Asynchronous Communication (Kafka):

  • Use for non-critical, delayed processing. For example, sending a notification about a reservation can be an asynchronous process.
  • Asynchronous communication also helps in handling heavy loads and preventing service overloading.

Logging Implementations

• Centralized Logging: Implement a centralized logging system using tools like ELK Stack or Graylog.
• Standardized Log Format: Ensure logs have a standardized format across services for easier aggregation and analysis.
• Correlation IDs: Include correlation IDs in logs to track a transaction across multiple services.
• Log Levels: Appropriately use different log levels (INFO, DEBUG, ERROR) to capture varying degrees of information.

---

Microservices Communication and Event Flow

1. API Gateway Routing: All user requests are first routed through the API Gateway which then directs them to the respective microservice.

2. Event-Driven Communication:

   • Example: After a successful reservation, the Reservation Service publishes an event that is consumed by the Customer Service to update the user's booking history.
   • CQRS Application: The command side (Reservation Service) emits events after state changes, which the query side (Customer Service, Reporting Service) listens to and updates its view.

3. Proxy Pattern Usage:

   • Example: The Notification Service acts as a proxy for external email/SMS services, optimizing communication and handling retries or failure scenarios.

---

Overall Functionalities and Purpose of the Hotel Reservation System

• Customer Service: Central hub for all customer-related data, ensuring a personalized user experience.
• Reservation Service: Core service for handling room bookings, the central functionality of the system.
• Payment Service: Securely manages all financial transactions, ensuring a smooth payment process.
• Hotel Management Service: Maintains room inventories, crucial for real-time availability checks.
• Notification Service: Enhances customer experience by providing timely and relevant communication.

Design Patterns and Their Combined Usage

• Saga Pattern: Ensures consistency across microservices in complex business transactions.
• API Gateway Pattern: Simplifies client interaction with the backend, providing a single entry point.
• Proxy Pattern: Adds an extra layer of abstraction over external service calls, offering better control and security.
• CQRS: Enhances the system's performance and scalability by separating the read and write operations, leading to more efficient data handling.

---

Scenarios for Hotel Reservation System Implementation

Scenario 1: Database Connection Failure in Customer Service

• Problem: Customer Service loses connection to its database.
• Task: Implement a fallback mechanism in Customer Service to return a default response for profile queries.
• Techniques: Use Resilience4j circuit breaker with fallback methods.
• Additional Consideration: Log the error details and send alerts to the monitoring system.

Scenario 2: Overloaded Payment Service

• Problem: High demand causes Payment Service to slow down, affecting the entire booking process.
• Task: Configure load balancing and rate limiting to manage the traffic. Implement a circuit breaker to temporarily hold and retry payment requests.
• Techniques: Spring Cloud LoadBalancer for load distribution, Resilience4j for rate limiting and circuit breaking.

Scenario 3: Inconsistent Data Between Services

• Problem: An update in the Hotel Management Service does not reflect immediately in the Reservation Service.
• Task: Implement event sourcing to ensure that all services are updated via events and have consistent data.
• Techniques: Kafka for event-driven communication, ensuring eventual consistency across services.

Scenario 4: Service Timeout During User Signup

• Problem: Customer Service times out while invoking the Notification Service during user registration.
• Task: Handle timeouts gracefully and ensure the user signup process is not affected.
• Techniques: Implement a circuit breaker with a fallback method to queue the notification request and process it later.

Scenario 5: Failure in Saga during Room Booking

• Problem: A failure occurs in the Payment Service after reserving a room in the Hotel Management Service.
• Task: Implement a saga with compensating transactions to revert the room reservation.
• Techniques: Saga orchestration to manage distributed transactions and rollback mechanisms.

Scenario 6: Invalid Request to Reservation Service

• Problem: Reservation Service receives invalid booking data from the client.
• Task: Implement robust validation logic in the Reservation Service to handle invalid requests. Provide meaningful error responses to the client.
• Techniques: Spring Boot validation, exception handling, and custom error messages.

Scenario 7: External Payment Gateway Unavailability

• Problem: The external payment gateway is temporarily down during payment processing.
• Task: Queue payment requests and retry when the gateway is back online.
• Techniques: Implement a circuit breaker for external service calls, and a queuing mechanism (possibly using Kafka) for retrying payments.

Scenario 8: Notification Service Rate Limiting

• Problem: Notification Service reaches its rate limit for sending SMS notifications.
• Task: Implement rate limiting in the Notification Service to avoid hitting third-party API limits.
• Techniques: Use Resilience4j to set up rate limiters and fallback methods for handling excess requests.

Scenario 9: Data Synchronization Issue Post Room Cancellation

• Problem: After a room cancellation, the updated room availability is not reflected in the Reservation Service.
• Task: Ensure real-time data synchronization between the Hotel Management Service and Reservation Service.
• Techniques: Use Kafka listeners in Reservation Service to update room availability based on events from Hotel Management Service.

Scenario 10: Microservice Deployment Failure

• Problem: Deployment of a new version of the Payment Service fails, causing service downtime.
• Task: Implement a rollback strategy to revert to the previous stable version in case of deployment failure.
• Techniques: Use blue-green deployment or canary releases strategies in the CI/CD pipeline for safe deployments.

Scenario 11: Security Breach in Customer Service

• Problem: A potential security breach is detected in the Customer Service.
• Task: Secure the service, identify the breach, and implement enhanced security measures.
• Techniques: Use Spring Security for securing endpoints, conduct a thorough audit, and implement API rate limiting.

Scenario 12: Simultaneous Room Booking Conflict

• Problem: Two customers attempt to book the last available room at the same time, leading to a conflict.
• Task: Implement a mechanism to handle concurrent booking requests to prevent overbooking.
• Techniques: Use optimistic locking in the Hotel Management Service. If a conflict is detected, one transaction should fail and trigger a compensating transaction.
• Additional Consideration: Notify the unsuccessful customer and offer alternative options.

Scenario 13: Microservice Communication Breakdown

• Problem: A network issue causes a breakdown in communication between the Reservation Service and Hotel Management Service.
• Task: Ensure the system remains functional and consistent even when internal service communication is disrupted.
• Techniques: Implement a circuit breaker with a sophisticated fallback strategy, such as temporarily storing reservation requests and processing them once the communication is restored.

Scenario 14: Cascading Failures from a Single Service

• Problem: A failure in the Payment Service cascades, affecting other services in the system.
• Task: Isolate the failure and prevent it from impacting the entire system.
• Techniques: Implement circuit breakers and bulkheads to contain failures within a service. Use asynchronous communication to decouple services.

Scenario 15: Incomplete Saga due to Service Downtime

• Problem: During a room booking saga, the Payment Service goes down before completing the transaction.
• Task: Manage incomplete sagas and ensure data consistency across services.
• Techniques: Implement saga timeouts and compensating transactions. If a service is down, the saga should timeout and trigger compensating actions to revert any changes made by previous saga steps.

Scenario 16: Data Loss in Event Store

• Problem: Event Store faces a data loss issue, leading to missing event records.
• Task: Recover from the data loss without impacting the overall system functionality.
• Techniques: Implement data backup and recovery mechanisms for the Event Store. Use service logs and database states to reconstruct lost events if necessary.

---

Scenario 17: High Latency in Inter-Service Communication

• Problem: Increased latency in calls between Reservation Service and Hotel Management Service, affecting user experience.
• Task: Identify and mitigate the source of latency.
• Techniques: Implement performance monitoring. Optimize service communication, possibly by introducing a cache or adjusting service resources.

Scenario 18: Misconfiguration in Production Environment

• Problem: A new deployment of the Customer Service contains a misconfiguration, causing erratic behavior.
• Task: Quickly rectify the configuration without significant downtime.
• Techniques: Use feature flags for risky features. Implement a quick rollback strategy and monitor configurations using Spring Cloud Config for centralized management.

Scenario 19: Payment Service Compliance Violation

• Problem: Payment Service fails a compliance audit due to inadequate data handling practices.
• Task: Address compliance issues and implement necessary changes to meet standards.
• Techniques: Revise data handling procedures, enhance security measures, and possibly refactor service to align with compliance requirements.

Scenario 20: Batch Processing Failure in Hotel Management Service

• Problem: A scheduled batch process for updating room prices fails, causing outdated prices.
• Task: Ensure successful execution of batch processes and maintain data accuracy.
• Techniques: Implement robust error handling in batch processes, use transaction management, and set up alerts for failures.

---

Development Tips

• Incremental Development: Start with basic implementations and gradually enhance features and complexity.
• Feature Toggles: Implement feature toggles for easy enabling/disabling of new features.
• Environment Segregation: Maintain separate environments for development, testing, staging, and production.
• Code Reviews: Regularly conduct code reviews to maintain code quality and mentor junior developers.
• Documentation: Keep the project documentation updated with each new feature or architectural change.
• Scalability Considerations: Design each microservice keeping scalability in mind. Use stateless services wherever possible.

Conclusion

This detailed manual provides a roadmap for implementing a robust Hotel Reservation System using Spring Boot microservices. By following the outlined architecture, implementing suggested patterns, and adhering to best practices, the development team can build a system that's not only functionally rich but also resilient and scalable.

The implementation of CQRS, sagas, and circuit breakers, combined with an event-driven architecture, ensures that the Hotel Reservation System can handle complex workflows and unexpected failures gracefully, thereby providing a seamless user experience. The project encapsulates a wide range of microservices patterns and principles, offering a comprehensive learning experience in modern software architecture and design.

[akash-coded]

Hotel Reservation System: Detailed Implementation Guide

Project Modules and Workflows

Let's drill down into each module and understand its purpose, interactions, and workflows that they will implement.

Customer Service

• Business Workflows:

  1. Customer Registration
  2. Update Profile
  3. View Hotel Listings

• Design Patterns & Annotations: Use API Gateway to route requests to Customer Service.

• Interactions: Will interact with Hotel Management Service for viewing listings.

Reservation Service

• Business Workflows:

  1. Make a Reservation
  2. Update a Reservation
  3. Cancel a Reservation
  4. View Reservations

• Design Patterns & Annotations: Use Saga pattern to handle complex reservation workflows.

• Interactions: Will interact with Payment Service and Hotel Management Service.

Payment Service

• Business Workflows:

  1. Process Payments
  2. Refund

• Design Patterns & Annotations: Use Circuit Breaker to prevent payment failures from cascading.

• Interactions: Called by Reservation Service.

Hotel Management Service

• Business Workflows:

  1. Add/Update Room Inventory
  2. Add/Update Amenities
  3. View Reservations

• Design Patterns & Annotations: Use Proxy pattern to interact with third-party inventory systems.

• Interactions: Will interact with Reservation Service.

Notification Service

• Business Workflows:

  1. Send Confirmation Email/SMS
  2. Send Cancellation Email/SMS

• Design Patterns & Annotations: Use Asynchronous Messaging for notification.

• Interactions: Listens to events from Reservation Service.

Business Workflows in Detail

1. Customer Registration (Customer Service)

1. Customer navigates to the registration page.
2. Enters details and submits.
3. Use Saga pattern to begin the customer creation process:
   • Validate customer details.
   • Create a customer record in the database.
   • Publish an event to notify Notification Service.

2. Make a Reservation (Reservation Service, Payment Service, Hotel Management Service)

1. Customer chooses a hotel and room type.
2. Calls makeReservation API in Reservation Service.
3. Saga begins:
   • Reserve room inventory in Hotel Management Service.
   • Process payment in Payment Service.
   • On successful payment, confirm reservation in Hotel Management Service.
   • Publish reservation event for Notification Service.

Step-by-Step Implementation Guidelines

Step 1: Set Up Development Environment

• Install JDK 11 or above, IntelliJ IDEA, Docker, Kubernetes, Maven, and Git.

Step 2: Create Spring Boot Projects

• Use Spring Initializr to create projects for each microservice.
• Include necessary dependencies: Web, JPA, SQL database, Spring Cloud (for API Gateway, Service Discovery, etc.).

Step 3: Implement Business Logic

• Implement entities, repositories, services, and controllers for each service based on the above-described workflows.

Step 4: Implement Microservice Patterns

• Saga Pattern: Implement this pattern in Customer Service and Reservation Service for registration and reservation workflows respectively. Use an event-driven approach to handle each step of the saga.
• API Gateway Pattern: Use Spring Cloud Gateway to route requests to different services. Configure routing rules based on URI patterns and HTTP methods.
• Circuit Breaker: Implement this pattern in Payment Service to gracefully degrade functionality when downstream services are unavailable.
• Proxy Pattern: Use this pattern in Hotel Management Service to decouple it from the third-party inventory system.

Step 5-13: Dockerization, Kubernetes, and DevOps

• Follow the project description for these steps, as they are sufficiently detailed.

By following this detailed guide, the development team will have a robust and comprehensive set of instructions to build a fully functional, production-grade hotel reservation system. Even a layman can follow this guide to understand the core functionalities and patterns used in building this system.

---

Security Measures, Observability, and Further Granular Details

Step 14: Implement Security

• Authentication & Authorization: Use Spring Security with OAuth2 for service-to-service and user-to-service authentication and authorization.

  Details:

  • Customer Service should require authentication for accessing profile information.
  • Use JWT tokens and secure all inter-service communications.
  • Only allow Hotel Management Service to update inventory.

• API Gateway Security: Your API Gateway should validate incoming requests and reject unauthorized or malformed requests.

  Details:

  • Rate limiting: Set rules for how many API requests a user or a service can make within a given time period.
  • IP Filtering: Whitelist IPs that are allowed to access your services directly.

• Data Encryption: Ensure that sensitive data is encrypted using strong encryption algorithms both at rest and in transit.

Step 15: Observability Measures

1. Logging: Use ELK (Elasticsearch, Logstash, Kibana) stack for centralized logging.

   • Ensure all services push logs to Logstash which then are visible through Kibana.

2. Monitoring: Use Prometheus and Grafana.

   • Set up various alerting thresholds in Grafana to monitor service health.

3. Tracing: Use Jaeger for distributed tracing.

   • This will help in debugging and identifying performance bottlenecks in your system.

Step 16: Testing Strategies

1. Unit Testing: Use JUnit along with Mockito for mocking dependencies.
2. Integration Testing: Use TestContainers to bring up an actual database and other services to test interactions.
3. End-to-End Testing: Implement this using Selenium for UI and RestAssured for API.

Step 17: CI/CD pipeline

• Integrate all the practices in a Jenkins pipeline.
• Create different stages in Jenkins, each corresponding to building the application, running unit and integration tests, creating Docker images, pushing them to a Docker registry, and deploying them onto Kubernetes.

Step 18: Implementing A/B Testing (Optional)

• Use Kubernetes to direct a small percentage of user traffic to new deployments to test the waters before a full-scale rollout.

Step 19: Documentation

• Keep comprehensive documentation for each service.
• Use Swagger for API documentation which can be bundled with the application code and is accessible via the web.

Business Workflow Examples

Refund Process Workflow

• Trigger: Customer cancels a reservation.
• Actors: Reservation Service, Payment Service, Notification Service.
• Flow:
  1. Reservation Service validates the cancellation and sends a refund request to Payment Service.
  2. Payment Service validates and processes the refund and responds to Reservation Service.
  3. Reservation Service updates the status of the reservation.
  4. Notification Service listens for cancellation events and sends notifications.

This is a complex operation that involves multiple services, and each service has its role clearly defined. Implement Saga patterns to maintain data consistency across these operations.

Room Inventory Update Workflow

• Trigger: Seasonal update or an event that necessitates a room inventory update.
• Actors: Hotel Management Service
• Flow:
  1. Hotel Management Service checks existing reservations to see if the update is feasible.
  2. If feasible, Hotel Management Service updates the inventory and publishes an event for any interested services (like a recommendation engine, if present).

Implement Proxy patterns to abstract the complexities involved in integrating with third-party inventory management systems.

By following this guide, you can ensure the architecture's robustness, security, and scalability, while adhering to best industry practices and patterns.

[akash-coded]

Implementation Guidelines (Roadmap)

Step 1: Setup Development Environment

• Install Java JDK (version 11 or newer).
• Install an Integrated Development Environment (IDE) such as IntelliJ IDEA or Eclipse.
• Install Docker and Kubernetes, which are needed for containerization and orchestration.
• Install Maven or Gradle for building your project.
• Set up a Git repository for version control.

Step 2: Create Spring Boot Projects

• For each of the services (Customer, Reservation, Payment, Hotel Management, Notification), create a separate Spring Boot project. You can do this using Spring Initializr: https://start.spring.io/
• Make sure to add the Web, JPA, and appropriate SQL database dependencies.

Step 3: Implement Business Logic for Each Service

• Each service should be designed around a business domain. Create entities, repositories, services, and controllers for each of them.

Step 4: Containerize Your Services

• Create a Dockerfile for each of your services. This will define how the Docker image for that service should be built.
• Build the Docker image for each service and test it by running it locally.

Step 5: Create Kubernetes Configuration

• For each service, create a Kubernetes Deployment and Service configuration.
• The Deployment specifies how the application should be deployed, including the Docker image to use, the number of replicas, etc.
• The Service exposes the application to the network, allowing it to be accessed.

Step 6: Implement API Gateway

• Use Spring Cloud Gateway or Netflix Zuul to implement the API Gateway pattern.
• The API Gateway will serve as the single entry point for client requests and will route requests to the appropriate microservice.

Step 7: Implement Service Discovery

• Use Netflix Eureka or Kubernetes native service discovery.
• Each service will register itself with the service discovery component, and can use it to find other services.

Step 8: Implement Circuit Breaker

• Use Netflix Hystrix to implement the Circuit Breaker pattern.
• This pattern will prevent failures in one service from cascading to other services.

Step 9: Implement Database Per Service Pattern

• Each service should have its own dedicated database. This could be a different database server or a different database on the same server, depending on your requirements.

Step 10: Implement Asynchronous Communication

• Use RabbitMQ, ActiveMQ, or Kafka for asynchronous communication.
• This is especially important for operations that are time-consuming and can be processed in the background.

Step 11: Implement Testing

• Unit Testing: Use JUnit and Mockito.
• Integration Testing: Use Spring Boot's support for integration testing.
• End-to-End Testing: Use Selenium or similar tools.

Step 12: Implement DevOps

• Set up a Jenkins server for CI/CD.
• Create Jenkins pipelines that build your project, run tests, build Docker images, and deploy them to Kubernetes.

Step 13: Implement Observability

• Set up an ELK (Elasticsearch, Logstash, Kibana) stack for centralized logging.
• Set up Prometheus and Grafana for monitoring.
• Use Zipkin or Jaeger for distributed tracing.

This is a roadmap you can follow to build your hotel reservation system using Spring Boot microservices. Start small, validate your steps as you go, and gradually add complexity as you become comfortable with each technology.

[akash-coded]

Detailed Implementation Details

Here's a more detailed example that includes Maven dependencies, entities, Liquibase migrations and seeders, and controller endpoints for the Customer and Reservation services.

Customer Service

Maven Dependencies (pom.xml)

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>com.h2database</groupId>
        <artifactId>h2</artifactId>
        <scope>runtime</scope>
    </dependency>
    <dependency>
        <groupId>org.liquibase</groupId>
        <artifactId>liquibase-core</artifactId>
    </dependency>
</dependencies>

Entity (Model)

@Entity
@Table(name = "customers")
public class Customer {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @Column(name = "name", nullable = false)
    private String name;

    @Column(name = "email", unique = true, nullable = false)
    private String email;

    @Column(name = "password", nullable = false)
    private String password;

    // Getters and setters...
}

Liquibase Migrations and Seeders

1. Create a changelog file db.changelog-master.yaml with the following content:

databaseChangeLog:
  - changeSet:
      id: create-customers-table
      author: yourName
      changes:
        - createTable:
            tableName: customers
            columns:
              - column:
                  name: id
                  type: bigint
                  autoIncrement: true
                  constraints:
                    primaryKey: true
                    nullable: false
              - column:
                  name: name
                  type: varchar(255)
                  constraints:
                    nullable: false
              - column:
                  name: email
                  type: varchar(255)
                  constraints:
                    nullable: false
                    unique: true
              - column:
                  name: password
                  type: varchar(255)
                  constraints:
                    nullable: false

2. Create a file db.changelog-data.yaml for seeders:

databaseChangeLog:
  - changeSet:
      id: seed-customers-table
      author: yourName
      changes:
        - insert:
            tableName: customers
            columns:
              - column:
                  name: name
                  value: "John Doe"
              - column:
                  name: email
                  value: "john.doe@example.com"
              - column:
                  name: password
                  value: "hashedpassword"

Controller Endpoints

@RestController
@RequestMapping("/api/v1/customers")
public class CustomerController {

    @PostMapping("/register")
    public ResponseEntity<?> registerCustomer() {
        // logic
    }

    @GetMapping("/{id}")
    public ResponseEntity<?> getCustomerById(@PathVariable Long id) {
        // logic
    }
}

Reservation Service

Maven Dependencies (pom.xml)

Same as the Customer Service, but add Eureka Client and Hystrix dependencies for service discovery and fault tolerance.

Entity (Model)

@Entity
@Table(name = "reservations")
public class Reservation {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @Column(name = "customerId", nullable = false)
    private Long customerId;

    @Column(name = "hotelId", nullable = false)
    private Long hotelId;

    @Column(name = "startDate", nullable = false)
    private LocalDate startDate;

    @Column(name = "endDate", nullable = false)
    private LocalDate endDate;

    // Getters and setters...
}

Liquibase Migrations and Seeders

Similar approach to Customer Service, create db.changelog-master.yaml and db.changelog-data.yaml for Reservation Service.

Controller Endpoints

@RestController
@RequestMapping("/api/v1/reservations")
public class ReservationController {

    @PostMapping
    public ResponseEntity<?> makeReservation() {
        // logic
    }

    @GetMapping("/{id}")
    public ResponseEntity<?> getReservationById(@PathVariable Long id) {
        // logic
    }
}

For each service, you'll also need a liquibase.properties file to configure Liquibase.

---

Absolutely, let's move on to the Payment, Hotel Management, and Notification services.

Payment Service

Maven Dependencies (pom.xml)

<!-- Same as previous services, plus any payment gateway dependencies you might need -->

Entity (Model)

@Entity
@Table(name = "payments")
public class Payment {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @Column(name = "customerId", nullable = false)
    private Long customerId;
    
    @Column(name = "amount", nullable = false)
    private BigDecimal amount;
    
    // Additional fields such as payment method, status etc.

    // Getters and setters...
}

Liquibase Migrations and Seeders

Follow the same format as the Customer and Reservation services, just adapt it for the Payment entity.

Controller Endpoints

@RestController
@RequestMapping("/api/v1/payments")
public class PaymentController {

    @PostMapping
    public ResponseEntity<?> makePayment() {
        // logic
    }

    @GetMapping("/{id}")
    public ResponseEntity<?> getPaymentById(@PathVariable Long id) {
        // logic
    }
}

liquibase.properties

changeLogFile=src/main/resources/db/changelog/db.changelog-master.yaml
url=jdbc:h2:mem:testdb
username=sa
password=password

application.properties

spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=password
spring.jpa.database-platform=org.hibernate.dialect.H2Dialect

Hotel Management Service

Maven Dependencies, Entity, Migrations, Seeders, and Controllers

Follow the same format as the Payment service, but adapt for managing hotels, rooms, etc.

liquibase.properties and application.properties

Would be the same as Payment service, with changes for specific needs.

Notification Service

Maven Dependencies (pom.xml)

<!-- Standard Spring Boot Dependencies plus email or SMS service dependencies -->

Entity (Model)

Since Notification could be event-driven and stateless, you may or may not need an entity model.

Controller Endpoints

@RestController
@RequestMapping("/api/v1/notifications")
public class NotificationController {

    @PostMapping("/send")
    public ResponseEntity<?> sendNotification() {
        // logic
    }
}

liquibase.properties

Only if you need database interaction.

application.properties

# Here would be the email/SMS service configurations

In all these services, don't forget to configure your service to register with Eureka for service discovery and to implement Circuit Breaker patterns using Hystrix where necessary. Saga pattern could be used in scenarios involving multiple service calls that need to be transactional, like a multi-step reservation process.

This should give a more detailed and comprehensive guide to your learners for implementing each microservice thoroughly.

[jay4tech]

Hi @akash-coded

Name: Jay Prakash Kumar

I have implemented event-driven messaging architecture with RabbitMQ, With Service Discovery and API gateway. Also the aggregator pattern and saga pattern.

https://github.com/jay4tech/discovery-service/tree/final-assignment
https://github.com/jay4tech/api-gateway

https://github.com/jay4tech/customer-service/tree/final-assignment
https://github.com/jay4tech/reservation-service/tree/final-assignment
https://github.com/jay4tech/hotel-management-service/tree/final-assignment
https://github.com/jay4tech/payment-service/tree/final-assignment
https://github.com/jay4tech/notification-service/tree/final-assignment

[AnuragMishra58]

Hi @akash-coded
Name: Anurag Mishra
Emp Id: 550966

I have implemented the capstone project using Kafka broker for notifications. Have created schema using liquibase that allows to readily test API with seed data once services are up. I have used Eureka Service Discovery and spring cloud api gateway. Utilised Saga Pattern along with email notifications. Also attached sonar qube reports for the project's. Email notifications can be checked at test smtp server. using sender email noreply@amhotels.com

capstone-project.zip

[Prasadpoojary]

Hi
Name : Prasad
EMI ID : 1844193

I have completed capstone project. Implemented SAGA pattern, Proxy pattern and API gateway. Used Kafka for event based actions and notification service. Implemented JWT token authentication in API gateway level to authenticate customer requests.

Capstone Project - Spring Microservices - Reservation System.zip

Thank you.

[arupmukherjee38]

Name : Arup Mukherjee
EMI ID : 1524555
I have completed capstone project
capstone.zip

[HarshDPandya]

Hi Akash, Sharing my code in zip file for Capstone Project - Spring Microservices - Reservation System
Name: Harsh Pandya
TCS Emp Id: 2066481
microservice-capstone-reservation-system-HarshPandya-2066481.zip

[sayanp-12]

hi @akash-coded ,

Please find below github link for Capstone Project - Spring Microservices - Reservation System
https://github.com/sayanp-12/Capstone-Project---Spring-Microservices---Reservation-System/tree/main

[akratimishra22]

Hi @akash-coded
PFB my microservices for Reservation System
https://github.com/akratimishra22/customer
https://github.com/akratimishra22/reservation
https://github.com/akratimishra22/hotel-management
https://github.com/akratimishra22/payment
https://github.com/akratimishra22/notification

I have added my postman suite in each of the microservices.

Also adding a google drive link which has a zip folder having all these microservices at one place and the postman suite used for testing individual microservices as well as end to end flows like customer sign up, reserving a room and cancelling it.

https://drive.google.com/file/d/1FrAZDEOFNy0YZS1tIsYwykHgTVEaCuVE/view?usp=drive_web

[akratimishra22]

Kindly acknowledge and do let me know if any of these links are not accessible. Thank you. @akash-coded

[Suchandra-Payal]

Hi @akash-coded ,
Emp Id: 675825
Please find my Hotel Reservation System project added here as zip with test evidence. Please let me know if any discrepancy.
Capstone-Hotel-Suchandra.zip

[shukrasahu]

Hi @akash-coded,

Emp Id: 2043299
Kindly find the capstone project on Hotel Reservation System.
capstone_hotel_reservation_system.zip

[asmitaLal]

Hi @akash-coded

Emp Id : 389145.
I have uploaded the capstone project on Hotel Reservation System on LMS.
Please provide your feedback and also confirm if you have got it.

Thanks,
Asmita

[arghyagiri]

Hi @akash-coded ,

As per the project guidelines below modules are created.
• Customer Service: Handles customer profiles and preferences.
• Reservation Service: Manages reservation logic.
• Payment Service: Handles payment transactions.
• Hotel Management Service: Manages room inventories.
• Notification Service: Sends out notifications.

Please find below the things exhibited in the project.

1. Saga, Proxy and Gateway pattern in well adapted.
2. Asynchronous communication (through Kafka message broker) has been established b/w other services and notification service.
3. Test cases are written in Spring boot test framework and postman as well. Spring boot test case is present in customer service Signup end point.
4. Implemented service discovery.
5. CI has been established with Github Actions
6. Docker images are published to Github Repository
   Follow this link to find the packages published: https://github.com/arghyagiri?tab=packages
7. Sonar cloud scan has been enabled and project README file shows the current status of the scan.

Project Source code:
• Customer Service: https://github.com/arghyagiri/hrs-customer-service
• Reservation Service: https://github.com/arghyagiri/hrs-reservation-service
• Payment Service: https://github.com/arghyagiri/hrs-payment-service
• Hotel Management Service: https://github.com/arghyagiri/hrs-hotel-management-service
• Notification Service: https://github.com/arghyagiri/notification-service
• API Gateway: https://github.com/arghyagiri/api-gateway
• Service Discovery: https://github.com/arghyagiri/service-discovery

The same has also been uploaded to LMS. Please review and let me know for any clarification.

[Rajashree-Ravi]

Hi @akash-coded

I have implemented the hotel reservation system.. Please review and let me know your comments.

Github links:

https://github.com/Rajashree-Ravi/hrs-api-discovery/tree/feature/capstone-project
https://github.com/Rajashree-Ravi/hrs-api-gateway/tree/feature/capstone-project
https://github.com/Rajashree-Ravi/hrs-customer-service/tree/feature/capstone-project
https://github.com/Rajashree-Ravi/hrs-reservation-service/tree/feature/capstone-project
https://github.com/Rajashree-Ravi/hrs-hotel-management-service/tree/feature/capstone-project
https://github.com/Rajashree-Ravi/hrs-payment-service/tree/feature/capstone-project
https://github.com/Rajashree-Ravi/hrs-notification-service/tree/feature/capstone-project

hotel-reservation-system.zip

[NidhiPaleja]

Nidhi Hamlai---final.zip

[AnuragMishra58]

@akash-coded Hi Akash

Please find below link to all services for Hotel Reservation System. Workflow and pattern details mentioned in readme.
https://github.com/AnuragMishra58/microservices/blob/main/hotel-reservation-system/Readme.md

Regards
Anurag

[HarshDPandya]

Hi @akash-coded , Sharing my code in zip file for Capstone Project - Spring Microservices - Reservation System
All microservices has springdoc-openapi-ui dependency so you can use swagger ui. Starting point for make reservation and cancel reservation are in customer service. please let me know any changes required. I have also uploaded same in the final project in edureka portal.
Name: Harsh Pandya
TCS Emp Id: 2066481

microservice-capstone-reservation-system-HarshPandya-2066481.zip

[arulsudarvizhi1]

Hi Akash (@akash-coded ),

Please find attached the capstone project for hotel reservation system. All key concepts like rest template, feign client, circuit breaker, event driven, saga pattern, api gateway, proxy authentication filter covered. Zip file contains all the microservices, read me file, postman collection to test.
I have submitted the same in LMS. In case of any feedback the same can be given here, which will be corrected and updated again

capstone_hotel_reservation_system.zip

Name: Arul
Batch: Nov 7-Dec 6 Morning 7.30 AM batch

[sathyakulandhaivel]

Hi Akash - Attached is the final assignment
Name: Sathya K
TCS Emp Id: 563920
Capstone_Reservation_System_SathyaK-563920.zip

[Vamsi-Krishna-Bhagi]

Hi @akash-coded I've completed this capstone project and the latest code is committed in the same repository mentioned in the LMS. Please review. Thanks!

[jyothi241868]

Hi Akash,

Please find the attached Capstone Project for Reservation system.

Hotel_Reservation_System.zip

Thanks,
Jyothi K

[Athithiyan]

Hi Akash,

I have uploaded the capstone project in LMS. Kindly Review and share your feedback. Please let me know if there are any changes/modifications to be made.