Solicitud POST a través de RestTemplate en JSON

No encontré ningún ejemplo de cómo resolver mi problema, por lo que quiero pedirle ayuda. No puedo simplemente enviar una solicitud POST usando el objeto RestTemplate en JSON

Cada vez que obtengo:

org.springframework.web.client.HttpClientErrorException: 415 Tipo de medio no admitido

Yo uso RestTemplate de esta manera:

...
restTemplate = new RestTemplate();
List<HttpMessageConverter<?>> list = new ArrayList<HttpMessageConverter<?>>();
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);

¿Qué es mi culpa?

Esta técnica me funcionó:

HttpHeaders headers = new HttpHeaders();
headers.setContentType(MediaType.APPLICATION_JSON);

HttpEntity<String> entity = new HttpEntity<String>(requestJson, headers);
ResponseEntity<String> response = restTemplate.put(url, entity);

espero que esto ayude

Me encontré con este problema al intentar depurar un punto final REST. Aquí hay un ejemplo básico usando la clase RestTemplate de Spring para hacer una solicitud POST que usé. Me tomó bastante tiempo reunir el código de diferentes lugares para obtener una versión que funcione.

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);

El analizador JSON particular de mi punto final de descanso estaba usando comillas dobles necesarias alrededor de los nombres de campo, por eso escapé de las comillas dobles en mi cadena de solicitud Json.

He estado usando la plantilla de descanso con JSONObjects de la siguiente manera:

// create request body
JSONObject request = new JSONObject();
request.put("username", name);
request.put("password", password);

// set headers
HttpHeaders headers = new HttpHeaders();
headers.setContentType(MediaType.APPLICATION_JSON);
HttpEntity<String> entity = new HttpEntity<String>(request.toString(), headers);

// send request and parse result
ResponseEntity<String> loginResponse = restTemplate
  .exchange(urlString, HttpMethod.POST, entity, String.class);
if (loginResponse.getStatusCode() == HttpStatus.OK) {
  JSONObject userJson = new JSONObject(loginResponse.getBody());
} else if (loginResponse.getStatusCode() == HttpStatus.UNAUTHORIZED) {
  // nono... bad credentials
}

Como se especifica aquí , supongo que debe agregar un messageConverterpara MappingJacksonHttpMessageConverter

Si está utilizando Spring 3.0, una manera fácil de evitar la excepción org.springframework.web.client.HttpClientErrorException: 415 Tipo de medio no admitido es incluir los archivos jackson jar en su classpath y usar el mvc:annotation-drivenelemento config. Como se especifica aquí .

Me estaba arrancando el pelo tratando de entender por qué la aplicación mvc-ajax funcionaba sin ninguna configuración especial para el MappingJacksonHttpMessageConverter. Si lees el artículo que vinculé arriba de cerca:

Debajo de las cubiertas, Spring MVC delega en un HttpMessageConverter para realizar la serialización. En este caso, Spring MVC invoca un MappingJacksonHttpMessageConverter integrado en el procesador Jackson JSON. Esta implementación se habilita automáticamente cuando utiliza el elemento de configuración mvc: anotado con Jackson presente en su classpath .

El error "415 Tipo de medio no admitido" le indica que el servidor no aceptará su solicitud POST. Su solicitud está absolutamente bien, es el servidor que está mal configurado.

MappingJacksonHttpMessageConverterconfigurará automáticamente el encabezado de tipo de contenido de solicitud en application/json, y supongo que su servidor lo está rechazando. Sin embargo, no nos ha dicho nada sobre la configuración de su servidor, por lo que realmente no puedo aconsejarle sobre eso.

Lo estoy haciendo de esta manera y funciona.

HttpHeaders headers = createHttpHeaders(map);
public HttpHeaders createHttpHeaders(Map<String, String> map)
{   
    HttpHeaders headers = new HttpHeaders();
    headers.setContentType(MediaType.APPLICATION_JSON);
    for (Entry<String, String> entry : map.entrySet()) {
        headers.add(entry.getKey(),entry.getValue());
    }
    return headers;
}

// Pase los encabezados aquí

 String requestJson = "{ // Construct your JSON here }";
logger.info("Request JSON ="+requestJson);
HttpEntity<String> entity = new HttpEntity<String>(requestJson, headers);
ResponseEntity<String> response = restTemplate.exchange(url, HttpMethod.POST, entity, String.class);
logger.info("Result - status ("+ response.getStatusCode() + ") has body: " + response.hasBody());
logger.info("Response ="+response.getBody());

Espero que esto ayude

Estaba teniendo este problema y estoy usando Spring's RestTemplate en el cliente y Spring Web en el servidor. Ambas API tienen informes de errores muy pobres, por lo que son extremadamente difíciles de desarrollar.

Después de muchas horas de probar todo tipo de experimentos, descubrí que el problema estaba siendo causado al pasar una referencia nula para el cuerpo POST en lugar de la Lista esperada. Supongo que RestTemplate no puede determinar el tipo de contenido de un objeto nulo, pero no se queja de ello. Después de agregar los encabezados correctos, comencé a obtener una excepción del lado del servidor diferente en Spring antes de ingresar a mi método de servicio.

La solución fue pasar una lista vacía del cliente en lugar de nula. No se requieren encabezados ya que el tipo de contenido predeterminado se usa para objetos no nulos.

Este código me está funcionando;

RestTemplate restTemplate = new RestTemplate();
Payment payment = new Payment("Aa4bhs");
MultiValueMap<String, Object> map = new LinkedMultiValueMap<String, Object>();
map.add("payment", payment);
HttpEntity<MultiValueMap<String, Object>> httpEntity = new HttpEntity<MultiValueMap<String, Object>>(map, headerObject);

Payment res = restTemplate.postForObject(url, httpEntity, Payment.class);

Si no quieres procesar la respuesta

private RestTemplate restTemplate = new RestTemplate();
restTemplate.postForObject(serviceURL, request, Void.class);

Si necesita respuesta para procesar

String result = restTemplate.postForObject(url, entity, String.class);

Para mí, se produjo un error con esta configuración:

AndroidAnnotations Spring Android RestTemplate Module y ...

GsonHttpMessageConverter

Las anotaciones de Android tienen algunos problemas con esto convertido para generar POSTsolicitud sin parámetro. Simplemente el parámetro lo new Object()resolvió para mí.

¿Por qué trabajar más duro de lo necesario? postForEntityacepta un Mapobjeto simple como entrada. Lo siguiente funciona bien para mí al escribir pruebas para un punto final REST dado en Spring. Creo que es la forma más simple posible de hacer una solicitud JSON POST en Spring:

@Test
public void shouldLoginSuccessfully() {
  // 'restTemplate' below has been @Autowired prior to this
  Map map = new HashMap<String, String>();
  map.put("username", "bob123");
  map.put("password", "myP@ssw0rd");
  ResponseEntity<Void> resp = restTemplate.postForEntity(
      "http://localhost:8000/login",
      map,
      Void.class);
  assertThat(resp.getStatusCode()).isEqualTo(HttpStatus.OK);
}

Si no desea asignar el JSON usted mismo, puede hacerlo de la siguiente manera:

RestTemplate restTemplate = new RestTemplate();
restTemplate.setMessageConverters(Arrays.asList(new MappingJackson2HttpMessageConverter()));
ResponseEntity<String> result = restTemplate.postForEntity(uri, yourObject, String.class);

Intenté lo siguiente en el arranque de primavera:

ParameterizedTypeReference<Map<String, Object>> typeRef = new ParameterizedTypeReference<Map<String, Object>>() {};
public Map<String, Object> processResponse(String urlendpoint)
{
    try{
    
        HttpHeaders headers = new HttpHeaders();
        headers.setContentType(MediaType.APPLICATION_JSON);
        //reqobj
        JSONObject request = new JSONObject();
        request.put("username", name);
        //Or Hashmap 
        Map<String, Object> reqbody =  new HashMap<>();
        reqbody.put("username",username);
        Gson gson = new Gson();//mvn plugin to convert map to String
        HttpEntity<String> entity = new HttpEntity<>( gson.toJson(reqbody), headers);
        ResponseEntity<Map<String, Object>> response = resttemplate.exchange(urlendpoint, HttpMethod.POST, entity, typeRef);//example of post req with json as request payload
        if(Integer.parseInt(response.getStatusCode().toString()) == HttpURLConnection.HTTP_OK)
        {
            Map<String, Object>  responsedetails = response.getBody();
            System.out.println(responsedetails);//whole json response as map object
            return responsedetails;
        }
    } catch (Exception e) {
        // TODO: handle exception
        System.err.println(e);
    }
    return null;
}