Building REST APIs with Spring Boot: Step-by-Step Guide

In today’s modern software world, RESTful APIs are at the heart of mobile apps, web applications, and cloud-based systems. And when it comes to building REST APIs in Java, Spring Boot is the top framework of choice. With its simplicity, flexibility, and powerful integrations, Spring Boot empowers developers to build robust APIs quickly and efficiently.

In this blog, we’ll guide you step-by-step through building a REST API using Spring Boot, from project setup to creating endpoints, handling data, and applying best practices.

🔍 What is Spring Boot?

Before diving into the code, let’s revisit what makes Spring Boot a powerful tool. Spring Boot is a Java-based framework that simplifies building stand-alone, production-ready Spring applications. It reduces boilerplate code, provides embedded web servers, and supports various integrations like Spring Data JPA, Spring Security, and more.

When you develop a REST API with Spring Boot, you get:

Auto-configuration of Spring applications
Embedded Tomcat/Jetty
Quick project initialization
Support for RESTful controllers and HTTP methods

✅ Why Use Spring Boot for REST APIs?

Here’s why Spring Boot is perfect for building RESTful APIs:

Ease of Setup: Minimal configuration and auto-setup.
Rapid Development: Reduced boilerplate code with annotations.
Built-in Tools: Spring Data JPA, Swagger, DevTools, and Actuator.
Scalable Architecture: Perfect for microservices and cloud-native APIs

⚙️ Step-by-Step Guide: Building a REST API with Spring Boot

Let’s walk through how to build a simple user management REST API using Spring Boot.

Step 1: Create the Project

Use https://start.spring.io to generate a Spring Boot project.

Project: Maven
Dependencies: Spring Web, Spring Boot DevTools, Spring Data JPA, H2 Database
Group: com.example
Artifact: user-api

Click Generate, then unzip and import into your IDE.

Step 2: Define the User Entity

Create a User model in com.example.model.

@Entity
public class User {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;

private String name;
private String email;

// Getters and setters
}

Step 3: Create a Repository

Create UserRepository in com.example.repository.

Spring Boot will automatically create the implementation using Spring Data JPA.

Step 4: Build the REST Controller

Create UserController in com.example.controller.

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

@Autowired
private UserRepository userRepository;

@GetMapping
public List<User> getAllUsers() {
return userRepository.findAll();
}

@PostMapping
public User createUser(@RequestBody User user) {
return userRepository.save(user);
}

@GetMapping(“/{id}”)
public ResponseEntity<User> getUserById(@PathVariable Long id) {
return userRepository.findById(id)
.map(ResponseEntity::ok)
.orElse(ResponseEntity.notFound().build());
}

@PutMapping(“/{id}”)
public ResponseEntity<User> updateUser(@PathVariable Long id, @RequestBody User userDetails) {
return userRepository.findById(id)
.map(user -> {
user.setName(userDetails.getName());
user.setEmail(userDetails.getEmail());
return ResponseEntity.ok(userRepository.save(user));
}).orElse(ResponseEntity.notFound().build());
}

@DeleteMapping(“/{id}”)
public ResponseEntity<Void> deleteUser(@PathVariable Long id) {
return userRepository.findById(id)
.map(user -> {
userRepository.delete(user);
return ResponseEntity.ok().<Void>build();
}).orElse(ResponseEntity.notFound().build());
}
}

Step 5: Configure H2 and Run the App

In application.properties:

spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=
spring.jpa.database-platform=org.hibernate.dialect.H2Dialect
spring.h2.console.enabled=true

Run your app and visit http://localhost:8080/h2-console to view your in-memory database.

🌐 Testing the API Endpoints

Use Postman or curl to test your REST API:

GET /api/users – List all users
POST /api/users – Create a new user
GET /api/users/{id} – Get user by ID
PUT /api/users/{id} – Update user by ID
DELETE /api/users/{id} – Delete user

🛡️ Best Practices for REST API in Spring Boot

Use DTOs (Data Transfer Objects): Separate your entity from API responses.
Implement Validation: Use @Valid, @NotNull, @Email, etc.
Handle Exceptions Gracefully: Use @ControllerAdvice for global error handling.
Secure Your APIs: Add authentication with Spring Security or OAuth2.
Document Your API: Use Swagger (Springfox or Springdoc).

🧠 Why Spring Boot is Ideal for RESTful API Development

Robust Ecosystem: Works seamlessly with Spring Security, Spring Cloud, and more.
Cloud Native: Easily deployable on platforms like AWS, Azure, and GCP.
Built for Performance: Highly optimized for production use.
Developer Friendly: Rapid development with rich tooling support.

Whether you’re a beginner or a seasoned Java developer, Spring Boot makes building REST APIs easy, maintainable, and scalable.

📊 Sample Swagger Integration (Optional)

Add dependency in pom.xml:

Now, navigate to:
http://localhost:8080/swagger-ui.html

Spring Boot now automatically generates interactive API documentation.

✅ Conclusion

Spring Boot has redefined how REST APIs are built in Java. Its ease of setup, out-of-the-box features, and rich integrations make it the first choice for developers building modern web services. With Spring Boot, you can create clean, maintainable, and secure APIs in record time.

Whether you’re building a monolith or microservices, Spring Boot helps you stay productive while following best industry practices.

📌 FAQs

Q1: Can I use Spring Boot with MongoDB or PostgreSQL?

Yes! Spring Boot supports various databases including MongoDB, MySQL, PostgreSQL, and more through Spring Data.

Q2: Is Swagger necessary?

Not mandatory, but highly recommended. It helps developers and teams understand and test your APIs easily.

Q3: Can I deploy Spring Boot APIs to the cloud?

Absolutely. You can deploy Spring Boot applications to AWS, Heroku, Azure, and other platforms with minimal configuration.