📘 Premium Read: Access my best content on
Medium member-only articles
— deep dives into Java, Spring Boot, Microservices, backend architecture, interview preparation, career advice, and industry-standard best practices.
🎓 Top 15 Udemy Courses (80-90% Discount):
My Udemy Courses - Ramesh Fadatare
— All my Udemy courses are real-time and project oriented courses.
▶️ Subscribe to My YouTube Channel (176K+ subscribers):
Java Guides on YouTube
▶️ For AI, ChatGPT, Web, Tech, and Generative AI, subscribe to another channel:
Ramesh Fadatare on YouTube
In this tutorial, we will learn how to use @PostMapping annotation in a Spring Boot application to handle HTTP POST requests.
@PostMapping Annotation Overview
The POST HTTP method is used to create a resource and @PostMapping annotation for mapping HTTP POST requests onto specific handler methods.
Specifically, @PostMapping is a composed annotation that acts as a shortcut for @RequestMapping(method = RequestMethod.POST).
@PostMapping annotation takes the following optional elements
consumes – Narrows the primary mapping by media types that can be consumed by the mapped handler.
headers – The headers of the mapped request, narrowing the primary mapping.
name – Assign a name to this mapping.
params – The parameters of the mapped request, narrowing the primary mapping.
path – The primary mapping expressed by this annotation.
produces – Narrows the primary mapping by media types that can be produced by the mapped handler.
value – The primary mapping expressed by this annotation.
@PostMapping Annotation Example
Let's build a simple Spring Boot project using IntelliJ IDEA to demonstrate the usage of @PostMapping annotation.
We will use Spring Data JPA to develop a repository layer and MySQL database at the backend. We will use the Postman client to test the REST API.
1. Create a Spring boot application
Spring Boot provides a web tool called
Spring Initializer to bootstrap an application quickly. Just go to
https://start.spring.io/ and generate a new spring boot project.
While generating the Spring Boot Project, make sure that you have added the following Maven dependencies:
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>com.mysql</groupId>
<artifactId>mysql-connector-j</artifactId>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<optional>true</optional>
</dependency>
Download the Spring Boot project as a zip file, unzip it, and import it into IntelliJ IDEA.
2. Configure MySQL Database
Since we’re using MySQL as our database, we need to configure the database URL, username, and password so that Spring can establish a connection with the database on startup.
Open the
src/main/resources/application.properties file and add the following properties to it:
spring.datasource.url=jdbc:mysql://localhost:3306/todo_management
spring.datasource.username=root
spring.datasource.password=Mysql@123
spring.jpa.properties.hibernate.dialect = org.hibernate.dialect.MySQLDialect
spring.jpa.hibernate.ddl-auto = update
Don’t forget to change the
spring.datasource.username and spring.datasource.password as per your MySQL installation. Also, create a database named
todo_management in MySQL before proceeding to the next section.
You don’t need to create any tables. The tables will automatically be created by Hibernate from the
Todo entity that we will define in the next step. This is made possible by the property
spring.jpa.hibernate.ddl-auto = update.
3. Create Model Layer - Todo JPA Entity
Let's create a class named
Todo and add the following content to it:
import jakarta.persistence.*;
import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
@Setter
@Getter
@NoArgsConstructor
@AllArgsConstructor
@Entity
@Table(name = "todos")
public class Todo {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
@Column(nullable = false)
private String title;
@Column(nullable = false)
private String description;
private boolean completed;
}
@Setter, @Getter, @NoArgsConstructor, and @AllArgsConstructor annotations are provided by the Lombok library and are used to generate getter and setter methods, a no-argument constructor, and an all-arguments constructor for the class.
The @Entity annotation indicates that the class is an entity in JPA, representing a table in a relational database.
The @Table annotation specifies the name of the table that corresponds to this entity. In this case, the table name is "todos".
The @Id annotation marks the field id as the primary key for the entity.
The @GeneratedValue annotation specifies the strategy for generating the primary key values. In this case, the GenerationType.IDENTITY strategy is used, which indicates that the database will automatically assign a unique identifier to each new entity.
The @Column annotation is used to specify the mapping of the field title to a column in the database table.
4. Create Repository Layer - TodoRepository
Now, we gonna create a Spring Data JPA repository to talk with the MySQL database. Let's create the following TodoRepository interface and add the following content to it:
import net.javaguides.todo.entity.Todo;
import org.springframework.data.jpa.repository.JpaRepository;
public interface TodoRepository extends JpaRepository<Todo, Long> {
}
5. Create DTO Class - TodoDto
Let's create TodoDto class to transfer the data between the client and server:
import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
@Setter
@Getter
@NoArgsConstructor
@AllArgsConstructor
public class TodoDto {
private Long id;
private String title;
private String description;
private boolean completed;
}
Note that we will be using TodoDto class in the request and response of the REST APIs.
6. Create Service Layer - TodoService interface and TodoServiceImpl class
TodoService interface
Let's create a TodoService interface and add the following code to it:
import net.javaguides.todo.dto.TodoDto;
public interface TodoService {
TodoDto addTodo(TodoDto todoDto);
}
TodoServiceImpl class
Let's create a TodoServiceImpl class that implements the TodoService interface and its method:
import lombok.AllArgsConstructor;
import net.javaguides.todo.dto.TodoDto;
import net.javaguides.todo.entity.Todo;
import net.javaguides.todo.repository.TodoRepository;
import net.javaguides.todo.service.TodoService;
import org.springframework.stereotype.Service;
@Service
@AllArgsConstructor
public class TodoServiceImpl implements TodoService {
private TodoRepository todoRepository;
@Override
public TodoDto addTodo(TodoDto todoDto) {
// convert TodoDto into Todo Jpa entity
Todo todo = new Todo();
todo.setTitle(todoDto.getTitle());
todo.setDescription(todoDto.getDescription());
todo.setCompleted(todo.isCompleted());
// Todo Jpa entity
Todo savedTodo = todoRepository.save(todo);
// Convert saved Todo Jpa entity object into TodoDto object
TodoDto savedTodoDto = new TodoDto();
savedTodoDto.setId(savedTodo.getId());
savedTodoDto.setTitle(savedTodo.getTitle());
savedTodoDto.setDescription(savedTodo.getDescription());
savedTodoDto.setCompleted(savedTodo.isCompleted());
return savedTodoDto;
}
}
7. Controller Layer - TodoController
Let's create TodoController class and build Add Todo REST API that handles HTTP POST requests:
import lombok.AllArgsConstructor;
import net.javaguides.todo.dto.TodoDto;
import net.javaguides.todo.service.TodoService;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
@RestController
@RequestMapping("api/todos")
@AllArgsConstructor
public class TodoController {
private TodoService todoService;
// Build Add Todo REST API
@PostMapping
public ResponseEntity<TodoDto> addTodo(@RequestBody TodoDto todoDto){
TodoDto savedTodo = todoService.addTodo(todoDto);
return new ResponseEntity<>(savedTodo, HttpStatus.CREATED);
}
}
The
@RestController annotation is used to indicate that this class is a REST controller, which means it handles incoming HTTP requests and returns the corresponding responses.
The @AllArgsConstructor annotation is provided by the Lombok library and generates a constructor with arguments for the class.
The @PostMapping annotation maps this method to the HTTP POST method for the base URL path "api/todos".
// Build Add Todo REST API
@PostMapping
public ResponseEntity<TodoDto> addTodo(@RequestBody TodoDto todoDto){
TodoDto savedTodo = todoService.addTodo(todoDto);
return new ResponseEntity<>(savedTodo, HttpStatus.CREATED);
}
The @RequestBody annotation is used to bind the request body to the TodoDto object, which represents the Todo item to be added.
Finally, a
ResponseEntity object is returned with the
saved Todo object as the body and the HTTP status code
HttpStatus.CREATED indicating the successful creation of the resource.
8. Start Spring Boot Application and Test POST REST API
Test Add Todo REST API:
Let's use Create Todo REST API to insert a todo into the database:9. Conclusion
In conclusion, this blog post provided an example of using the @PostMapping annotation in a Spring Boot application.
The @PostMapping annotation is used to handle HTTP POST requests and is commonly used for creating resources in RESTful APIs.
Related Spring and Spring Boot Annotations
Related Spring Boot and Microservices Tutorials/Guides:
The Hidden Magic of Spring Boot: Secrets Every Developer Should Know
What Happens When You Hit a Spring Boot REST API Endpoint (Behind the Scenes)
Spring Boot Exception Handling
Build CRUD REST API with Spring Boot, Spring Data JPA, Hibernate, and MySQL
Spring Boot DELETE REST API: @DeleteMapping Annotation
Spring Boot PUT REST API — @PutMapping Annotation
Spring Boot POST REST API
Spring Boot GET REST API — @GetMapping Annotation
Spring Boot REST API with Request Param | Spring Boot Course
Spring Boot REST API with Path Variable — @PathVariable
Chapter 13: Understanding @SpringBootApplication Annotation | Spring Boot Course
Chapter 5: Create Spring Boot Project and Build Hello World REST API | Spring Boot Course
10 Real-World Spring Boot Architecture Tips Every Developer Should Follow
Top 10 Spring Boot Tricks Every Java Developer Should Know
Debugging Spring Dependency Injection Issues - Very Important
Common Code Smells in Spring Applications — How to Fix Them
Spring Boot + OpenAI ChatGPT API Integration Tutorial
Spring Boot Course -> New Series on Medium ❤️
Spring Boot Microservices with RabbitMQ Example
React JS + Spring Boot Microservices
Dockerizing a Spring Boot Application
How to Change the Default Port in Spring Boot
How to Change Context Path in Spring Boot
Top 10 Spring Boot REST API Mistakes and How to Avoid Them (2025 Update)
Spring Boot REST API Best Practices
Spring Boot Security Database Authentication Example Tutorial
Spring Boot Security Form-Based Authentication
Spring Boot Security In-Memory Authentication
What is Spring Boot Really All About?
Why Spring Boot over Spring?
Top 10 Spring Boot Key Features That You Should Know
Spring vs Spring Boot
Setting Up the Development Environment for Spring Boot
Spring Boot Auto-Configuration: A Quick Guide
Spring Boot Starters
Quick Guide to Spring Boot Parent Starter
Spring Boot Embedded Servers
Spring Boot Thymeleaf Hello World Example
Chapter 10: Spring Boot DevTools | Spring Boot Course
Chapter 13: Spring Boot REST API That Returns JSON | Spring Boot Course
Spring Boot REST API That Returns List of Java Objects in JSON Format
Top 10 Spring Boot Mistakes and How to Avoid Them
Advanced Spring Boot Concepts that Every Java Developer Should Know
What Are Microservices in Spring Boot?
Integrating React Frontend with Spring Boot ChatGPT API (Step-by-Step Guide)
Build a Chatbot Using Spring Boot, React JS, and ChatGPT API
Top 10 Mistakes in Spring Boot Microservices and How to Avoid Them (With Examples)
Spring Boot Security Best Practices: Protecting Your Application from Attacks
🔄 Dependency Injection in Spring (Explained with Coding Examples)
⚙️ How Spring Container Works Behind the Scenes
How Spring Container Works Behind the Scenes (Spring Container Secrets Revealed!)
Spring @Component vs @Bean vs @Service vs @Repository Explained
How Component Scanning Works Behind the Scenes in Spring
How Spring Autowiring Works Internally
Top 20 Spring Boot Best Practices for Java Developers
Build Spring Boot React Full Stack Project — Todo App [2025 Update]
Spring vs Spring MVC vs Spring Boot
Spring Boot Best Practices: Use DTOs Instead of Entities in API Responses
Spring Boot DTO Tutorial (Using Java record) – Complete CRUD REST API Implementation
Spring Boot Architecture: Controller, Service, Repository, Database and Architecture Flow
Java Stream filter() Method with Real-World Examples
Spring Boot Auto Configuration Explained | How It Works
Spring Boot Profiles: How to Manage Environment-Based Configurations
Create a Custom Spring Boot Starter | Step-by-Step Guide
Spring Boot Starter Modules Explained | Auto-Configuration Guide
Deploy Spring Boot Applications with Profile-Based Settings | Step-by-Step Guide
Spring Boot Performance Tuning: 10 Best Practices for High Performance
Spring Boot @ComponentScan Annotation | Customizing Component Scanning
Difference Between @RestController and @RequestMapping in Spring Boot
Spring Boot @Cacheable Annotation – Improve Performance with Caching
Spring Boot Redis Cache — @Cacheable Complete Guide
When to Use @Service, @Repository, @Controller, and @Component Annotations in Spring Boot
Why, When, and How to Use @Bean Annotation in Spring Boot App
Java Spring Boot vs. Go (Golang) for Backend Development in 2025
Is Autowired Annotation Deprecated in Spring Boot? Everything You Need to Know
🚫 Stop Making These Common Mistakes in Spring Boot Projects
Top 10 Mind-Blowing Spring Boot Tricks for Beginners
Why Choose Spring Boot Over Spring Framework? | Key Differences and Benefits
How to Run a Spring Boot Application | 5 Easy Ways for Developers
What is AutoConfiguration in Spring Boot? | Explained with Example
Customize Default Configuration in Spring Boot | 5 Proven Ways
Chapter 12: Understanding SpringApplication.run() Method Internals | Spring Boot Course
What is CommandLineRunner in Spring Boot?
How to Create Custom Bean Validation in Spring Boot
Can You Build a Non-Web Application with Spring Boot?
How to Disable Auto-Configuration in Spring Boot (Step-by-Step Guide)
Top 25 Spring Boot Interview Questions and Answers for Beginners
How to Use Java Records with Spring Boot
Spring Boot Constructor Injection Explained with Step-by-Step Example
🚫 Stop Using @Transactional Everywhere: Understand When You Actually Need It
🚫 Stop Writing Fat Controllers: Follow the Controller-Service-Repository Pattern
🚫 Stop Using Field Injection in Spring Boot: Use Constructor Injection
🚫 Stop Sharing Databases Between Microservices: Use Database Per Service Pattern
10 Java Microservices Best Practices Every Developer Should Follow
How to Choose the Right Java Microservices Communication Style (Sync vs Async)
How to Implement Event-Driven Communication in Java Microservices (Step-by-Step Guide with Kafka)
Stop Building Tight-Coupled Microservices: Aim for Loose Coupling
Spring Boot Microservices E-Commerce Project: Step-by-Step Guide
Spring Boot Microservices with RabbitMQ Example
React JS + Spring Boot Microservices
The Ultimate Microservices Roadmap for Beginners: Building Modern Scalable Systems
What Are Microservices in Spring Boot?
Top 5 Message Brokers Every Developer Should Know
Top 10 Spring Cloud Microservices Best Practices [Removed Deprecated Features]
Best Tools for Microservices Development in 2025
How to Break a Monolithic Application into Microservices (E-Commerce Use Case)
Monoliths Aren’t Dead — Microservices Are Just Overused
When to Break a Monolith: A Developer’s Checklist
👑 Java Is Still the King of Microservices — And Here’s the Proof
5 Microservices Design Patterns You Must Know in 2025
Bulkhead Pattern in Microservices — Improve Resilience and Fault Isolation
Strangler Fig Pattern in Microservices — Migrate Monolith to Microservices
Event Sourcing Pattern in Microservices (With Real-World Example)
Circuit Breaker Pattern in Microservices using Spring Boot 3, WebClient and Resilience4j
CQRS Pattern in Microservices
Aggregator Design Pattern in Microservices — A Complete Guide
Database Per Service Pattern in Microservices
API Gateway Pattern in Microservices — A Complete Guide
Saga Pattern in Microservices: A Step-by-Step Guide
Microservices Are a Mess Without These Java Design Patterns️
Java Microservices Interview Questions and Answers for Freshers
Top Microservices Interview Questions and Answers for Experienced Professionals
Top 10 Microservices Design Pattern Interview Questions and Answers
Top Microservices Tricky Interview Questions You Should Know (With Answers)
Microservices Best Practices: Building Scalable and Resilient Systems
Why Microservices Are the Future of Software Architecture
Microservices with Spring Cloud: Simplify Your Architecture
Spring Boot and Microservices Roadmap for Beginners [2025 Update]
Best Programming Language for Microservices Project Development in 2025
My 50+ Must-Read Microservices Tutorials, Articles and Guides on the Medium Platform
Comments
Post a Comment
Leave Comment