Demande POST via RestTemplate en JSON

Je n'ai trouvé aucun exemple pour résoudre mon problème, je veux donc vous demander de l'aide. Je ne peux pas simplement envoyer une requête POST à ​​l'aide de l'objet RestTemplate dans JSON

Chaque fois que je reçois:

org.springframework.web.client.HttpClientErrorException: 415 Type de support non pris en charge

J'utilise RestTemplate de cette manière:

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

Quelle est ma faute?

Cette technique a fonctionné pour moi:

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

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

J'espère que ça aide

J'ai rencontré ce problème lors de la tentative de débogage d'un point de terminaison REST. Voici un exemple de base utilisant la classe RestTemplate de Spring pour faire une requête POST que j'ai utilisée. Il m'a fallu un peu de temps pour reconstituer le code de différents endroits pour obtenir une version fonctionnelle.

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

L'analyseur JSON particulier de mon point de terminaison de repos utilisait les guillemets doubles nécessaires autour des noms de champ, c'est pourquoi j'ai échappé les guillemets doubles dans ma chaîne requestJson.

J'ai utilisé le modèle de repos avec JSONObjects comme suit:

// 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
}

Comme spécifié ici, je suppose que vous devez ajouter un messageConverterpour MappingJacksonHttpMessageConverter

Si vous utilisez Spring 3.0, un moyen simple d'éviter l' exception org.springframework.web.client.HttpClientErrorException: 415 Unsupported Media Type , consiste à inclure les fichiers jar jackson dans votre chemin de classe et à utiliser l' mvc:annotation-drivenélément config. Comme spécifié ici .

Je m'arrachais les cheveux en essayant de comprendre pourquoi l'application mvc-ajax fonctionnait sans aucune configuration spéciale pour le MappingJacksonHttpMessageConverter. Si vous lisez attentivement l'article que j'ai lié ci-dessus:

Sous les couvertures, Spring MVC délègue à un HttpMessageConverter pour effectuer la sérialisation. Dans ce cas, Spring MVC appelle un MappingJacksonHttpMessageConverter construit sur le processeur Jackson JSON. Cette implémentation est activée automatiquement lorsque vous utilisez l'élément de configuration mvc: annotation-driven avec Jackson présent dans votre classpath .

L'erreur «415 Unsupported Media Type» vous indique que le serveur n'acceptera pas votre demande POST. Votre demande est tout à fait correcte, c'est le serveur qui est mal configuré.

MappingJacksonHttpMessageConverterdéfinira automatiquement l'en-tête de type de contenu de la demande sur application/json, et je suppose que votre serveur le rejette. Cependant, vous ne nous avez rien dit sur la configuration de votre serveur, donc je ne peux pas vraiment vous conseiller à ce sujet.

Je fais de cette façon et ça marche.

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

// Passez les en-têtes ici

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

J'espère que cela t'aides

J'avais ce problème et j'utilise RestTemplate de Spring sur le client et Spring Web sur le serveur. Les deux API ont des rapports d'erreurs très médiocres, ce qui les rend extrêmement difficiles à développer.

Après de nombreuses heures à essayer toutes sortes d'expériences, j'ai compris que le problème était causé par la transmission d'une référence nulle pour le corps POST au lieu de la liste attendue. Je présume que RestTemplate ne peut pas déterminer le type de contenu à partir d'un objet nul, mais ne s'en plaint pas. Après avoir ajouté les en-têtes corrects, j'ai commencé à obtenir une exception côté serveur différente dans Spring avant d'entrer ma méthode de service.

Le correctif consistait à transmettre une liste vide du client au lieu de null. Aucun en-tête n'est requis car le type de contenu par défaut est utilisé pour les objets non nuls.

Ce code fonctionne pour moi;

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 vous ne souhaitez pas traiter la réponse

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

Si vous avez besoin d'une réponse pour traiter

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

Pour moi, une erreur s'est produite avec cette configuration:

AndroidAnnotations Spring Android RestTemplate Module et ...

GsonHttpMessageConverter

Les annotations Android ont quelques problèmes avec cette conversion pour générer POST requête sans paramètre. Simplement le paramètre l'a new Object()résolu pour moi.

Pourquoi travailler plus dur que nécessaire? postForEntityaccepte un Mapobjet simple comme entrée. Ce qui suit fonctionne très bien pour moi lors de l'écriture de tests pour un point de terminaison REST donné dans Spring. Je pense que c'est le moyen le plus simple de faire une requête JSON POST au printemps:

@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 vous ne souhaitez pas mapper le JSON par vous-même, vous pouvez le faire comme suit:

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

J'ai essayé comme suit dans Spring Boot:

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