RestTemplate 封装 - RestUtils (2)

引入依赖

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

配置restTemplate

@Bean
public RestTemplate getRestTemplate() {
    try {
        // 配置后可以使用 https
        TrustStrategy acceptingTrustStrategy = (x509Certificates, em) -> true;
        SSLContext sslContext = org.apache.http.ssl.SSLContexts.custom().loadTrustMaterial(null, acceptingTrustStrategy).build();
        SSLConnectionSocketFactory csf = new SSLConnectionSocketFactory(sslContext, new NoopHostnameVerifier());
        CloseableHttpClient httpClient = HttpClients.custom().setSSLSocketFactory(csf).build();
        HttpComponentsClientHttpRequestFactory requestFactory = new HttpComponentsClientHttpRequestFactory();
        requestFactory.setHttpClient(httpClient);
        return new RestTemplate(requestFactory);
    } catch (Exception e) {
        log.error("getRestTemplate error.", e);
    }
    return new RestTemplate();
}

创建工具类

import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.MediaType;
import org.springframework.web.client.RestTemplate;

import java.util.HashMap;
import java.util.Map;

public class RestUtils {

    /**
     * 发送 get 请求
     *     默认：客户端接受 json 类型数据
     */
    public static  <T> T get(String url, Class<T> responseType) {
        // 设置默认请求头
        Map<String, String> httpHeaderMap = new HashMap<>();
        httpHeaderMap.put(HttpHeaders.ACCEPT, MediaType.APPLICATION_JSON_VALUE);
        return sendRequest(url, HttpMethod.GET, null, responseType, httpHeaderMap);
    }

    /**
     * 发送 post 请求
     *    默认：服务器接受 json 类型数据，客户端接受 json 类型数据
     */
    public static  <T> T post(String url, Object requestBody, Class<T> responseType) {
        Map<String, String> httpHeaderMap = new HashMap<>();
        httpHeaderMap.put(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE);
        httpHeaderMap.put(HttpHeaders.ACCEPT, MediaType.APPLICATION_JSON_VALUE);
        return sendRequest(url, HttpMethod.POST, requestBody, responseType, httpHeaderMap);
    }


    /**
     * 发送请求
     * @param method 请求方式
     */
    public static  <T> T sendRequest(String url, HttpMethod method, Object requestBody, Class<T> responseType, Map<String, String> httpHeaderMap) {
        HttpHeaders headers = new HttpHeaders();
        // 设置请求头
        httpHeaderMap.keySet().forEach(key -> {
            headers.add(key,httpHeaderMap.get(key));
        });
        HttpEntity<Object> entity = new HttpEntity<>(requestBody, headers);
        RestTemplate restTemplate = ApplicationContextAwareUtil.getBean(RestTemplate.class);
        return restTemplate.exchange(url, method, entity, responseType).getBody();
    }


    /**
     * 在 url 后面拼接参数
     * @param url 原请求路径
     * @param paramMap 参数map
     */
    public static String getParamUrl(String url, Map<String, String> paramMap) {
        StringBuilder sb = new StringBuilder(url);
        if (paramMap != null && !paramMap.isEmpty()) {
            sb.append("?");
            for (Map.Entry<String, String> entry : paramMap.entrySet()) {
                String key = entry.getKey();
                String value = entry.getValue();
                sb.append(key).append("=").append(value).append("&");
            }
            sb.deleteCharAt(sb.length() - 1); // 移除最后一个多余的"&"
        }
        return sb.toString();
    }
}

补充：Springboot 3.X，HttpClient 5.0/5.1

<dependency>
    <groupId>org.apache.httpcomponents.client5</groupId>
    <artifactId>httpclient5</artifactId>
</dependency>

import lombok.extern.slf4j.Slf4j;
import org.apache.hc.client5.http.impl.classic.CloseableHttpClient;
import org.apache.hc.client5.http.impl.classic.HttpClients;
import org.apache.hc.client5.http.impl.io.PoolingHttpClientConnectionManager;
import org.apache.hc.client5.http.impl.io.PoolingHttpClientConnectionManagerBuilder;
import org.apache.hc.client5.http.ssl.NoopHostnameVerifier;
import org.apache.hc.client5.http.ssl.SSLConnectionSocketFactory;
import org.apache.hc.client5.http.ssl.TrustAllStrategy;
import org.apache.hc.core5.ssl.SSLContextBuilder;
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.time.Duration;

@Slf4j
@Configuration
public class RestConfig {

    @Bean
    public RestTemplate restTemplate() {
        try {
            // 仅测试环境使用：信任所有证书 + 关闭主机名校验
            SSLContext sslContext = SSLContextBuilder.create()
                    .loadTrustMaterial(null, TrustAllStrategy.INSTANCE)
                    .build();

            SSLConnectionSocketFactory sslSocketFactory =
                    new SSLConnectionSocketFactory(sslContext, NoopHostnameVerifier.INSTANCE);

            // 在连接管理器上设置 SSL Socket Factory（适用于 HttpClient 5.0/5.1）
            PoolingHttpClientConnectionManager cm =
                    PoolingHttpClientConnectionManagerBuilder.create()
                            .setSSLSocketFactory(sslSocketFactory)
                            .build();

            CloseableHttpClient httpClient = HttpClients.custom()
                    .setConnectionManager(cm)
                    .build();

            HttpComponentsClientHttpRequestFactory requestFactory = new HttpComponentsClientHttpRequestFactory(httpClient);
            requestFactory.setConnectTimeout(Duration.ofSeconds(10));
            requestFactory.setConnectionRequestTimeout(Duration.ofSeconds(10));
            requestFactory.setReadTimeout(Duration.ofSeconds(30));

            return new RestTemplate(requestFactory);
        } catch (Exception e) {
            log.error("Create RestTemplate error.", e);
            return new RestTemplate();
        }
    }
}