Spring Boot REST API (2026) – Java 21 Production Setup

Java is not the verbose, clunky language it was ten years ago. With the release of Java 21 and Spring Boot 3, building enterprise backends is leaner, faster, and highly scalable. The introduction of features like Virtual Threads and Records has completely revolutionized how we approach web architecture.

What is a Spring Boot REST API?

Spring Boot is an opinionated framework built on top of the Spring ecosystem. It eliminates the complex XML configurations that used to plague Java developers, giving you a ready-to-run environment (complete with an embedded Tomcat server) right out of the box.

• Java 21 is the modern LTS (Long Term Support) release bringing massive performance boosts.
• Spring Boot 3 is the backend framework optimized for cloud-native deployment.
• A REST API is the interface that allows your frontend (like React or a mobile app) to communicate with your database through JSON.

Spring Boot powers the backends of Netflix, LinkedIn, and countless banking systems. If you want to understand where this fits into the big picture, read my Complete Beginner's Guide to Backend Development.

Why Java 21 and Spring Boot 3 Matter in Real-World Projects

Many developers ask: "Why use Java when I can use Node.js or Python?" The answer lies in stability, massive ecosystem support, and recent game-changing performance updates.

• Virtual Threads (Project Loom): Java 21 introduced virtual threads, allowing your API to handle millions of concurrent requests using a fraction of the memory previously required.
• Records: Immutable data carriers (DTOs) are now a one-liner in Java, eliminating the need for libraries like Lombok to generate getters and setters.
• Type Safety & Ecosystem: The Java compiler catches bugs before they ever reach production, and Maven/Gradle provides the most mature dependency management in the industry.

Step-by-Step Implementation: Building a REST API

We are going to build a production-ready "Employee Management" API. We will implement clean architecture by separating our Controllers, Services, and Repositories.

Step 1 — Project Initialization (Spring Initializr)

The easiest way to bootstrap a Spring Boot project is via Spring Initializr. Use the following settings:

• Project: Maven
• Language: Java
• Spring Boot: 3.2.x (or latest stable)
• Java Version: 21
• Dependencies: Spring Web, Spring Data JPA, H2 Database (or PostgreSQL)

Generate, download, and open the project in your favorite IDE (like IntelliJ IDEA).

Step 2 — Enabling Java 21 Virtual Threads

To get the massive scalability benefits of Java 21, you simply need to tell Tomcat to use Virtual Threads. Open your application.properties (or application.yml) and add this single magical line:

# src/main/resources/application.properties
spring.threads.virtual.enabled=true
spring.datasource.url=jdbc:h2:mem:employeedb
spring.jpa.hibernate.ddl-auto=update

Step 3 — Domain Model and Record Classes (DTOs)

First, let's create our Entity. This is the object that maps directly to our database table.

package com.drift.api.model;

import jakarta.persistence.*;

@Entity
public class Employee {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    private String name;
    private String role;

    // Getters and Setters (or use your IDE to generate them)
    public Long getId() { return id; }
    public void setId(Long id) { this id = id; }
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public String getRole() { return role; }
    public void setRole(String role) { this.role = role; }
}

Instead of exposing our Entity directly to the client, we use Java 21 Records for our Data Transfer Objects (DTOs). They are immutable and clean:

package com.drift.api.dto;

public record EmployeeDTO(String name, String role) {}

Step 4 — Creating the Repository

Spring Data JPA removes the need to write raw SQL queries. By simply extending an interface, we get all CRUD (Create, Read, Update, Delete) operations for free.

package com.drift.api.repository;

import com.drift.api.model.Employee;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

@Repository
public interface EmployeeRepository extends JpaRepository<Employee, Long> {
    // Spring Boot automatically implements this!
}

Step 5 — Service Layer Logic

Never put business logic inside a Controller. The Service Layer is where your API makes decisions, throws errors, and processes data.

package com.drift.api.service;

import com.drift.api.model.Employee;
import com.drift.api.dto.EmployeeDTO;
import com.drift.api.repository.EmployeeRepository;
import org.springframework.stereotype.Service;
import java.util.List;

@Service
public class EmployeeService {

    private final EmployeeRepository repository;

    // Constructor injection is best practice
    public EmployeeService(EmployeeRepository repository) {
        this.repository = repository;
    }

    public List<Employee> getAllEmployees() {
        return repository.findAll();
    }

    public Employee createEmployee(EmployeeDTO dto) {
        Employee employee = new Employee();
        employee.setName(dto.name());
        employee.setRole(dto.role());
        return repository.save(employee);
    }
    
    public Employee getEmployeeById(Long id) {
        return repository.findById(id)
            .orElseThrow(() -> new RuntimeException("Employee not found with id: " + id));
    }
}

Step 6 — The REST Controller

Finally, we expose our endpoints over HTTP. The @RestController annotation tells Spring to automatically serialize the returned objects into JSON format.

package com.drift.api.controller;

import com.drift.api.model.Employee;
import com.drift.api.dto.EmployeeDTO;
import com.drift.api.service.EmployeeService;
import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("/api/v1/employees")
public class EmployeeController {

    private final EmployeeService service;

    public EmployeeController(EmployeeService service) {
        this.service = service;
    }

    @GetMapping
    public List<Employee> getAll() {
        return service.getAllEmployees();
    }
    
    @GetMapping("/{id}")
    public Employee getById(@PathVariable Long id) {
        return service.getEmployeeById(id);
    }

    @PostMapping
    @ResponseStatus(HttpStatus.CREATED)
    public Employee create(@RequestBody EmployeeDTO dto) {
        return service.createEmployee(dto);
    }
}

Production-Level Improvements

To take this API from a local tutorial to a production-grade enterprise system, you must implement the following architectural patterns:

• Global Exception Handling: Never return raw 500 server stack traces to users. Use @ControllerAdvice to map exceptions (like "User Not Found") to clean JSON 404 responses.
• Input Validation: Use spring-boot-starter-validation to annotate your DTOs (e.g., @NotBlank, @Email) so bad data is blocked before it even hits your Service layer.
• Containerization: For cloud deployment on AWS or Kubernetes, wrap your Spring Boot jar in a Docker image. Learn how in my Docker Complete Guide.
• CI/CD Pipelines: Manage your codebase securely using GitHub Actions. Check out my Git Workflow Guide.

Common Mistakes in Spring Boot

Watch out for these classic pitfalls that trip up junior Java developers:

• Using @Autowired on Fields: Field injection makes unit testing difficult. Always use Constructor Injection (like we did in the Service layer above).
• Returning Entities Directly in Production: While we did it for simplicity here, in large apps you should map Entities to DTOs before returning them to avoid infinite recursion and leaking sensitive database fields.
• Heavy Logic in Controllers: Controllers should ONLY handle HTTP routing. Business logic belongs in the @Service.

Real-World Use Cases for Spring Boot

When should you actively choose Spring Boot over other frameworks?

• Banking and FinTech: When transactional integrity and strict type safety are non-negotiable, Java's ecosystem is unparalleled.
• High-Traffic Microservices: With Java 21 Virtual Threads, Spring Boot handles massive concurrent traffic (e.g., streaming apps, booking engines) with tiny memory footprints.
• Enterprise Integration: If you need to connect to Kafka, Redis, active directories, and legacy SQL databases simultaneously, Spring Boot has a pre-built starter for everything.

Frequently Asked Questions (FAQ)

What's Next in Your Backend Journey?

You have successfully built a clean, scalable REST API using modern Java 21 patterns. The next logical step is securing your endpoints. You should look into implementing Spring Security with JWT (JSON Web Tokens) to protect your application.

Additionally, if you want to see how this compares to other backend ecosystems, read my Node.js Production REST API Guide to understand the differences between Java and JavaScript on the server.