Layered Architecture with Spring Annotations

Why Bother with Layers?

Before we start writing code, it's crucial to understand why we structure applications this way. A layered architecture is built on the principle of Separation of Concerns. This means that each part of the application focuses on a single responsibility, making the system easier to develop, test, maintain, and scale.

In a typical Spring Boot application, we use a three-layer architecture.

1. Controller (Presentation Layer): This is the outermost layer. Its job is to handle all incoming web requests (e.g., from a browser or a mobile app), parse the input, and then delegate the actual work to the Service layer. It doesn't contain any business logic.
2. Service (Business Layer): This is the heart of the application. It contains the core business logic, orchestrates operations, and coordinates calls to the Repository layer. For example, logic like "calculate a discount for a premium user" would live here.
3. Repository (Data Access Layer): This is the innermost layer. Its sole purpose is to interact with the database. It handles all the data persistence logic, such as fetching, saving, updating, and deleting data.

The Flow of a Request

Understanding how these layers interact is key. When a client sends a request to your API, the data flows through the layers in a specific sequence.

The "CodeSnippet" YouTube channel offers an excellent explanation of this flow and the responsibilities of each layer.

Implementing the Layers in Code

Now, let's translate this theory into practice within the Spring Boot project you created in the last lesson.

1. Creating the Package Structure

First, we'll create the necessary packages inside your main source folder (src/main/java/com/yourgroup/yourartifact). This organization makes your project structure immediately clear to any developer.

src/main/java/com/yourgroup/yourartifact/
├── controller/
├── service/
├── repository/
└── YourApplication.java

The Camunda blog provides a step-by-step guide that we can follow.

2. Defining the Components with Annotations

With the packages in place, we'll create a class or interface in each one and annotate it correctly. These annotations—@RestController, @Service, and @Repository—are called stereotype annotations. They tell Spring's IoC container to create and manage these classes as beans.

• Controller Layer (@RestController)
  In the controller package, create a new Java class. We annotate it with @RestController. This is a specialized version of @Controller used for building REST APIs. It tells Spring that the return value of methods in this class should be automatically serialized into JSON and sent back as the HTTP response body.

  package com.learning.demo.controller;
  
  import org.springframework.web.bind.annotation.RestController;
  
  @RestController
  public class UserController {
      // Methods to handle HTTP requests will go here
  }
  

• Service Layer (@Service)
  In the service package, create another class. We annotate it with @Service to indicate that it holds the business logic.

  package com.learning.demo.service;
  
  import org.springframework.stereotype.Service;
  
  @Service
  public class UserService {
      // Business logic methods will go here
  }
  

• Repository Layer (@Repository)
  Finally, in the repository package, create a Java interface. We'll annotate it with @Repository. This annotation marks it as a data access component and enables Spring's exception translation mechanism. In a later lesson, we will make this interface extend JpaRepository to get full CRUD functionality for free.

  package com.learning.demo.repository;
  
  import org.springframework.stereotype.Repository;
  
  @Repository
  public interface UserRepository {
      // Methods for database operations will go here
  }
  

Connecting the Layers with Dependency Injection

We've created the components, but how do they talk to each other? The answer is Dependency Injection, which you learned about conceptually in our first Spring lesson. We use the @Autowired annotation to let Spring automatically "wire" the dependent beans together.

The flow is:

• The Controller needs the Service.
• The Service needs the Repository.

The CodeSnippet video provides a perfect, hands-on demonstration of creating these files and then linking them.

Here's how the code looks after wiring the dependencies, based on the video's example:

UserController.java

@RestController
public class UserController {

    @Autowired
    private UserService userService;

    // A controller method would call userService.someMethod()
}

UserService.java

@Service
public class UserService {

    @Autowired
    private UserRepository userRepository;

    // A service method would call userRepository.someMethod()
}

A Quick but Important Detour: DTOs and Entities

As you saw in the video, professional applications make a distinction between two types of data objects:

• Entity: An object that is a direct representation of a database table. It has an @Entity annotation (which we'll cover soon) and is used primarily between the Service and Repository layers.
• DTO (Data Transfer Object): A plain object designed specifically to transfer data to or from the client. It is used between the Controller and the Client. A DTO allows you to control exactly what data you expose. For example, you would never include a user's password hash in a DTO sent to the client.

The conversion between an Entity (from the database) and a DTO (for the client) typically happens in the Service layer. This is a perfect example of Separation of Concerns in action.

The CodeSnippet video explains this concept and shows you how to implement it.

Conclusion

In this lesson, you've established a solid, professional structure for your Spring Boot application. This layered approach is not just a "nice-to-have"; it's a critical practice for building scalable and maintainable software, and it's something every hiring manager will expect you to know.

Key Takeaways:

• Layered Architecture separates your application into a Controller (presentation), Service (business), and Repository (data access) layer.
• This separation improves maintainability, testability, and reusability.
• Spring uses stereotype annotations (@RestController, @Service, @Repository) to identify and manage components in each layer.
• Dependency Injection (with @Autowired) is the mechanism used to connect the layers, allowing the controller to call the service, and the service to call the repository.
• Using DTOs to transfer data to and from the client is a best practice that separates your internal data model (Entities) from your public API contract.

In our next lesson, we will put this structure to full use by creating RESTful API endpoints for GET, POST, PUT, and DELETE requests. You will see how easily we can add new features by simply adding methods to our existing layers.