如何设置一个；接受：“；SpringRESTTemplate请求上的标头？

我想在使用Spring的

RestTemplate

发出的请求中设置

Accept:

的值

这是我的Spring请求处理代码

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

这是我的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);
}

public void post（）{
多值映射参数=新的LinkedMultiValueMap（）；
参数添加（“parentId”、“parentId”）；
String result=rest.postForObject（url、参数、String.class）；
系统输出打印项次（结果）；
}

这对我有用；我从服务器端得到一个JSON字符串

---

我的问题是：当我使用RestTemplate时，如何指定

Accept:

头（例如

application/json

，

application/xml

，…）和请求方法（例如

GET

，

POST

，…）呢？

我建议使用一种方法，该方法接受一个您还可以为其设置。（您还可以指定要使用的HTTP方法。）

比如说,

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

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

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

这在报告中提到

request

参数可以是

HttpEntity

，以便添加额外的 请求的HTTP头

---

您可以在RestTemplate中设置拦截器“ClientHttpRequestInterceptor”，以避免每次发送请求时都设置标头

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

然后

List interceptors=new ArrayList（）；
add（新的HeaderRequestInterceptor（“Accept”，MediaType.APPLICATION_JSON_VALUE））；
RestTemplate RestTemplate=新RestTemplate（）；
restTemplate.setInterceptors（拦截器）；

如果像我一样，您很难找到一个使用带有基本身份验证的头和rest模板交换API的示例，那么这就是我最终得出的结论

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

私有HttpHeaders createHttpHeaders（字符串用户，字符串密码）
{
字符串notEncoded=user+“：”+密码；
字符串encodedAuth=Base64.getEncoder（）.encodeToString（notEncoded.getBytes（））；
HttpHeaders=新的HttpHeaders（）；
headers.setContentType（MediaType.APPLICATION_JSON）；
添加（“授权”、“基本”+encodedAuth）；
返回标题；
}
你的私人物品
{
字符串URL=”http://blah.blah.com:8080/rest/api/blah";
RestTemplate RestTemplate=新RestTemplate（）；
试一试{
HttpHeaders=createHttpHeaders（“fred”，“1234”）；
HttpEntity=新的HttpEntity（“参数”，标题）；
ResponseEntity response=restemplate.exchange（URL、HttpMethod.GET、entity、String.class）；
System.out.println（“结果-状态（“+response.getStatusCode（）+”）有主体：“+response.hasBody（）”）；
}
捕获（异常eek）{
System.out.println（“**异常：+eek.getMessage（））；
}
}

以下是一个简单的答案。希望它能帮助别人

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

import org.springframework.boot.devtools.remote.client.HttpHeaderInterceptor；
导入org.springframework.http.MediaType；
导入org.springframework.http.client.clienthttpprequestinterceptor；
导入org.springframework.web.client.rest模板；
公共字符串post（SomeRequest SomeRequest）{
//创建一个包含标题的列表
列表拦截器=新的ArrayList（）；
add（新的HttpHeaderInterceptor（“Accept”，MediaType.APPLICATION_JSON_VALUE））；
add（新的HttpHeaderInterceptor（“ContentType”，MediaType.APPLICATION_JSON_VALUE））；
add（新的HttpHeaderInterceptor（“用户名”、“用户123”）；
添加（新的HttpHeaderInterceptor（“customHeader1”、“c1”）；
添加（新的HttpHeaderInterceptor（“customHeader2”、“c2”）；
//初始化RestTemplate
RestTemplate RestTemplate=新RestTemplate（）；
//在这里设置标题拦截器
restTemplate.setInterceptors（拦截器）；
//发布请求。响应应该是JSON字符串
String response=restTemplate.postForObject（Url、someRequest、String.class）；
返回响应；
}

使用RestTemplate调用RESTful API 例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);
        

---

不带

HttpHeaders的简短解决方案

创建：

RequestEntity<Void> request = RequestEntity.post(URI.create(url))
                .accept(MediaType.APPLICATION_JSON)
                // any other headers
                .header("PRIVATE-TOKEN", "token")
                .build();

ResponseEntity<String> response = restTemplate.exchange(request, String.class);
return response.getBody();

RequestEntity request=RequestEntity.post（URI.create（url））
.accept（MediaType.APPLICATION_JSON）
//任何其他标题
.header（“专用令牌”、“令牌”）
.build（）；
ResponseEntity response=restTemplate.exchange（请求，String.class）；
返回response.getBody（）；

Spring Boot 1.3有一个HttpHeaderInterceptor，因此我们不需要创建自己的ClientHttpRequestInterceptor实现。由于某些原因，HttpHeaderInterceptor仅在Spring Boot开发工具中。因此，我们仍然必须自己实现ClientHttpRequestInterceptor。我认为应该将它移到spring-web中。将默认头添加到rest模板的ClientHttpRequestFactory集合中，而不是添加拦截器，这样更好吗？另外，您应该在单独的问题中添加您的答案，因为这涉及默认标题。必须找一段时间才能到达这里！如果有两个服务使用我们必须调用的两个diff id/pass，那么resttemplate级别的拦截器的级别太高了，对吗？您需要在请求级别使用它-通常RestTemplate是spring boot配置中的@Bean您的代码将使用spring Devtools作为生产依赖项（通过导入org.springframework.boot.Devtools.remote.client.HttpHeaderInterceptor）。。。

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

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

private String getRequetJson(String Code, String emailAddr, String name) {
    ObjectMapper mapper = new ObjectMapper();
    JsonNode rootNode = mapper.createObjectNode();
    ((ObjectNode) rootNode).put("code", Code);
    ((ObjectNode) rootNode).put("email", emailAdd);
    ((ObjectNode) rootNode).put("firstName", name);
    String jsonString = null;
    try {
        jsonString = mapper.writerWithDefaultPrettyPrinter()
                               .writeValueAsString(rootNode);
    }
    catch (JsonProcessingException e) {
        e.printStackTrace();
    }
    return jsonString;
}

RequestEntity<Void> request = RequestEntity.post(URI.create(url))
                .accept(MediaType.APPLICATION_JSON)
                // any other headers
                .header("PRIVATE-TOKEN", "token")
                .build();

ResponseEntity<String> response = restTemplate.exchange(request, String.class);
return response.getBody();