SpringBoot配置RestTemplate

---

以下为2种配置方式,均可实现实现远程调用，jar引入只要其一即可；

方式一：RestTemplate + HttpClients

方式二：RestTemplate + OkHttp3

依赖

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>>2.4.0</version>
    <relativePath/>
</parent>

<dependency>
    <!--  不需要版本号  -->
    <groupId>org.apache.httpcomponents</groupId>
    <artifactId>httpclient</artifactId>
</dependency>

<dependency>
    <groupId>com.squareup.okhttp3</groupId>
    <artifactId>okhttp</artifactId>
    <version>3.9.1</version>
</dependency>

配置

RestTemplate + HttpClients

import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.conn.ssl.TrustStrategy;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.client.HttpComponentsClientHttpRequestFactory;
import org.springframework.web.client.RestTemplate;
import javax.net.ssl.SSLContext;
import java.security.KeyManagementException;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.cert.X509Certificate;
/**
 * className    RestTemplateConfig
 * author       demon
 * createTime   2021/6/8 13:09
 * description  RestTemplate + HttpClients 实现远程调用
 */
@Configuration
class RestTemplateConfig {
    @Bean
    public RestTemplate restTemplate() throws KeyStoreException, NoSuchAlgorithmException, KeyManagementException {
        TrustStrategy acceptingTrustStrategy = (X509Certificate[] chain, String authType) -> true;
        SSLContext sslContext = org.apache.http.ssl.SSLContexts.custom().loadTrustMaterial(null, acceptingTrustStrategy).build();
        SSLConnectionSocketFactory csf = new SSLConnectionSocketFactory(sslContext);
        CloseableHttpClient httpClient = HttpClients.custom().setSSLSocketFactory(csf).build();
        //使用httpclient的factory
        HttpComponentsClientHttpRequestFactory requestFactory = new HttpComponentsClientHttpRequestFactory();
        // 请求连接超时时间  毫秒
        requestFactory.setConnectTimeout(1000 * 60);
        // 从链接池获取连接超时时间  毫秒
        requestFactory.setConnectionRequestTimeout(6000);
        // 获取数据超时时间 毫秒
        requestFactory.setReadTimeout(1000 * 360);
        requestFactory.setHttpClient(httpClient);
        return new RestTemplate(requestFactory);
    }
}

RestTemplate + OkHttp3

import lombok.extern.slf4j.Slf4j;
import okhttp3.ConnectionPool;
import okhttp3.OkHttpClient;
import org.springframework.boot.web.client.RestTemplateBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.client.ClientHttpRequestInterceptor;
import org.springframework.http.client.ClientHttpResponse;
import org.springframework.http.client.OkHttp3ClientHttpRequestFactory;
import org.springframework.stereotype.Component;
import org.springframework.web.client.ResponseErrorHandler;
import org.springframework.web.client.RestTemplate;

import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSocketFactory;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;
import java.io.IOException;
import java.net.URI;
import java.security.KeyManagementException;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.security.cert.X509Certificate;
import java.time.Instant;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.time.format.DateTimeFormatter;
import java.util.concurrent.TimeUnit;

/**
 * className    RestTemplateConfig
 * author       demon
 * createTime   2021/6/8 13:09
 * description  RestTemplate + OkHttp3 实现远程调用
 */
@Slf4j
@Component
public class RestTemplateConfig {

    /**
     * 基于OkHttp3配置RestTemplate
     */
    @Bean
    public RestTemplate restTemplate(RestTemplateBuilder restTemplateBuilder) {
        RestTemplate restTemplate = restTemplateBuilder
                .errorHandler(new ResponseErrorHandler() {
                    @Override
                    public boolean hasError(ClientHttpResponse clientHttpResponse) throws IOException {
                        return clientHttpResponse.getStatusCode().value() != 200 && clientHttpResponse.getStatusCode().value() != 302;
                    }

                    @Override
                    public void handleError(ClientHttpResponse clientHttpResponse) {

                    }

                    @Override
                    public void handleError(URI url, HttpMethod method, ClientHttpResponse response) throws IOException {
                        log.error("=======================ERROR============================");
                        log.error("DateTime：{}", LocalDateTime.ofInstant(Instant.ofEpochMilli(response.getHeaders().getDate()), ZoneId.systemDefault()).format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
                        log.error("HOST:{}，URI：{}", url.getHost(), url.getPath());
                        log.error("Method：{}", method.name());
                        log.error("Exception：{}", response.getStatusCode());
                        log.error("========================================================");
                    }
                })
                .interceptors((ClientHttpRequestInterceptor) (httpRequest, bytes, clientHttpRequestExecution) -> {
                    HttpHeaders headers = httpRequest.getHeaders();
                    // 加入自定义字段
                    headers.add("Content-Type", "application/json;charset=UTF-8");
                    return clientHttpRequestExecution.execute(httpRequest, bytes);
                })
                .build();
        restTemplate.setRequestFactory(new OkHttp3ClientHttpRequestFactory(new OkHttpClient.Builder()
                // 整个流程耗费的超时时间
                .callTimeout(180, TimeUnit.SECONDS)
                // 读取耗时
                .readTimeout(60, TimeUnit.SECONDS)
                // 写入耗时
                .writeTimeout(60, TimeUnit.SECONDS)
                // 三次握手 + SSL建立耗时
                .connectTimeout(60, TimeUnit.SECONDS)
                .sslSocketFactory(sslSocketFactory(), x509TrustManager())
                // 当连接失败，尝试重连
                .retryOnConnectionFailure(true)
                // 最大空闲连接数及连接的保活时间进行配置
                .connectionPool(new ConnectionPool(200, 5, TimeUnit.MINUTES))
                // 绕过需要SSL证书验证的HTTPS的请求
                .hostnameVerifier((s, sslSession) -> true)
                .build()));
        return restTemplate;
    }

    @Bean
    public SSLSocketFactory sslSocketFactory() {
        try {
            // 信任任何链接
            SSLContext sslContext = SSLContext.getInstance("TLS");
            sslContext.init(null, new TrustManager[]{x509TrustManager()}, new SecureRandom());
            return sslContext.getSocketFactory();
        } catch (NoSuchAlgorithmException | KeyManagementException e) {
            e.printStackTrace();
        }
        return null;
    }

    @Bean
    public X509TrustManager x509TrustManager() {
        return new X509TrustManager() {
            @Override
            public void checkClientTrusted(X509Certificate[] x509Certificates, String s) {
            }

            @Override
            public void checkServerTrusted(X509Certificate[] x509Certificates, String s) {
            }

            @Override
            public X509Certificate[] getAcceptedIssuers() {
                return new X509Certificate[0];
            }
        };
    }


}

测试

@Slf4j
@SpringBootTest
class SpringBootApiApplicationTests {
    @Resource
    private RestTemplate restTemplate;
    @Test
    void contextLoads(){
        String url = "https://www.baidu.com/";
        String resp = restTemplate.getForObject(url, String.class);
        System.out.println(resp);
    }
}

结果

RestTemplate简单使用
RestTemplate封装使用