OkhttpUtil：简化HTTP请求处理的工具类封装

已退乎

1338人浏览 · 2025-08-13 14:51:20

已退乎 · 2025-08-13 14:51:20 发布

简介： OkhttpUtil 是一个基于OkHttp库的封装工具类，用于简化Android或Java开发中的HTTP请求操作。该工具类提供了GET、POST请求的封装，以及文件的上传和下载功能。 OkhttpUtil 通过拦截器机制和回调处理简化了网络通信过程，同时也提供了进度监听和错误处理等实用功能。开发者可以利用 OkhttpUtil 中的静态方法快速发起网络请求，并能够针对不同需求对工具类进行定制和优化。
OkhttpUtil工具类

1. OkHttp基础与特性介绍

1.1 OkHttp简介

OkHttp是一个支持HTTP/2和SPDY协议的高效HTTP客户端。由Square公司开发，旨在通过减少网络资源占用以及减少网络延迟来提供更快速的网络请求。它封装了底层的网络调用，并提供同步与异步请求的能力，适用于Android和Java应用程序。

1.2 OkHttp核心特性

支持HTTP/2和SPDY协议，可以建立同一个主机的多个请求，实现多路复用，提升网络资源利用率。
自动管理连接的持久化和重用，减少请求的延迟。
支持透明的GZIP压缩，减少传输数据量。
提供同步和异步两种请求方式，灵活性高。
支持响应缓存，减少网络请求次数。
通过拦截器可以实现请求和响应的拦截处理，便于进行自定义的错误处理、重试、日志记录等。
易于使用的API，使得开发者可以轻松地发送和接收数据。

1.3 OkHttp的应用场景

OkHttp常被用于网络请求频繁的场景，如社交媒体应用、在线游戏、地图服务等。其高效的特性使得在移动设备上进行网络操作时更加省电且快速，因此尤其适合在移动应用开发中使用。

OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
    .url("https://api.example.com")
    .build();

Response response = client.newCall(request).execute();

上述代码展示了如何使用OkHttpClient发起一个同步的网络请求。在本章中，我们将详细介绍OkHttp的基本使用和核心特性，并逐步深入探讨如何在各种网络请求中封装和应用这些特性。

2. GET请求的封装实现

2.1 GET请求的基本使用

2.1.1 GET请求的定义与作用

GET请求是HTTP协议中的一种方法，其用途是获取指定资源的数据。它通过向服务器发送一个请求来查询指定的资源，该请求包含必要的URL和头信息，但不包含请求体（body）。GET请求具有幂等性，即多次对同一URL执行GET请求，结果应是一致的，不应产生副作用。在Web应用中，GET请求广泛用于获取网页内容、图片、文件等静态资源。

2.1.2 GET请求的参数传递方式

在GET请求中，参数通常附加在URL之后，以“?”开始，后跟键值对。多个参数之间使用“&”分隔。键值对的格式为 key=value 。例如： http://example.com/api/users?name=John&age=30 。这种方式简单明了，但需要注意URL长度限制和安全性问题，因为参数是明文传输的，可能会造成敏感信息泄露。

2.2 GET请求的封装方法

2.2.1 封装GET请求的步骤

封装GET请求的步骤通常包括：

创建 OkHttpClient 实例，用于配置HTTP连接。
构造 HttpUrl 对象，设置请求的URL和参数。
使用 Request.Builder 构建 Request 对象。
配置 Request 对象的header和body（虽然GET请求通常不包含body）。
使用 OkHttpClient 发送 Request ，并处理响应。

2.2.2 封装GET请求的示例代码

下面是一个简单的GET请求封装实现示例：

import okhttp3.OkHttpClient
import okhttp3.Request
import okhttp3.Response

class HttpGetRequest {
    private val client = OkHttpClient()
    fun executeGet(url: String, headers: Map<String, String> = mapOf()): Response? {
        val requestBuilder = Request.Builder()
            .url(url)
        // 添加Headers
        headers.forEach { (key, value) ->
            requestBuilder.addHeader(key, value)
        }
        // 构建Request对象
        val request = requestBuilder.build()
        // 发送GET请求并获取响应
        return client.newCall(request).execute()
    }
}

// 使用示例
val httpGetRequest = HttpGetRequest()
val response = httpGetRequest.executeGet("http://example.com/api/users", mapOf("Authorization" to "Bearer token"))
response?.let { 
    val body = it.body?.string()
    println("Response body: $body")
} ?: println("Request failed")

在上述代码中，首先创建了一个 OkHttpClient 实例，然后创建了 Request.Builder 来构建 Request 对象。在构建请求时，我们设置了URL并添加了可选的headers。最后，使用 OkHttpClient 的 newCall 方法发送请求，并通过 execute 方法同步获取响应。

注意，上述代码中的 executeGet 方法接受URL和headers作为参数，并返回一个 Response 对象。如果请求成功， response.body?.string() 将输出响应体内容；如果请求失败，则输出”Request failed”。

3. POST请求的封装实现

3.1 POST请求的基本使用

3.1.1 POST请求的定义与作用

POST请求是一种常见的HTTP请求方法，它主要用于向服务器提交数据。在客户端和服务器进行交互的场景中，当我们需要创建一个新的资源或对现有资源进行更新时，通常会使用POST请求。例如，在Web应用中，提交一个表单到服务器，或者在移动应用中向服务器发送数据进行用户认证，都是POST请求的应用场景。

与GET请求相比，POST请求更适合用来处理大量数据的传输。因为POST请求的参数是在请求体（body）中发送的，所以理论上没有URL长度的限制。同时，POST请求的参数不会被缓存，不会保存在浏览器历史记录中，也不会被附加到服务器日志中，这增加了数据的隐私性和安全性。

3.1.2 POST请求的参数传递方式

在使用POST请求时，客户端会将数据封装在请求体中发送到服务器。数据的传递方式主要有两种：表单形式（application/x-www-form-urlencoded）和JSON格式（application/json）。

表单形式 ：这是最传统的方式，适用于简单的键值对数据传递。当服务器接收到表单形式的POST请求时，可以通过请求头中的 Content-Type 字段来识别数据格式为 application/x-www-form-urlencoded 。这种方式的数据传输效率不如JSON格式，但对于简单的表单数据传递来说，已经足够使用。
JSON格式 ：随着Web服务的复杂化，JSON格式逐渐成为主流的数据交换格式。在发送POST请求时，客户端将数据转换成JSON格式的字符串，并将其放入请求体中发送。这种方式的优点是表达能力强，易于阅读和编写，且可以很好地与现代JavaScript前端框架配合使用。服务器端也可以方便地将JSON字符串解析为相应的对象进行处理。

3.2 POST请求的封装方法

3.2.1 封装POST请求的步骤

为了方便在各种场景下复用POST请求的代码，我们可以将其封装成一个通用的方法。以下是封装POST请求的基本步骤：

创建RequestBody ：根据需要传递的数据类型（表单或JSON），创建一个RequestBody对象。
构建Request ：使用Request.Builder构建Request对象，将创建好的RequestBody对象放入请求中。
同步或异步请求 ：通过OkHttpClient发起同步或异步的请求，并处理响应。
异常处理 ：对可能出现的异常情况进行处理。

3.2.2 封装POST请求的示例代码

以下是一个封装POST请求的示例代码，其中包含了表单和JSON数据的发送方法：

// 导入OkHttp和相关类库
import okhttp3.MediaType;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.RequestBody;
import okhttp3.Response;
import okio.BufferedSink;
import okio.GzipSink;
import okio.Okio;

import java.io.IOException;
import java.util.concurrent.TimeUnit;

public class PostRequestUtil {
    private static final MediaType JSON = MediaType.get("application/json; charset=utf-8");
    private static final MediaType FORM = MediaType.get("application/x-www-form-urlencoded; charset=utf-8");

    private OkHttpClient okHttpClient = new OkHttpClient.Builder()
            .connectTimeout(15, TimeUnit.SECONDS)
            .readTimeout(20, TimeUnit.SECONDS)
            .writeTimeout(20, TimeUnit.SECONDS)
            .build();

    /**
     * POST请求发送JSON数据
     * @param url 请求的URL
     * @param jsonStr JSON格式字符串
     * @return 响应字符串
     */
    public String sendJsonPostRequest(String url, String jsonStr) {
        RequestBody body = RequestBody.create(jsonStr, JSON);
        Request request = new Request.Builder()
                .url(url)
                .post(body)
                .build();

        try (Response response = okHttpClient.newCall(request).execute()) {
            return response.body().string();
        } catch (IOException e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * POST请求发送表单数据
     * @param url 请求的URL
     * @param formParams 表单参数，key-value形式
     * @return 响应字符串
     */
    public String sendFormPostRequest(String url, String formParams) {
        RequestBody body = RequestBody.create(formParams, FORM);
        Request request = new Request.Builder()
                .url(url)
                .post(body)
                .build();

        try (Response response = okHttpClient.newCall(request).execute()) {
            return response.body().string();
        } catch (IOException e) {
            e.printStackTrace();
            return null;
        }
    }
}

在上述代码中，我们创建了一个 PostRequestUtil 类，其中包含了两个方法： sendJsonPostRequest 和 sendFormPostRequest 。这两个方法分别用于发送JSON格式和表单格式的POST请求。通过使用OkHttp的 RequestBody 和 Request.Builder ，我们可以方便地构建出符合要求的请求。

每个方法都做了异常处理，并返回了服务器响应的内容。如果在执行网络请求的过程中发生异常，则会捕获 IOException 并打印堆栈跟踪信息。

这种封装方式极大地简化了在不同情况下发送POST请求的代码量，使得开发者可以更加专注于业务逻辑的实现，而不需要重复编写网络请求的相关代码。

4. 文件下载的封装实现

4.1 文件下载的基本使用

4.1.1 文件下载的定义与作用

文件下载是指将互联网上存储的文件资源，通过网络传输到本地设备的过程。在移动应用开发中，文件下载是一个常见的需求，可能涉及到图片、视频、音频以及各种文档等。文件下载的使用可以极大地丰富应用的功能，例如，允许用户下载内容到本地阅读或分享给其他用户。

4.1.2 文件下载的方式与方法

文件下载的方式通常有以下几种：
- 使用Android系统API，如 downloadManager 。
- 使用HTTP客户端库，如OkHttp，进行文件下载。

在选择使用哪种方法下载文件时，需要考虑以下因素：
- 下载文件的大小和数量。
- 是否需要显示下载进度。
- 下载过程中对用户交互的需求。
- 对于低功耗和节省流量的要求。

OkHttp因其简洁、高效且易于使用而受到开发者的喜爱。它是实现文件下载的常见方式之一。

4.2 文件下载的封装方法

4.2.1 封装文件下载的步骤

封装文件下载通常需要以下步骤：
1. 创建一个 OkHttpClient 实例。
2. 创建 Request 实例，设置请求方法和目标URL。
3. 创建 Response 处理逻辑，包括处理网络响应和文件写入本地磁盘。
4. 异步执行文件下载任务。
5. 监听下载进度和处理完成后的回调。

4.2.2 封装文件下载的示例代码

以下是一个使用OkHttp封装文件下载功能的示例代码：

// 导入必要的类
import okhttp3.Call;
import okhttp3.Callback;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;

import java.io.BufferedSink;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;

public class Downloader {

    private OkHttpClient client = new OkHttpClient();

    // 文件下载方法
    public void downloadFile(String fileUrl, final String destDir, final String fileName, final Callback callback) {
        Request request = new Request.Builder()
                .url(fileUrl)
                .build();

        client.newCall(request).enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {
                e.printStackTrace();
                if (callback != null) {
                    callback.onFailure(call, e);
                }
            }

            @Override
            public void onResponse(Call call, Response response) throws IOException {
                if (response.isSuccessful()) {
                    // 创建文件目录
                    File destFile = new File(destDir, fileName);
                    if (!destFile.exists()) {
                        destFile.createNewFile();
                    }
                    // 写入文件
                    try (FileOutputStream out = new FileOutputStream(destFile)) {
                        byte[] fileBytes = response.body().bytes();
                        out.write(fileBytes);
                        out.flush();
                        if (callback != null) {
                            callback.onResponse(call, response);
                        }
                    } catch (IOException e) {
                        e.printStackTrace();
                        if (callback != null) {
                            callback.onFailure(call, e);
                        }
                    }
                } else {
                    if (callback != null) {
                        callback.onFailure(call, null);
                    }
                }
            }
        });
    }
}

在上述代码中，我们创建了一个名为 Downloader 的类，其中包含一个 downloadFile 方法，该方法接收文件URL、目标目录、文件名以及一个回调接口。当文件下载成功时，回调接口的 onResponse 方法会被调用；当下载失败时， onFailure 方法会被调用。

调用 downloadFile 方法时，传入相应的参数即可开始下载。例如：

Downloader downloader = new Downloader();
downloader.downloadFile("http://example.com/file.zip", "/path/to/dest", "file.zip", new Callback() {
    @Override
    public void onFailure(Call call, IOException e) {
        // 处理下载失败的情况
    }

    @Override
    public void onResponse(Call call, Response response) throws IOException {
        // 处理下载成功的情况
    }
});

在实际应用中，还应添加错误处理和用户交互代码，例如显示下载进度和下载完成后的提示信息。

5. 文件上传的封装实现

5.1 文件上传的基本使用

5.1.1 文件上传的定义与作用

文件上传功能是网络应用中不可或缺的一部分，它允许用户将本地文件发送到服务器端进行存储、处理或分享。在移动应用、Web应用以及各种服务端交互中，文件上传提供了一种快速有效地交换信息的手段。常见的应用场景包括图片、视频、文档的上传，以及与第三方服务的数据集成。

5.1.2 文件上传的方式与方法

文件上传通常可以通过多种方式实现，包括传统的表单提交（Form-based File Upload），以及现代的Ajax上传等。在移动开发中，常用的库如OkHttp就提供了强大的工具来支持文件上传，包括多部分表单数据（multipart/form-data）的创建和发送。OkHttp支持流式传输，这意味着可以边上传边读取数据，对于大文件尤其重要，能够有效避免内存溢出的问题。

5.2 文件上传的封装方法

5.2.1 封装文件上传的步骤

为了更好地管理和复用文件上传代码，我们可以将其封装为一个通用的方法或工具类。封装的步骤大致可以分为以下几个阶段：

创建一个工具类，例如 FileUploader 。
定义文件上传的API接口，如 uploadFile(File file, String url, Callback callback) 。
实现文件上传的逻辑，利用OkHttp库构建请求，处理多部分表单数据。
设置请求进度回调，以便在上传过程中实时反馈状态。
实现失败重试逻辑，确保上传操作的可靠性。
对上传的结果进行处理，包括成功上传的回调与错误处理。

5.2.2 封装文件上传的示例代码

下面是一个简单的文件上传封装示例，使用了OkHttp库：

public class FileUploader {

    public void uploadFile(File file, String uploadUrl, Callback callback) {
        // 构建一个OkHttpClient
        OkHttpClient client = new OkHttpClient();

        // 创建表单数据，添加文件内容
        MultipartBody.Builder builder = new MultipartBody.Builder();
        builder.setType(MultipartBody.FORM);

        // 添加文件数据
        RequestBody requestBody = RequestBody.create(MediaType.parse("multipart/form-data"), file);
        builder.addFormDataPart("file", file.getName(), requestBody);

        // 构建请求体
        MultipartBody multipartBody = builder.build();

        // 创建请求
        Request request = new Request.Builder()
                .url(uploadUrl)
                .post(multipartBody)
                .build();

        // 发起网络请求
        client.newCall(request).enqueue(callback);
    }

    // 示例的回调接口
    public interface Callback {
        void onResponse(Call call, Response response) throws IOException;
        void onFailure(Call call, IOException e);
    }
}

在上述代码中，我们首先创建了一个 MultipartBody.Builder 实例，用于构建表单数据。然后，将文件内容添加到表单中，并设置 multipart/form-data 作为媒体类型。构建好请求体后，我们创建了一个 Request 对象，并通过OkHttpClient发起异步请求。这样封装的好处是，文件上传的逻辑集中管理，使用时只需调用 uploadFile 方法即可。

通过文件上传的封装，可以简化代码的重复编写工作，提升开发效率，并使得维护变得更加容易。同时，封装后的工具类可以很容易地集成日志打印、超时设置、错误重试等高级功能，形成一套完整的解决方案。

结语

在本章节中，我们详细介绍了文件上传的基本使用和封装实现方法。文件上传是网络应用中十分常见的需求，通过OkHttp库，我们可以方便地实现这一功能，并进行有效的封装优化。在实际开发过程中，通过合理的封装，可以大大简化重复代码的编写，提升代码的可维护性和可读性。下一章节，我们将探讨如何设置自定义超时时间，并展示其在实际应用中的效果。

6. 自定义超时时间

6.1 超时时间的设置方法

6.1.1 超时时间的定义与作用

在使用OkHttp进行网络请求时，超时时间的设置是一个关键环节。超时时间定义了网络请求的最大等待时间，包括连接、读取和写入操作的超时限制。合理设置超时时间能有效避免因网络状况不佳或服务器响应缓慢而导致的长时间等待，提高应用的响应效率。

6.1.2 设置超时时间的步骤

OkHttp提供了灵活的API来设置连接、读取和写入的超时时间。以下是如何通过代码设置这些超时时间的详细步骤：

OkHttpClient client = new OkHttpClient.Builder()
    .connectTimeout(15, TimeUnit.SECONDS) // 设置连接超时时间为15秒
    .readTimeout(20, TimeUnit.SECONDS)    // 设置读取超时时间为20秒
    .writeTimeout(20, TimeUnit.SECONDS)   // 设置写入超时时间为20秒
    .build();

在这段代码中，我们创建了一个新的 OkHttpClient 实例，并使用链式调用来分别设置连接超时、读取超时和写入超时。 TimeUnit.SECONDS 指明了超时时间的单位是秒。在设置这些参数时，应该根据实际的网络状况和服务器响应特性来调整，以保证既能覆盖正常的请求时间，又能及时处理网络延迟或服务无响应的情况。

6.2 超时时间的实际应用

6.2.1 应用超时时间的示例代码

// 定义一个接口，封装网络请求逻辑
public interface NetworkRequestInterface {
    void fetch(String url, Callback callback);
}

// 实现网络请求接口
public class NetworkRequestImpl implements NetworkRequestInterface {

    private OkHttpClient client = new OkHttpClient.Builder()
        .connectTimeout(15, TimeUnit.SECONDS)
        .readTimeout(20, TimeUnit.SECONDS)
        .writeTimeout(20, TimeUnit.SECONDS)
        .build();

    @Override
    public void fetch(String url, Callback callback) {
        Request request = new Request.Builder()
                .url(url)
                .build();

        client.newCall(request).enqueue(callback);
    }
}

// 使用网络请求接口
public class NetworkUsageExample {
    public void performNetworkRequest(String url) {
        NetworkRequestInterface networkRequest = new NetworkRequestImpl();
        networkRequest.fetch(url, new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {
                // 处理请求失败的情况
            }

            @Override
            public void onResponse(Call call, Response response) throws IOException {
                // 处理请求成功的情况
            }
        });
    }
}

在这个示例中，我们首先定义了一个网络请求接口 NetworkRequestInterface ，然后创建了一个类 NetworkRequestImpl 来实现这个接口，其中包含了超时时间的设置。 performNetworkRequest 方法是使用该接口的一个实例，进行实际的网络请求。

6.2.2 超时时间的应用效果

设置超时时间后，网络请求的执行情况将会有明显的改善。当网络状况不佳或者服务器响应慢时，超出设定的超时时间，OkHttp会主动终止未完成的请求，并通过回调机制通知调用者。这样可以有效防止应用进入长时间等待的状态，提高用户体验。

表格和代码块结合分析

超时类型	默认时间	设置方法	说明
连接超时	10秒	`.connectTimeout(15, TimeUnit.SECONDS)`	从发起请求到连接建立的最大等待时间
读取超时	10秒	`.readTimeout(20, TimeUnit.SECONDS)`	从连接建立到响应返回的最大等待时间
写入超时	10秒	`.writeTimeout(20, TimeUnit.SECONDS)`	从数据发送到写入完成的最大等待时间

表格解释：表格展示了OkHttp中不同超时类型、其默认时间、设置方法及具体含义。代码块演示了设置这些超时参数的示例。

代码块分析：

.connectTimeout(15, TimeUnit.SECONDS) 表示将连接超时时间设置为15秒。
.readTimeout(20, TimeUnit.SECONDS) 表示将读取超时时间设置为20秒。
.writeTimeout(20, TimeUnit.SECONDS) 表示将写入超时时间设置为20秒。

通过合理设置这些超时时间，可以有效控制网络请求的执行效率，减少因网络问题导致的应用阻塞。

7. 错误重试机制

在实际的网络请求中，由于网络状况的不稳定，或者服务器的暂时性故障，我们经常可能会遇到请求失败的情况。此时，为了保证用户体验和数据的一致性，需要对请求失败的情况进行重试处理。错误重试机制就是为了解决这个问题。

7.1 错误重试机制的定义与作用

7.1.1 错误重试机制的基本理解

错误重试机制，简单来说，就是当一个网络请求失败时，根据预设的策略，自动重新发起请求。这个机制可以帮助我们应对一些短暂的网络波动或服务端的临时错误。当然，重试次数需要合理设置，以避免因为不断的重试导致的资源浪费和无谓的延迟。

7.1.2 错误重试机制的应用场景

错误重试机制广泛应用于各种网络请求库中，用于提升网络请求的稳定性和可靠性。例如，在支付、订单操作等需要高可靠性的业务场景中，使用错误重试机制可以大幅提升用户体验和系统的健壮性。

7.2 错误重试机制的实现方法

7.2.1 实现错误重试机制的步骤

实现错误重试机制，大致可以分为以下几个步骤：
1. 捕获并识别可重试的错误类型。
2. 设置合理的重试次数和重试间隔。
3. 实现重试策略，比如指数退避策略可以避免瞬间对服务器造成过大压力。
4. 在重试逻辑中加入超时处理，防止无限重试导致的程序挂起。

7.2.2 错误重试机制的示例代码

下面是一个使用OkHttp实现错误重试机制的简单示例：

// 创建一个OkHttpClient实例
OkHttpClient client = new OkHttpClient.Builder()
        .addInterceptor(chain -> {
            Request request = chain.request();
            Response response = chain.proceed(request);

            // 检查响应是否为失败状态码
            if (!response.isSuccessful()) {
                // 重试逻辑，这里简化为直接调用一次重试，实际应用中可能需要根据不同的状态码来决定是否重试
                return chain.proceed(request);
            }
            return response;
        })
        .build();

// 创建一个请求
Request request = new Request.Builder()
        .url("http://example.com/api")
        .build();

// 使用client发起请求，并处理响应
client.newCall(request).enqueue(new Callback() {
    @Override
    public void onFailure(Call call, IOException e) {
        // 处理请求失败的情况
        e.printStackTrace();
    }

    @Override
    public void onResponse(Call call, Response response) throws IOException {
        // 处理请求成功的响应
        if (response.isSuccessful()) {
            // 处理返回的数据
        }
    }
});

在上面的代码中，我们在构建OkHttpClient时添加了一个自定义的Interceptor，当响应状态码不成功时，重新发起一次请求。这种方式虽然简单，但是其实现了一个非常基础的重试机制。

需要注意的是，在实际应用中，我们还需要考虑重试次数的限制，防止无休止的重试。可以通过增加一个重试次数计数器，并在达到最大重试次数后停止重试，或者使用OkHttp的RetryAndFollowUpInterceptor来实现更完善的重试机制。

本文还有配套的精品资源，点击获取

天工造物局

北京人形旗下天工造物具身智能开源社区，聚焦具身天工与慧思开物两大平台

更多推荐

deck.gl TripsLayer 出租车轨迹动画示例实战：从示例运行到着色器原理

TripsLayer 是 deck.gl 中用于渲染**随时间流动的轨迹动画**（如出租车行程、物流路径、迁徙路线）的核心图层。本文以仓库中的最小独立示例 [examples/website/trips](https://link.gitcode.com/i/1442af8f442f4cff39ff546e050fceb5) 为骨架，带你完成从安装依赖、启动应用、理解曼哈顿出租车数据格式，到深入

天工造物局

Foundry Anvil 中 eth_simulateV1 的 Blob 交易与 Blob Gas 字段规范化：原理、实现与测试验证

本篇技术指南以 [anvil-simulate-blob-transactions.md](https://link.gitcode.com/i/3d2ebe227262de169335eb290af80da8) 这条 changelog 条目为起点，深入剖析 Foundry Anvil 对 `eth_simulateV1` RPC 返回结果中 blob（EIP-4844）交易与 blob gas

天工造物局

LMCache CLI 实战：用 `lmcache kvcache clear` 管理运行中服务的 KV Cache 状态

本文是一份针对 LMCache 官方 CLI 命令 `lmcache kvcache` 的完整技术指南。该命令用于在**运行中的 LMCache 服务（MP HTTP server）**上管理 KV cache 状态，当前提供 `clear` 子命令，用于清空 L1（CPU 内存）层中缓存的全部 KV 数据。读完本文，你将掌握该命令的完整参数体系、退出码语义、终端/JSON/静默三种输出模式，并能

天工造物局

所有评论(0)

查看更多评论

已退乎

@weixin_36427956

已为社区贡献18条内容

OkhttpUtil：简化HTTP请求处理的工具类封装

已退乎

1. OkHttp基础与特性介绍

1.1 OkHttp简介

1.2 OkHttp核心特性

1.3 OkHttp的应用场景

2. GET请求的封装实现

2.1 GET请求的基本使用

2.1.1 GET请求的定义与作用

2.1.2 GET请求的参数传递方式

2.2 GET请求的封装方法

2.2.1 封装GET请求的步骤

2.2.2 封装GET请求的示例代码

3. POST请求的封装实现

3.1 POST请求的基本使用

3.1.1 POST请求的定义与作用

3.1.2 POST请求的参数传递方式

3.2 POST请求的封装方法

3.2.1 封装POST请求的步骤

3.2.2 封装POST请求的示例代码

4. 文件下载的封装实现

4.1 文件下载的基本使用

4.1.1 文件下载的定义与作用

4.1.2 文件下载的方式与方法

4.2 文件下载的封装方法

4.2.1 封装文件下载的步骤

4.2.2 封装文件下载的示例代码

5. 文件上传的封装实现

5.1 文件上传的基本使用

5.1.1 文件上传的定义与作用

5.1.2 文件上传的方式与方法

5.2 文件上传的封装方法

5.2.1 封装文件上传的步骤

5.2.2 封装文件上传的示例代码

结语

6. 自定义超时时间

6.1 超时时间的设置方法

6.1.1 超时时间的定义与作用

6.1.2 设置超时时间的步骤

6.2 超时时间的实际应用

6.2.1 应用超时时间的示例代码

6.2.2 超时时间的应用效果

表格和代码块结合分析

7. 错误重试机制

7.1 错误重试机制的定义与作用

7.1.1 错误重试机制的基本理解

7.1.2 错误重试机制的应用场景

7.2 错误重试机制的实现方法

7.2.1 实现错误重试机制的步骤

7.2.2 错误重试机制的示例代码

所有评论(0)

温馨提示：您尚未绑定手机号

已退乎