java中几种常用的HTTP请求工具类

最新推荐文章于 2025-02-18 15:10:24 发布

所念皆为东辞

最新推荐文章于 2025-02-18 15:10:24 发布

阅读量1k

点赞数 14

分类专栏： java http 文章标签： http 网络 java

本文链接：https://blog.youkuaiyun.com/qsfhngy/article/details/145000737

版权

java 同时被 2 个专栏收录

5 篇文章

订阅专栏

http

1 篇文章

订阅专栏

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 {

    /**
     * 发起HTTP请求（支持GET和POST）
     *
     * @param serverPrefix 服务器前缀
     * @param urlSuffix    URL路径后缀
     * @param method       HTTP请求方法
     * @param headers      请求头
     * @param params       请求参数（POST时为JSON体，GET时为查询参数）
     * @return 请求结果字符串
     */
    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"); // 默认设置Content-Type为JSON
        } else {
            throw new IllegalArgumentException("Unsupported HTTP method: " + method);
        }

        // 设置请求头
        if (headers != null) {
            headers.forEach(request::header);
        }

        // 执行请求并获取响应
        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);
    }
}

调用：

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

public class Main {
    public static void main(String[] args) {
        String serverPrefix = "https://api.example.com";
        
        // 准备GET请求的参数
        Map<String, Object> getParams = new HashMap<>();
        getParams.put("page", 1);
        getParams.put("pageSize", 1000);
        
        // 准备GET请求的头
        Map<String, String> getHeaders = new HashMap<>();
        getHeaders.put("x-auth-token", "your-auth-token");
        getHeaders.put("Custom-Header", "CustomValue");
        
        // 发起GET请求
        String getResponse = HttpUtilTools.sendGetRequest(serverPrefix, "/api/v1/projects/page", getHeaders, getParams);
        System.out.println("GET Response: " + getResponse);
        
        // 准备POST请求的参数
        Map<String, Object> postParams = new HashMap<>();
        postParams.put("page", 1);
        postParams.put("pageSize", 1000);
        postParams.put("parentId", "your-parent-id");
        
        // 准备POST请求的头
        Map<String, String> postHeaders = new HashMap<>();
        postHeaders.put("x-auth-token", "your-auth-token");
        postHeaders.put("Content-Type", "application/json"); // 虽然工具类内部会设置，但这里展示可以自定义
        
        // 发起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 {
        // 设置超时时间为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);
            }
        });
    }
    /**
     * 发送POST请求 入参:请求体，请求体格式类型
     */
    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();
    }

    /**
     * 发送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();
    }

    /**
     * 发送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();
    }

    /**
     * 发送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请求头参数
     *
     * @param body         body参数
     * @param headerParams 请求头参数
     * @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参数是否为空
        if (ObjectUtils.isEmpty(body)) {
            return new HttpEntity<>(httpHeaders);
        } else {
            return new HttpEntity<>(JSON.toJSONString(body), httpHeaders);
        }
    }
}

总结:

性能对比
OkHttp：

性能最高：OkHttp 是一个专门为高性能设计的 HTTP 客户端，支持连接池、请求拦截器、GZIP 压缩等优化。
适合高并发场景：如果你的应用需要处理大量 HTTP 请求，OkHttp 是最佳选择。
Hutool：

性能中等：Hutool 的 HTTP 工具是基于 JDK 的 HttpURLConnection 实现的，性能不如 OkHttp，但足够应对大多数场景。
适合小型项目：如果你的项目对性能要求不高，且需要快速开发，Hutool 是一个不错的选择。
RestTemplate：

性能中等：RestTemplate 是基于 JDK 的 HttpURLConnection 或 Apache 的 HttpClient 实现的，性能与 Hutool 类似。
适合 Spring 项目：如果你的项目已经使用了 Spring 框架，RestTemplate 可以很好地与 Spring 生态集成。

使用场景推荐
Hutool：

适合小型项目或工具类需求。
如果你需要快速实现 HTTP 请求功能，且不想引入复杂的依赖，Hutool 是一个很好的选择。
OkHttp：

适合高性能需求或复杂 HTTP 请求场景。
如果你需要处理大量并发请求，或者需要自定义请求拦截器、连接池等，OkHttp 是最佳选择。
RestTemplate：

适合 Spring 项目。
如果你的项目已经使用了 Spring 框架，且需要与 Spring 生态（如 Spring Boot、Spring Cloud）集成，RestTemplate 是一个不错的选择。