web-dev-qa-db-fra.com

Comment définir un en-tête "Accept:" sur la demande Spring RestTemplate?

Je souhaite définir la valeur du Accept: dans une demande que je fais à l'aide de la variable RestTemplate de Spring.

Voici le code de traitement de ma demande de printemps

@RequestMapping(
    value= "/uom_matrix_save_or_edit", 
    method = RequestMethod.POST,
    produces="application/json"
)
public @ResponseBody ModelMap uomMatrixSaveOrEdit(
    ModelMap model,
    @RequestParam("parentId") String parentId
){
    model.addAttribute("attributeValues",parentId);
    return model;
}

et voici mon client Java REST:

public void post(){
    MultiValueMap<String, String> params = new LinkedMultiValueMap<String, String>();
    params.add("parentId", "parentId");
    String result = rest.postForObject( url, params, String.class) ;
    System.out.println(result);
}

Cela fonctionne pour moi. Je reçois une chaîne JSON du côté serveur.

Ma question est la suivante: comment puis-je spécifier l'en-tête Accept: (par exemple application/json, application/xml, ...) et la méthode de requête (par exemple GET, POST, ...) lorsque j'utilise RestTemplate?

springrestresttemplate
148
edaklij

Je suggère d'utiliser l'une des méthodes exchange acceptant un HttpEntity pour lequel vous pouvez également définir le HttpHeaders . (Vous pouvez également spécifier la méthode HTTP que vous souhaitez utiliser.)

Par exemple,

RestTemplate restTemplate = new RestTemplate();
HttpHeaders headers = new HttpHeaders();
headers.setAccept(Collections.singletonList(MediaType.APPLICATION_JSON));

HttpEntity<String> entity = new HttpEntity<>("parameters", headers);

restTemplate.exchange(url, HttpMethod.POST, entity, String.class);

Je préfère cette solution car elle est fortement typée, c'est à dire. exchange s'attend à une HttpEntity.

Cependant, vous pouvez également passer cette HttpEntity comme argument request à postForObject. 

HttpEntity<String> entity = new HttpEntity<>("parameters", headers);
restTemplate.postForObject(url, entity, String.class);

Ceci est mentionné dans le RestTemplate#postForObject Javadoc .

Le paramètre request peut être un HttpEntity afin de ajouter plus de En-têtes HTTP à la demande.

270
Sotirios Delimanolis

Vous pouvez définir un intercepteur "ClientHttpRequestInterceptor" dans votre RestTemplate pour éviter de définir l'en-tête chaque fois que vous envoyez une demande.

public class HeaderRequestInterceptor implements ClientHttpRequestInterceptor {

        private final String headerName;

        private final String headerValue;

        public HeaderRequestInterceptor(String headerName, String headerValue) {
            this.headerName = headerName;
            this.headerValue = headerValue;
        }

        @Override
        public ClientHttpResponse intercept(HttpRequest request, byte[] body, ClientHttpRequestExecution execution) throws IOException {
            request.getHeaders().set(headerName, headerValue);
            return execution.execute(request, body);
        }
    }

Ensuite

List<ClientHttpRequestInterceptor> interceptors = new ArrayList<ClientHttpRequestInterceptor>();
interceptors.add(new HeaderRequestInterceptor("Accept", MediaType.APPLICATION_JSON_VALUE));

RestTemplate restTemplate = new RestTemplate();
restTemplate.setInterceptors(interceptors);
97
Ammar

Si, comme moi, vous avez eu du mal à trouver un exemple utilisant des en-têtes avec une authentification de base et l'API d'échange de modèles, les problèmes que j'ai rencontrés sont finalement ceux que j'ai définis ...

private HttpHeaders createHttpHeaders(String user, String password)
{
    String notEncoded = user + ":" + password;
    String encodedAuth = Base64.getEncoder().encodeToString(notEncoded.getBytes());
    HttpHeaders headers = new HttpHeaders();
    headers.setContentType(MediaType.APPLICATION_JSON);
    headers.add("Authorization", "Basic " + encodedAuth);
    return headers;
}

private void doYourThing() 
{
    String theUrl = "http://blah.blah.com:8080/rest/api/blah";
    RestTemplate restTemplate = new RestTemplate();
    try {
        HttpHeaders headers = createHttpHeaders("fred","1234");
        HttpEntity<String> entity = new HttpEntity<String>("parameters", headers);
        ResponseEntity<String> response = restTemplate.exchange(theUrl, HttpMethod.GET, entity, String.class);
        System.out.println("Result - status ("+ response.getStatusCode() + ") has body: " + response.hasBody());
    }
    catch (Exception eek) {
        System.out.println("** Exception: "+ eek.getMessage());
    }
}
13
Dave

Code: appeler une api de repos à l'aide d'un modèle 

1) 

       RestTemplate restTemplate = new RestTemplate();
        // Add the Jackson message converter
        restTemplate.getMessageConverters().add(new 
           MappingJackson2HttpMessageConverter());

        HttpHeaders headers = new HttpHeaders();
        headers.setContentType(MediaType.APPLICATION_JSON);
        headers.set("Authorization", "Basic XXXXXXXXXXXXXXXX=");
        HttpEntity<String> entity = new HttpEntity<String>("parameters", headers);

        restTemplate.getInterceptors().add(new BasicAuthorizationInterceptor(USERID, PWORD));

        String requestJson = getRequetJson(Code, emailAddr, firstName, lastName);
        //
        response = restTemplate.postForObject(URL, requestJson, MYObject.class);

ou 

2) 

    RestTemplate restTemplate = new RestTemplate();
    String requestJson = getRequetJson(code, emil, name, lastName);

    //
    HttpHeaders headers = new HttpHeaders();
    String userPass = USERID + ":" + PWORD;
    String authHeaderValue = "Basic " + Base64.getEncoder().encodeToString(userPass.getBytes());
    headers.set(HttpHeaders.AUTHORIZATION, authHeaderValue);
    headers.setContentType(MediaType.APPLICATION_JSON);
    headers.setAccept(Collections.singletonList(MediaType.APPLICATION_JSON));
    HttpEntity<String> request = new HttpEntity<String>(requestJson, headers);
    //
    ResponseEntity<MyObject> responseEntity =this.restTemplate.exchange(URI, HttpMethod.POST, request, MyObject.class);

    responseEntity.getBody()

Méthode de création d'objet json 

    private String getRequetJson(String Code, String emailAddr, String firstName, String lastName) {
        ObjectMapper mapper = new ObjectMapper();
        JsonNode rootNode = mapper.createObjectNode();

        ((ObjectNode) rootNode).put("code", Code);
        ((ObjectNode) rootNode).put("email", emailAdd);
        ((ObjectNode) rootNode).put("firstName", firstname);
        ((ObjectNode) rootNode).put("lastName", lastname);

        String jsonString = null;
        try {
            jsonString = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(rootNode);
        } catch (JsonProcessingException e) {

            e.printStackTrace();
        }
        return jsonString;

    }
3
vaquar khan

Voici une réponse simple. J'espère que ça aide quelqu'un.

import org.springframework.boot.devtools.remote.client.HttpHeaderInterceptor;
import org.springframework.http.MediaType;
import org.springframework.http.client.ClientHttpRequestInterceptor;
import org.springframework.web.client.RestTemplate;


public String post(SomeRequest someRequest) {
    // create a list the headers 
    List<ClientHttpRequestInterceptor> interceptors = new ArrayList<>();
    interceptors.add(new HttpHeaderInterceptor("Accept", MediaType.APPLICATION_JSON_VALUE));
    interceptors.add(new HttpHeaderInterceptor("ContentType", MediaType.APPLICATION_JSON_VALUE));
    interceptors.add(new HttpHeaderInterceptor("username", "user123"));
    interceptors.add(new HttpHeaderInterceptor("customHeader1", "c1"));
    interceptors.add(new HttpHeaderInterceptor("customHeader2", "c2"));
    // initialize RestTemplate
    RestTemplate restTemplate = new RestTemplate();
    // set header interceptors here
    restTemplate.setInterceptors(interceptors);
    // post the request. The response should be JSON string
    String response = restTemplate.postForObject(Url, someRequest, String.class);
    return response;
}
0
Tunde Michael