Java resttemplate post json

How to send JSON via POST request using RestTemplate in Spring | PostForObject, PostForEntity, and PostLocation Example in Java

Hello guys, if you are wondering how to send a Post request with Json in Java application using Spring framework then you have come to the right place. Earlier, I have shown how to consume JSON from a RESTful AP I and In this tutorial, we are going to discuss how to send POST requests via RestTemplate in JSON. We will have an example project which is having POST API and then test it by sending request body along with request headers using postEntry() . POST requests can be made using the RestTemplate class’s postForObject() , postForEntity() , and postForLocation() template methods. The first two techniques are fairly similar to what I covered in the GET request lesson for RestTemplate . Instead of returning the whole resource, the last method returns the location of the newly formed resource.

How to send JSON with POST request in Java RESTful API using Spring RestTempalte

So let’s start our example application where you will learn how to send JSON to the server using a POST request using RestTemplate and its various post methods like PostForObject , PostForEntity , andPostForLocation with having the pom.xml file updated.

1. Add maven dependencies to your project.

To allow loading of the spring text context, bean initialization, and dependency management, include the spring-boot-starter-test dependency in the project.

  org.springframework.boot spring-boot-starter-test test 

2. Setting up an example project.

Let’s start our project by having the Student model class represent the data.

package com.school.model; public class Student  private String firstName; private String lastName; private int age; public String getFirstName()  return firstName; > public void setFirstName(String firstName)  this.firstName = firstName; > public String getLastName()  return lastName; > public void setLastName(String lastName)  this.lastName = lastName; > public int getAge()  return age; > public void setAge(int age)  this.age = age; > >

Here we are using the h2 database to store our data. The StudentRepository class looks like below.

import org.springframework.data.jpa.repository.JpaRepository; public interface StudentRepository extends JpaRepository  Student, Integer >  Student findById(int id); >

To add the students and update them, we use the IStudentService interface and implementation of them as below

import java.util.List; public interface IStudentService  Student saveStudent(Student student); Student getStudentById(Integer id); >

So we are going to implement these services in the StudentServiceImpl class in the project.

import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service; @Service public class StudentServiceImpl implements IStudentService  @Autowired StudentRepository studentRepository; //add a new student to h2 database @Override public String saveStudent(Cards card)  try  studentRepository.save(card); return "Saved to database successfully !"; > catch (Exception e)  e.printStackTrace(); return "Error in saving the value"; > > //get the specific student from the h2 database @Override public Student getStudentById(String cardNumber)  return studentRepository.findById(cardNumber); > >

So let’s define the REST APIs for these services in the StudentController class.

@Controller public class StudentController  @Autowired StudentServiceImpl studentService; @PostMapping( value = "/addstudent", consumes = "application/json", produces = "application/json") public Person createPerson(@RequestBody Student student)  return studentService.saveStudent(student); > @PostMapping( value = "/updatestudent", consumes = "application/json", produces = "application/json") public Student updateStudent(@RequestBody Student student, HttpServletResponse response)  response.setHeader("Location", ServletUriComponentsBuilder.fromCurrentContextPath() .path("/findStudent/" + student.getId()).toUriString()); return studentService.saveStudent(student); > >

For both approaches, we used the @RequestBody annotation on the Student argument. This instructs
Spring to bind the student object to the body of the HTTP request. And also we added the consumes
attribute in the @PostMapping annotation with the value of «application/json» for both methods.

3. RestTemplate Example

Here, we will try to send POST requests to the person API by using the POST methods provided
by the RestTemplate. We are using the postForObject, postForEntity, and postForLocation methods in this example. Before, going into the implementation of our unit tests, let’s define a setup method to initialize the objects.

@BeforeClass public static void runBeforeAllTestMethods()  createPersonUrl = "http://localhost:8080/addstudent"; updatePersonUrl = "http://localhost:8080/updatestudent"; restTemplate = new RestTemplate(); headers = new HttpHeaders(); headers.setContentType(MediaType.APPLICATION_JSON); JsonObjectStudent = new JSONObject(); JsonObjectStudent.put("id", 1); JsonObjectStudent.put("name", "John"); >

As we want the post data in JSON format , we can add the Content-Type header to our request with
APPLICATION_JSON media type.

4. PostForEntity Example

This is returning the response as a ResponseEntity object. Let’s get an example as the POST
request to the Student API to create a new Student object and return the response as a ResponseEntity.

@Test public void postforEnityMethod() throws IOException  HttpEntity  String > request = new HttpEntity  String > (.toString(), headers); ResponseEntity  String > responseEntityStr = restTemplate. postForEntity(JsonObjectStudent, request, String.class); JsonNode root = objectMapper.readTree(responseEntityStr.getBody()); assertNotNull(responseEntityStr.getBody()); assertNotNull(root.path("name").asText()); >

Here, there is a responseType parameter to convert the response body to the requested java type.
Here we were able to return the response body as a ResponseEntity .

5. PostForObject Example

Here, first, we are going to make the HttpEntity based on the HttpEntity on studentJsonObject containing headers of Content-Type.

@Test public void postJsonObject() throws IOException  HttpEntity  String > request = new HttpEntity  String > (studentJsonObject.toString(), headers); String personResultAsJsonStr = restTemplate.postForObject(createStudentUrl, request, String.class); JsonNode root = objectMapper.readTree(personResultAsJsonStr); assertNotNull(studentResultInJsonUrl); assertNotNull(root); assertNotNull(root.path("name").asText()); >

This method will return the requested body as a string. postForObject() may automatically convert the response body to the Java type given in the responseType argument (e.g. String, Person).

6. PostForLocation Example

The postForLocation() method, like the postForObject() and postForEntity methods,
generates a new resource by publishing the provided object to the specified URI. The only difference is that the value of the Location header is returned.

So think if you want to return the LocationHeader of the response after updating the student object we posted.

@Test public void postJsonLocationObject() throws JsonProcessingException  HttpEntity  String > request = new HttpEntity String> (studentJsonObject.toString(), headers); URI locationHeader = restTemplate.postForLocation(updateStudentUrl, request); assertNotNull(locationHeader); >

So let’s discuss a question that may arise from using the POST request via RestTemplate in JSON .

In here, the RestTemplate is used like below

restTemplate = new RestTemplate(); ListHttpMessageConverter> list = new ArrayListHttpMessageConverter>(); list.add(new MappingJacksonHttpMessageConverter()); restTemplate.setMessageConverters(list); . Payment payment= new Payment("Aa4bhs"); Payment res = restTemplate.postForObject("http://localhost:8080/aurest/rest/payment", payment, Payment.class);

So everytime using this method, will get an error like below.
org.springframework.web.client.HttpClientErrorException: 415 Unsupported Media Type

How to fix org.springframework.web.client.HttpClientErrorException: 415 Unsupported Media Type exception in Spring

If you are using Spring 3.0, an easy way to avoid the org.springframework.web.client.HttpClientErrorException: 415 Unsupported Media Type exception , is to include the Jackson jar files in your classpath, and use mvc:annotation-driven config element.

Underneath the covers, Spring MVC delegates to a HttpMessageConverter to perform the serialization. In this case, Spring MVC invokes a MappingJacksonHttpMessageConverter built on the Jackson JSON processor.

This implementation is enabled automatically when you use the mvc:annotation-driven configuration element with Jackson present in your classpath .

So this method below works fine.

HttpHeaders headers = new HttpHeaders(); headers.setContentType(MediaType.APPLICATION_JSON); HttpEntityString> entity = new HttpEntityString>(requestJson, headers); ResponseEntityString> response = restTemplate.put(url, entity);

and another method of solving the above error is given below.

So here used a basic example using Spring’s RestTemplate class to make a POST request. This way is also good to implement as the particular JSON parser of the rest endpoint was using needed double quotes around field names.

RestTemplate restTemplate = new RestTemplate(); String url = "endpoint url"; String requestJson = "\"queriedQuestion\":\"Is there pain in your hand?\">"; HttpHeaders headers = new HttpHeaders(); headers.setContentType(MediaType.APPLICATION_JSON); HttpEntity  String > entity = new HttpEntity  String > (requestJson, headers); String answer = restTemplate.postForObject(url, entity, String.class); System.out.println(answer);

You can use this code to send post requests to your Java application and verify the result on the backend.

That’s all about how to send Post requests via RestTempalte in Java using Spring Framework . You can use this method to send JSON to the server. So in this tutorial, we discussed how to send POST requests via RestTemplate in JSON. The three methods postForEntity, postForObject, and postForLocation are used the send POST request via RestTemplate in JSON.

Источник