Spring RestTemplate post 在 HashMap 中使用参数会抛出 400 Bad Request

Question

When I use Spring RestTemplate.postForObject to post parameters using HashMap , server throws 400 Bad Request:

Map<String, Object> uriVariables = new HashMap<>();
uriVariables.put("param1", "param1val");
restTemplate.postForObject(url, uriVariables, responseType);

Log:

14:51:20.102 [main] DEBUG org.springframework.web.client.RestTemplate - Created POST request for "http://localhost:8080/demo-1/test"
14:51:20.113 [main] DEBUG org.springframework.web.client.RestTemplate - Setting request Accept header to [text/plain, application/json, application/*+json, */*]
14:51:20.161 [main] DEBUG org.springframework.web.client.RestTemplate - Writing [{param1=1}] using [org.springframework.http.converter.json.MappingJackson2HttpMessageConverter@8e24743]
14:51:20.225 [main] DEBUG org.springframework.web.client.RestTemplate - POST request for "http://localhost:8080/demo-1/test" resulted in 400 (null); invoking error handler
Exception in thread "main" org.springframework.web.client.HttpClientErrorException: 400 null
    at org.springframework.web.client.DefaultResponseErrorHandler.handleError(DefaultResponseErrorHandler.java:78)
    at org.springframework.web.client.RestTemplate.handleResponse(RestTemplate.java:700)
    at org.springframework.web.client.RestTemplate.doExecute(RestTemplate.java:653)
    at org.springframework.web.client.RestTemplate.execute(RestTemplate.java:613)
    at org.springframework.web.client.RestTemplate.postForObject(RestTemplate.java:380)

But if I use MultiValueMap , it works.

MultiValueMap<String, Object> uriVariables = new LinkedMultiValueMap<>();
uriVariables.add("param1", "param1val");
restTemplate.postForObject(url, uriVariables, responseType);

Log:

14:52:08.493 [main] DEBUG org.springframework.web.client.RestTemplate - Created POST request for "http://localhost:8080/demo-1/test"
14:52:08.501 [main] DEBUG org.springframework.web.client.RestTemplate - Setting request Accept header to [text/plain, application/json, application/*+json, */*]
14:52:08.502 [main] DEBUG org.springframework.web.client.RestTemplate - Writing [{param1=[1]}] using [org.springframework.http.converter.support.AllEncompassingFormHttpMessageConverter@4abdb505]
14:52:08.537 [main] DEBUG org.springframework.web.client.RestTemplate - POST request for "http://localhost:8080/demo-1/test" resulted in 200 (null)
14:52:08.539 [main] DEBUG org.springframework.web.client.RestTemplate - Reading [java.lang.String] as "text/plain;charset=UTF-8" using [org.springframework.http.converter.StringHttpMessageConverter@13c27452]
{"name":"1"}

Here is controller method:

@RequestMapping(name = "/test", method = RequestMethod.POST)
@ResponseBody
public String test(@RequestParam("param1") final String param1) {
    // some class Test
    final Test test = new Test();
    test.setName(param1);
    return JsonUtils.toJson(test);
}

Can somebody explain why passing request parameters using a HashMap doesn't work?

Answer 1

When you say : it throws 400 Bad Request: do you understand what is referred by it ? hint : it is not Spring REST client code, but the server you are talking to, which do not accept your http request as valid.

You could activate logging of the httpclient implementation used by spring restTemplate to see how going from HashMap to LinkedMultiValueMap change the generated http request.

You also could look at spring restTemplate source code to see why generate different requests.

EDIT: the important part of the log you've posted :

14:51:20.161 [main] DEBUG org.springframework.web.client.RestTemplate - Writing [{param1=1}] using [org.springframework.http.converter.json.MappingJackson2HttpMessageConverter@8e24743]

here it is writing json most certainly on the http request body

while with LinkedMultiValueMap :

14:52:08.502 [main] DEBUG org.springframework.web.client.RestTemplate - Writing [{param1=[1]}] using [org.springframework.http.converter.support.AllEncompassingFormHttpMessageConverter@4abdb505]

in the first case, your request won't have a parameter param1 but all data in the request body, while in the second case, you get a param1 parameter, making the request valid for the server

It should be possible to configure RestTemplate by extending / creating a message converter to work the way you want with a HashMap , but I advise you to stay with LinkedMultiValueMap for 2 reasons :

• this is the default spring settings. So you will have an easier migration when you'll need to update to next versions.
• other people using your code won't be surprised by the "new" way RestTemplate is working with your custom configuration

Answer 2

MultiValueMap has different value type than HashMap. It can be seen in its interface definition:

interface MultiValueMap<K, V> extends Map<K, List<V>>

and HashMap:

class HashMap<K,V> extends AbstractMap<K,V>

You use put method to fill HashMap and add method to fill MultiValueMap, so it looks similar, but in fact MultiValueMap holds lists , not single values. It can be seen in your logs:

HashMap:

14:51:20.161 [main] DEBUG org.springframework.web.client.RestTemplate - Writing [{param1=1}]

MultiValueMap:

14:52:08.502 [main] DEBUG org.springframework.web.client.RestTemplate - Writing [{param1= 1 }]

As you see {param1=1} does not work and {param1=[1]} works.

Additionally, in the documentation of RestTemplate it is recommended to use MultiValueMap:

The body of the entity, or request itself, can be a MultiValueMap to create a multipart request. The values in the MultiValueMap can be any Object representing the body of the part, or an HttpEntity representing a part with body and headers. The MultiValueMap can be built conveniently using MultipartBodyBuilder.

Answer 3

You choice to use HttpHeaders and HttpEntity and MultiValueMap or hashMap . you look up this keyword and link. may be useful.

RestTemplate

HttpHeaders

HttpEntity

MultiValueMap

This is sample code :

HttpHeaders headers = new HttpHeaders();

headers.add("x-sample-session-id", sampleService.getServerSessionId());

MultiValueMap<String, Object> map = new LinkedMultiValueMap<String, Object>();


map.add("file", new ByteArrayResource(model.getFile().getBytes()));
map.add("apList", model.getApList());

HttpEntity<?> request = new HttpEntity<Object>(map, headers);

String url = sampleService.getContextPath() + "/thirdParty/" + sampleService.getThirdPartyId() + "/child/"
        + childId + "/location?sessionId=" + childSessionId
        + "&op=sendOnDemandLocationResponseWithPhoto&latitude=" + latitude + "&longitude=" + longitude
        + "&datetime=" + datetime + "&provider=" + provider + "&guardianId=" + guardianId + "&cellInfos="
        + cellInfos + "&timestamp=" + timestamp + "&battery=" + battery;

RestTemplate rest = new RestTemplate();

try {
    // success
    return rest.exchange(url, HttpMethod.POST, request, String.class);
} catch (HttpStatusCodeException e) {
    // new Error Response
    return ResponseEntity.status(e.getStatusCode()).headers(e.getResponseHeaders())
            .body(e.getResponseBodyAsString());
}

Answer 4

For making it to work using HashMap try this:-

List<HttpMessageConverter<?>> messageConverters = new ArrayList<>();
messageConverters.add(new MappingJackson2HttpMessageConverter());
restTemplate.setMessageConverters(messageConverters);

Explanation

By default RestTemplate sets a number of MessageConverters like below in the constructor

this.messageConverters.add(new ByteArrayHttpMessageConverter());
this.messageConverters.add(new StringHttpMessageConverter());
this.messageConverters.add(new ResourceHttpMessageConverter(false));
this.messageConverters.add(new SourceHttpMessageConverter<>());
this.messageConverters.add(new AllEncompassingFormHttpMessageConverter());

And also it adds automatically MappingJackson2HttpMessageConverter but that is after AllEncompassingFormHttpMessageConverter

which doesn't work(very strange) because AllEncompassingFormHttpMessageConverter takes over and returns before MappingJackson2HttpMessageConverter could have actually worked

if (jackson2Present) {
    this.messageConverters.add(new MappingJackson2HttpMessageConverter());
}

And the class AllEncompassingFormHttpMessageConverter extends FormHttpMessageConverter which is implementing the HttpMessageConverter<MultiValueMap<String, ?>> , here MultiValueMap is something to note .

While in the case of MappingJackson2HttpMessageConverter it extends AbstractJackson2HttpMessageConverter which is further extending the AbstractGenericHttpMessageConverter<Object> and note Object here