Core Layers of Spring Boot Architecture

Spring Boot applications use a layered architecture to organize code into separate modules with clear responsibilities. This design pattern promotes modularity, maintainability, testability, and separation of concerns, making applications easier to develop, debug, scale, and maintain in teams.

The architecture divides into core layers for main functionality and supporting components that work across layers. The most common implementation divides the application into three main layers—Presentation (Controller), Service (Business Logic), and Repository (Data Access)—with an additional Persistence layer for database operations.

1. Presentation Layer (Web / Controller Layer)

Role: Handles client interactions by receiving HTTP requests and returning responses. Acts as the entry/exit point for browsers, mobile apps, or API consumers. Validates, processes, and formats requests/responses.

Key Features:

• Controllers (@RestController / @Controller) define endpoints.
• URL Mapping: @RequestMapping, @GetMapping, @PostMapping.
• Input Validation: @Valid / @Validated.
• Exception Handling: @ControllerAdvice / @ExceptionHandler.
• DTOs: Separate API models from internal entities.
• Request/Response Conversion: JSON/XML via HttpMessageConverter.

Internal Mechanism:

• DispatcherServlet: Front controller routing requests to controllers.
• Filters & Interceptors: Handle logging, security, or authentication.
• Service Interaction: Delegates business logic to Service Layer.

Example:

@RestController
@RequestMapping("/api/users")
public class UserController {

    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping("/{id}")
    public ResponseEntity<UserDTO> getUser(@PathVariable Long id) {
        return ResponseEntity.ok(userService.getUserById(id));
    }
}

Best Practices:

• Keep controllers thin, delegate logic to Service Layer.
• Use DTOs for requests/responses.
• Handle validation and exceptions centrally.

2. Service Layer (Business Layer)

Role: Contains the core business logic, acting as a bridge between Presentation and Repository layers. Handles computations, validations, workflows, and orchestrates operations across multiple repositories.

Key Features:

• @Service: Marks the class as a Spring-managed service component
• Transaction Management (@Transactional): Ensures atomic operations and rollback on errors
• Business Validation: Applies domain rules before interacting with repositories
• Orchestration: Calls multiple repositories or external services
• Caching (@Cacheable, @CachePut, @CacheEvict): Improves performance
• Error Handling: Propagates or handles exceptions for the Presentation Layer

Internal Mechanism:

• Dependency Injection: Spring injects required dependencies automatically
• Proxies & AOP: Manages transactions, logging, and security
• Decoupling: Independent of request source (REST, MVC) and data persistence

Example:

@Service
public class UserService {

    private final UserRepository userRepository;

    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    @Transactional(readOnly = true)
    public UserDTO getUserById(Long id) {
        if (id <= 0) throw new IllegalArgumentException("Invalid ID");
        User user = userRepository.findById(id)
            .orElseThrow(() -> new RuntimeException("User not found"));
        return new UserDTO(user.getId(), user.getName());
    }

    @Transactional
    public UserDTO createUser(UserDTO userDTO) {
        User user = new User(userDTO.getName(), userDTO.getEmail());
        userRepository.save(user);
        return new UserDTO(user.getId(), user.getName());
    }
}

Best Practices:

• Keep business logic in services, not controllers or repositories
• Prefer constructor injection for testability
• Keep methods focused and cohesive
• Handle transactions at the service level
• Keep services stateless for thread safety and scalability

3. Repository Layer (Data Access Layer)

Role: Manages database operations and queries, serving as the bridge between the Service Layer and the database. It abstracts persistence logic and provides clean access to data.

Key Features:

• Implemented with @Repository or Spring Data JPA interfaces (JpaRepository).
• Handles CRUD operations automatically via Spring Data.
• Supports custom queries with JPQL, SQL, or Query Methods.
• Provides transaction support for database operations.
• Returns domain models or entities to the service layer.

Internal Mechanism:

• Spring Boot detects repository interfaces and auto-generates implementations.
• Integrates with JPA/Hibernate or other ORMs automatically.
• Uses auto-configured DataSource for database connectivity.
• Manages entity caching if configured (optional).

Example:

@Repository
public interface UserRepository extends JpaRepository<User, Long> {
    Optional<User> findByEmail(String email);
}

Best Practices:

• Keep repository methods focused on data access only.
• Use Spring Data’s query derivation where possible to reduce boilerplate.
• Avoid placing business logic in repositories.
• Leverage transactions at the service layer, not repository layer.

4. Persistence Layer (Database Layer)

Role: Stores application data permanently and provides reliable access for the Repository Layer. Handles interaction with SQL, NoSQL, or in-memory databases.

Key Features:

• Supports SQL databases like MySQL, PostgreSQL, Oracle.
• Supports NoSQL databases like MongoDB, Redis.
• Supports in-memory databases like H2 for testing and development.
• Spring Boot auto-configures database connections via application.properties or application.yml.

Internal Mechanism:

• Auto-Configuration: Detects database drivers and sets up the DataSource.
• JPA Support: Configures EntityManagerFactory if JPA is used.
• Connection Pooling: Uses HikariCP or Tomcat JDBC pool for efficient resource management.

Best Practices:

• Use configuration files to manage database URLs, credentials, and pool settings.
• Separate production and development databases.
• Prefer connection pooling for better performance.
• Avoid putting business logic at this layer; focus purely on data storage and retrieval.

Example (application.properties):

spring.datasource.url=jdbc:mysql://localhost:3306/demo
spring.datasource.username=root
spring.datasource.password=secret
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true

Layered Architecture

Supporting / Cross-Cutting Components

These auto-configured components work across all layers to simplify development:

How Layers Interact (Request-Response Flow)

1. Client sends an HTTP request (e.g., GET /api/users/1)
2. Presentation Layer receives the request, validates input, and calls Service Layer
3. Service Layer applies business logic and calls Repository Layer
4. Repository Layer queries the Persistence Layer (Database)
5. Data flows back: Repository → Service → Presentation
6. Presentation Layer formats and returns response (JSON/HTML)

Diagram – Layer Interaction Flow

Client (Browser / Postman / Mobile)
           │ (HTTP Request)
           ▼
Presentation Layer (@RestController)
           │
           ▼
Service Layer (@Service – Business Logic)
           │
           ▼
Repository Layer (@Repository – Data Access)
           │
           ▼
Persistence Layer (Database)
           ▲
           │
←←←←← JSON / HTML Response ←←←←←

Key Benefits

• Separation of Concerns: Each layer has a single responsibility, easing debugging and maintenance
• Maintainability: Change one layer (e.g., database switch) with minimal impact
• Reusability: Service logic reusable across multiple controllers
• Testability: Independent unit/integration testing per layer
• Scalability: Supports microservices, cloud deployment (Docker/Kubernetes)
• Reduced Boilerplate: Auto-configuration and starters handle setup
• Production-Ready: Built-in support for logging, monitoring, and security

Conclusion

Spring Boot’s layered architecture—Presentation → Service → Repository → Persistence—combined with supporting components like Auto-Configuration, Starters, and Embedded Servers, ensures applications are modular, maintainable, scalable, and production-ready.

This design allows developers to build clean, testable, and enterprise-grade applications quickly, making it ideal for REST APIs, microservices, and full-stack projects.