SpringBoot使用OkHttp完成高效网络请求详解

目录

• 一、OkHttp 简介
• 二、在 Spring Boot 中集成 OkHttp
• 三、封装 OkHttp 客户端工具类
• 3.1 初始化 OkHttpClient
• 3.2 构建请求
• 3.3 同步与异步请求
• 四、优化与扩展
• 4.1 添加请求头
• 4.2 处理 HTTPS 请求

一、OkHttp 简介

OkHttp 是一个高效的 HTTP 客户端，它支持同步和异步请求，且具备自动处理 cookie、缓存和连接池等高级功能javascript。

与 Java 原生的 HttpURLConnection 和 Apache 的 HttpClient 相比，OkHttp 的 API 设计更加人性化，使用起来也更加方便。

二、在 Spring Boot 中集成 OkHttp

首先，我们需要在 Spring Boot 项目中引入 OkHttp 的依赖。

在 pom.XML 文件中添加以下依赖：

<dependency>
    <groupId>com.squareup.okhttp3</groupId>
    <artifactId>okhttp</artifactId>
    <version>4.9.3</version> <!-- 注意：版本号可能有所更新，请根据实际情况选择 -->
</dependency>

三、封装 OkHttp 客户端工具类

为了方便在项目中统一管理和使用 OkHttp 客户端，我们可以将其封装成一个工具类。

这个工具类将负责初始化 OkHttpClient 实例、构建请求、处理响应等任务。

3.1 初始化 OkHttp编程客栈Client

在工具类中，我们使用单例模式来初始化 OkHttpClient 实例，并设置一些全局的配置，如连接超时、读写超时等。

import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import okhttp3.ResponseBody;
import okio.Buffer;

import javax.net.ssl.SSLContext;
imppythonort javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;
import java.io.IOException;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import java.util.concurrent.TimeUnit;

public class OkHttpUtil {
    
    private static final OkHttpClient OK_HTTP_CLIENT;

    static {
        TrustManager[] trustManagers = newTrustManager[]{
                newX509TrustManager() {
                    @Override
                    publicvoidcheckClientTrusted(X509Certificate[] chain, String authType)throws CertificateException {
                    }

                    @Override
                    publicvoidcheckServerTrusted(X509Certificate[] chain, String authType)throws CertificateException {
                    }

                    @Override
                    public X509Certificate[] getAcceptedIssuers() {
                        returnnewX509Certificate[]{};
                    }
                }
        };

        try {
            SSLCont编程客栈extsslContext= SSLContext.getInstance("SSL");
            sslContext.init(null, trustManagers, newjava.security.SecureRandom());

            OK_HTTP_CLIENT = newOkHttpClient.Builder()
                    .connectTimeout(15, TimeUnit.SECONDS)
                    .writeTimeout(20, TimeUnit.SECONDS)
                    .readTimeout(20, TimeUnit.SECONDS)
                    .sslSocketFactory(sslContext.getSocketFactory(), (X509TrustManager) trustManagers[0])
                    .hostnameVerifier((hostname, session) -> true)
                    .build();
        } catch (Exception e) {
            thrownewRuntimeException(e);
        }
    }

    // 省略其他方法...
}

在这里，我们使用了自定义的 TrustManager 来忽略 SSL 证书验证，这通常用于开发和测试环境。

在生产环境中，应该使用正确的证书验证机制。

3.2 构建请求

接下来，我们需要在工具类中提供构建请求的方法。

这些方法将允许用户设置请求的 URL、参数、头部等信息。

import okhttp3.FormBody;
import okhttp3.MediaType;
import okhttp3.Request;
import okhttp3.RequestBody;

import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Objects;

public class OkHttpUtil {
    
    // ... 省略其他代码

    private String url;
    private Map<String, String> headers = newLinkedHashMap<>();
    private Map<String, Object> params = newLinkedHashMap<>();
    private Request.Builder requestBuilder;

    privat eOkHttpUtil() {
        // 可以在这里添加一些全局的请求头部，比如 User-Agent
        this.headers.put("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (Khtml, like Gecko) Chrome/78.0.3904.108 Safari/537.36");
    }

    public static OkHttpUtil builder() {
        returnnewOkHttpUtil();
    }

    public OkHttpUtil url(String url) {
        this.url = url;
        returnthis;
    }

    public OkHttpUtil addParam(String key, String value) {
        this.params.put(key, value);
        returnthis;
    }

    public OkHttpUtil addHeader(String key, String value) {
        this.headers.put(key, value);
        returnthis;
    }

    public OkHttpUtil initGet() {
        this.requestBuilder = newRequest.Builder().get();
        StringBuilder urlBuilder=newStringBuilder(this.url);
        if (!this.params.isEmpty()) {
            urlBuilder.append("?");
            this.params.forEach((k, v) -> urlBuilder.append(k).append("=").append(v).append("&"));
            urlBuilder.deleteCharAt(urlBuilder.length() - 1);
        }
        this.requestBuilder.url(urlBuilder.toString());
        returnthis;
    }

    public OkHttpUtil initPost(boolean isjson) {
        RequestBody requestBody;
        if (isJson) {
            Stringjson="";
            if (!this.params.isEmpty()) {
                // 这里需要使用合适的 JSON 库将 Map 转换为 JSON 字符串
                // 例如：json = JSON.toJSONString(this.params);
                // 注意：实际代码中需要引入 JSON 库，并处理相关的依赖和异常
                // 为简化示例，这里省略了 JSON 转换的代码
            }
            requestBody = RequestBody.create(json, MediaType.parse("application/json; charset=utf-8"));
        } else {
            FormBody.Builder formBuilder=newFormBody.Builder();
            this.params.forEach((k, v) -> formBuilder.add(k, v.toString()));
            requestBody = formBuilder.build();
        }
        this.requestBuilder = newRequest.Builder().post(requestBody).url(this.url);
        returnthis;
    }

    // ... 省略其他方法...
}

3.3 同步与异步请求

最后，我们需要在工具类中提供同步和异步请求的方法。

这些方法将负责发送请求并处理响应。

import okhttp3.Call;
import okhttp3.Callback;
import okhttp3.Response;

public class OkHttpUtil {
    
    // ... 省略其他代码

    public String sync() {
        try {
            Request request=this.requestBuilder.build();
            this.headers.forEach(request::addHeader);
            Response response= OK_HTTP_CLIENT.newCall(request).execute();
            if (response.isSuccessful()) {
                return response.body().string();
            } else {
                return"请求失败，状态码：" + response.code();
            }
        } catch (IOException e) {
            e.printStackTrace();
            return"请求失败，异常：" + e.getMessage();
        }
    }

    public String async() {
        final StringBuffer buffer=newStringBuffer();
        Request request=this.requestBuilder.build();
        this.headers.forEach(request::addHeader);
        OK_HTTP_CLIENT.newCall(request).enqueue(newCallback() {
            @Override
            public void onFailure(Call call, IOException e) {
                buffer.append("请求出错：").append(e.getMessage());
            }

            @Override
            public void onResponse(Call call, Response response)throws IOException {
                if (response.isSuccessful()) {
                    buffer.appen编程d(response.body().string());
                } else {
                    buffer.append("请求失败，状态码：").append(response.code());
                }
            }
        });
        // 注意：这里返回的是一个空字符串或者是一个表示请求正在进行的提示
        // 因为异步请求是非阻塞的，所以不能直接返回最终的响应结果
        // 实际应用中，可以通过回调接口或者其他机制来处理异步请求的响应
    }
}

四、优化与扩展

4.1 添加请求头

在工具类中添加方法，支持自定义请求头：

public OkHttpUtil addHeader(String key, String value) {
    okHttpClient = okHttpClient.newBuilder()
            .addInterceptor(chain -> {
                Requestoriginal= chain.request();
                RequestnewRequest= original.newBuilder()
                        .header(key, value)
                        .build();
                return chain.proceed(newRequest);
            })
            .build();
    returnthis;
}

4.2 处理 HTTPS 请求

如果需要支持 HTTPS 请求，可以在工具类中添加 SSL 配置：

private static SSLSocketFactory createSSLSocketFactory() {
    try {
        SSLContextsslContext= SSLContext.getInstance("SSL");
        sslContext.init(null, newTrustManager[]{newX509TrustManager() {
            @Override
            publicvoidcheckClientTrusted(X509Certificate[] chain, String authType) {}

            @Override
            publicvoidcheckServerTrusted(X509Certificate[] chain, String authType) {}

            @Override
            public X509Certificate[] getAcceptedIssuers() {
                returnnewX509Certificate[]{};
            }
        }}, newSecureRandom());
        return sslContext.getSocketFactory();
    } catch (Exception e) {
        thrownewRuntimeException(e);
    }
}

然后在初始化 OkHttpClient 时使用：

okHttpClient = new OkHttpClient.Builder()
        .sslSocketFactory(createSSLSocketFactory(), newX509TrustManager() {
            @Override
            publicvoidcheckClientTrusted(X509Certificate[] chain, String authType) {}

            @Override
            publicvoidcheckServerTrusted(X509Certificate[] chain, String authType) {}

            @Override
            public X509Certificate[] getAcceptedIssuers() {
                returnnewX509Certificate[]{};
            }
        })
        .build();

以上就是SpringBoot使用OkHttp完成高效网络请求详解的详细内容，更多关于SpringBoot OkHttp网络请求的资料请关注编程客栈(www.devze.com)其它相关文章！