Spring Boot Architecture: Controller, Service, Repository, Database & Architecture Flow

 🚀 Introduction to Spring Boot Architecture

Spring Boot is one of the most popular frameworks for building RESTful APIs and microservices in Java. It simplifies development by providing an opinionated, pre-configured environment, reducing boilerplate code, and ensuring scalability and maintainability.

📌 Why Learn Spring Boot Architecture?

✅ Better Code Organization — Follow a well-defined structure.
 ✅ Scalability — Makes it easy to expand the application.
 ✅ Maintainability — Each layer has a clear responsibility.
 ✅ Faster Development — Simplifies API and database interactions.

In this guide, we’ll explore the Spring Boot Layered Architecture and how data flows between different components.

🔹 Spring Boot Layered Architecture (Explained with Diagram)

The Spring Boot architecture is based on a layered approach, where each layer is responsible for a specific part of the application.

🖼️ Spring Boot Architecture Diagram

Image credit: https://medium.com/@dulanjayasandaruwan1998/understanding-spring-boot-architecture-flow-615d209b95f9

1️⃣ Client Layer (API Consumer)

📌 This is the external entity (browser, mobile app, Postman, frontend app) that interacts with the API.

• Sends HTTP Requests (GET, POST, PUT, DELETE)
• Receives API Responses (JSON format)

Examples of clients:
 ✔ Frontend apps (React, Angular, Vue.js)
 ✔ Mobile apps (Android, iOS)
 ✔ API testing tools (Postman, cURL)

2️⃣ Controller Layer (Handles HTTP Requests & Responses)

📌 The Controller Layer acts as the “entry point” for API requests. It is responsible for processing incoming HTTP requests and returning appropriate responses.

🔹 Responsibilities of Controller Layer:

✔ Receives client requests (@GetMapping, @PostMapping, etc.)
 ✔ Validates input data
 ✔ Calls the Service Layer for business logic
 ✔ Returns the appropriate HTTP response

🔹 Example of a Spring Boot Controller:

@RestController
@RequestMapping("/api/products")
public class ProductController {
    
    private final ProductService productService;

    public ProductController(ProductService productService) {
        this.productService = productService;
    }

    @GetMapping
    public ResponseEntity<List<ProductDTO>> getAllProducts() {
        return ResponseEntity.ok(productService.getAllProducts());
    }
}

🚀 The controller does not contain business logic. It only routes the request to the appropriate service method.

3️⃣ Service Layer (Business Logic Processing)

📌 The Service Layer is responsible for implementing business logic and processing the data before sending it to the client.

🔹 Responsibilities of Service Layer:

✔ Implements business rules and logic
 ✔ Handles transactions
 ✔ Calls the Repository Layer for database interactions
 ✔ Uses DTOs (Data Transfer Objects) to structure data

🔹 Example of a Spring Boot Service Class:

@Service
public class ProductService {
    
    private final ProductRepository productRepository;
    private final ProductMapper productMapper;

    public ProductService(ProductRepository productRepository, ProductMapper productMapper) {
        this.productRepository = productRepository;
        this.productMapper = productMapper;
    }

    public List<ProductDTO> getAllProducts() {
        return productRepository.findAll()
                .stream()
                .map(productMapper::toDTO)
                .toList();
    }
}

🚀 The service layer ensures that the controller does not contain business logic. It is responsible for handling business operations.

4️⃣ Repository Layer (Database Access Layer)

📌 The Repository Layer is responsible for communicating with the database.

• Uses Spring Data JPA to perform CRUD operations.
• Uses @Repository annotation to indicate that it's a DAO (Data Access Object).
• Implements database queries using JPA, Hibernate, or Native SQL.

🔹 Example of a Spring Boot Repository:

public interface ProductRepository extends JpaRepository<Product, Long> {
}

🚀 Spring Data JPA reduces the need for boilerplate CRUD code by providing pre-built methods like findAll(), save(), deleteById(), etc.

5️⃣ Model Layer (Entity & DTOs Representation)

📌 The Model Layer represents database tables and ensures data encapsulation.

🔹 Entities are mapped to database tables.
 🔹 DTOs (Data Transfer Objects) help transfer only required data.

🔹 Example of an Entity Class:

@Entity
public class Product {
    
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    private String name;
    
    private String description;
    
    private double price;
}

🚀 Entities should not be exposed directly in API responses. Instead, use DTOs.

🔹 Example of a DTO Using Java record:

public record ProductDTO(Long id, String name, String description, double price) {}

🚀 Using record for DTOs ensures immutability and a cleaner code structure.

6️⃣ Database Layer (Persistence Storage)

📌 The Database Layer stores and retrieves data using Spring Boot’s persistence framework.

• Uses relational databases (MySQL, PostgreSQL, H2, etc.)
• Uses JPA and Hibernate to manage entity mappings
• Executes queries using CRUD operations

🔹 Example of Database Configuration (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

🚀 H2 is an in-memory database used for testing. In production, you can use MySQL or PostgreSQL.

🔹 How Data Flows in a Spring Boot Application?

1️⃣ The Client sends an HTTP request to the Controller Layer.
 2️⃣ The Controller validates the request and forwards it to the Service Layer.
 3️⃣ The Service Layer processes the business logic and calls the Repository Layer.
 4️⃣ The Repository Layer fetches or updates data in the Database.
 5️⃣ The Model Layer maps database records into Java objects.
 6️⃣ The processed data is sent back to the Service Layer, then to the Controller Layer, and finally returned to the Client as an API response.

🎯 Summary of Spring Boot Architecture

✅ Follows a layered architecture for better separation of concerns.
 ✅ Uses Controller, Service, Repository, Model, and Database layers.
 ✅ Ensures clean code, maintainability, and scalability.
 ✅ Uses Spring Data JPA for database interactions.

💡 Next Steps

🔥 Learn how to implement CRUD operations in Spring Boot.
 🔥 Understand how to secure Spring Boot APIs using JWT authentication.
 🔥 Explore Microservices Architecture using Spring Boot.

📢 Share this guide to help others understand Spring Boot Architecture! 🚀

📢 Stay Connected & Keep Learning! 🚀

If you find my content valuable, please support with a clap 👏 and share it with others! 🚀

🔗 Explore my Udemy courses: Java Guides Udemy Courses
📖 Read more tutorials on my blog: Java Guides
🎥 Watch free Java video tutorials on YouTube: Java Guides YouTube