Building a REST API with Spring Boot: Initial Setup

Creating a robust backend for web applications requires careful setup and design. This post outlines the initial steps in building a REST API using Spring Boot, focusing on entities, repositories, services, and controllers.

Project Structure

When starting a new Spring Boot project, it's crucial to establish a well-defined project structure. This approach enhances maintainability and scalability.

com/
└── example/
    └── api/
        ├── entity/
        │   └── User.java
        ├── repository/
        │   └── UserRepository.java
        ├── service/
        │   ├── UserService.java
        │   └── UserServiceImpl.java
        └── controller/
            └── UserController.java

• entity: Contains the data models (e.g., User).
• repository: Manages database interactions using Spring Data JPA (e.g., UserRepository).
• service: Implements the business logic (e.g., UserService, UserServiceImpl).
• controller: Handles incoming HTTP requests and returns responses (e.g., UserController).

Defining Entities

Entities represent the data structure of the application. For example, a User entity might look like this:

import javax.persistence.Entity;
import javax.persistence.Id;

@Entity
public class User {
    @Id
    private Long id;
    private String username;
    private String email;
}

This simple entity defines a User with an ID, username, and email. The @Entity annotation marks this class as a JPA entity, and @Id specifies the primary key.

Creating Repositories

Repositories provide an abstraction layer for data access. Spring Data JPA simplifies this process:

import org.springframework.data.jpa.repository.JpaRepository;
import example.api.entity.User;

public interface UserRepository extends JpaRepository<User, Long> {
}

By extending JpaRepository, UserRepository inherits methods for common database operations like create, read, update, and delete (CRUD) without needing explicit implementation.

Implementing Services

Services contain the business logic of the application. A UserService interface and its implementation might look like this:

public interface UserService {
    User getUserById(Long id);
}

import org.springframework.stereotype.Service;

@Service
public class UserServiceImpl implements UserService {

    @Override
    public User getUserById(Long id) {
        // Implementation to fetch user from the database
        return null; // Placeholder
    }
}

The @Service annotation marks UserServiceImpl as a service component, making it eligible for dependency injection. The implementation would typically use the UserRepository to interact with the database.

Exposing Controllers

Controllers handle incoming HTTP requests and route them to the appropriate service methods. A basic UserController might look like this:

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class UserController {

    @GetMapping("/users/{id}")
    public String getUser(@PathVariable Long id) {
        return "User with id: " + id;
    }
}

The @RestController annotation indicates that this class is a REST controller. The @GetMapping annotation maps HTTP GET requests to the getUser method, which returns a simple string in this example.

Generated with Gitvlg.com