参考链接#

Summary#

As of 5.0 the RestTemplate is in maintenance mode, with only minor requests for changes and bugs to be accepted going forward. Please, consider using the WebClient which offers a more modern API and supports sync, async, and streaming scenarios.

从RestTemplate5.0开始处于维护模式中，仅接受较小的变更请求和bug处理。请关注使用WebClient参考一个更现代的API，它同样支持同步、异步和流场景。

Spring官方已经不再对RestTemplate做新特性开发，处理维护模式，而且只接受小改动和bug。个人认为更像是说明不再进行维护了。

Getting Started#

Dependency#

1
<dependency>
2
      <groupId>org.springframework.boot</groupId>
3
      <artifactId>spring-boot-starter-web</artifactId>
4
</dependency>

RestTemplate for Get#

1
URI uri = UriComponentsBuilder
2
    .fromUriString("http://localhost:8080/coffee/{id}")
3
      .build(1);
4
ResponseEntity<Coffee> c = restTemplate.getForEntity(uri, Coffee.class);
5
log.info("Response Status: {}, Response Headers: {}", c.getStatusCode(), c.getHeaders().toString());
6
log.info("Coffee: {}", c.getBody());

RestTemplate for Post#

1
String coffeeUri = "http://localhost:8080/coffee/";
2
Coffee request = Coffee.builder()
3
    .name("Americano")
4
    .price(BigDecimal.valueOf(25.00))
5
    .build();
6
Coffee response = restTemplate.postForObject(coffeeUri, request, Coffee.class);
7
log.info("New Coffee: {}", response);
8

9
String s = restTemplate.getForObject(coffeeUri, String.class);
10
log.info("String: {}", s);

Advanced feature#

可对请求头进行设置
可对泛型进行解析

Add Header to request#

1
URI uri = UriComponentsBuilder
2
        .fromUriString("http://localhost:8080/coffee/?name={name}")
3
        .build("mocha");
4
RequestEntity<Void> req = RequestEntity.get(uri)
5
    .accept(MediaType.APPLICATION_XML)
6
    .build();
7
ResponseEntity<String> resp = restTemplate.exchange(req, String.class);
8
log.info("Response Status: {}, Response Headers: {}", resp.getStatusCode(), resp.getHeaders().toString());
9
log.info("Coffee: {}", resp.getBody());

泛型解析#

1
ParameterizedTypeReference<List<Coffee>> ptr =
2
        new ParameterizedTypeReference<List<Coffee>>() {};
3
ResponseEntity<List<Coffee>> list = restTemplate
4
        .exchange(coffeeUri, HttpMethod.GET, null, ptr);
5
//设置泛型为List<Coffee>
6
list.getBody().forEach(c -> log.info("Coffee: {}", c));

定制RestTemplate#

RestTemplate是可以基于okhttp、httpclient、Netty或者是java默认的HttpConnection来实现的，也就是你也可以自己选择低层依赖。

通过接口ClientHttpRequestFactory#

可以基于RestTemplate实现底层依赖

RestTemplate的默认实现SimpleClientHttpRequestFactory#

SimpleClientHttpRequestFactory从名字上就可以看出是实现了ClientHttpRequestFactory，是Spring默认提供的，基于原始java的HttpConnection编写的。

基于Apache HttpClient的HttpComponentsClientHttpRequestFactory#

众所周知的Apache HttpClient已经改名为HttpComponents，所以是基于HttpComponents开发的RestTemplate

基于Netty4开发的Netty4ClientHttpRequestFactory#

Netty4ClientHttpRequestFactory基于Netty4开发

示例：基于HttpComponents的RestTemplate#

在spring中创建HttpComponentsClientHttpRequestFactory的Bean，即可完成对RestTemplate的底层依赖的切换。

1
  @Bean
2
  public HttpComponentsClientHttpRequestFactory requestFactory() {
3
    PoolingHttpClientConnectionManager connectionManager =
4
        new PoolingHttpClientConnectionManager(30, TimeUnit.SECONDS);
5
    connectionManager.setMaxTotal(200);
6
    connectionManager.setDefaultMaxPerRoute(20);
7

8
    CloseableHttpClient httpClient = HttpClients.custom()
9
        .setConnectionManager(connectionManager)
10
        .evictIdleConnections(30, TimeUnit.SECONDS)
11
        .disableAutomaticRetries()
12
        // 有 Keep-Alive 认里面的值，没有的话永久有效
13
        //.setKeepAliveStrategy(DefaultConnectionKeepAliveStrategy.INSTANCE)
14
        // 换成自定义的
15
        .setKeepAliveStrategy(new CustomConnectionKeepAliveStrategy())
16
        .build();
17

18
    HttpComponentsClientHttpRequestFactory requestFactory =
19
        new HttpComponentsClientHttpRequestFactory(httpClient);
20

21
    return requestFactory;
22
  }
23

24
  /**
25
   * RestTemplate的bean初始化
26
   * @param builder
27
   * @return
28
   */
29
  @Bean
30
  public RestTemplate restTemplate(RestTemplateBuilder builder) {
31
//    return new RestTemplate();
32

33
    return builder
34
        .setConnectTimeout(Duration.ofMillis(100))
35
        .setReadTimeout(Duration.ofMillis(500))
36
        .requestFactory(this::requestFactory)
37
        .build();
38
  }

调用方式跟平常的RestTemplate调用没有区别

1
@SpringBootApplication
2
@Slf4j
3
public class CustomerServiceApplication implements ApplicationRunner {
4
  @Autowired
5
  private RestTemplate restTemplate;
6

7
  public static void main(String[] args) {
8
    new SpringApplicationBuilder()
9
        .sources(CustomerServiceApplication.class)
10
        .bannerMode(Banner.Mode.OFF)
11
        .web(WebApplicationType.NONE)
12
        .run(args);
13
  }
14

15
  @Bean
16
  public HttpComponentsClientHttpRequestFactory requestFactory() {
17
    PoolingHttpClientConnectionManager connectionManager =
18
        new PoolingHttpClientConnectionManager(30, TimeUnit.SECONDS);
19
    connectionManager.setMaxTotal(200);
20
    connectionManager.setDefaultMaxPerRoute(20);
21

22
    CloseableHttpClient httpClient = HttpClients.custom()
23
        .setConnectionManager(connectionManager)
24
        .evictIdleConnections(30, TimeUnit.SECONDS)
25
        .disableAutomaticRetries()
26
        // 有 Keep-Alive 认里面的值，没有的话永久有效
27
        //.setKeepAliveStrategy(DefaultConnectionKeepAliveStrategy.INSTANCE)
28
        // 换成自定义的，这是底层策略的自定义配置
29
        .setKeepAliveStrategy(new CustomConnectionKeepAliveStrategy())
30
        .build();
31

32
    HttpComponentsClientHttpRequestFactory requestFactory =
33
        new HttpComponentsClientHttpRequestFactory(httpClient);
34

35
    return requestFactory;
36
  }
37

38
  /**
39
   * RestTemplate的bean初始化
40
   * @param builder
41
   * @return
42
   */
43
  @Bean
44
  public RestTemplate restTemplate(RestTemplateBuilder builder) {
45
//    return new RestTemplate();
46

47
    return builder
48
        .setConnectTimeout(Duration.ofMillis(100))
49
        .setReadTimeout(Duration.ofMillis(500))
50
        .requestFactory(this::requestFactory)
51
        .build();
52
  }
53

54
  @Override
55
  public void run(ApplicationArguments args) throws Exception {
56
    URI uri = UriComponentsBuilder
57
        .fromUriString("http://localhost:8080/coffee/?name={name}")
58
        .build("mocha");
59
    RequestEntity<Void> req = RequestEntity.get(uri)
60
        .accept(MediaType.APPLICATION_XML)
61
        .build();
62
    ResponseEntity<String> resp = restTemplate.exchange(req, String.class);
63
    log.info("Response Status: {}, Response Headers: {}", resp.getStatusCode(), resp.getHeaders().toString());
64
    log.info("Coffee: {}", resp.getBody());
65

66
    String coffeeUri = "http://localhost:8080/coffee/";
67
    Coffee request = Coffee.builder()
68
        .name("Americano")
69
        .price(Money.of(CurrencyUnit.of("CNY"), 25.00))
70
        .build();
71
    Coffee response = restTemplate.postForObject(coffeeUri, request, Coffee.class);
72
    log.info("New Coffee: {}", response);
73

74
    ParameterizedTypeReference<List<Coffee>> ptr =
75
        new ParameterizedTypeReference<List<Coffee>>() {};
76
    ResponseEntity<List<Coffee>> list = restTemplate
77
        .exchange(coffeeUri, HttpMethod.GET, null, ptr);
78
    list.getBody().forEach(c -> log.info("Coffee: {}", c));
79
  }
80
}

底层策略的配置#

底层策略支持对连接的管理（PoolingHttpClientConnectionManager、KeepAlive策略）、超时设置（ConnectTimeout/readTimeout）、SSL校验（证书检查策略）

连接复用#

1
package geektime.spring.springbucks.customer.support;
2

3
import org.apache.commons.lang3.StringUtils;
4
import org.apache.commons.lang3.math.NumberUtils;
5
import org.apache.http.HttpResponse;
6
import org.apache.http.conn.ConnectionKeepAliveStrategy;
7
import org.apache.http.protocol.HTTP;
8
import org.apache.http.protocol.HttpContext;
9

10
import java.util.Arrays;
11

12
public class CustomConnectionKeepAliveStrategy implements ConnectionKeepAliveStrategy {
13
    private final long DEFAULT_SECONDS = 30;
14

15
    @Override
16
    public long getKeepAliveDuration(HttpResponse response, HttpContext context) {
17
        return Arrays.asList(response.getHeaders(HTTP.CONN_KEEP_ALIVE))
18
                .stream()
19
                .filter(h -> StringUtils.equalsIgnoreCase(h.getName(), "timeout")
20
                        && StringUtils.isNumeric(h.getValue()))
21
                .findFirst()
22
                .map(h -> NumberUtils.toLong(h.getValue(), DEFAULT_SECONDS))
23
                .orElse(DEFAULT_SECONDS) * 1000;
24
    }
25
}