Spring Boot REST API Development

Spring Boot makes it easy to develop RESTful APIs with minimal configuration and effort. REST (Representational State Transfer) is an architectural style for designing networked applications, and REST APIs are widely used for building web services. Spring Boot simplifies the creation of these services by leveraging the Spring Framework’s features and providing built-in support for handling HTTP requests and responses.

Key Concepts of Spring Boot REST API Development

RESTful Principles:
- Stateless: Each request from a client to a server must contain all the information the server needs to understand and process the request.
- Client-Server: The client and server are independent of each other, allowing for separation of concerns.
- Cacheable: Responses should be explicitly marked as cacheable or non-cacheable.
- Uniform Interface: The system should have a standardized interface (using HTTP methods, status codes, and URIs).
- Layered System: The system should be structured in layers (client, server, etc.) to improve scalability and performance.
Spring Boot Overview:
- Spring Boot is a framework built on top of the Spring Framework. It simplifies the setup and development of Spring applications by providing defaults and configurations, reducing boilerplate code.
- It includes built-in libraries, such as Spring Web, Spring Data JPA, Spring Security, and others, to make it easier to build enterprise-level applications.
- It comes with embedded web servers (e.g., Tomcat, Jetty), so you don’t need to deploy your application in a separate web server.

Steps for Building a REST API with Spring Boot

1. Setting Up a Spring Boot Project

You can set up a Spring Boot project using Spring Initializr, an online tool provided by Spring, or use an IDE like IntelliJ IDEA or Spring Tool Suite.

Spring Initializr: Visit start.spring.io and configure the project details (Group, Artifact, Name, etc.).
- Add dependencies such as Spring Web, Spring Data JPA, H2 Database (for testing), or MySQL (for production), depending on your project needs.
- Download the project and unzip it into your development environment.
IDE Setup: Import the generated project into your favorite IDE (IntelliJ IDEA, Eclipse, or Spring Tool Suite).

2. Define Entity Class

The first step in building a REST API is defining the model or entity. For example, let’s assume you’re building an API for a Product:

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

@Entity
public class Product {

    @Id
    private Long id;
    private String name;
    private Double price;

    // Getters and Setters
}

3. Create Repository Interface

Spring Data JPA simplifies the interaction with the database. You just need to create a repository interface that extends JpaRepository.

import org.springframework.data.jpa.repository.JpaRepository;

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

This interface will provide all basic CRUD operations (save, find, delete) for the Product entity without needing to write any implementation.

4. Create Service Layer

The service layer handles the business logic and interacts with the repository. It encapsulates the interaction between the controller and repository.

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
import java.util.Optional;

@Service
public class ProductService {

    @Autowired
    private ProductRepository productRepository;

    public List<Product> getAllProducts() {
        return productRepository.findAll();
    }

    public Optional<Product> getProductById(Long id) {
        return productRepository.findById(id);
    }

    public Product saveProduct(Product product) {
        return productRepository.save(product);
    }

    public void deleteProduct(Long id) {
        productRepository.deleteById(id);
    }
}

5. Create Controller

The controller layer exposes the REST API endpoints. In Spring Boot, you can use the @RestController annotation to define a controller that will handle HTTP requests.

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.util.List;
import java.util.Optional;

@RestController
@RequestMapping("/api/products")
public class ProductController {

    @Autowired
    private ProductService productService;

    @GetMapping
    public List<Product> getAllProducts() {
        return productService.getAllProducts();
    }

    @GetMapping("/{id}")
    public ResponseEntity<Product> getProductById(@PathVariable Long id) {
        Optional<Product> product = productService.getProductById(id);
        return product.map(ResponseEntity::ok).orElseGet(() -> ResponseEntity.notFound().build());
    }

    @PostMapping
    public ResponseEntity<Product> createProduct(@RequestBody Product product) {
        Product savedProduct = productService.saveProduct(product);
        return ResponseEntity.status(HttpStatus.CREATED).body(savedProduct);
    }

    @PutMapping("/{id}")
    public ResponseEntity<Product> updateProduct(@PathVariable Long id, @RequestBody Product product) {
        if (productService.getProductById(id).isPresent()) {
            product.setId(id);
            Product updatedProduct = productService.saveProduct(product);
            return ResponseEntity.ok(updatedProduct);
        } else {
            return ResponseEntity.notFound().build();
        }
    }

    @DeleteMapping("/{id}")
    public ResponseEntity<Void> deleteProduct(@PathVariable Long id) {
        if (productService.getProductById(id).isPresent()) {
            productService.deleteProduct(id);
            return ResponseEntity.noContent().build();
        } else {
            return ResponseEntity.notFound().build();
        }
    }
}

@GetMapping: Handles GET requests to retrieve resources.
@PostMapping: Handles POST requests to create resources.
@PutMapping: Handles PUT requests to update resources.
@DeleteMapping: Handles DELETE requests to delete resources.
@RequestBody: Binds the request body to the Product object.
@PathVariable: Extracts the id from the URI.

6. Run the Application

To run your Spring Boot application, create a main class annotated with @SpringBootApplication and execute the main method:

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class ProductApplication {

    public static void main(String[] args) {
        SpringApplication.run(ProductApplication.class, args);
    }
}

7. Testing the REST API

Once the application is running, you can test the API using tools like Postman or curl.

Get All Products:
- GET http://localhost:8080/api/products
Get Product by ID:
- GET http://localhost:8080/api/products/1
Create Product:
- POST http://localhost:8080/api/products
- Request Body: { "name": "Laptop", "price": 1200.00 }
Update Product:
- PUT http://localhost:8080/api/products/1
- Request Body: { "name": "Updated Laptop", "price": 1100.00 }
Delete Product:
- DELETE http://localhost:8080/api/products/1

8. Error Handling (Optional)

To handle errors and provide custom error messages in your REST API, you can create a @ControllerAdvice class to handle exceptions globally.

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;

@RestControllerAdvice
public class GlobalExceptionHandler {

    @ExceptionHandler(ResourceNotFoundException.class)
    public ResponseEntity<String> handleNotFound(ResourceNotFoundException ex) {
        return new ResponseEntity<>(ex.getMessage(), HttpStatus.NOT_FOUND);
    }

    @ExceptionHandler(Exception.class)
    public ResponseEntity<String> handleException(Exception ex) {
        return new ResponseEntity<>(ex.getMessage(), HttpStatus.INTERNAL_SERVER_ERROR);
    }
}