HTTP 接口调用工具类（OkHttp 版）

-1
原创 已于 2025-08-26 23:58:47 修改 · 719 阅读 · 5 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#http #okhttp #网络协议

于 2025-08-24 23:31:53 首次发布

说明

HTTP 基本知识

序号方法请求体描述
1GET一般没有，可以有从服务器获取资源。用于请求数据而不对数据进行更改。例如，从服务器获取网页、图片等。
2POST有向服务器发送数据以创建新资源。常用于提交表单数据或上传文件。发送的数据包含在请求体中。
3PUT有向服务器发送数据以更新现有资源。如果资源不存在，则创建新的资源。与 POST 不同，PUT 通常是幂等的，即多次执行相同的 PUT 请求不会产生不同的结果。
4DELETE有从服务器删除指定的资源。请求中包含要删除的资源标识符。
5PATCH有对资源进行部分修改。与 PUT 类似，但 PATCH 只更改部分数据而不是替换整个资源。
6HEAD无类似于 GET，但服务器只返回响应的头部，不返回实际数据。用于检查资源的元数据（例如，检查资源是否存在，查看响应的头部信息）。
7OPTIONS无返回服务器支持的 HTTP 方法。用于检查服务器支持哪些请求方法，通常用于跨域资源共享（CORS）的预检请求。
8TRACE无回显服务器收到的请求，主要用于诊断。客户端可以查看请求在服务器中的处理路径。
9CONNECT-建立一个到服务器的隧道，通常用于 HTTPS 连接。客户端可以通过该隧道发送加密的数据。

POST、PUT、DELETE、PATCH 一般是有请求体的，GET、HEAD、OPTIONS、TRACE 一般没有请求体（GET 请求其实也可以包含请求体，Spring Boot 也可以接收 GET 请求的请求体），CONNECT 方法并不是直接由用户调用的，而是在建立连接时使用的。

功能

  1. 支持发送 GET、POST、PUT、DELETE、PATCH、HEAD、OPTIONS、TRACE 请求，且均有同步、异步调用方式；

  2. 支持的请求体目前支持常见的 JSON 格式请求体application/json和表单请求体multipart/mixed，表单请求体支持传输 File、InputStream、byte[]类型的（文件）对象；

  3. POST、PUT、DELETE、PATCH 支持以上两种请求体；OkHttp 中，GET 不支持请求体，所以工具类也不支持 GET 请求携带请求体。

代码

引入依赖

 <dependency>
     <groupId>com.squareup.okhttp3</groupId>
     <artifactId>okhttp-jvm</artifactId>
     <version>5.0.0</version>
 </dependency>

注：okhttp 5.x版本，需要引用okhttp-jvm，如果IDEA版本不够新（如2024.1.2），引入okhttp 5.x版本后，idea代码联想可能无法关联上okhttp相关类（实测社区版2025.1.1.1可以）。如果遇到此种情况，可以引入4.x版本，如下：

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

HTTP请求类型枚举类

package com.example.study.enums;

import lombok.Getter;

@Getter
public enum HttpMethodEnum {
    GET("GET"),
    POST("POST"),
    PUT("PUT"),
    PATCH("PATCH"),
    DELETE("DELETE"),
    OPTIONS("OPTIONS"),
    HEAD("HEAD"),
    TRACE("TRACE"),
    CONNECT("CONNECT");

    private String value;

    HttpMethodEnum(String value) {
        this.value = value;
    }
}

HTTP响应类

package com.example.study.util;

import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Getter;
import lombok.Setter;
import lombok.ToString;

import java.util.Map;

@Setter
@Getter
@ToString
@Builder
@AllArgsConstructor
public class HttpUtilResponse {
    private boolean isSuccessful;

    private boolean isRedirect;

    private int code;

    private Map<String, String> headers;

    private byte[] body;

    public String getStringBody() {
        return body == null ? "null" : new String(body);
    }
}

HTTP请求工具类（同步）

package com.example.study.util;

import com.alibaba.fastjson.JSON;
import com.example.study.enums.HttpMethodEnum;
import lombok.extern.slf4j.Slf4j;
import okhttp3.Headers;
import okhttp3.MediaType;
import okhttp3.MultipartBody;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.RequestBody;
import okhttp3.Response;
import org.springframework.util.StringUtils;

import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

/**
 * HTTP请求工具类（同步）
 */
@Slf4j
public class HttpUtils {
    private static final MediaType APPLICATION_JSON_UTF8 = MediaType.parse("application/json; charset=utf-8");

    private static final MediaType APPLICATION_OCTET_STREAM = MediaType.parse("application/octet-stream");

    private static final DateTimeFormatter FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SSS");

    private static final OkHttpClient CLIENT = new OkHttpClient.Builder()
            .connectTimeout(2, TimeUnit.MINUTES)
            .readTimeout(2, TimeUnit.MINUTES)
            .writeTimeout(2, TimeUnit.MINUTES)
            .build();

    /**
     * 执行get请求
     *
     * @param url url
     * @return 请求结果
     */
    public static HttpUtilResponse get(String url) {
        return get(url, null);
    }

    /**
     * 执行get请求
     *
     * @param url     url
     * @param headers 请求头
     * @return 请求结果
     */
    public static HttpUtilResponse get(String url, Map<String, String> headers) {
        if (!StringUtils.hasText(url)) {
            throw new RuntimeException("url must not be null");
        }
        Request.Builder builder = new Request.Builder().url(url);
        setHeaders(builder, headers);
        Request request = builder.get().build();
        return execute(request);
    }

    /**
     * 执行post请求（请求体为json）
     *
     * @param url  url
     * @param body 请求体
     * @return 请求结果
     */
    public static HttpUtilResponse post(String url, Map<String, ?> body) {
        return post(url, body, null);
    }

    /**
     * 执行post请求（请求体为json）
     *
     * @param url     url
     * @param body    请求体
     * @param headers 请求头
     * @return 请求结果
     */
    public static HttpUtilResponse post(String url, Map<String, ?> body, Map<String, String> headers) {
        if (!StringUtils.hasText(url)) {
            throw new RuntimeException("url must not be null");
        }
        Request.Builder builder = new Request.Builder().url(url);
        setHeaders(builder, headers);
        setJsonBody(builder, body, HttpMethodEnum.POST);
        Request request = builder.build();
        return execute(request);
    }

    /**
     * 执行post请求（请求体为form）
     *
     * @param url  url
     * @param body 请求体
     * @return 请求结果
     */
    public static HttpUtilResponse postForm(String url, Map<String, ?> body) {
        return postForm(url, body, null);
    }

    /**
     * 执行post请求（请求体为form）
     *
     * @param url     url
     * @param body    请求体
     * @param headers 请求头
     * @return 请求结果
     */
    public static HttpUtilResponse postForm(String url, Map<String, ?> body, Map<String, String> headers) {
        if (!StringUtils.hasText(url)) {
            throw new RuntimeException("url must not be null");
        }
        Request.Builder builder = new Request.Builder().url(url);
        setHeaders(builder, headers);
        setFormBody(builder, body, HttpMethodEnum.POST);
        Request request = builder.build();
        return execute(request);
    }

    /**
     * 执行put请求（请求体为json）
     *
     * @param url  url
     * @param body 请求体
     * @return 请求结果
     */
    public static HttpUtilResponse put(String url, Map<String, ?> body) {
        return put(url, body, null);
    }

    /**
     * 执行put请求（请求体为json）
     *
     * @param url     url
     * @param body    请求体
     * @param headers 请求头
     * @return 请求结果
     */
    public static HttpUtilResponse put(String url, Map<String, ?> body, Map<String, String> headers) {
        if (!StringUtils.hasText(url)) {
            throw new RuntimeException("url must not be null");
        }
        Request.Builder builder = new Request.Builder().url(url);
        setHeaders(builder, headers);
        setJsonBody(builder, body, HttpMethodEnum.PUT);
        Request request = builder.build();
        return execute(request);
    }

    /**
     * 执行put请求（请求体为form）
     *
     * @param url  url
     * @param body 请求体
     * @return 请求结果
     */
    public static HttpUtilResponse putForm(String url, Map<String, ?> body) {
        return putForm(url, body, null);
    }

    /**
     * 执行put请求（请求体为form）
     *
     * @param url     url
     * @param body    请求体
     * @param headers 请求头
     * @return 请求结果
     */
    public static HttpUtilResponse putForm(String url, Map<String, ?> body, Map<String, String> headers) {
        if (!StringUtils.hasText(url)) {
            throw new RuntimeException("url must not be null");
        }
        Request.Builder builder = new Request.Builder().url(url);
        setHeaders(builder, headers);
        setFormBody(builder, body, HttpMethodEnum.PUT);
        Request request = builder.build();
        return execute(request);
    }

    /**
     * 执行patch请求（请求体为json）
     *
     * @param url  url
     * @param body 请求体
     * @return 请求结果
     */
    public static HttpUtilResponse patch(String url, Map<String, ?> body) {
        return patch(url, body, null);
    }

    /**
     * 执行patch请求（请求体为json）
     *
     * @param url     url
     * @param body    请求体
     * @param headers 请求头
     * @return 请求结果
     */
    public static HttpUtilResponse patch(String url, Map<String, ?> body, Map<String, String> headers) {
        if (!StringUtils.hasText(url)) {
            throw new RuntimeException("url must not be null");
        }
        Request.Builder builder = new Request.Builder().url(url);
        setHeaders(builder, headers);
        setJsonBody(builder, body, HttpMethodEnum.PATCH);
        Request request = builder.build();
        return execute(request);
    }

    /**
     * 执行patch请求（请求体为form）
     *
     * @param url  url
     * @param body 请求体
     * @return 请求结果
     */
    public static HttpUtilResponse patchForm(String url, Map<String, ?> body) {
        return patchForm(url, body, null);
    }

    /**
     * 执行patch请求（请求体为form）
     *
     * @param url     url
     * @param body    请求体
     * @param headers 请求头
     * @return 请求结果
     */
    public static HttpUtilResponse patchForm(String url, Map<String, ?> body, Map<String, String> headers) {
        if (!StringUtils.hasText(url)) {
            throw new RuntimeException("url must not be null");
        }
        Request.Builder builder = new Request.Builder().url(url);
        setHeaders(builder, headers);
        setFormBody(builder, body, HttpMethodEnum.PATCH);
        Request request = builder.build();
        return execute(request);
    }

    /**
     * 执行delete请求（请求体为json）
     *
     * @param url  url
     * @param body 请求体
     * @return 请求结果
     */
    public static HttpUtilResponse delete(String url, Map<String, ?> body) {
        return delete(url, body, null);
    }

    /**
     * 执行delete请求（请求体为json）
     *
     * @param url     url
     * @param body    请求体
     * @param headers 请求头
     * @return 请求结果
     */
    public static HttpUtilResponse delete(String url, Map<String, ?> body, Map<String, String> headers) {
        if (!StringUtils.hasText(url)) {
            throw new RuntimeException("url must not be null");
        }
        Request.Builder builder = new Request.Builder().url(url);
        setHeaders(builder, headers);
        setJsonBody(builder, body, HttpMethodEnum.DELETE);
        Request request = builder.build();
        return execute(request);
    }

    /**
     * 执行delete请求（请求体为form）
     *
     * @param url  url
     * @param body 请求体
     * @return 请求结果
     */
    public static HttpUtilResponse deleteForm(String url, Map<String, ?> body) {
        return deleteForm(url, body, null);
    }

    /**
     * 执行delete请求（请求体为form）
     *
     * @param url     url
     * @param body    请求体
     * @param headers 请求头
     * @return 请求结果
     */
    public static HttpUtilResponse deleteForm(String url, Map<String, ?> body, Map<String, String> headers) {
        if (!StringUtils.hasText(url)) {
            throw new RuntimeException("url must not be null");
        }
        Request.Builder builder = new Request.Builder().url(url);
        setHeaders(builder, headers);
        setFormBody(builder, body, HttpMethodEnum.DELETE);
        Request request = builder.build();
        return execute(request);
    }

    /**
     * 执行options请求
     *
     * @param url url
     * @return 请求结果
     */
    public static HttpUtilResponse options(String url) {
        return options(url, null);
    }

    /**
     * 执行options请求
     *
     * @param url     url
     * @param headers 请求头
     * @return 请求结果
     */
    public static HttpUtilResponse options(String url, Map<String, String> headers) {
        if (!StringUtils.hasText(url)) {
            throw new RuntimeException("url must not be null");
        }
        Request.Builder builder = new Request.Builder().url(url);
        setHeaders(builder, headers);
        Request request = builder.method(HttpMethodEnum.OPTIONS.getValue(), null).build();
        return execute(request);
    }

    /**
     * 执行head请求
     *
     * @param url url
     * @return 请求结果
     */
    public static HttpUtilResponse head(String url) {
        return head(url, null);
    }

    /**
     * 执行head请求
     *
     * @param url     url
     * @param headers 请求头
     * @return 请求结果
     */
    public static HttpUtilResponse head(String url, Map<String, String> headers) {
        if (!StringUtils.hasText(url)) {
            throw new RuntimeException("url must not be null");
        }
        Request.Builder builder = new Request.Builder().url(url);
        setHeaders(builder, headers);
        Request request = builder.head().build();
        return execute(request);
    }

    /**
     * 执行trace请求
     *
     * @param url url
     * @return 请求结果
     */
    public static HttpUtilResponse trace(String url) {
        return trace(url, null);
    }

    /**
     * 执行trace请求
     *
     * @param url     url
     * @param headers 请求头
     * @return 请求结果
     */
    public static HttpUtilResponse trace(String url, Map<String, String> headers) {
        if (!StringUtils.hasText(url)) {
            throw new RuntimeException("url must not be null");
        }
        Request.Builder builder = new Request.Builder().url(url);
        setHeaders(builder, headers);
        Request request = builder.method(HttpMethodEnum.TRACE.getValue(), null).build();
        return execute(request);
    }

    private static void setHeaders(Request.Builder builder, Map<String, String> headers) {
        if (headers != null) {
            log.info("request headers:{}", JSON.toJSONString(headers));
            builder.headers(Headers.of(headers));
        }
    }

    private static void setJsonBody(Request.Builder builder, Map<String, ?> body, HttpMethodEnum method) {
        if (body == null) {
            return;
        }
        String jsonBody = JSON.toJSONString(body);
        log.info("request body json:{}", jsonBody);

        RequestBody requestBody = RequestBody.create(jsonBody, APPLICATION_JSON_UTF8);
        switch (method) {
            case PUT -> builder.put(requestBody);
            case POST -> builder.post(requestBody);
            case PATCH -> builder.patch(requestBody);
            case DELETE -> builder.delete(requestBody);
        }
    }

    private static void setFormBody(Request.Builder builder, Map<String, ?> body, HttpMethodEnum method) {
        if (body == null) {
            return;
        }
        MultipartBody.Builder requestBodyBuilder = new MultipartBody.Builder().setType(MultipartBody.FORM);
        for (Map.Entry<String, ?> entry : body.entrySet()) {
            if (entry.getKey() == null || entry.getValue() == null) {
                continue;
            }
            if (entry.getValue() instanceof File file) {
                log.info("form body {} is File.", entry.getKey());
                requestBodyBuilder.addFormDataPart(entry.getKey(), file.getName(), RequestBody.create(file,
                        APPLICATION_OCTET_STREAM));
            } else if (entry.getValue() instanceof InputStream is) {
                try {
                    log.info("form body {} is InputStream.", entry.getKey());
                    requestBodyBuilder.addFormDataPart(entry.getKey(), entry.getKey(), RequestBody.create(is.readAllBytes(),
                            APPLICATION_OCTET_STREAM));
                } catch (IOException exception) {
                    throw new RuntimeException(exception.getMessage());
                }
            } else if (entry.getValue() instanceof byte[] bytes) {
                log.info("form body {} is byte[].", entry.getKey());
                requestBodyBuilder.addFormDataPart(entry.getKey(), entry.getKey(), RequestBody.create(bytes,
                        APPLICATION_OCTET_STREAM));
            } else if (entry.getValue() instanceof String value) {
                log.info("form body {} is String. value:{}", entry.getKey(), value);
                requestBodyBuilder.addFormDataPart(entry.getKey(), value);
            } else {
                log.info("form body {} is {}. value:{}", entry.getKey(), entry.getValue().getClass(), entry.getValue());
                requestBodyBuilder.addFormDataPart(entry.getKey(), String.valueOf(entry.getValue()));
            }
        }
        RequestBody requestBody = requestBodyBuilder.build();
        switch (method) {
            case PUT -> builder.put(requestBody);
            case POST -> builder.post(requestBody);
            case PATCH -> builder.patch(requestBody);
            case DELETE -> builder.delete(requestBody);
        }
    }

    private static HttpUtilResponse execute(Request request) {
        log.info("{} =====start send {} request. url:{}=====", timestamp(), request.method(), request.url());
        long startTime = System.currentTimeMillis();
        try (Response response = CLIENT.newCall(request).execute()) {
            if (response.isSuccessful()) {
                log.info("{} =====send {} request success. code:{}, url:{}, spend {}ms=====",
                        timestamp(),
                        request.method(),
                        response.code(),
                        request.url(),
                        (System.currentTimeMillis() - startTime));
            } else {
                log.warn("{} =====send {} request fail. code:{}, url:{}, spend {}ms=====",
                        timestamp(),
                        request.method(),
                        response.code(),
                        request.url(),
                        (System.currentTimeMillis() - startTime));
            }
            return HttpUtilResponse.builder()
                    .isSuccessful(response.isSuccessful())
                    .isRedirect(response.isRedirect())
                    .code(response.code())
                    .headers(transHeaders(response.headers()))
                    .body(response.body().bytes())
                    .build();
        } catch (IOException exception) {
            log.error("{} =====send {} request error. url:{}, spend {}ms=====",
                    timestamp(),
                    request.method(),
                    request.url(),
                    (System.currentTimeMillis() - startTime));
            throw new RuntimeException(String.format("send %s request error. url:%s, reason:%s",
                    request.method(), request.url(), exception.getMessage()));
        }
    }

    private static Map<String, String> transHeaders(Headers headers) {
        Map<String, String> headerMap = new HashMap<>();
        if (headers == null) {
            return headerMap;
        }
        Set<String> names = headers.names();
        for (String name : names) {
            headerMap.put(name, headers.get(name));
        }
        return headerMap;
    }

    private static String timestamp() {
        return FORMATTER.format(LocalDateTime.now());
    }
}

HTTP请求工具类（异步）

package com.example.study.util;

import com.alibaba.fastjson.JSON;
import com.example.study.enums.HttpMethodEnum;
import lombok.extern.slf4j.Slf4j;
import okhttp3.Callback;
import okhttp3.Headers;
import okhttp3.MediaType;
import okhttp3.MultipartBody;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.RequestBody;
import org.springframework.util.StringUtils;

import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.Map;
import java.util.concurrent.TimeUnit;

/**
 * HTTP请求工具类（异步）
 */
@Slf4j
public class HttpAsyncUtils {
    private static final MediaType APPLICATION_JSON_UTF8 = MediaType.parse("application/json; charset=utf-8");

    private static final MediaType APPLICATION_OCTET_STREAM = MediaType.parse("application/octet-stream");

    private static final DateTimeFormatter FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SSS");

    private static final OkHttpClient CLIENT = new OkHttpClient.Builder()
            .connectTimeout(2, TimeUnit.MINUTES)
            .readTimeout(2, TimeUnit.MINUTES)
            .writeTimeout(2, TimeUnit.MINUTES)
            .build();

    /**
     * 执行get请求
     *
     * @param url      url
     * @param callback 请求成功后的回调函数
     */
    public static void get(String url, Callback callback) {
        get(url, null, callback);
    }

    /**
     * 执行get请求
     *
     * @param url      url
     * @param headers  请求头
     * @param callback 请求成功后的回调函数
     */
    public static void get(String url, Map<String, String> headers, Callback callback) {
        if (!StringUtils.hasText(url)) {
            throw new RuntimeException("url must not be null");
        }
        if (callback == null) {
            throw new RuntimeException("callback must not be null");
        }
        Request.Builder builder = new Request.Builder().url(url);
        setHeaders(builder, headers);
        Request request = builder.get().build();
        execute(request, callback);
    }

    /**
     * 执行post请求（请求体为json）
     *
     * @param url      url
     * @param body     请求体
     * @param callback 请求成功后的回调函数
     */
    public static void post(String url, Map<String, ?> body, Callback callback) {
        post(url, body, null, callback);
    }

    /**
     * 执行post请求（请求体为json）
     *
     * @param url      url
     * @param body     请求体
     * @param headers  请求头
     * @param callback 请求成功后的回调函数
     */
    public static void post(String url, Map<String, ?> body, Map<String, String> headers, Callback callback) {
        if (!StringUtils.hasText(url)) {
            throw new RuntimeException("url must not be null");
        }
        if (callback == null) {
            throw new RuntimeException("callback must not be null");
        }
        Request.Builder builder = new Request.Builder().url(url);
        setHeaders(builder, headers);
        setJsonBody(builder, body, HttpMethodEnum.POST);
        Request request = builder.build();
        execute(request, callback);
    }

    /**
     * 执行post请求（请求体为form）
     *
     * @param url      url
     * @param body     请求体
     * @param callback 请求成功后的回调函数
     */
    public static void postForm(String url, Map<String, ?> body, Callback callback) {
        postForm(url, body, null, callback);
    }

    /**
     * 执行post请求（请求体为form）
     *
     * @param url      url
     * @param body     请求体
     * @param headers  请求头
     * @param callback 请求成功后的回调函数
     */
    public static void postForm(String url, Map<String, ?> body, Map<String, String> headers, Callback callback) {
        if (!StringUtils.hasText(url)) {
            throw new RuntimeException("url must not be null");
        }
        if (callback == null) {
            throw new RuntimeException("callback must not be null");
        }
        Request.Builder builder = new Request.Builder().url(url);
        setHeaders(builder, headers);
        setFormBody(builder, body, HttpMethodEnum.POST);
        Request request = builder.build();
        execute(request, callback);
    }

    /**
     * 执行put请求（请求体为json）
     *
     * @param url      url
     * @param body     请求体
     * @param callback 请求成功后的回调函数
     */
    public static void put(String url, Map<String, ?> body, Callback callback) {
        put(url, body, null, callback);
    }

    /**
     * 执行put请求（请求体为json）
     *
     * @param url      url
     * @param body     请求体
     * @param headers  请求头
     * @param callback 请求成功后的回调函数
     */
    public static void put(String url, Map<String, ?> body, Map<String, String> headers, Callback callback) {
        if (!StringUtils.hasText(url)) {
            throw new RuntimeException("url must not be null");
        }
        if (callback == null) {
            throw new RuntimeException("callback must not be null");
        }
        Request.Builder builder = new Request.Builder().url(url);
        setHeaders(builder, headers);
        setJsonBody(builder, body, HttpMethodEnum.PUT);
        Request request = builder.build();
        execute(request, callback);
    }

    /**
     * 执行put请求（请求体为form）
     *
     * @param url      url
     * @param body     请求体
     * @param callback 请求成功后的回调函数
     */
    public static void putForm(String url, Map<String, ?> body, Callback callback) {
        putForm(url, body, null, callback);
    }

    /**
     * 执行put请求（请求体为form）
     *
     * @param url      url
     * @param body     请求体
     * @param headers  请求头
     * @param callback 请求成功后的回调函数
     */
    public static void putForm(String url, Map<String, ?> body, Map<String, String> headers, Callback callback) {
        if (!StringUtils.hasText(url)) {
            throw new RuntimeException("url must not be null");
        }
        if (callback == null) {
            throw new RuntimeException("callback must not be null");
        }
        Request.Builder builder = new Request.Builder().url(url);
        setHeaders(builder, headers);
        setFormBody(builder, body, HttpMethodEnum.PUT);
        Request request = builder.build();
        execute(request, callback);
    }

    /**
     * 执行patch请求（请求体为json）
     *
     * @param url      url
     * @param body     请求体
     * @param callback 请求成功后的回调函数
     */
    public static void patch(String url, Map<String, ?> body, Callback callback) {
        patch(url, body, null, callback);
    }

    /**
     * 执行patch请求（请求体为json）
     *
     * @param url      url
     * @param body     请求体
     * @param headers  请求头
     * @param callback 请求成功后的回调函数
     */
    public static void patch(String url, Map<String, ?> body, Map<String, String> headers, Callback callback) {
        if (!StringUtils.hasText(url)) {
            throw new RuntimeException("url must not be null");
        }
        if (callback == null) {
            throw new RuntimeException("callback must not be null");
        }
        Request.Builder builder = new Request.Builder().url(url);
        setHeaders(builder, headers);
        setJsonBody(builder, body, HttpMethodEnum.PATCH);
        Request request = builder.build();
        execute(request, callback);
    }

    /**
     * 执行patch请求（请求体为form）
     *
     * @param url      url
     * @param body     请求体
     * @param callback 请求成功后的回调函数
     */
    public static void patchForm(String url, Map<String, ?> body, Callback callback) {
        patchForm(url, body, null, callback);
    }

    /**
     * 执行patch请求（请求体为form）
     *
     * @param url      url
     * @param body     请求体
     * @param headers  请求头
     * @param callback 请求成功后的回调函数
     */
    public static void patchForm(String url, Map<String, ?> body, Map<String, String> headers, Callback callback) {
        if (!StringUtils.hasText(url)) {
            throw new RuntimeException("url must not be null");
        }
        if (callback == null) {
            throw new RuntimeException("callback must not be null");
        }
        Request.Builder builder = new Request.Builder().url(url);
        setHeaders(builder, headers);
        setFormBody(builder, body, HttpMethodEnum.PATCH);
        Request request = builder.build();
        execute(request, callback);
    }

    /**
     * 执行delete请求（请求体为json）
     *
     * @param url      url
     * @param body     请求体
     * @param callback 请求成功后的回调函数
     */
    public static void delete(String url, Map<String, ?> body, Callback callback) {
        delete(url, body, null, callback);
    }

    /**
     * 执行delete请求（请求体为json）
     *
     * @param url      url
     * @param body     请求体
     * @param headers  请求头
     * @param callback 请求成功后的回调函数
     */
    public static void delete(String url, Map<String, ?> body, Map<String, String> headers, Callback callback) {
        if (!StringUtils.hasText(url)) {
            throw new RuntimeException("url must not be null");
        }
        if (callback == null) {
            throw new RuntimeException("callback must not be null");
        }
        Request.Builder builder = new Request.Builder().url(url);
        setHeaders(builder, headers);
        setJsonBody(builder, body, HttpMethodEnum.DELETE);
        Request request = builder.build();
        execute(request, callback);
    }

    /**
     * 执行delete请求（请求体为form）
     *
     * @param url      url
     * @param body     请求体
     * @param callback 请求成功后的回调函数
     */
    public static void deleteForm(String url, Map<String, ?> body, Callback callback) {
        deleteForm(url, body, null, callback);
    }

    /**
     * 执行delete请求（请求体为form）
     *
     * @param url      url
     * @param body     请求体
     * @param headers  请求头
     * @param callback 请求成功后的回调函数
     */
    public static void deleteForm(String url, Map<String, ?> body, Map<String, String> headers, Callback callback) {
        if (!StringUtils.hasText(url)) {
            throw new RuntimeException("url must not be null");
        }
        if (callback == null) {
            throw new RuntimeException("callback must not be null");
        }
        Request.Builder builder = new Request.Builder().url(url);
        setHeaders(builder, headers);
        setFormBody(builder, body, HttpMethodEnum.DELETE);
        Request request = builder.build();
        execute(request, callback);
    }

    /**
     * 执行options请求
     *
     * @param url      url
     * @param callback 请求成功后的回调函数
     */
    public static void options(String url, Callback callback) {
        options(url, null, callback);
    }

    /**
     * 执行options请求
     *
     * @param url      url
     * @param headers  请求头
     * @param callback 请求成功后的回调函数
     */
    public static void options(String url, Map<String, String> headers, Callback callback) {
        if (!StringUtils.hasText(url)) {
            throw new RuntimeException("url must not be null");
        }
        if (callback == null) {
            throw new RuntimeException("callback must not be null");
        }
        Request.Builder builder = new Request.Builder().url(url);
        setHeaders(builder, headers);
        Request request = builder.method(HttpMethodEnum.OPTIONS.getValue(), null).build();
        execute(request, callback);
    }

    /**
     * 执行head请求
     *
     * @param url      url
     * @param callback 请求成功后的回调函数
     */
    public static void head(String url, Callback callback) {
        head(url, null, callback);
    }

    /**
     * 执行head请求
     *
     * @param url      url
     * @param headers  请求头
     * @param callback 请求成功后的回调函数
     */
    public static void head(String url, Map<String, String> headers, Callback callback) {
        if (!StringUtils.hasText(url)) {
            throw new RuntimeException("url must not be null");
        }
        if (callback == null) {
            throw new RuntimeException("callback must not be null");
        }
        Request.Builder builder = new Request.Builder().url(url);
        setHeaders(builder, headers);
        Request request = builder.head().build();
        execute(request, callback);
    }

    /**
     * 执行trace请求
     *
     * @param url      url
     * @param callback 请求成功后的回调函数
     */
    public static void trace(String url, Callback callback) {
        trace(url, null, callback);
    }

    /**
     * 执行trace请求
     *
     * @param url      url
     * @param headers  请求头
     * @param callback 请求成功后的回调函数
     */
    public static void trace(String url, Map<String, String> headers, Callback callback) {
        if (!StringUtils.hasText(url)) {
            throw new RuntimeException("url must not be null");
        }
        if (callback == null) {
            throw new RuntimeException("callback must not be null");
        }
        Request.Builder builder = new Request.Builder().url(url);
        setHeaders(builder, headers);
        Request request = builder.method(HttpMethodEnum.TRACE.getValue(), null).build();
        execute(request, callback);
    }

    private static void setHeaders(Request.Builder builder, Map<String, String> headers) {
        if (headers != null) {
            log.info("request headers:{}", JSON.toJSONString(headers));
            builder.headers(Headers.of(headers));
        }
    }

    private static void setJsonBody(Request.Builder builder, Map<String, ?> body, HttpMethodEnum method) {
        if (body == null) {
            return;
        }
        String jsonBody = JSON.toJSONString(body);
        log.info("request body json:{}", jsonBody);

        RequestBody requestBody = RequestBody.create(jsonBody, APPLICATION_JSON_UTF8);
        switch (method) {
            case PUT -> builder.put(requestBody);
            case POST -> builder.post(requestBody);
            case PATCH -> builder.patch(requestBody);
            case DELETE -> builder.delete(requestBody);
        }
    }

    private static void setFormBody(Request.Builder builder, Map<String, ?> body, HttpMethodEnum method) {
        if (body == null) {
            return;
        }
        MultipartBody.Builder requestBodyBuilder = new MultipartBody.Builder().setType(MultipartBody.FORM);
        for (Map.Entry<String, ?> entry : body.entrySet()) {
            if (entry.getKey() == null || entry.getValue() == null) {
                continue;
            }
            if (entry.getValue() instanceof File file) {
                log.info("form body {} is File.", entry.getKey());
                requestBodyBuilder.addFormDataPart(entry.getKey(), file.getName(), RequestBody.create(file,
                        APPLICATION_OCTET_STREAM));
            } else if (entry.getValue() instanceof InputStream is) {
                try {
                    log.info("form body {} is InputStream.", entry.getKey());
                    requestBodyBuilder.addFormDataPart(entry.getKey(), entry.getKey(), RequestBody.create(is.readAllBytes(),
                            APPLICATION_OCTET_STREAM));
                } catch (IOException exception) {
                    throw new RuntimeException(exception.getMessage());
                }
            } else if (entry.getValue() instanceof byte[] bytes) {
                log.info("form body {} is byte[].", entry.getKey());
                requestBodyBuilder.addFormDataPart(entry.getKey(), entry.getKey(), RequestBody.create(bytes,
                        APPLICATION_OCTET_STREAM));
            } else if (entry.getValue() instanceof String value) {
                log.info("form body {} is String. value:{}", entry.getKey(), value);
                requestBodyBuilder.addFormDataPart(entry.getKey(), value);
            } else {
                log.info("form body {} is {}. value:{}", entry.getKey(), entry.getValue().getClass(), entry.getValue());
                requestBodyBuilder.addFormDataPart(entry.getKey(), String.valueOf(entry.getValue()));
            }
        }
        RequestBody requestBody = requestBodyBuilder.build();
        switch (method) {
            case PUT -> builder.put(requestBody);
            case POST -> builder.post(requestBody);
            case PATCH -> builder.patch(requestBody);
            case DELETE -> builder.delete(requestBody);
        }
    }

    private static void execute(Request request, Callback callback) {
        if (callback == null) {
            throw new RuntimeException("callback must not be null");
        }
        log.info("{} =====send {} request. url:{}=====", timestamp(), request.method(), request.url());
        CLIENT.newCall(request).enqueue(callback);
    }

    private static String timestamp() {
        return FORMATTER.format(LocalDateTime.now());
    }
}
OkHttp工具类封装，更优雅的调用接口
Champion-Dai
02-03 4245
OkHttp工具类封装，开箱即用。
【java学习】HTTP接口调用：Httpclient、Okhttp、HttpURLConnection、RestTemplate 和 Feign
午后阳光
08-26 5830
HttpClient 是 Apache Jakarta Common 下的子项目，用来提供高效的、最新的、功能丰富的支持 Http 协议的客户端编程工具包，并且它支持 HTTP 协议最新版本和建议。HttpClient 相比传统 JDK 自带的 URLConnection，提升了易用性和灵活性，使客户端发送 HTTP 请求变得容易，提高了开发的效率。首先，对于服务提供者，不需要进行任何配置，feign的访问对于服务提供者其实就是一次http访问。代表一次请求的范围，一般用于请求转发的多个资源中共享数据。
okHttp请求工具类
12-29
android网络框架之OKhttp[1] 一个处理网络请求的开源项目,是安卓端最火热的轻量级框架,由移动支付Square公司贡献(该公司还贡献了Picasso)[2] 用于替代HttpUrlConnection和Apache HttpClient(android API23 6.0里已移除HttpClient,现在已经打不出来)
Okhttp请求工具类
laolitou2的博客
07-19 686
这工具类是半个月前在网上找的放上来以后可能会用得上，忘了原文链接了，总之感谢大佬 源码 package com.test.cn.entity; import okhttp3.*; import org.apache.commons.lang3.exception.ExceptionUtils; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import java.util.Iterator; import java.
功能完整的HTTP请求测试工具实战应用
最新发布
weixin_42599558的博客
10-11 947
在现代Web开发与系统集成过程中，HTTP请求作为客户端与服务器通信的核心机制，其稳定性、准确性和可测试性直接决定了应用的质量。HTTP请求测试工具作为一种关键的调试与验证手段，广泛应用于接口联调、性能压测、安全检测和自动化测试等场景。本章将从HTTP协议的基本模型出发，深入剖析测试工具的设计目标与核心功能，明确其在实际开发中的定位。
okhttpUtil信任所有证书
GMaya的博客
03-19 730
使用okhttp调用https信任所有证书工具类。 请求示例： 结果： Caused by: javax.net.ssl.SSLHandshakeException: sun.security.validator.ValidatorException: PKIX path building failed: sun.security.provider.certpath.SunCertPathBuilderException: unable to find valid certification pat.
okhttp的工具类
sakurakbaby的博客
04-06 340
package com.example.gjl.yuekao1.http;import android.os.Handler;import android.os.Message;import java.io.IOException;import okhttp3.Call;import okhttp3.Callback;import okhttp3.FormBody;import okhttp3.I...
okhttp工具类
qq_42828293的博客
12-02 489
/** * 网络请求工具类 */ public class OkHttpUtil { private static Gson gson = new Gson(); private static final String MEDIA_TYPE = "application/json; charset=utf-8"; private static final String...
Android-OkHttp3.0网络工具类
08-13
- 开发者通常会封装一个OkHttp的工具类，以简化网络请求的调用，提供统一的接口供其他模块使用。封装的内容可能包括设置baseUrl、添加全局Header、处理请求结果等。 - 通过`OkHttpClient.Builder`构建自定义的...
超简洁OkHttp封装工具类高效请求解决方案
07-13
总结一下，通过上述方法，我们能够实现一个超简洁的OkHttp封装工具类，它不仅包含了通用的工具集合，还有高效简洁的网络请求调用方式。这不仅可以减少开发者的重复工作，还能提高代码的可维护性和可读性，从而提升...
Okhttp调用第三方系统接口【随记】
边走、边悟、迟早变好
06-17 889
Okhttp调用第三方系统接口。对象，包含你要发送的数据。方法发送请求并获取响应。
http工具类
03-28
SyncHttp getInstance this sendPost URLAPI QueryCMTypeList new HashMap<String String> new SyncHttp Ivolley { @Override public void response String response { Gson gson new Gson ; CMType type gson fromJson response CMType class ; Log i TAG type toString ; }">SyncHttp getInstance this sendPost URLAPI QueryCMTypeList new HashMap<String String> new SyncHttp Ivolley { @Override public void response String response { Gson gson new Gson ; CMType type gson fromJson response CMType [更多]
OKhttp工具类
weixin_42074882的博客
08-24 555
    package com.bwie.yuekao.utils; import android.util.Log; import java.io.IOException; import java.util.HashMap; import java.util.Map; import java.util.concurrent.TimeUnit; import okhttp3.Call; ...
OKhttp 工具类
king_wt的博客
05-31 380
package com.example.mytex.utils; import android.os.Handler; import java.io.IOException; import java.util.Map; import okhttp3.Call; import okhttp3.Callback; import okhttp3.FormBody; import okhttp3.O...
Okhttp 工具类
tongtongzhao的博客
11-10 336
package bwie.mylibrary;import com.google.gson.Gson; import java.io.IOException; import java.util.Map; import okhttp3.Call; import okhttp3.Callback; import okhttp3.FormBody; import okhttp3.MediaType; im
okhttp调用工具类
facesunny的博客
06-01 374
package com.lonely.utils; import com.ztkj.common.log.interceptors.HttpLogInterceptor; import okhttp3.*; import org.apache.http.client.utils.URIBuilder; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import javax.net.ssl.*; import java.io.IOExce
Okhttp通用工具类
无为萌新
06-03 601
【代码】Okhttp通用工具类。
http 工具类
qq_31544285的博客
06-11 343
package com.llgx.utils; /** * @author: DengJiong * @date: 2018-05-09 18:43 * @description: */ import org.apache.commons.lang3.StringUtils; import javax.net.ssl.*; import java.io.*; import java....
java 实现根据http 接口调用工具类
06-08
Java实现根据HTTP接口调用工具类的基本思路如下： 1. 引入HTTP客户端库，例如Apache HttpClient或OkHttp。 2. 封装HTTP请求和响应的工具类，例如： ``` public class HttpUtils { // 发送HTTP GET请求 public static String get(String url) throws IOException { CloseableHttpClient httpClient = HttpClients.createDefault(); HttpGet httpGet = new HttpGet(url); CloseableHttpResponse response = httpClient.execute(httpGet); String result = EntityUtils.toString(response.getEntity()); response.close(); httpClient.close(); return result; } // 发送HTTP POST请求 public static String post(String url, Map<String, String> params) throws IOException { CloseableHttpClient httpClient = HttpClients.createDefault(); HttpPost httpPost = new HttpPost(url); List<NameValuePair> nameValuePairs = new ArrayList<>(); for (Map.Entry<String, String> entry : params.entrySet()) { nameValuePairs.add(new BasicNameValuePair(entry.getKey(), entry.getValue())); } httpPost.setEntity(new UrlEncodedFormEntity(nameValuePairs, "UTF-8")); CloseableHttpResponse response = httpClient.execute(httpPost); String result = EntityUtils.toString(response.getEntity()); response.close(); httpClient.close(); return result; } } ``` 3. 在代码中使用HTTP工具类调用接口，例如： ``` // 发送HTTP GET请求 String result = HttpUtils.get("http://example.com/api?param1=value1&param2=value2"); // 发送HTTP POST请求 Map<String, String> params = new HashMap<>(); params.put("param1", "value1"); params.put("param2", "value2"); String result = HttpUtils.post("http://example.com/api", params); ``` 需要注意的是，Java实现根据HTTP接口调用工具类需要根据具体的业务逻辑和接口协议进行实现，需要进行接口参数的封装和解析，并进行异常处理和错误码处理。同时，还需要进行HTTP请求和响应的监控和管理，保证接口的稳定性和可靠性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值