Event Booking Microservices Platform

A microservices-based event booking platform built with Java, Spring Boot, Spring Cloud, Redis, and MySQL. The project focuses on reliable event booking, concurrent seat management, caching, distributed locking, and inter-service communication.

Features

• Event CRUD operations
• Seat reservation and release
• Booking and cancellation workflows
• Optimistic locking for concurrent booking requests
• Redis caching
• Redis cache eviction
• Distributed locking with Redisson
• Inter-service communication
• Compensating rollback for failed booking workflows
• Service discovery with Eureka
• Centralized configuration with Spring Cloud Config Server
• API Gateway for request routing
• Unit testing for core services

Architecture

                         Client
                           |
                           v
                    +--------------+
                    | API Gateway  |
                    +--------------+
                           |
              +------------+------------+
              |                         |
              v                         v
       +-------------+           +--------------+
       | Event       |<----------| Booking      |
       | Service     |           | Service      |
       +-------------+           +--------------+
              |                         |
              v                         v
          +--------+                +--------+
          | MySQL  |                | MySQL  |
          +--------+                +--------+
              |
              v
          +--------+
          | Redis  |
          +--------+

    +------------------+     +------------------+
    | Eureka Server    |     | Config Server    |
    | Service Discovery|     | Central Config   |
    +------------------+     +------------------+

Services

Event Service

Responsible for:

• Creating events
• Updating events
• Retrieving events
• Deleting events
• Managing event seats
• Reserving seats
• Releasing seats

Booking Service

Responsible for:

• Creating bookings
• Communicating with Event Service
• Booking cancellation
• Handling booking failures
• Compensating rollback

Eureka Server

Provides service discovery so that microservices can locate and communicate with each other.

Config Server

Provides centralized configuration for the microservices.

API Gateway

Acts as the entry point for client requests and routes requests to the appropriate microservice.

Technology Stack

• Language: Java
• Backend: Spring Boot
• Architecture: Microservices
• Cloud: Spring Cloud
• Service Discovery: Eureka
• Configuration: Spring Cloud Config Server
• Gateway: Spring Cloud Gateway
• Caching: Redis
• Distributed Locking: Redisson
• Database: MySQL
• Testing: JUnit
• Build Tool: Maven

Concurrency Handling

The project uses optimistic locking to prevent conflicting updates when multiple users attempt to reserve seats simultaneously.

Redisson distributed locking is used to coordinate concurrent operations and prevent multiple service instances from performing conflicting booking operations.

Booking Request
      |
      v
Acquire Distributed Lock
      |
      v
Check Seat Availability
      |
      v
Reserve Seat
      |
      v
Release Lock

Redis Caching

Redis is used to cache event data and reduce repeated database queries.

When event data changes, the corresponding cache entry is evicted to prevent stale data.

Request
   |
   v
Redis Cache
   |
   +---- Cache Hit ----> Return Data
   |
   +---- Cache Miss ---> MySQL
                           |
                           v
                      Store in Redis

Compensating Rollback

The booking workflow uses a compensating rollback mechanism to maintain consistency when a booking operation fails after a seat has already been reserved.

Create Booking
      |
      v
Reserve Seat
      |
      v
Continue Booking
      |
   +--+--+
   |     |
Success Failure
   |     |
   v     v
Complete Release Seat
         |
         v
      Rollback

Development Progress

Week 1 — Event Service

• CRUD operations
• Seat reservation and release
• Optimistic locking
• Unit tests

Week 2 — Booking Service

• Inter-service communication
• Compensating rollback
• Booking cancellation

Week 3 — Spring Cloud

• Eureka Service Registry
• Config Server
• API Gateway
• End-to-end routing

Week 4 — Redis

• Redis caching
• Cache eviction
• Redisson distributed locking
• Lock/unlock verification

Getting Started

Prerequisites

• Java 21+
• Maven
• MySQL
• Redis

Clone the Repository

git clone https://github.com/YOUR_USERNAME/event-booking-microservices.git
cd event-booking-microservices

Run the Services

Start the services in the following order:

1. Config Server
2. Eureka Server
3. Event Service
4. Booking Service
5. API Gateway

Then send requests through the API Gateway.

Project Structure

event-booking-microservices/
├── event-service/
├── booking-service/
├── config-server/
├── api-gateway/
├── service-registry/
├── config-repo/
├── .gitignore
└── README.md

Future Improvements

• JWT authentication and authorization
• Kafka/RabbitMQ for asynchronous communication
• Resilience4j circuit breaker
• Docker containerization
• Centralized logging
• Application monitoring

Author

Raju Chowdhury

Java Backend Developer
Java | Spring Boot | Microservices | Spring Cloud | Redis