springboot中的RestTemplate使用詳解

更新時間：2023年09月09日 10:04:41 作者：morris131

這篇文章主要介紹了springboot中的RestTemplate使用詳解,RestTemplate繼承自InterceptingHttpAccessor并且實現(xiàn)了RestOperations接口,其中RestOperations接口定義了基本的RESTful操作,這些操作在RestTemplate中都得到了實現(xiàn),需要的朋友可以參考下

RestTemplate介紹

RestTemplate提供了一個基于Http客戶端庫（HttpClient，OkHttp等）的高層次API，并不是重復(fù)制造輪子。

RestTemplate提供了常見的REST請求方案的模版，例如GET請求、POST請求、PUT請求、DELETE請求以及一些通用的請求執(zhí)行方法exchange以及execute。

RestTemplate已處于維護(hù)狀態(tài)，官方推薦使用WebClient。

RestTemplate繼承自InterceptingHttpAccessor并且實現(xiàn)了RestOperations接口，其中RestOperations接口定義了基本的RESTful操作，這些操作在RestTemplate中都得到了實現(xiàn)。

RestTemplate的核心API

getForObject：發(fā)送GET請求，直接返回一個對象
getForEntity：發(fā)送GET請求，返回ResponseEntity (包含status, headers, and body)
headForHeaders：指定header，返回HttpHeaders對象
postForLocation：返回URI
postForObject：發(fā)送POST請求，直接返回一個對象
postForEntity：發(fā)送POST請求，返回ResponseEntity (包含status, headers, and body)
put：發(fā)送PUT請求
delete：發(fā)送Delete請求
optionsForAllow：發(fā)送OPTIONS請求
exchange：提供更靈活的方式去發(fā)送請求，請求參數(shù)RequestEntity（包含HTTP方式，請求頭，請求體），返回ResponseEntity，支持泛型
execute：在exchange的基礎(chǔ)上，可以通過callback來對請求和響應(yīng)進(jìn)行處理

RestTemplate的創(chuàng)建

RestTemplate底層默認(rèn)使用JDK自帶的HttpURLConnection來處理請求的。我們可以使用其他HTTP客戶端庫來處理請求，只需要實現(xiàn)ClientHttpRequestFactory。

目前官方支持的HTTP客戶端庫有：

Apache HttpComponents：HttpComponentsClientHttpRequestFactory
Netty：Netty4ClientHttpRequestFactory
OkHttp：OkHttp3ClientHttpRequestFactory

例如使用Apache HttpComponents，可以這樣創(chuàng)建RestTemplate：

RestTemplate template = new RestTemplate(new HttpComponentsClientHttpRequestFactory());

URIs

Restful風(fēng)格的請求URL上面通常會帶有變量。

RestTemplate可以使用可變數(shù)組來處理URL上面的變量：

String result = restTemplate.getForObject(
		"https://example.com/hotels/{hotel}/bookings/{booking}", String.class, "42", "21");

也可以使用MAP來處理URL上面的變量，MAP中的key需要與URL中的占位符的變量一致：

Map<String, String> vars = Collections.singletonMap("hotel", "42");
String result = restTemplate.getForObject(
		"https://example.com/hotels/{hotel}/rooms/{hotel}", String.class, vars);

注意URI會自動進(jìn)行編碼，例如：

restTemplate.getForObject("https://example.com/hotel list", String.class);
// Results in request to "https://example.com/hotel%20list"

可以指定RestTemplate的uriTemplateHandler屬性來自定義URI如何進(jìn)行編碼，另外RestTemplate的方法也支持傳入URI類型的參數(shù)。

RestTemplate的簡單使用

GET

發(fā)送簡單的GET請求，URL支持帶參數(shù)。

@GetMapping("get")
public String getUser() {
    String url = "http://localhost:8888/rest/user/{id}";
    RestTemplate restTemplate = new RestTemplate();
    String result = restTemplate.getForObject(url, String.class, 1);
    log.info("getForObject: {}", result);
    HashMap<String, Long> map = new HashMap<>();
    map.put("id", 1L);
    String result2 = restTemplate.getForObject(url, String.class, map);
    log.info("getForObject2: {}", result2);
    URI uri = UriComponentsBuilder.fromUriString(url).build(1);
    ResponseEntity<String> responseEntity = restTemplate.getForEntity(uri, String.class);
    log.info("getForEntity status: {}", responseEntity.getStatusCode());
    log.info("getForEntity header: {}", responseEntity.getHeaders());
    log.info("getForEntity body: {}", responseEntity.getBody());
    return result;
}

POST

發(fā)送POST請求。

@GetMapping("post")
public R<Void> postUser() {
    String url = "http://localhost:8888/rest/user";
    RestTemplate restTemplate = new RestTemplate();
    User user = new User();
    user.setName("jj");
    user.setAge(16);
    String result = restTemplate.postForObject(url, user, String.class);
    log.info("postForObject: {}", result);
    ResponseEntity<String> responseEntity = restTemplate.postForEntity(url, user, String.class);
    log.info("postForEntity: {}", responseEntity);
    return R.ok();
}

PUT

發(fā)送PUT請求。

@GetMapping("put")
public R<Void> putUser() {
    String url = "http://localhost:8888/rest/user";
    RestTemplate restTemplate = new RestTemplate();
    User user = new User();
    user.setName("jj");
    user.setAge(16);
    restTemplate.put(url, user);
    log.info("put: {}", user);
    return R.ok();
}

DELETE

發(fā)送DELETE請求

@GetMapping("delete")
public R<Void> deleteUser() {
    String url = "http://localhost:8888/rest/user/{id}";
    RestTemplate restTemplate = new RestTemplate();
    restTemplate.delete(url, 1);
    return R.ok();
}

指定Header

可以使用HttpEntity來指定請求Header頭中的參數(shù)，也可以使用RequestEntity，RequestEntity是HttpEntity的子類。

可以從ResponseEntity中獲取響應(yīng)的Header頭中的參數(shù)。

@GetMapping("header")
public R<Void> header() {
    String url = "http://localhost:8888/rest/user";
    RestTemplate restTemplate = new RestTemplate();
    User user = new User();
    user.setName("jj");
    user.setAge(16);
    MultiValueMap<String, Object> paramMap = new LinkedMultiValueMap<>();
    paramMap.add("token", "2yy01x90x2xxx25");
    // set headers
    HttpHeaders headers = new HttpHeaders();
    HttpEntity<User> httpEntity = new HttpEntity<>(user, headers);
    ResponseEntity<String> response2 = restTemplate.postForEntity(url, httpEntity, String.class);
    log.info("postForEntity: {}", response2.getBody());
    // 使用exchange請求接口
    ResponseEntity<String> response3 = restTemplate.exchange(url, HttpMethod.POST, httpEntity, String.class);
    log.info("exchange: {}", response3.getBody());
    return R.ok();
}

返回值支持泛型

可以使用ParameterizedTypeReference來支持泛型。

@GetMapping("generic")
public R<User> generic() {
    String url = "http://localhost:8888/rest/user/{id}";
    ParameterizedTypeReference<R<User>> parameterizedTypeReference = new ParameterizedTypeReference<R<User>>() {
    };
    RestTemplate template = new RestTemplate();
    ResponseEntity<R<User>> responseEntity = template.exchange(url, HttpMethod.GET, null, parameterizedTypeReference, 1);
    return responseEntity.getBody();
}

消息內(nèi)容的轉(zhuǎn)換

RestTemplate的方法中能夠直接傳入對象或者返回對象，這是因為底層使用了HttpMessageConverter進(jìn)行了轉(zhuǎn)換。

常用的HttpMessageConverter有以下幾個：

StringHttpMessageConverter：將請求和響應(yīng)當(dāng)成字符串來處理，支持Content-Type為text/plain。
MappingJackson2HttpMessageConverter：使用Jackson的ObjectMapper將請求和響應(yīng)當(dāng)成JSON對象來處理。

如果想修改MappingJackson2HttpMessageConverter的序列化或者反序列化方式，可以自定義ObjectMapper來實現(xiàn)：

RestTemplate template = new RestTemplate();
ObjectMapper objectMapper = new ObjectMapper();
objectMapper.setPropertyNamingStrategy(PropertyNamingStrategy.SNAKE_CASE);
template.setMessageConverters(Collections.singletonList(new MappingJackson2HttpMessageConverter(objectMapper)));

異常處理

RestTemplate發(fā)起請求時如果發(fā)生錯誤默認(rèn)就會直接拋出異常，而不會往下執(zhí)行，所以無法在代碼中直接根據(jù)ResponseEntity的status來判斷接口是否響應(yīng)成功，例如下面的代碼就會直接拋出異常：

@GetMapping("exception")
public String exception() {
    String url = "http://localhost:8888/rest/user11";
    RestTemplate template = new RestTemplate();
    ResponseEntity<String> responseEntity = template.getForEntity(url, String.class);
    log.info("responseEntity status: {}", responseEntity.getStatusCode());
    return responseEntity.getBody();
}

運(yùn)行結(jié)果如下：

2023-07-19 15:50:49.425 ERROR 15268 --- [nio-8888-exec-2] o.a.c.c.C.[.[.[/].[dispatcherServlet] : Servlet.service() for servlet [dispatcherServlet] in context with path [] threw exception [Request processing failed; nested exception is org.springframework.web.client.HttpClientErrorException$NotFound: 404 : "{"timestamp":"2023-07-19T07:50:49.225+00:00","status":404,"error":"Not Found","path":"/rest/user11"}"] with root cause

RestTemplate支持設(shè)置ResponseErrorHandler來處理異常，默認(rèn)是使用DefaultResponseErrorHandler，DefaultResponseErrorHandler的處理就是狀態(tài)碼不是20X都會拋出異常：

protected boolean hasError(int unknownStatusCode) {
    HttpStatus.Series series = HttpStatus.Series.resolve(unknownStatusCode);
    return (series == HttpStatus.Series.CLIENT_ERROR || series == HttpStatus.Series.SERVER_ERROR);
}
@Override
public void handleError(ClientHttpResponse response) throws IOException {
    HttpStatus statusCode = HttpStatus.resolve(response.getRawStatusCode());
    if (statusCode == null) {
        byte[] body = getResponseBody(response);
        String message = getErrorMessage(response.getRawStatusCode(),
                response.getStatusText(), body, getCharset(response));
        throw new UnknownHttpStatusCodeException(message,
                response.getRawStatusCode(), response.getStatusText(),
                response.getHeaders(), body, getCharset(response));
    }
    handleError(response, statusCode);
}
private String getErrorMessage(
        int rawStatusCode, String statusText, @Nullable byte[] responseBody, @Nullable Charset charset) {
    String preface = rawStatusCode + " " + statusText + ": ";
    if (ObjectUtils.isEmpty(responseBody)) {
        return preface + "[no body]";
    }
    charset = (charset != null ? charset : StandardCharsets.UTF_8);
    String bodyText = new String(responseBody, charset);
    bodyText = LogFormatUtils.formatValue(bodyText, -1, true);
    return preface + bodyText;
}
protected void handleError(ClientHttpResponse response, HttpStatus statusCode) throws IOException {
    String statusText = response.getStatusText();
    HttpHeaders headers = response.getHeaders();
    byte[] body = getResponseBody(response);
    Charset charset = getCharset(response);
    String message = getErrorMessage(statusCode.value(), statusText, body, charset);
    switch (statusCode.series()) {
        case CLIENT_ERROR:
            throw HttpClientErrorException.create(message, statusCode, statusText, headers, body, charset);
        case SERVER_ERROR:
            throw HttpServerErrorException.create(message, statusCode, statusText, headers, body, charset);
        default:
            throw new UnknownHttpStatusCodeException(message, statusCode.value(), statusText, headers, body, charset);
    }
}

自定義ResponseErrorHandler進(jìn)行異常處理：

@GetMapping("exception2")
public R<Void> exception2() {
    String url = "http://localhost:8888/rest/user11";
    RestTemplate template = new RestTemplate();
    template.setErrorHandler(new ResponseErrorHandler() {
        @Override
        public boolean hasError(ClientHttpResponse response) throws IOException {
            log.info("hasError: {}", response.getStatusCode());
            return false;
        }
        @Override
        public void handleError(ClientHttpResponse response) throws IOException {
            // hasError
            log.info("handleError: {}", response.getStatusCode());
        }
    });
    ResponseEntity<String> responseEntity = template.getForEntity(url, String.class);
    log.info("responseEntity status: {}", responseEntity.getStatusCode());
    if(responseEntity.getStatusCode().is2xxSuccessful()) {
        return R.ok();
    }
    return R.fail();
}

攔截請求

RestTemplate支持添加攔截器ClientHttpRequestInterceptor在請求前對請求參數(shù)進(jìn)行處理，在請求后對響應(yīng)進(jìn)行處理。

例如可以使用ClientHttpRequestInterceptor對URL進(jìn)行重寫，從注冊中心拉取配置實現(xiàn)負(fù)載均衡?？梢允褂肅lientHttpRequestInterceptor對Header增加全局TraceId參數(shù)，對請求進(jìn)行鏈路跟蹤定位。

下面通過攔截器來實現(xiàn)負(fù)載均衡。

String[] loabancerhost = {"https://www.baidu.com", "https://www.sina.com.cn"};
AtomicInteger times = new AtomicInteger(0);
@GetMapping("intercept")
public String intercept() {
    String url = "http://test";
    RestTemplate restTemplate = new RestTemplate();
    restTemplate.setInterceptors(Collections.singletonList((request, body, execution) -> {
        log.info("請求開始");
        int length = loabancerhost.length;
        int i = times.getAndIncrement() % length;
        // 因為 HttpRequest 和 URI 不提供修改功能，因此需要借助 HttpRequestWrapper 對request進(jìn)行包裝
        Request newRequest = new Request(request, loabancerhost[i]);
        return execution.execute(newRequest, body);
    }));
    ResponseEntity<String> exchange = restTemplate.exchange(url, HttpMethod.GET, null, String.class);
    log.info("intercept: {}", exchange);
    return exchange.getBody();
}
private static class Request extends HttpRequestWrapper {
    private String url;
    public Request(HttpRequest request,String url) {
        super(request);
        this.url = url;
    }
    @Override
    public URI getURI() {
        try {
            return new URI(url);
        } catch (URISyntaxException e) {
        }
        return null;
    }
}

到此這篇關(guān)于springboot中的RestTemplate使用詳解的文章就介紹到這了,更多相關(guān)springboot的RestTemplate內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

您可能感興趣的文章: