前言：

• 在日常工作和学习中，有很多地方都需要发送 HTTP/HTTPS 请求，本文介绍了几种常用的实现方式，供大家参考，收藏不迷路。

由于篇幅问题，本篇文章分为上、下两篇，链接如下：

• 【上篇】HttpURLConnection、HttpClient
• 【下篇】Okhttp3、RestTemplate、Hutool

一、五种实现方式对比结果

为了方便大家选择适合自己的实现方式，先展示五种实现方式的对比结果：

实现方式	底层依赖	优点	缺点
HttpURLConnection	Java标准库 (java.net)	1、不需要外部依赖。 2、能够直接访问java.net.URL类的功能。	1、功能相对有限。 2、需要手动管理很多资源（如打开和关闭连接）。 3、缺乏错误处理和重试机制。
HttpClient	Apache HttpClient库	1、提供了丰富的功能集。 2、支持HTTP协议的各种特性。 3、可以方便地管理连接池和请求超时。	1、需要引入额外的依赖。 2、相比其他轻量级库来说可能显得有些笨重。
OkHttp3	OkHttp3库	1、高性能，支持HTTP/2和其他现代特性。 2、易于使用，API设计友好。 3、提供了很好的错误处理和重试策略。	1、需要引入外部依赖。 2、对于只需要简单请求的应用来说，可能有些过于复杂。
RestTemplate	Spring框架	1、集成了Spring框架，便于集成使用。 2、提供了方便的方法来发送各种类型的HTTP请求。 3、支持消息转换器，可以方便地处理请求和响应对象。	1、依赖于Spring框架。 2、如果不在Spring环境中使用，可能显得冗余。
Hutool	Hutool库 (cn.hutool.http)	1、API简单易用。 2、提供了丰富的辅助方法。 3、轻量级，可以作为独立的库使用。	1、需要引入额外的依赖。 2、相比于专门的HTTP客户端库，可能在某些高级功能上有所欠缺。

二、Demo接口地址

在开始介绍实现方式之前，推荐一个用于 HTTP/HTTPS 测试的网站，超级好用：

• HTTP 测试：http://httpbin.org/#/HTTP_Methods
• HTTPS测试：https://httpbin.org/#/HTTP_Methods

这个网站提供了各种方式的接口测试，页面如下所示：

除了模拟基本的请求方式，这个网站还可以模拟以下各种类型的接口响应：

---

实现方式三、Okhttp3 库实现

3.1 简介

• okhttp 是由 Square 公司开发的一款轻量级网络请求库，支持普通的 HTTP/1.1 和 SPDY 网络协议，可与 Retrofit 等网络请求框架搭配使用。

3.2 Maven依赖

<!-- okhttp3 依赖 -->
<dependency>
	<groupId>com.squareup.okhttp3</groupId>
	<artifactId>okhttp</artifactId>
	<version>4.9.3</version>
</dependency>

3.3 配置文件

application.yml

ok:
  http:
    connect-timeout: 60
    read-timeout: 60
    write-timeout: 60
    # 连接池中整体的空闲连接的最大数量
    max-idle-connections: 200
    # 连接空闲时间最多为 300 秒
    keep-alive-duration: 300

3.4 配置类

需要给配置添加相应的配置类，来让配置生效。

OkHttpConfiguration.java

import okhttp3.ConnectionPool;
import okhttp3.OkHttpClient;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSocketFactory;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;
import java.security.KeyManagementException;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import java.util.concurrent.TimeUnit;

/**
 * okhttp3配置类
 */
@Configuration
public class OkHttpConfiguration {
   

    @Value("${ok.http.connect-timeout}")
    private Integer connectTimeout;
    @Value("${ok.http.read-timeout}")
    private Integer readTimeout;
    @Value("${ok.http.write-timeout}")
    private Integer writeTimeout;
    @Value("${ok.http.max-idle-connections}")
    private Integer maxIdleConnections;
    @Value("${ok.http.keep-alive-duration}")
    private Long keepAliveDuration;
    @Bean
    public OkHttpClient okHttpClient() {
   
        return new OkHttpClient.Builder()
                .sslSocketFactory(sslSocketFactory(), x509TrustManager())
                // 是否开启缓存
                .retryOnConnectionFailure(false)
                .connectionPool(pool())
                .connectTimeout(connectTimeout, TimeUnit.SECONDS)
                .readTimeout(readTimeout, TimeUnit.SECONDS)
                .writeTimeout(writeTimeout,TimeUnit.SECONDS)
                .hostnameVerifier((hostname, session) -> true)
                // 设置代理
                // .proxy(new Proxy(Proxy.Type.HTTP, new InetSocketAddress("127.0.0.1", 8888)))
                // 拦截器
                // .addInterceptor()
                .build();
    }
    @Bean
    public X509TrustManager x509TrustManager() {
   
        return new X509TrustManager() {
   
            @Override
            public void checkClientTrusted(X509Certificate[] chain, String authType)
                    throws CertificateException {
   
            }
            @Override
            public void checkServerTrusted(X509Certificate[] chain, String authType)
                    throws CertificateException {
   
            }
            @Override
            public X509Certificate[] getAcceptedIssuers() {
   
                return new X509Certificate[0];
            }
        };
    }
    @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 ConnectionPool pool() {
   
        return new ConnectionPool(maxIdleConnections, keepAliveDuration, TimeUnit.SECONDS);
    }
}

3.5 工具类

OkHttpClientUtil.java

package com.demo.util;

import lombok.extern.slf4j.Slf4j;
import okhttp3.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import java.util.Map;

/**
 * okhttp3工具类
 */
@Slf4j
@Component
public class OkHttpClientUtil {
   
    private static final MediaType JSON = MediaType.parse("application/json; charset=utf-8");
    private static final MediaType XML = MediaType.parse("application/xml; charset=utf-8");

    private static OkHttpClient okHttpClient;

    // 为使用静态调用异步注入
    @Autowired
    private OkHttpClient getOkHttpClient;
    @PostConstruct
    public void init() {
   
        okHttpClient = getOkHttpClient;
    }
    /**
     * get 请求
     * @param url  请求url地址
     * @return string
     * */
    public static String doGet(String url) {
   
        return doGet(url, null, null);
    }

    public static byte[] doGetByte(String url) {
   
        return doGetByte(url, null, null);
    }

    public static String doPost(String url) {
   
        return doPost(url, null, null);
    }
    /**
     * get 请求
     * @param url  请求url地址
     * @param params 请求参数 map
     * @return string
     * */
    public static