Simple restful JSON POST with java as server and jquery as client

Please try to create new class :

public class InputData{
   private String name;
   public String getName(){
      return name;
   }
   public void setName(String name){
      this.name = name;
   }
}

Then

public void downloadByCode(@RequestBody InputData stringRequest, final HttpServletResponse response)

And

$.ajax({
   url:"/downloadByCode",
   contentType:"application/json",
   type:"POST",
   data: JSON.stringify({"name":"value"}) });

try @RequestBody final Map<String, String> stringRequest

also you will need consumes = "application/json" on the @RequestMapping because you have that in your AJAX call

You will get 400 if spring doesn't like the format in which you send your ajax - I've had so much trouble with this in the past and it seems better to just ignore header types and content types unless necessary

You might try sending your response back as a ResponseEntity instead of using the HttpServletResponse directly. My hunch is that second argument, the HttpServletRequest argument, is what is causing the problem. I've never used that. I've always send my response back using the spring mvc api.

With Jersey api you can try just: @POST public void downloadByCode(String stringRequest)

and I think you'll find the body of your post in stringRequest.

You can take request body as string with usage of org.springframework.http.HttpEntity<String> as request type, here is example with your code as base:

@RequestMapping (value = "/downloadByCode", method = RequestMethod.POST)
@ResponseBody
public void downloadByCode(final HttpEntity<String> request, final HttpServletResponse response)
{
    try
    {
        final ObjectMapper objectMapper = new ObjectMapper();
        final JsonNode jsonRequest = objectMapper.readValue(request.getBody(), JsonNode.class);

        // ...
        // some processings here to create the result
        // ....

        final ServletOutputStream outputStream = response.getOutputStream();
        outputStream.write(result);
        // Flush the result
        outputStream.flush();
    }
    catch (final Exception exception)
    {
        LOG.debug("Exception Thrown [downloadByCode]", exception);
    }
}

But maybe it will be better to use also String as return type, if you are planning to return result as string value, like this:

@RequestMapping (value = "/downloadByCode", method = RequestMethod.POST)
@ResponseBody
public String downloadByCode(HttpEntity<String> request) {
    String requestBody = request.getBody();
    String result;

    // ...
    // some processings here to create the result text
    // ....

    return result;
}

I made simple application using Spring Boot with usage of proposed solutions using HttpEntity and also additional example of usage POJO, to run application you need to have Maven and JDK >= 1.7.

#clonning repository with sample
git clone [email protected]:mind-blowing/samples.git

#change current folder to sample application root
cd samples/spring-boot/rest-handler-for-plain-text

#running application using maven spring-boot plugin
mvn spring-boot:run

After application will be started you can open http://localhost:8080 and you will see html page with simple usage of JQuery to send POST requests, text of request and response will visible on html page, in controller I added two handlers, first with usage of HttpEntity and second with usage of POJO.

Controller: SampleRestController.java

HTML page: index.html

Project: https://github.com/mind-blowing/samples/tree/master/spring-boot/rest-handler-for-plain-text

First of all If you are using maven you should add dependency for jackson

 <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
        <version>2.4.1</version>
    </dependency>

or you can download the jar and put it in our project class path (you can use other mapper as well)

then you should create a model or DTO class where you can map your json

 public class Data{
     private String name;

     pubilc Data(){}

    //getter and setter

 }

THEN you controller

@RequestMapping (value = "/downloadByCode", method = RequestMethod.POST)
@ResponseBody
public Data downloadByCode(@RequestBody final Data data, final HttpServletResponse response)
{
//your code
    return data;
}

AJAX CALL

$.ajax({
   url:"/downloadByCode",
   contentType:"application/json",
   type:"POST",
   data: JSON.stringify({"name":"value"}) });

(Optional)You can override behavior by telling object mapper not to fail on missing properties by defining the bean as follows:

 @Bean
    public MappingJackson2HttpMessageConverter mappingJackson2HttpMessageConverter() {
        MappingJackson2HttpMessageConverter converter = new MappingJackson2HttpMessageConverter();
        converter.setObjectMapper(new ObjectMapper().configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false));
        return converter;
    }

http://websystique.com/springmvc/spring-mvc-requestbody-responsebody-example/

Looking at your errors, it's clear that you have configured 'Jaxb2RootElementHttpMessageConverter' or similar XML converter in your spring configuration. And since you have registerned an XML converter, the @RequestBody and @ResponseBody work based on the registered message converters.

So, to solve your problem, go with a JSON message converter such as 'MappingJacksonHttpMessageConverter'. Once you register a JSON message converter, create a bean class to hold your json data and use it with RequestBody as below:

// It has to meet the json structure you are mapping it with
public class YourInputData {
    //properties with getters and setters
}

Update 1:

Since you have defined multiple message converters, Spring tries to use the first one available by default. In order to use specific message converter(in this case Jackson converter), you should specify 'Accept' header from client like below:

$.ajax({     
          headers: {          
                 "Accept" : "application/json; charset=utf-8",         
                "Content-Type": "application/json; charset=utf-8"   
  }     
  data: "data",    
  success : function(response) {  
       ...  
   } })

Delete the @ResponseBody on your downloadByCode method

Change your method downloadByCode() return type to String and then return the String

Response body will automatically convert the returned String to JSON and then use the data appropriately

I am not that well versed with java but as much as I know your java code must be something like this.

public class downloadByCode{
  @GET
  @Produces(MediaType.APPLICATION_JSON + ";charset=utf-8")
  public Response downloadByCode(@QueryParam("paramater1") final String parameter 1, @Context HttpServletRequest httpRequest) {

If this not helps you can keep you code somewhere and share it.