springboot系列12、springboot集成RestTemplate及常见用法

1、背景介绍

　在微服务都是以HTTP接口的形式暴露自身服务的，所以在调用远程服务时就必须使用HTTP客户端。咱们可使用JDK原生的URLConnection、Apache的Http Client、Netty的异步HTTP Client, Spring的RestTemplate。这里介绍的是RestTemplate。RestTemplate底层用仍是HttpClient，对其作了封装，使用起来更简单。

一、什么是RestTemplate？

RestTemplate是Spring提供的用于访问Rest服务的客户端，
RestTemplate提供了多种便捷访问远程Http服务的方法,可以大大提升客户端的编写效率。
调用RestTemplate的默认构造函数，RestTemplate对象在底层经过使用java.net包下的实现建立HTTP 请求，
能够经过使用ClientHttpRequestFactory指定不一样的HTTP请求方式。
ClientHttpRequestFactory接口主要提供了两种实现方式
1、一种是SimpleClientHttpRequestFactory，使用J2SE提供的方式（既java.net包提供的方式）建立底层的Http请求链接。
2、一种方式是使用HttpComponentsClientHttpRequestFactory方式，底层使用HttpClient访问远程的Http服务，使用HttpClient能够配置链接池和证书等信息。

　　其实spring并无真正的去实现底层的http请求（3次握手），而是集成了别的http请求，spring只是在原有的各类http请求进行了规范标准，让开发者更加简单易用，底层默认用的是jdk的http请求。

二、RestTemplate的优缺点：

          优势：链接池、超时时间设置、支持异步、请求和响应的编解码

          缺点：依赖别的spring版块、参数传递不灵活

RestTemplate默认是使用SimpleClientHttpRequestFactory，内部是调用jdk的HttpConnection，默认超时为-1

@Autowired
RestTemplate simpleRestTemplate;
@Autowired
RestTemplate restTemplate;

2、配置RestTemplate

一、引入依赖

<dependency>
    <groupId>org.apache.httpcomponents</groupId>
    <artifactId>httpclient</artifactId>
    <version>4.5.6</version>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

二、链接池配置

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

三、初始化链接池

package com.example.demo.config;

import org.apache.http.client.HttpClient;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.config.Registry;
import org.apache.http.config.RegistryBuilder;
import org.apache.http.conn.socket.ConnectionSocketFactory;
import org.apache.http.conn.socket.PlainConnectionSocketFactory;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.impl.client.HttpClientBuilder;
import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.client.ClientHttpRequestFactory;
import org.springframework.http.client.HttpComponentsClientHttpRequestFactory;
import org.springframework.web.client.RestTemplate;

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

}

四、使用示例

RestTemplate是对HttpCilent的封装，因此，依HttpCilent然能够继续使用HttpCilent。看下二者的区别

HttpCilent：

  @RequestMapping("/testHttpClient")
    @ResponseBody
    public Object getUser(String msg) throws IOException {
        CloseableHttpClient closeableHttpClient = HttpClients.createDefault();
        HttpGet get = new HttpGet("http://192.168.1.100:8080/User/getAllUser");
        CloseableHttpResponse response = closeableHttpClient.execute(get);
        return EntityUtils.toString(response.getEntity(), "utf-8");
    }

RestTemplate：

   @RequestMapping("/testRestTemplate")
    @ResponseBody
    public Object testRestTemplate() throws IOException {
        ResponseEntity result= restTemplate.getForEntity("http://192.168.1.100:8080/User/getAllUser",ResponseEntity.class);
        return result.getBody();
    }

RestTemplate更简洁了。

3、RestTemplate经常使用方法

一、getForEntity

getForEntity方法的返回值是一个ResponseEntity<T>，ResponseEntity<T>是Spring对HTTP请求响应的封装，包括了几个重要的元素，如响应码、contentType、contentLength、响应消息体等。好比下面一个例子：

@RequestMapping("/sayhello")
public String sayHello() {
    ResponseEntity<String> responseEntity = restTemplate.getForEntity("http://HELLO-SERVICE/sayhello?name={1}", String.class, "张三");
    return responseEntity.getBody();
}
@RequestMapping("/sayhello2")
public String sayHello2() {
    Map<String, String> map = new HashMap<>();
    map.put("name", "李四");
    ResponseEntity<String> responseEntity = restTemplate.getForEntity("http://HELLO-SERVICE/sayhello?name={name}", String.class, map);
    return responseEntity.getBody();
}

二、getForObject

 getForObject函数其实是对getForEntity函数的进一步封装，若是你只关注返回的消息体的内容，对其余信息都不关注，此时可使用getForObject，举一个简单的例子，以下：

@RequestMapping("/book2")
public Book book2() {
    Book book = restTemplate.getForObject("http://HELLO-SERVICE/getbook1", Book.class);
    return book;
}

三、postForEntity

@RequestMapping("/book3")
public Book book3() {
    Book book = new Book();
    book.setName("红楼梦");
    ResponseEntity<Book> responseEntity = restTemplate.postForEntity("http://HELLO-SERVICE/getbook2", book, Book.class);
    return responseEntity.getBody();
}

• 方法的第一参数表示要调用的服务的地址
• 方法的第二个参数表示上传的参数
• 方法的第三个参数表示返回的消息体的数据类型

四、postForObject

若是你只关注，返回的消息体，能够直接使用postForObject。用法和getForObject一致。

五、postForLocation

postForLocation也是提交新资源，提交成功以后，返回新资源的URI，postForLocation的参数和前面两种的参数基本一致，只不过该方法的返回值为Uri，这个只须要服务提供者返回一个Uri便可，该Uri表示新资源的位置。

六、PUT请求

在RestTemplate中，PUT请求能够经过put方法调用，put方法的参数和前面介绍的postForEntity方法的参数基本一致，只是put方法没有返回值而已。举一个简单的例子，以下：

@RequestMapping("/put")
public void put() {
    Book book = new Book();
    book.setName("红楼梦");
    restTemplate.put("http://HELLO-SERVICE/getbook3/{1}", book, 99);
}

七、DELETE请求

delete请求咱们能够经过delete方法调用来实现，以下例子：

@RequestMapping("/delete")
public void delete() {
    restTemplate.delete("http://HELLO-SERVICE/getbook4/{1}", 100);
}