Easiest Way to Create REST API using Spring Boot

Last Updated : 13 Mar, 2025

Spring Boot is a powerful framework that makes it easy to create RESTful APIs. Creating a REST API using Spring Boot is one of the fastest and simplest ways to develop scalable and production-ready web services. Spring Boot simplifies REST API development by providing built-in features such as automatic configurations, embedded servers, and minimal boilerplate code. In this article, we will learn the easiest way to create a RESTful API with Spring Boot, covering essential aspects such as dependencies, controllers, services, and database integration.

Step-by-Step Implementation to Create REST API using Spring Boot

Below are the steps to implement REST API in Spring Boot with MySQL and JPA.

Step 1: Setup Development Environment

Before we begin, we need to set up our development environment. We will need to install the following software:

Java Development Kit (JDK)
Intellij (or any other preferred IDE like Eclipse)
MySQL Server

Step 2: Create a Spring Boot Project

The first step is to create a new Spring Boot project using the Spring Initializr. Open any web browser and go to Spring Initializr

Set the following options:

Project: Maven Project/Gradle according to your need
Language: Java
Spring Boot: 3.x.x (or the latest version)
Group: com.example
Artifact: spring boot API/any desired info of your own choice
Packaging: Jar
Java: 17 or later

Click on the “Add Dependencies” button and add the following dependencies:

Spring Web
Spring Data JPA
MySQL Driver

Select these dependencies and click on the Generate button. Extract the downloaded project ZIP file to your preferred location.

Step 3: Add Dependencies

To create a REST API with Spring Boot, include the following dependencies in pom.xml:

<dependencies>

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>


<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>


<dependency>
<groupId>com.h2database</groupId>
<artifactId>h2</artifactId>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<scope>runtime</scope>
</dependency>
</dependencies>

Step 4: Configure Database in application.properties

For MySQL configuration, add the following to src/main/resources/application.properties:

spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=root
spring.datasource.password=yourpassword
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

spring.jpa.database-platform=org.hibernate.dialect.MySQL8Dialect
spring.jpa.hibernate.ddl-auto=update

Step 5: Create Entity Class

Next, we need to create an entity class to represent our data model. In this example, we will create a “Product” entity class.

Right-click on the “com.example” package and create a package called entity inside it.
Enter “Product” as the class name in the “entity” package and click on the “Finish” button.
In the “Product” class, add the following code:

Java

package com.example.entity; import javax.persistence.*;  @Entity @Table(name = "product") public class Product {      @Id     @GeneratedValue(strategy = GenerationType.IDENTITY)     private Long id;      @Column(nullable = false)     private String name;      @Column(nullable = false)     private double price;      @Column(nullable = false)     private int quantity;      // Constructors, getters and setters, and other methods...      // Getters     public Long getId() {         return id;     }      public String getName() {         return name;     }      public double getPrice() {         return price;     }      public int getQuantity() {         return quantity;     }      // Setters     public void setId(Long id) {         this.id = id;     }      public void setName(String name) {         this.name = name;     }      public void setPrice(double price) {         this.price = price;     }      public void setQuantity(int quantity) {         this.quantity = quantity;     } }

The @Entity annotation specifies that this class is an entity and should be mapped to a database table. The @Table annotation specifies the name of the database table that will store instances of this entity. The @Id annotation specifies the primary key of the entity, while the @GeneratedValue annotation specifies that the primary key should be generated automatically.

Step 6: Create Repository Interface

Now, we need to create a repository interface to handle database operations for the “Product” entity. In the “ProductRepository” interface, add the following code:

Java

package com.example.springbootapi.repository;  import com.example.springbootapi.entity.Product; import org.springframework.data.jpa.repository.JpaRepository; import org.springframework.stereotype.Repository;  /**  * Repository interface for Product entity.  */ @Repository public interface ProductRepository extends JpaRepository<Product, Long> { }

The @Repository annotation specifies that this interface is a repository, and Spring will create an instance of it automatically. The JpaRepository interface provides a set of methods for performing CRUD (Create, Read, Update, Delete) operations on the “Product” entity.

Step 7: Create a Service Class

Next, we need to create a service class to handle the business logic for our REST API. In the “ProductService” class, add the following code:

Java

package com.example.springbootapi.service;  import com.example.springbootapi.entity.Product; import com.example.springbootapi.repository.ProductRepository; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service;  import java.util.List; import java.util.Optional;  /**  * Service class for managing Product entities.  */ @Service public class ProductService {      private final ProductRepository productRepository;      @Autowired     public ProductService(ProductRepository productRepository) {         this.productRepository = productRepository;     }      /**      * Save a product.      *      * @param product the entity to save      * @return the persisted entity      */     public Product saveProduct(Product product) {         return productRepository.save(product);     }      /**      * Get all the products.      *      * @return the list of entities      */     public List<Product> getAllProducts() {         return productRepository.findAll();     }      /**      * Get one product by ID.      *      * @param id the ID of the entity      * @return the entity      */     public Optional<Product> getProductById(Long id) {         return productRepository.findById(id);     }      /**      * Update a product.      *      * @param id the ID of the entity      * @param updatedProduct the updated entity      * @return the updated entity      */     public Product updateProduct(Long id, Product updatedProduct) {         Optional<Product> existingProduct = productRepository.findById(id);         if (existingProduct.isPresent()) {             Product product = existingProduct.get();             product.setName(updatedProduct.getName());             product.setPrice(updatedProduct.getPrice());             product.setQuantity(updatedProduct.getQuantity());             return productRepository.save(product);         } else {             throw new RuntimeException("Product not found");         }     }      /**      * Delete the product by ID.      *      * @param id the ID of the entity      */     public void deleteProduct(Long id) {         productRepository.deleteById(id);     } }

For saving a product in the database we will use the following code:

// Save Product
@PostMapping
public ResponseEntity<Product> saveProduct(@RequestBody Product product) {
Product newProduct = productRepository.save(product);
return ResponseEntity.ok(newProduct);
}

For getting all products from the database we will use the following code:

// Get all products
@GetMapping
public ResponseEntity<List<Product>> fetchAllProducts() {
return ResponseEntity.ok(productRepository.findAll());
}

For getting a single product from the database we will use the following code:

// Get a product by ID
@GetMapping("/{id}")
public ResponseEntity<Product> fetchProductById(@PathVariable Long id) {
return productRepository.findById(id)
.map(ResponseEntity::ok)
.orElseGet(() -> ResponseEntity.notFound().build());
}

For updating a single product from the database, we will use the following code:

// Update a product
@PutMapping("/{id}")
public ResponseEntity<Product> updateProduct(@PathVariable Long id, @RequestBody Product updatedProduct) {
Product existingProduct = productRepository.findById(id)
.orElseThrow(() -> new EntityNotFoundException("Product with ID " + id + " not found"));

existingProduct.setName(updatedProduct.getName());
existingProduct.setPrice(updatedProduct.getPrice());
existingProduct.setQuantity(updatedProduct.getQuantity());

return ResponseEntity.ok(productRepository.save(existingProduct));
}

For deleting a single product from the database, we will use the following code:

// Delete a product
@DeleteMapping("/{id}")
public ResponseEntity<String> deleteProduct(@PathVariable Long id) {
if (!productRepository.existsById(id)) {
return ResponseEntity.status(HttpStatus.NOT_FOUND).body("Product not found");
}

productRepository.deleteById(id);
return ResponseEntity.ok("Product Deleted Successfully");
}

Step 8: Create Controller Class

Next, we need to create a controller class to handle HTTP requests for our REST API. In the “ProductController” class, add the following code:

Java

package com.example.springbootapi.controller;  import com.example.springbootapi.entity.Product; import com.example.springbootapi.service.ProductService; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.http.ResponseEntity; import org.springframework.web.bind.annotation.*;  import java.util.List; import java.util.Optional;  @RestController @RequestMapping("/api/v1") public class ProductController {      private final ProductService productService;      @Autowired     public ProductController(ProductService productService) {         this.productService = productService;     }      /**      * Create a new product.      *      * @param product the product to create      * @return the ResponseEntity with status 200 (OK) and with body of the new product      */     @PostMapping("/product")     public ResponseEntity<Product> saveProduct(@RequestBody Product product) {         Product newProduct = productService.saveProduct(product);         return ResponseEntity.ok(newProduct);     }      /**      * Get all products.      *      * @return the ResponseEntity with status 200 (OK) and with body of the list of products      */     @GetMapping("/products")     public List<Product> getAllProducts() {         return productService.getAllProducts();     }      /**      * Get a product by ID.      *      * @param id the ID of the product to get      * @return the ResponseEntity with status 200 (OK) and with body of the product, or with status 404 (Not Found) if the product does not exist      */     @GetMapping("/products/{id}")     public ResponseEntity<Product> getProductById(@PathVariable Long id) {         Optional<Product> product = productService.getProductById(id);         return product.map(ResponseEntity::ok).orElseGet(() -> ResponseEntity.notFound().build());     }      /**      * Update a product by ID.      *      * @param id the ID of the product to update      * @param product the updated product      * @return the ResponseEntity with status 200 (OK) and with body of the updated product, or with status 404 (Not Found) if the product does not exist      */     @PutMapping("/products/{id}")     public ResponseEntity<Product> updateProduct(@PathVariable Long id, @RequestBody Product product) {         Product updatedProduct = productService.updateProduct(id, product);         return ResponseEntity.ok(updatedProduct);     }      /**      * Delete a product by ID.      *      * @param id the ID of the product to delete      * @return the ResponseEntity with status 200 (OK) and with body of the message "Product deleted successfully"      */     @DeleteMapping("/products/{id}")     public ResponseEntity<String> deleteProduct(@PathVariable Long id) {         productService.deleteProduct(id);         return ResponseEntity.ok("Product deleted successfully");     } }

The @RestController annotation specifies that this class is a controller for RESTful API requests. The @RequestMapping annotation specifies the base URL for all requests handled by this controller.

Next, we need to add methods to handle HTTP requests. In this example, we will add methods to handle GET, POST, PUT, and DELETE requests.

For Post Request, we will be using the following code:

// Create a new Product @PostMapping("/product") public ResponseEntity<Product> saveProduct(@RequestBody Product product) { Product newProduct = productService.saveProduct(product); return ResponseEntity.ok(newProduct); }

The @PostMapping annotation is used to indicate that this class will handle HTTP Post requests and return the response as JSON. It is used to map the /api/v1/products path to this class. @RequestBody is an annotation in Spring Framework used to bind the HTTP request body to a parameter in a controller method. When a client sends an HTTP POST or PUT request, it may include data in the request body. This data is typically in JSON or XML format and contains information about the resource being created or updated.

For Get Request all the products, we will be using the following code:

// Get all Products @GetMapping("/products") public List<Product> getAllProducts() { return productService.getAllProducts(); }

The @GetMapping annotation is used to indicate that this class will handle HTTP Get requests and return the response as JSON. It is used to map the /api/v1/products path to this class. Here the getAllProducts() method fetches all the products and has a path/products.

For Get Request of a single product, we will be using the following code:

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

The @PathVariable annotation is used to extract data from the URL path of an HTTP request. It is used to capture dynamic segments of a URL and map them to a method parameter in a Spring Boot controller. getProductById() method is used to get a product by id and has a path /products/{id}.

For Update Requests, we will be using the following code:

// Update Product @PutMapping("/products/{id}") public ResponseEntity<Product> updateProduct(@PathVariable Long id, @RequestBody Product product) { Product updatedProduct = productService.updateProduct(id, product); return ResponseEntity.ok(updatedProduct); }

In this example, we’ve added a @PutMapping annotation for the updateProduct() method. The @PutMapping annotation is used to map HTTP PUT requests to the /product/{id} endpoint, where {id} is a path variable for the product ID. The @RequestBody annotation is used to bind the request body to the product parameter in the method. When a PUT request is made to /api/v1/product/{id}, the updateProduct() method will be executed with the id parameter set to the product ID from the URL path and the product.

For Delete Requests, we will be using the following code:

// Delete a Product @DeleteMapping("/products/{id}") public ResponseEntity<String> deleteProduct(@PathVariable Long id) { productService.deleteProduct(id); return ResponseEntity.ok("Product deleted successfully"); }

Now, we are completed with the programming side and just remain with the database and then test the endpoints and then we are done.

Now, after this, we will test our API endpoints in postman. The default port for Spring Boot is 8080. You can change the port by using the command inside the application.properties file: