JavaHttpClient发送请求的多种方法

今日不肯埋头，明日何以抬头！每日一句努力自己的话哈哈~哈喽，今天我将给大家带来一篇《Java中使用HttpClient发送请求的几种方式》，主要内容是讲解等等，感兴趣的朋友可以收藏或者有更好的建议在评论提出，我都会认真看的！大家一起进步，一起学习！

1.在复杂场景下Apache HttpClient更受青睐的原因是其提供了更高级、更人性化的API，支持连接池、重试机制、身份认证、上传大文件、处理流式响应等功能；2.其内置连接管理、请求配置、重定向处理和Cookie管理，简化了底层网络细节的处理；3.连接池管理通过减少频繁创建和关闭TCP连接显著提升性能，尤其适用于高并发场景；4.HttpClient的异步请求基于NIO，允许非阻塞发起请求并通过回调处理响应，提升吞吐量、降低延迟；5.合理配置连接池参数（如最大连接数、空闲超时时间）可避免连接泄露或耗尽，保障系统稳定性；6.请求参数可通过URIBuilder处理GET参数，UrlEncodedFormEntity或StringEntity处理POST参数，支持JSON、XML等多种格式；7.Header可通过setHeader或addHeader方法设置，承载认证信息、内容类型等元数据；8.响应处理需检查状态码并根据HttpEntity获取响应体内容，支持一次性读取或流式处理；9.超时配置可通过RequestConfig设置连接和数据传输超时时间，防止请求长时间阻塞。

在Java中进行网络请求，你主要会遇到两种主流方式：一是Java标准库内置的HttpURLConnection，它简单直接，适合轻量级任务；二是功能更丰富、更强大的第三方库，其中Apache HttpClient无疑是长期以来社区的首选，而在Java 11之后，JDK自带的java.net.http.HttpClient也变得非常值得关注。不过，当我们谈论“HttpClient库”时，很多时候还是指向那个久经考验的Apache HttpClient，它在企业级应用中扮演着举足轻重的角色。

解决方案

使用Apache HttpClient发送网络请求，核心流程其实挺直观的。你需要先构建一个HttpClient实例，然后创建具体的请求对象（比如HttpGet或HttpPost），设置好请求参数和头部，执行请求，最后处理服务器的响应。

首先，你需要将Apache HttpClient的依赖添加到你的项目里。如果你用的是Maven：

<dependency>
    <groupId>org.apache.httpcomponents</groupId>
    <artifactId>httpclient</artifactId>
    <version>4.5.13</version>
</dependency>

接着，一个简单的GET请求可以这样写：

import org.apache.http.HttpEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;

import java.io.IOException;

public class HttpClientExample {

    public static void main(String[] args) {
        // 创建HttpClient实例，这是执行请求的入口
        CloseableHttpClient httpClient = HttpClients.createDefault();

        // 定义请求目标URL
        String url = "https://jsonplaceholder.typicode.com/todos/1";
        HttpGet httpGet = new HttpGet(url);

        CloseableHttpResponse response = null;
        try {
            // 执行GET请求
            response = httpClient.execute(httpGet);

            // 获取响应实体
            HttpEntity entity = response.getEntity();

            // 打印响应状态码
            System.out.println("Status Code: " + response.getStatusLine().getStatusCode());

            // 将响应实体转换为字符串并打印
            if (entity != null) {
                String result = EntityUtils.toString(entity);
                System.out.println("Response Body: " + result);
            }

        } catch (IOException e) {
            // 捕获可能发生的网络或IO错误
            System.err.println("Error during HTTP request: " + e.getMessage());
            e.printStackTrace();
        } finally {
            // 确保关闭响应和HttpClient实例，释放资源
            try {
                if (response != null) {
                    response.close();
                }
                httpClient.close(); // 实际项目中，httpClient实例通常是复用的，这里只是示例
            } catch (IOException e) {
                System.err.println("Error closing resources: " + e.getMessage());
            }
        }
    }
}

如果你需要发送POST请求，流程也类似，只是你需要使用HttpPost对象，并且可以通过setEntity方法来设置请求体，比如StringEntity、UrlEncodedFormEntity或者MultipartEntityBuilder来处理表单数据或文件上传。

import org.apache.http.HttpEntity;
import org.apache.http.NameValuePair;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;

import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.List;

public class HttpClientPostExample {

    public static void main(String[] args) {
        CloseableHttpClient httpClient = HttpClients.createDefault();
        String url = "https://jsonplaceholder.typicode.com/posts"; // 这是一个测试API，可以接受POST请求

        HttpPost httpPost = new HttpPost(url);
        httpPost.setHeader("Content-Type", "application/x-www-form-urlencoded"); // 设置请求头

        // 准备表单数据
        List<NameValuePair> params = new ArrayList<>();
        params.add(new BasicNameValuePair("title", "foo"));
        params.add(new BasicNameValuePair("body", "bar"));
        params.add(new BasicNameValuePair("userId", "1"));

        CloseableHttpResponse response = null;
        try {
            // 设置请求体
            httpPost.setEntity(new UrlEncodedFormEntity(params, StandardCharsets.UTF_8));

            response = httpClient.execute(httpPost);
            HttpEntity entity = response.getEntity();

            System.out.println("Status Code: " + response.getStatusLine().getStatusCode());
            if (entity != null) {
                String result = EntityUtils.toString(entity);
                System.out.println("Response Body: " + result);
            }

        } catch (IOException e) {
            System.err.println("Error during HTTP POST request: " + e.getMessage());
            e.printStackTrace();
        } finally {
            try {
                if (response != null) {
                    response.close();
                }
                httpClient.close();
            } catch (IOException e) {
                System.err.println("Error closing resources: " + e.getMessage());
            }
        }
    }
}

为什么在复杂场景下HttpClient更受青睐？

说到Java里发网络请求，很多人可能首先想到的是HttpURLConnection，毕竟它是JDK自带的。我个人觉得，对于那些简单的、一次性的GET请求，HttpURLConnection确实够用，它轻量、无需额外依赖。但一旦你的需求稍微复杂一点，比如需要处理连接池、重试机制、身份认证、或者上传大文件、处理流式响应，HttpURLConnection用起来就显得力不从心了，代码会变得非常冗长和难以维护。

Apache HttpClient之所以在企业级应用中长期占据主导地位，因为它提供了一整套更高级、更人性化的API来处理这些复杂场景。它内置了连接管理、请求配置（超时、代理）、重定向处理、Cookie管理等诸多功能。你不需要自己去操心底层的Socket连接、流的读写这些细节，它都帮你封装好了。比如，连接池管理，这在并发请求量大的时候至关重要，HttpClient能帮你高效地复用连接，避免频繁地创建和关闭TCP连接，从而显著提升性能。相比之下，用HttpURLConnection实现同样的功能，你可能需要写大量的模板代码，而且还容易出错。所以，当项目规模和复杂性提升时，选择HttpClient几乎是自然而然的事情。当然，现在Java 11+的java.net.http.HttpClient也提供了很多类似的高级功能，并且是异步非阻塞的，未来可能会成为新的主流，但Apache HttpClient的生态和成熟度依然不可小觑。

HttpClient的异步请求与连接池管理：构建高性能应用的基石

在现代微服务架构和高并发场景下，同步阻塞的I/O操作往往会成为性能瓶颈。想象一下，如果你的服务需要同时向几十个外部API发起请求，每个请求都得等待上一个完成才能继续，那整个响应时间会急剧增加。这时候，异步请求就显得尤为重要了。Apache HttpClient也提供了异步客户端，即HttpAsyncClient。它基于NIO（非阻塞I/O），允许你在不阻塞当前线程的情况下发起请求，并在请求完成后通过回调机制处理响应。这对于构建高吞吐量、低延迟的服务非常关键。

// 异步请求的依赖通常是：
// <dependency>
//     <groupId>org.apache.httpcomponents</groupId>
//     <artifactId>httpasyncclient</artifactId>
//     <version>4.1.4</version>
// </dependency>

// 异步请求示例（概念性代码，实际需处理回调和异常）
/*
import org.apache.http.client.methods.HttpGet;
import org.apache.http.concurrent.FutureCallback;
import org.apache.http.impl.nio.client.CloseableHttpAsyncClient;
import org.apache.http.impl.nio.client.HttpAsyncClients;
import org.apache.http.HttpResponse;

public class HttpAsyncClientExample {
    public static void main(String[] args) throws Exception {
        CloseableHttpAsyncClient httpclient = HttpAsyncClients.createDefault();
        httpclient.start();

        HttpGet request = new HttpGet("http://www.example.com");
        httpclient.execute(request, new FutureCallback<HttpResponse>() {
            @Override
            public void completed(HttpResponse response) {
                System.out.println("Async Request Completed: " + response.getStatusLine());
            }

            @Override
            public void failed(Exception ex) {
                System.err.println("Async Request Failed: " + ex.getMessage());
            }

            @Override
            public void cancelled() {
                System.out.println("Async Request Cancelled.");
            }
        });

        // 实际应用中，这里会有其他业务逻辑，或者等待所有请求完成
        Thread.sleep(5000); // 仅为演示，实际不会这样阻塞
        httpclient.close();
    }
}
*/

再来说说连接池管理。这简直是网络请求优化中的“隐形冠军”。每次建立TCP连接（包括三次握手）和SSL/TLS握手都是有开销的。如果没有连接池，每次请求都得重新建立连接，这在请求量大的时候会带来巨大的性能损耗和资源浪费。HttpClient通过PoolingHttpClientConnectionManager提供了一套完善的连接池管理机制。你可以配置最大连接数、每个路由的最大连接数、连接的空闲超时时间等参数。合理配置连接池，能够显著减少连接建立的开销，提高请求的响应速度和系统的吞吐量。我见过不少线上系统，因为连接池配置不当，导致连接泄露或者连接耗尽，最终服务不可用的情况。所以，这块的配置，绝对值得花时间去理解和调优。

import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.config.RegistryBuilder;
import org.apache.http.conn.socket.ConnectionSocketFactory;
import org.apache.http.conn.socket.PlainConnectionSocketFactory;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.config.Registry;
import javax.net.ssl.SSLContext; // 实际应用中可能需要自定义SSLContext

public class HttpClientConnectionPoolExample {
    public static void main(String[] args) {
        // 配置支持HTTP和HTTPS的Socket工厂
        Registry<ConnectionSocketFactory> socketFactoryRegistry = RegistryBuilder.<ConnectionSocketFactory>create()
                .register("http", PlainConnectionSocketFactory.INSTANCE)
                // 生产环境通常需要更复杂的SSLContext配置
                .register("https", SSLConnectionSocketFactory.getSocketFactory())
                .build();

        // 创建连接池管理器
        PoolingHttpClientConnectionManager cm = new PoolingHttpClientConnectionManager(socketFactoryRegistry);
        // 设置最大连接数
        cm.setMaxTotal(200);
        // 设置每个路由（即到每个主机的最大连接数，例如到www.baidu.com的最大连接数）
        cm.setDefaultMaxPerRoute(20);

        // 创建HttpClient实例，使用连接池管理器
        CloseableHttpClient httpClient = HttpClients.custom()
                .setConnectionManager(cm)
                .build();

        // 此时，httpClient实例就可以用于发送请求了，它会从连接池中获取连接
        // ... (使用httpClient发送请求)

        // 应用程序关闭时，需要关闭连接池管理器
        // cm.shutdown();
        // httpClient.close(); // 确保也关闭了httpClient
    }
}

处理请求参数、Header和响应：HttpClient实战技巧

在实际开发中，网络请求远不止一个简单的GET或POST。你可能需要发送JSON、XML，或者上传文件，这些都涉及到请求参数和Header的精细控制。

请求参数： 对于GET请求，参数通常拼接在URL后面，HttpClient会自动帮你处理URL编码：

// GET请求带参数
URIBuilder builder = new URIBuilder("http://www.example.com/search");
builder.setParameter("query", "HttpClient")
       .setParameter("page", "1");
HttpGet httpGet = new HttpGet(builder.build());
// ... 执行请求

对于POST请求，如果发送的是application/x-www-form-urlencoded类型的表单数据，就像前面示例那样，使用UrlEncodedFormEntity。如果需要发送JSON或XML，那就用StringEntity，并设置Content-Type头部：

import org.apache.http.entity.StringEntity;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.HttpHeaders;

// ...
String jsonPayload = "{\"name\": \"test\", \"value\": 123}";
HttpPost httpPost = new HttpPost("http://api.example.com/data");
httpPost.setHeader(HttpHeaders.CONTENT_TYPE, "application/json"); // 关键！
httpPost.setEntity(new StringEntity(jsonPayload, StandardCharsets.UTF_8));
// ... 执行请求

请求Header： Header是HTTP请求的元数据，承载着认证信息、内容类型、缓存控制等关键信息。HttpClient提供了多种设置Header的方式：

// 设置单个Header
httpPost.setHeader("Authorization", "Bearer your_token_here");
httpPost.setHeader("User-Agent", "MyJavaApp/1.0");

// 也可以添加多个同名Header（如果协议允许）
// httpPost.addHeader("Set-Cookie", "key=value");

响应处理： 拿到CloseableHttpResponse后，首先要检查响应状态码。200 OK是最理想的，但也要处理4xx（客户端错误）和5xx（服务器错误）。response.getStatusLine().getStatusCode()会给你这个数字。

获取响应体内容通常通过response.getEntity()拿到HttpEntity。然后你可以用EntityUtils.toString(entity)把它完整地读成字符串，或者用entity.getContent()获取一个InputStream来流式处理，这对于大文件下载非常有用，避免一次性加载到内存导致OOM。

// ... 获取response
int statusCode = response.getStatusLine().getStatusCode();
if (statusCode >= 200 && statusCode < 300) {
    // 成功响应
    HttpEntity entity = response.getEntity();
    if (entity != null) {
        // 假设是JSON响应
        String jsonResponse = EntityUtils.toString(entity, StandardCharsets.UTF_8);
        System.out.println("成功响应: " + jsonResponse);
        // 这里可以进一步使用Jackson/Gson等库解析JSON
    }
} else {
    // 错误响应
    System.err.println("请求失败，状态码: " + statusCode);
    HttpEntity errorEntity = response.getEntity();
    if (errorEntity != null) {
        String errorBody = EntityUtils.toString(errorEntity, StandardCharsets.UTF_8);
        System.err.println("错误详情: " + errorBody);
    }
}
// ... 确保关闭资源

超时配置： 网络请求最怕的就是“卡住”。HttpClient允许你设置连接超时（建立连接的超时时间）和套接字超时（数据传输的超时时间）。

import org.apache.http.client.config.RequestConfig;

// ...
RequestConfig requestConfig = RequestConfig.custom()
    .setConnectTimeout(5000) // 连接超时5秒
    .setSocketTimeout(10000) // 数据传输超时10秒
    .build();

HttpGet httpGet = new HttpGet(url);
httpGet.setConfig(requestConfig); // 将配置应用到请求上
// 或者应用到HttpClient实例上作为默认配置
// CloseableHttpClient httpClient = HttpClients.custom().setDefaultRequestConfig(requestConfig).build();

这些都是我在实际项目中经常会用到的一些技巧。HttpClient的强大之处在于它的可配置性和扩展性，熟练掌握这些，能够让你在处理各种复杂的网络通信场景时游刃有余。

今天关于《JavaHttpClient发送请求的多种方法》的内容介绍就到此结束，如果有什么疑问或者建议，可以在golang学习网公众号下多多回复交流；文中若有不正之处，也希望回复留言以告知！