How to Make Post Request in Java Spring?

Making a POST request in a Spring Boot application typically involves sending data to an external service or endpoint. Spring provides the RestTemplate and the newer WebClient classes for this purpose.

Below are examples demonstrating how to make POST requests using both RestTemplate and WebClient.

Using RestTemplate:

Add Dependency: Add Spring Boot Starter Web to your pom.xml:

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

Code Example: Use RestTemplate to make a POST request:

import org.springframework.web.client.RestTemplate;

public class RestTemplatePostExample {
    public static void main(String[] args) {
        RestTemplate restTemplate = new RestTemplate();
        String url = "https://jsonplaceholder.typicode.com/posts";

        // Data to send
        Post post = new Post();
        post.setTitle("Sample Title");
        post.setBody("Sample Body");
        post.setUserId(1L);

        // Make POST request
        Post response = restTemplate.postForObject(url, post, Post.class);
        System.out.println("Response ID: " + response.getId());
    }
}

// Define classes to capture the data and response
class Post {
    private Long id;
    private Long userId;
    private String title;
    private String body;

    // getters and setters
}

Using WebClient:

Add Dependency: Add Spring Boot Starter WebFlux to your pom.xml:

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

Code Example: Use WebClient to make a POST request:

import org.springframework.web.reactive.function.client.WebClient;

public class WebClientPostExample {
    public static void main(String[] args) {
        WebClient webClient = WebClient.create();
        String url = "https://jsonplaceholder.typicode.com/posts";

        // Data to send
        Post post = new Post();
        post.setTitle("Sample Title");
        post.setBody("Sample Body");
        post.setUserId(1L);

        // Make POST request
        Post response = webClient.post()
                .uri(url)
                .bodyValue(post)
                .retrieve()
                .bodyToMono(Post.class)
                .block();

        System.out.println("Response ID: " + response.getId());
    }
}

// Define a class to capture the data and response
class Post {
    private Long id;
    private Long userId;
    private String title;
    private String body;

    // getters and setters
}

In both examples, we're using the free JSONPlaceholder API to simulate a POST request, and the data sent in the POST request is captured in the Post object.

Feel free to adjust these examples to meet the requirements of your application.

Spring MVC POST request example:

Description: Handling a POST request in Spring MVC involves creating a controller method annotated with @PostMapping and specifying the resource to create.

Code snippet (Java):

@Controller
@RequestMapping("/api")
public class ApiController {

    @PostMapping("/create")
    public ResponseEntity<String> createResource(@RequestBody Resource resource) {
        // Logic to create the resource
        // ...

        return ResponseEntity.ok("Resource created successfully");
    }
}

RestTemplate POST request in Spring:

Description: Making a POST request using RestTemplate involves using the postForObject() method and specifying the URL, request object, and any path variables.

Code snippet (Java):

RestTemplate restTemplate = new RestTemplate();

String url = "http://localhost:8080/api/create";
Resource newResource = new Resource(/*...*/);

ResponseEntity<String> response = restTemplate.postForEntity(url, newResource, String.class);

Spring WebClient POST example:

Description: Using WebClient for POST requests involves creating a WebClient instance and using the post() method.

Code snippet (Java):

WebClient webClient = WebClient.create("http://localhost:8080");

Resource newResource = new Resource(/*...*/);

String response = webClient
    .post()
    .uri("/api/create")
    .body(Mono.just(newResource), Resource.class)
    .retrieve()
    .bodyToMono(String.class)
    .block();

Post mapping in Spring Controller:

Description: Using @PostMapping annotation in a Spring Controller provides a convenient way to handle POST requests for a specific mapping.

Code snippet (Java):

@Controller
@RequestMapping("/resources")
public class ResourceController {

    @PostMapping("/create")
    public ResponseEntity<String> createResource(@RequestBody Resource resource) {
        // Logic to create the resource
        // ...

        return ResponseEntity.ok("Resource created successfully");
    }
}

Spring Data JPA save method:

Description: Spring Data JPA provides a convenient way to save entities using the save() method.

Code snippet (Java):

public interface ResourceRepository extends JpaRepository<Resource, Long> {
    // Spring Data JPA automatically generates save method
}

Usage:

Resource newResource = new Resource(/*...*/);
resourceRepository.save(newResource);

HTTP POST request in Spring Rest API:

Description: Handling a POST request in a Spring Rest API involves using @PostMapping in a controller method.

Code snippet (Java):

@RestController
@RequestMapping("/api")
public class ApiController {

    @PostMapping("/create")
    public ResponseEntity<String> createResource(@RequestBody Resource resource) {
        // Logic to create the resource
        // ...

        return ResponseEntity.ok("Resource created successfully");
    }
}

Spring MVC post request with RequestBody:

Description: Handling a POST request in Spring MVC with @RequestBody involves accepting the request body as a parameter in the controller method.

Code snippet (Java):

@Controller
@RequestMapping("/resources")
public class ResourceController {

    @PostMapping("/create")
    public ResponseEntity<String> createResource(@RequestBody Resource resource) {
        // Logic to create the resource
        // ...

        return ResponseEntity.ok("Resource created successfully");
    }
}

RestAssured POST request in Spring Boot:

Description: Using RestAssured for POST requests in Spring Boot involves specifying the URL and request body.

Code snippet (Java):

RestAssured.baseURI = "http://localhost:8080";

Resource newResource = new Resource(/*...*/);

String response = given()
    .contentType(ContentType.JSON)
    .body(newResource)
.when()
    .post("/api/create")
.then()
    .extract()
    .asString();

Spring POST request with RequestMapping:

Description: Handling a POST request in Spring with @RequestMapping involves specifying the method as POST and the path.

Code snippet (Java):

@Controller
@RequestMapping("/api")
public class ApiController {

    @RequestMapping(value = "/create", method = RequestMethod.POST)
    public ResponseEntity<String> createResource(@RequestBody Resource resource) {
        // Logic to create the resource
        // ...

        return ResponseEntity.ok("Resource created successfully");
    }
}