</>KemmerApp

Programming

POST JSON fails with 415 Unsupported media type Spring 3 mvc

25 September 2026 · 6 min read

POST JSON fails with 415 Unsupported media type Spring 3 mvc

Encountering an “HTTP Status 415 – Unsupported Media Type” error can be a frustrating roadblock when developing web applications, especially when you expect your Spring 3 MVC application to seamlessly handle JSON data. This particular issue often arises when you attempt to POST JSON fails with 415 Unsupported media type, Spring 3 mvc applications, indicating a mismatch between the client’s request and the server’s expected data format. Essentially, your server is telling you it doesn’t know how to process the Content-Type of the data you’re sending. This isn’t just a minor hiccup; it points to fundamental configuration or communication issues that prevent your RESTful services from functioning correctly. Understanding the root causes and implementing the right solutions is crucial for building robust and reliable Spring applications.

Understanding the 415 Unsupported Media Type Error

The HTTP 415 “Unsupported Media Type” status code is a client error that signifies the server is refusing to accept the request because the payload format is in an unsupported format. This means the server, or more specifically, your Spring 3 MVC application, doesn’t recognize or isn’t configured to process the Content-Type specified in the request’s header. While this error can occur with various media types, it’s particularly common when developers are trying to send JSON data to a Spring endpoint that isn’t properly set up to deserialize it.

In the context of Spring MVC, this error often points to a missing or misconfigured HttpMessageConverter. Spring uses these converters to transform HTTP request bodies into Java objects and vice-versa. For JSON, the most commonly used converter is provided by the Jackson library. If Spring doesn’t find an appropriate converter for application/json (the standard Content-Type for JSON), it will reject the request, resulting in a 415 error. This is a clear signal that the framework cannot bridge the gap between the raw JSON payload and the Java object your controller method expects.

It’s vital to differentiate this from other client errors like 400 Bad Request or 404 Not Found. A 415 error specifically targets the Content-Type header, not the request’s validity or the resource’s existence. Therefore, debugging efforts should primarily focus on ensuring the client sends the correct Content-Type and that the Spring application has the necessary components to process that specific media type.

Common Causes for 415 in Spring 3 MVC JSON Posts

When you encounter a 415 error while trying to POST JSON fails with 415 Unsupported media type, Spring 3 mvc, several common culprits are usually at play. The primary reason often revolves around a mismatch in media type expectations. On the client side, the request might not be sending the correct Content-Type header, or it might be missing entirely. For JSON, this header should always be set to application/json. If the client sends text/plain, application/xml, or no Content-Type at all, Spring won’t know how to handle the incoming data.

The most common cause for a 415 Unsupported Media Type error in Spring 3 MVC when posting JSON is the absence of a proper HttpMessageConverter configuration for JSON processing. Spring relies on these converters to deserialize the JSON request body into a Java object. Without the Jackson library (or an alternative like GSON) and its corresponding MappingJacksonHttpMessageConverter registered, Spring simply won’t know how to convert the application/json payload into the @RequestBody parameter of your controller method. This essential converter tells Spring how to map the JSON string from the HTTP request to your Java POJO.

Furthermore, incorrect usage of the @RequestBody annotation in your Spring controller method can also lead to this error. This annotation is crucial for instructing Spring to bind the HTTP request body to a method parameter. If it’s missing, or if the parameter type doesn’t align with the expected JSON structure (though this usually results in a 400 error), Spring might not properly invoke the HttpMessageConverter. Lastly, older Spring 3 MVC setups sometimes required explicit configuration of web.xml or custom bean definitions, which, if overlooked, could prevent the necessary JSON processing components from being initialized. Ensuring your Spring MVC REST configuration is complete is key.

Step-by-Step Solutions to Resolve 415 Errors

Resolving the “415 Unsupported Media Type” error in Spring 3 MVC when dealing with JSON POST requests involves a systematic check of your client-side request and server-side configuration. Each step is crucial to ensure that your application can properly process the incoming JSON payload.

1. Verify Client-Side Request Header

The very first step is to confirm that your client-side application is sending the correct Content-Type header. For JSON, this must be application/json. Many developers overlook this, leading to the server rejecting the request. For example, if you’re using JavaScript’s Fetch API or Axios, ensure your headers are correctly set:

fetch('/your-api-endpoint', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ key: 'value' }) });

Tools like Postman or your browser’s developer console can help you inspect the outgoing request headers.

2. Configure Spring MVC for JSON Processing

Your Spring 3 MVC application needs to know how to convert JSON strings into Java objects. This is primarily achieved through the Jackson Mapper library and its integration with Spring’s HttpMessageConverters. Here’s how to set it up:

  1. Add Jackson Dependencies: Ensure your pom.xml (for Maven projects) includes the necessary Jackson dependencies. Spring 3 typically uses Jackson 1.x or 2.x, but for 2.x, you’d need jackson-databind, jackson-core, and jackson-annotations. ``` org.codehaus.jackson jackson-mapper-asl 1.9.13 & Question & Answer :

    I am trying to send a POST request to a servlet. Request is sent via jQuery in this way:

    var productCategory = new Object(); productCategory.idProductCategory = 1; productCategory.description = “Descrizione2”; newCategory(productCategory);

    where newCategory is

    function newCategory(productCategory) { $.postJSON(“ajax/newproductcategory”, productCategory, function( idProductCategory) { console.debug(“Inserted: " + idProductCategory); }); }

    and postJSON is

    $.postJSON = function(url, data, callback) { return jQuery.ajax({ ’type’: ‘POST’, ‘url’: url, ‘contentType’: ‘application/json’, ‘data’: JSON.stringify(data), ‘dataType’: ‘json’, ‘success’: callback }); };

    With firebug I see that JSON is sent correctly:

    {“idProductCategory”:1,“description”:“Descrizione2”}

    But I get 415 Unsupported media type. Spring mvc controller has signature

    @RequestMapping(value = “/ajax/newproductcategory”, method = RequestMethod.POST) public @ResponseBody Integer newProductCategory(HttpServletRequest request, @RequestBody ProductCategory productCategory)

    Some days ago it worked, now it is not. I’ll show more code if needed.



    I’ve had this happen before with Spring @ResponseBody and it was because there was no accept header sent with the request. Accept header can be a pain to set with jQuery, but this worked for me source

    $.postJSON = function(url, data, callback) { return jQuery.ajax({ headers: { ‘Accept’: ‘application/json’, ‘Content-Type’: ‘application/json’ }, ’type’: ‘POST’, ‘url’: url, ‘data’: JSON.stringify(data), ‘dataType’: ‘json’, ‘success’: callback }); };

    The Content-Type header is used by @RequestBody to determine what format the data being sent from the client in the request is. The accept header is used by @ResponseBody to determine what format to sent the data back to the client in the response. That’s why you need both headers.