RestTemplate的使用(一)

背景

spring为了简化与http服务的交互，执行rest原则而开发一个工具类

简单使用

1.引入spring-webmvc包,版本自己选

<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.1.5.RELEASE</version>
</dependency>

也可以直接引用spring-boot-starter-web，这个依赖了spring-webmvc

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
<version>2.1.3.RELEASE</version>
</dependency>

2.需要做配置优化，可引入httpclient包

3.加入配置

@Slf4j
@Configuration
public class RestTemplateConfig {

    @Bean
    public RestTemplate restTemplate() {
        RestTemplate restTemplate = new RestTemplate();
        //不做优化，可不重新赋值
        restTemplate.setRequestFactory(clientHttpRequestFactory());
        //不自定义错误处理，可不重新赋值
        restTemplate.setErrorHandler(new ResponseErrorHandler() {

            @Override
            public boolean hasError(ClientHttpResponse response) throws IOException {
                return false;
            }

            @Override
            public void handleError(ClientHttpResponse response) throws IOException {
                try {
                    log.error("resulted in {} ({}),header:{},body:{}",
                            response.getRawStatusCode(), response.getStatusText(), response.getHeaders(),
                            new String(getResponseBody(response), getCharset(response)));

                } catch (IOException ex) {
                    // ignore
                }
            }

            protected Charset getCharset(ClientHttpResponse response) {
                HttpHeaders headers = response.getHeaders();
                MediaType contentType = headers.getContentType();
                return (contentType != null ? contentType.getCharset() : null);
            }

            protected byte[] getResponseBody(ClientHttpResponse response) {
                try {
                    return FileCopyUtils.copyToByteArray(response.getBody());
                } catch (IOException ex) {
                    // ignore
                }
                return new byte[0];
            }
        });
        // 设置string消息转换器编码
        List<HttpMessageConverter<?>> list = restTemplate.getMessageConverters();
        for (HttpMessageConverter<?> httpMessageConverter : list) {
            if (httpMessageConverter instanceof StringHttpMessageConverter) {
                ((StringHttpMessageConverter)
                        httpMessageConverter).setDefaultCharset(Charset.forName("utf-8"));
                break;
            }
        }
        return restTemplate;
    }

    @Bean
    public HttpComponentsClientHttpRequestFactory clientHttpRequestFactory() {
        try {
            HttpClientBuilder httpClientBuilder = HttpClientBuilder.create();
            SSLContext sslContext = new SSLContextBuilder().loadTrustMaterial(null, new TrustStrategy() {
                public boolean isTrusted(X509Certificate[] arg0, String arg1) {
                    return true;
                }
            }).build();
            httpClientBuilder.setSSLContext(sslContext);
            HostnameVerifier hostnameVerifier = NoopHostnameVerifier.INSTANCE;
            SSLConnectionSocketFactory sslConnectionSocketFactory = new SSLConnectionSocketFactory(sslContext,
                    hostnameVerifier);
            Registry<ConnectionSocketFactory> socketFactoryRegistry = RegistryBuilder.<ConnectionSocketFactory>create()
                    .register("http", PlainConnectionSocketFactory.getSocketFactory())
                    .register("https", sslConnectionSocketFactory).build();// 注册http和https请求
            // 开始设置连接池
            PoolingHttpClientConnectionManager poolingHttpClientConnectionManager = new PoolingHttpClientConnectionManager(
                    socketFactoryRegistry);
            poolingHttpClientConnectionManager.setMaxTotal(2700); // 最大连接数2700
            poolingHttpClientConnectionManager.setDefaultMaxPerRoute(100); // 同路由并发数100
            httpClientBuilder.setConnectionManager(poolingHttpClientConnectionManager);
            httpClientBuilder.setRetryHandler(new DefaultHttpRequestRetryHandler(3, true)); // 重试次数
            HttpClient httpClient = httpClientBuilder.build();
            HttpComponentsClientHttpRequestFactory clientHttpRequestFactory = new HttpComponentsClientHttpRequestFactory(
                    httpClient); // httpClient连接配置
            clientHttpRequestFactory.setConnectTimeout(20000); // 连接超时
            clientHttpRequestFactory.setReadTimeout(30000); // 数据读取超时时间
            clientHttpRequestFactory.setConnectionRequestTimeout(20000); // 连接不够用的等待时间
            return clientHttpRequestFactory;
        } catch (KeyManagementException | NoSuchAlgorithmException | KeyStoreException e) {
            log.error("初始化HTTP连接池出错", e);
        }
        return null;
    }
}

 注：错误处理器没有重新定义，只要请求不是200，都会抛出异常

5.在需要使用的地方注入RestTemplate

最常用方法介绍

 

1.public <T> ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType, Map<String, ?> uriVariables);
url为请求地址,request请求参数,responseType为请求返回对象的class，T为返回对象，uriVariables为连接上的请求参数

2.public <T> ResponseEntity<T> postForEntity(URI url, Object request, Class<T> responseType);
url为请求地址,request请求参数,responseType为请求返回对象的class，T为返回对象

3.public <T> ResponseEntity<T> getForEntity(String url, Class<T> responseType, Map<String, ?> uriVariables)
 url为请求地址,responseType为请求返回对象的class，T为返回对象，uriVariables为连接上的请求参数

4.public <T> ResponseEntity<T> getForEntity(URI url, Class<T> responseType)
url为请求地址,responseType为请求返回对象的class，T为返回对象