java中幾種常用的HTTP請求工具類舉例詳解

更新時間：2025年05月12日 09:18:09 作者：所念皆為東辭

這篇文章主要介紹了java中幾種常用的HTTP請求工具類,詳細(xì)對比了OkHttp、Hutool和RestTemplate三種HTTP客戶端工具類的性能和適用場景,文中給出了詳細(xì)的代碼示例,需要的朋友可以參考下

1.使用hutool

引入依賴

        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>5.8.8</version>
        </dependency>

工具類

package org.example.task;

import cn.hutool.http.HttpRequest;
import cn.hutool.http.HttpResponse;
import cn.hutool.json.JSONUtil;

import java.util.Map;

public class HttpUtilTools {

    /**
     * 發(fā)起HTTP請求（支持GET和POST）
     *
     * @param serverPrefix 服務(wù)器前綴
     * @param urlSuffix    URL路徑后綴
     * @param method       HTTP請求方法
     * @param headers      請求頭
     * @param params       請求參數(shù)（POST時為JSON體，GET時為查詢參數(shù)）
     * @return 請求結(jié)果字符串
     */
    public static String sendRequest(String serverPrefix, String urlSuffix, String method, Map<String, String> headers, Map<String, Object> params) {
        HttpRequest request;
        if ("GET".equalsIgnoreCase(method)) {
            request = HttpRequest.get(serverPrefix + urlSuffix);
            if (params != null) {
                params.forEach(request::form);
            }
        } else if ("POST".equalsIgnoreCase(method)) {
            String jsonStr = JSONUtil.toJsonStr(params);
            request = HttpRequest.post(serverPrefix + urlSuffix)
                    .body(jsonStr);
            headers.put("Content-Type", "application/json"); // 默認(rèn)設(shè)置Content-Type為JSON
        } else {
            throw new IllegalArgumentException("Unsupported HTTP method: " + method);
        }

        // 設(shè)置請求頭
        if (headers != null) {
            headers.forEach(request::header);
        }

        // 執(zhí)行請求并獲取響應(yīng)
        HttpResponse response = request.execute();
        return response.body();
    }

    // 便捷的GET請求方法
    public static String sendGetRequest(String serverPrefix, String urlSuffix, Map<String, String> headers, Map<String, Object> params) {
        return sendRequest(serverPrefix, urlSuffix, "GET", headers, params);
    }

    // 便捷的POST請求方法
    public static String sendPostRequest(String serverPrefix, String urlSuffix, Map<String, String> headers, Map<String, Object> params) {
        return sendRequest(serverPrefix, urlSuffix, "POST", headers, params);
    }
}

調(diào)用：

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

public class Main {
    public static void main(String[] args) {
        String serverPrefix = "https://api.example.com";
        
        // 準(zhǔn)備GET請求的參數(shù)
        Map<String, Object> getParams = new HashMap<>();
        getParams.put("page", 1);
        getParams.put("pageSize", 1000);
        
        // 準(zhǔn)備GET請求的頭
        Map<String, String> getHeaders = new HashMap<>();
        getHeaders.put("x-auth-token", "your-auth-token");
        getHeaders.put("Custom-Header", "CustomValue");
        
        // 發(fā)起GET請求
        String getResponse = HttpUtilTools.sendGetRequest(serverPrefix, "/api/v1/projects/page", getHeaders, getParams);
        System.out.println("GET Response: " + getResponse);
        
        // 準(zhǔn)備POST請求的參數(shù)
        Map<String, Object> postParams = new HashMap<>();
        postParams.put("page", 1);
        postParams.put("pageSize", 1000);
        postParams.put("parentId", "your-parent-id");
        
        // 準(zhǔn)備POST請求的頭
        Map<String, String> postHeaders = new HashMap<>();
        postHeaders.put("x-auth-token", "your-auth-token");
        postHeaders.put("Content-Type", "application/json"); // 雖然工具類內(nèi)部會設(shè)置，但這里展示可以自定義
        
        // 發(fā)起POST請求
        String postResponse = HttpUtilTools.sendPostRequest(serverPrefix, "/api/v1/media/projects/your-project-id/files", postHeaders, postParams);
        System.out.println("POST Response: " + postResponse);
    }
}

2.使用okhttp

引入依賴

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

工具類

package org.example.task;

import com.alibaba.fastjson.JSONObject;
import okhttp3.*;

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

public class HttpClientUtils {

    private static final OkHttpClient httpClient = new OkHttpClient.Builder()
            .connectTimeout(60, TimeUnit.SECONDS) // 連接超時時間 60 秒
            .readTimeout(60, TimeUnit.SECONDS)    // 讀取超時時間 60 秒
            .writeTimeout(60, TimeUnit.SECONDS)   // 寫入超時時間 60 秒
            .build();

    public static final MediaType MEDIA_TYPE_JSON = MediaType.parse("application/json; charset=utf-8");

    public static JSONObject get(String url) {
        Request request = new Request.Builder().url(url).get().build();
        return execute(request);
    }

    public static JSONObject get(String url, Map<String, String> headers) {
        Request.Builder requestBuilder = new Request.Builder().url(url).get();
        // 添加請求頭
        if (headers != null) {
            for (Map.Entry<String, String> entry : headers.entrySet()) {
                requestBuilder.addHeader(entry.getKey(), entry.getValue());
            }
        }
        Request request = requestBuilder.build();
        return execute(request);
    }

    public static JSONObject post(String url, JSONObject content) {
        RequestBody body = RequestBody.create(MEDIA_TYPE_JSON, content.toJSONString());
        Request request = new Request.Builder().url(url).post(body).build();
        return execute(request);
    }

    public static JSONObject post(String url, JSONObject content, Map<String, String> headers) {
        RequestBody body = RequestBody.create(MEDIA_TYPE_JSON, content.toJSONString());
        Request.Builder requestBuilder = new Request.Builder().url(url).post(body);
        // 添加請求頭
        if (headers != null) {
            for (Map.Entry<String, String> entry : headers.entrySet()) {
                requestBuilder.addHeader(entry.getKey(), entry.getValue());
            }
        }
        Request request = requestBuilder.build();
        return execute(request);
    }

    private static JSONObject execute(Request request) {
        try (Response response = httpClient.newCall(request).execute()) {
            if (!response.isSuccessful()) {
                throw new IOException("Unexpected code " + response);
            }
            String str = response.body().string();
            return JSONObject.parseObject(str);
        } catch (IOException e) {
            e.printStackTrace();
            return new JSONObject();
        }
    }
}

3.使用spring自帶的RestTemplate

工具類

package org.example.task;

import com.alibaba.fastjson.JSON;
import org.apache.commons.lang3.ObjectUtils;
import org.springframework.http.*;
import org.springframework.http.client.ClientHttpRequestExecution;
import org.springframework.http.client.ClientHttpRequestInterceptor;
import org.springframework.http.client.ClientHttpResponse;
import org.springframework.http.client.SimpleClientHttpRequestFactory;
import org.springframework.web.client.RestTemplate;

import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URLEncoder;
import java.nio.charset.StandardCharsets;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;


public class HttpUtil {
    private static final RestTemplate REST_TEMPLATE = new RestTemplate();

    static {
        // 設(shè)置超時時間為60S
        SimpleClientHttpRequestFactory requestFactory = new SimpleClientHttpRequestFactory();
        requestFactory.setConnectTimeout(60000);
        requestFactory.setReadTimeout(60000);
        REST_TEMPLATE.setRequestFactory(requestFactory);
        // 添加請求攔截器，用于打印請求信息
        REST_TEMPLATE.getInterceptors().add(new ClientHttpRequestInterceptor() {
            @Override
            public ClientHttpResponse intercept(HttpRequest request, byte[] body, ClientHttpRequestExecution execution) throws IOException, IOException {
                System.out.println("sendPost:   url = " + request.getURI() + ",headers=" + request.getHeaders());
                return execution.execute(request, body);
            }
        });
    }
    /**
     * 發(fā)送POST請求 入?yún)?請求體，請求體格式類型
     */
    public static <T> T sendPost(String url, Object bodyParams, Class<T> clazz) {
        Map<String, Object> headerParam = new HashMap<>();
        headerParam.put("Content-Type", "application/json");
        headerParam.put("Connection", "close");
        HttpEntity<String> httpEntity = formatHeaders(bodyParams, headerParam);
        ResponseEntity<T> responseEntity = REST_TEMPLATE.postForEntity(url, httpEntity, clazz);
        return responseEntity.getBody();
    }

    /**
     * 發(fā)送POST請求(帶請求頭)
     */
    public static <T> T sendPostWithHeader(String url, Object bodyParams, Map<String, Object> headerParams, Class<T> clazz) {
        HttpEntity<String> httpEntity = formatHeaders(bodyParams, headerParams);
        ResponseEntity<T> responseEntity = REST_TEMPLATE.postForEntity(url, httpEntity, clazz);
        return responseEntity.getBody();
    }

    /**
     * 發(fā)送GET請求 不帶請求頭
     * @return
     */
    public static <T> T sendGet(String url, Map<String, Object> params, Class<T> clazz) throws MalformedURLException {
        String realUrl = formatGetParams(url, params);
        ResponseEntity<T> responseEntity = REST_TEMPLATE.getForEntity(realUrl, clazz);
        return responseEntity.getBody();
    }

    /**
     * 發(fā)送GET請求 帶請求頭
     */
    public static <T> T sendGetWithHeader(String url, Map<String, Object> params, Map<String, Object> headerParams, Class<T> clazz) {
        String realUrl = formatGetParams(url, params);
        HttpEntity<String> httpEntity = formatHeaders(null, headerParams);
        ResponseEntity<T> responseEntity = REST_TEMPLATE.exchange(realUrl, HttpMethod.GET, httpEntity, clazz);
        return responseEntity.getBody();
    }

    /**
     * 格式化Get請求url
     *
     * @param params
     * @return
     */
    public static String formatGetParams(String url, Map<String, Object> params) {
        System.out.println("formatGetParams=" + params);
        StringBuilder sb = new StringBuilder();
        sb.append(url).append("?");
        try {
            Set<String> keySet = params.keySet();
            Iterator<String> iterator = keySet.iterator();
            while (iterator.hasNext()) {
                String key = iterator.next();
                String value = String.valueOf(params.get(key));
                if ("params".equals(key)) {
                    value = URLEncoder.encode(value, StandardCharsets.UTF_8.toString());
                }
                sb.append(key).append("=").append(value).append("&");

            }
            return sb.substring(0, sb.length() - 1);
        } catch (Exception e) {
            throw new RuntimeException();
        }
    }

    /**
     * 格式化Get請求頭參數(shù)
     *
     * @param body         body參數(shù)
     * @param headerParams 請求頭參數(shù)
     * @return httpEntity
     */
    private static HttpEntity<String> formatHeaders(Object body, Map<String, Object> headerParams) {
        HttpHeaders httpHeaders = new HttpHeaders();
        if (headerParams != null && headerParams.size() > 0) {
            for (Map.Entry<String, Object> entry : headerParams.entrySet()) {
                httpHeaders.add(entry.getKey(), entry.getValue().toString());
            }
        }
        //判斷body參數(shù)是否為空
        if (ObjectUtils.isEmpty(body)) {
            return new HttpEntity<>(httpHeaders);
        } else {
            return new HttpEntity<>(JSON.toJSONString(body), httpHeaders);
        }
    }
}

總結(jié):

性能對比OkHttp：

性能最高：OkHttp 是一個專門為高性能設(shè)計的 HTTP 客戶端，支持連接池、請求攔截器、GZIP 壓縮等優(yōu)化。
適合高并發(fā)場景：如果你的應(yīng)用需要處理大量 HTTP 請求，OkHttp 是最佳選擇。
Hutool：

性能中等：Hutool 的 HTTP 工具是基于 JDK 的 HttpURLConnection 實現(xiàn)的，性能不如 OkHttp，但足夠應(yīng)對大多數(shù)場景。
適合小型項目：如果你的項目對性能要求不高，且需要快速開發(fā)，Hutool 是一個不錯的選擇。
RestTemplate：

性能中等：RestTemplate 是基于 JDK 的 HttpURLConnection 或 Apache 的 HttpClient 實現(xiàn)的，性能與 Hutool 類似。
適合 Spring 項目：如果你的項目已經(jīng)使用了 Spring 框架，RestTemplate 可以很好地與 Spring 生態(tài)集成。

使用場景推薦Hutool：

適合小型項目或工具類需求。
如果你需要快速實現(xiàn) HTTP 請求功能，且不想引入復(fù)雜的依賴，Hutool 是一個很好的選擇。
OkHttp：

適合高性能需求或復(fù)雜 HTTP 請求場景。
如果你需要處理大量并發(fā)請求，或者需要自定義請求攔截器、連接池等，OkHttp 是最佳選擇。
RestTemplate：

適合 Spring 項目。
如果你的項目已經(jīng)使用了 Spring 框架，且需要與 Spring 生態(tài)（如 Spring Boot、Spring Cloud）集成，RestTemplate 是一個不錯的選擇。

到此這篇關(guān)于java中幾種常用的HTTP請求工具類的文章就介紹到這了,更多相關(guān)java HTTP請求工具類內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

您可能感興趣的文章: