参考链接

[URI Links——Spring/WebServlet](https://docs.spring.io/spring/docs/5.2.6.RELEASE/spring-framework-reference/web.html#mvc-uri-building)

RestClient——Spring/WebServlet

玩转Spring全家桶——极客时间@丁雪丰

Spring之RestTemplate

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](https://docs.spring.io/spring/docs/5.2.6.RELEASE/spring-framework-reference/web-reactive.html#webflux-client) which offers a more modern API and supports sync, async, and streaming scenarios. > > 从RestTemplate5.0开始处于维护模式中，仅接受较小的变更请求和bug处理。请关注使用WebClient参考一个更现代的API，它同样支持同步、异步和流场景。 >

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

Getting Started

Dependency

```xml org.springframework.boot spring-boot-starter-web ```

RestTemplate for Get

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

RestTemplate for Post

```java String coffeeUri = "http://localhost:8080/coffee/"; Coffee request = Coffee.builder() .name("Americano") .price(BigDecimal.valueOf(25.00)) .build(); Coffee response = restTemplate.postForObject(coffeeUri, request, Coffee.class); log.info("New Coffee: {}", response);

String s = restTemplate.getForObject(coffeeUri, String.class); log.info(“String: {}”, s);

1
<h2 id="YLLM8">Advanced feature</h2>
2
+ 可对请求头进行设置
3
+ 可对泛型进行解析
4

5
<h3 id="i6ouR">Add Header to request</h3>
6
```java
7
URI uri = UriComponentsBuilder
8
        .fromUriString("http://localhost:8080/coffee/?name={name}")
9
        .build("mocha");
10
RequestEntity<Void> req = RequestEntity.get(uri)
11
    .accept(MediaType.APPLICATION_XML)
12
    .build();
13
ResponseEntity<String> resp = restTemplate.exchange(req, String.class);
14
log.info("Response Status: {}, Response Headers: {}", resp.getStatusCode(), resp.getHeaders().toString());
15
log.info("Coffee: {}", resp.getBody());

泛型解析

```java ParameterizedTypeReference> ptr = new ParameterizedTypeReference>() {}; ResponseEntity> list = restTemplate .exchange(coffeeUri, HttpMethod.GET, null, ptr); //设置泛型为List 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校验（证书检查策略）

连接复用

```java package geektime.spring.springbucks.customer.support;

import org.apache.commons.lang3.StringUtils; import org.apache.commons.lang3.math.NumberUtils; import org.apache.http.HttpResponse; import org.apache.http.conn.ConnectionKeepAliveStrategy; import org.apache.http.protocol.HTTP; import org.apache.http.protocol.HttpContext;

import java.util.Arrays;

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

1
@Override
2
public long getKeepAliveDuration(HttpResponse response, HttpContext context) {
3
    return Arrays.asList(response.getHeaders(HTTP.CONN_KEEP_ALIVE))
4
            .stream()
5
            .filter(h -> StringUtils.equalsIgnoreCase(h.getName(), "timeout")
6
                    && StringUtils.isNumeric(h.getValue()))
7
            .findFirst()
8
            .map(h -> NumberUtils.toLong(h.getValue(), DEFAULT_SECONDS))
9
            .orElse(DEFAULT_SECONDS) * 1000;
10
}

}