restTemplate

简介

Spring Boot提供了很多调用外部REST服务的方式，在Spring Boot应用中请求其他微服务接口发起外部HTTP请求，可以使用JDK原生的URLConnection、Apache的Http Client、Netty的异步HTTP Client, Spring的RestTemplate。
RestTemplate 是 Spring Framework 提供的同步 HTTP 客户端工具，用于简化 Web Service 调用。它只是对其他的HTTP客户端的封装，其本身并没有实现HTTP相关的基础功能。其底层实现是可以配置切换的。
调用RestTemplate的默认构造函数，RestTemplate对象在底层通过使用java.net包下的实现创建HTTP 请求，可以通过使用ClientHttpRequestFactory指定不同的HTTP请求方式。
RestTemplate 支持至少三种HTTP客户端库。

• SimpleClientHttpRequestFactory：对应的HTTP库是java JDK自带的HttpURLConnection，是默认的底层HTTP实现客户端。不支持HTTP协议的Patch方法，如果希望使用Patch方法，需要将底层HTTP客户端实现切换为Apache HttpComponents 或 OkHttp。
• HttpComponentsAsyncClientHttpRequestFactory：对应的HTTP库是Apache HttpComponents。底层使用HttpClient访问远程的Http服务，使用HttpClient可以配置连接池和证书等信息。
• OkHttp3ClientHttpRequestFactory：对应的HTTP库是OkHttp
  可以通过设置setRequestFactory方法，来切换RestTemplate的底层HTTP客户端实现类库。

底层实现切换方法

切换为okHTTP

首先通过maven坐标将okHTTP的包引入到项目中来,使用OkHttp3ClientHttpRequestFactory初始化RestTemplate bean对象。

@Configuration
public class ContextConfig {
    @Bean("OKHttp3")
    public RestTemplate OKHttp3RestTemplate(){
        RestTemplate restTemplate = new RestTemplate(new OkHttp3ClientHttpRequestFactory());
        return restTemplate;
    }
}

切换为Apache HttpComponents

首先通过maven坐标将包引入到项目中来,使用HttpComponentsClientHttpRequestFactory初始化RestTemplate bean对象。

@Bean("httpClient")
public RestTemplate httpClientRestTemplate(){
    RestTemplate restTemplate = new RestTemplate(new HttpComponentsClientHttpRequestFactory());
    return restTemplate;
}

使用方法

引入依赖后配置连接池

#最大连接数
http.maxTotal: 100
#并发数
http.defaultMaxPerRoute: 20
#创建连接的最长时间
http.connectTimeout: 1000
#从连接池中获取到连接的最长时间
http.connectionRequestTimeout: 500
#数据传输的最长时间
http.socketTimeout: 10000
#提交请求前测试连接是否可用
http.staleConnectionCheckEnabled: true
#可用空闲连接过期时间,重用空闲连接时会先检查是否空闲时间超过这个时间，如果超过，释放socket重新建立
http.validateAfterInactivity: 3000000

初始化连接池

@Configuration
public class RestTemplateConfig {
    @Value("${http.maxTotal}")
    private Integer maxTotal;
    @Value("${http.defaultMaxPerRoute}")
    private Integer defaultMaxPerRoute;
    @Value("${http.connectTimeout}")
    private Integer connectTimeout;
    @Value("${http.connectionRequestTimeout}")
    private Integer connectionRequestTimeout;
    @Value("${http.socketTimeout}")
    private Integer socketTimeout;
    @Value("${http.staleConnectionCheckEnabled}")
    private boolean staleConnectionCheckEnabled;
    @Value("${http.validateAfterInactivity}")
    private Integer validateAfterInactivity;
    @Bean
    public RestTemplate restTemplate() {
        return new RestTemplate(httpRequestFactory());
    }
    @Bean
    public ClientHttpRequestFactory httpRequestFactory() {
        return new HttpComponentsClientHttpRequestFactory(httpClient());
    }
    @Bean
    public HttpClient httpClient() {
        Registry<ConnectionSocketFactory> registry = RegistryBuilder.<ConnectionSocketFactory>create()
                .register("http", PlainConnectionSocketFactory.getSocketFactory())
                .register("https", SSLConnectionSocketFactory.getSocketFactory())
                .build();
        PoolingHttpClientConnectionManager connectionManager = new PoolingHttpClientConnectionManager(registry);
        connectionManager.setMaxTotal(maxTotal); // 最大连接数
        connectionManager.setDefaultMaxPerRoute(defaultMaxPerRoute);    //单个路由最大连接数
        connectionManager.setValidateAfterInactivity(validateAfterInactivity); // 最大空间时间
        RequestConfig requestConfig = RequestConfig.custom()
                .setSocketTimeout(socketTimeout)        //服务器返回数据(response)的时间，超过抛出read timeout
                .setConnectTimeout(connectTimeout)      //连接上服务器(握手成功)的时间，超出抛出connect timeout
                .setStaleConnectionCheckEnabled(staleConnectionCheckEnabled) // 提交前检测是否可用
                .setConnectionRequestTimeout(connectionRequestTimeout)//从连接池中获取连接的超时时间，超时间未拿到可用连接，会抛出org.apache.http.conn.ConnectionPoolTimeoutException: Timeout waiting for connection from pool
                .build();
        return HttpClientBuilder.create()
                .setDefaultRequestConfig(requestConfig)
                .setConnectionManager(connectionManager)
                .build();
    }

优点：连接池、超时时间设置、支持异步、请求和响应的编解码
缺点：依赖别的spring版块、参数传递不灵活
RestTemplate默认是使用SimpleClientHttpRequestFactory，内部是调用jdk的HttpConnection，默认超时为-1

常用方法示例

exchange

public ResponseEntity<String> postWithHeaders() {
    HttpHeaders headers = new HttpHeaders();
    headers.set("X-API-Key", "secret-key");
    headers.setContentType(MediaType.APPLICATION_JSON);
    HttpEntity<User> request = new HttpEntity<>(new User(), headers);
    String url = "https://api.example.com/users"；
    return restTemplate.exchange(
        url,
        HttpMethod.POST,
        request,
        String.class
    );

postforEntity

restTemplate.postForEntity(url, request, responseType)参数信息

• url（String 类型）：请求的目标 URL。可以是一个字符串形式的 URL，也可以是一个 URI 对象。
• request（Object 类型）：表示要发送的请求体内容。可以是一个简单对象、一个 HttpEntity 对象或一个 MultiValueMap（用于传递表单数据）。
• responseType（Class 类型）：表示期望的响应类型。可以是任何 Java 类型，包括自定义类型。例如，如果期望返回一个 User 对象，则可以将其设置为 User.class。

//示例1
@RequestMapping("/user")
public User user() {
    User user = new User();
    user.setName("zhangsan");
    String url = "https://api.example.com/users"；
    ResponseEntity<User> responseEntity = restTemplate.postForEntity(url, user, User.class);
    return responseEntity.getBody();
}
//示例2
public List<User> user() {
	//设置请求头信息
    HttpHeaders headers = new HttpHeaders);
    String url = "https://api.example.com/users"；
    // 构建请求体
    User user = new User("John", 30); // 自定义 User 类
    HttpEntity<User> req = new HttpEntity<>(user);
    //请求
	ResponseEntity<Object> responseEntity = RestTemplateUtil.getHttpsRestTemplate().postForEntity(url, new HttpEntity<>(req,headers), Object.class);
	// 获取响应结果
	HttpStatus statusCode = response.getStatusCode();
    HttpHeaders headers = response.getHeaders();
    //String body = response.getBody();
	Object obj = responseEntity.getBody;
	JSONArray jsonArray = new JSONArray (obj);
	List<User> resultList = Beanutil.copyTeList(jsonArray, User.class);
	return resultList;
}