✅ 常用 Java HTTP 客户端汇总及使用示例

在 Java 开发中,HTTP 客户端是与服务端交互的关键组件。随着技术发展,出现了多种 HTTP 客户端库,本文汇总了常用的 Java HTTP 客户端,介绍其特点、适用场景,并附上简单使用示例,方便开发者快速选择和上手。


1.常用 HTTP 客户端一览

名称 简介 特点
HttpClient(JDK 自带) Java 11 引入的官方 HTTP 客户端 支持异步、HTTP/2,API 现代
RestTemplate Spring 提供的同步 HTTP 客户端(即将被淘汰) 简洁,适合小项目;被 WebClient 替代
WebClient Spring 5 提供的响应式 HTTP 客户端 支持响应式编程,推荐替代 RestTemplate
OkHttpClient Square 出品,轻量级高性能 HTTP 客户端 支持异步、连接池、拦截器
Apache HttpClient Apache 出品的经典 HTTP 客户端库 功能强大、稳定、支持各种高级特性
Feign 声明式 HTTP 客户端,适用于 Spring Cloud 开发效率高,集成 Ribbon/Hystrix
Retrofit Square 出品,封装 OkHttp 的声明式客户端 强大的 JSON 自动转换,适合 REST API
AsyncHttpClient 异步非阻塞 HTTP 客户端(如 Netty 实现) 高并发性能好,用于微服务场景
Vert.x WebClient Vert.x 框架的异步 HTTP 客户端 轻量级、响应式,非常适合微服务
Jetty HttpClient Jetty 提供的 HTTP 客户端实现 支持异步和 HTTP/2,常用于嵌入式

2.推荐选择场景

需求 推荐客户端
简单同步请求 RestTemplate(传统)或 HttpClient(Java 11+)
响应式或高并发 WebClient, AsyncHttpClient, Vert.x WebClient
简洁封装、声明式调用 Feign, Retrofit
高度可定制 OkHttp, Apache HttpClient

3.各客户端 GET 和 POST 示例


1. HttpClient(Java 11+)

java 复制代码
// GET 请求
HttpClient client = HttpClient.newHttpClient();

HttpRequest getRequest = HttpRequest.newBuilder()
        .uri(URI.create("https://jsonplaceholder.typicode.com/posts/1"))
        .GET()
        .build();

HttpResponse<String> getResponse = client.send(getRequest, HttpResponse.BodyHandlers.ofString());
System.out.println("GET response: " + getResponse.body());

// POST 请求
String json = "{\"title\":\"foo\",\"body\":\"bar\",\"userId\":1}";

HttpRequest postRequest = HttpRequest.newBuilder()
        .uri(URI.create("https://jsonplaceholder.typicode.com/posts"))
        .header("Content-Type", "application/json")
        .POST(HttpRequest.BodyPublishers.ofString(json))
        .build();

HttpResponse<String> postResponse = client.send(postRequest, HttpResponse.BodyHandlers.ofString());
System.out.println("POST response: " + postResponse.body());

2. RestTemplate

java 复制代码
RestTemplate restTemplate = new RestTemplate();

// GET 请求
String getResult = restTemplate.getForObject("https://jsonplaceholder.typicode.com/posts/1", String.class);
System.out.println("GET response: " + getResult);

// POST 请求
String url = "https://jsonplaceholder.typicode.com/posts";
Map<String, Object> postBody = new HashMap<>();
postBody.put("title", "foo");
postBody.put("body", "bar");
postBody.put("userId", 1);

String postResult = restTemplate.postForObject(url, postBody, String.class);
System.out.println("POST response: " + postResult);

3. WebClient

java 复制代码
WebClient client = WebClient.create();

// GET 请求
client.get()
      .uri("https://jsonplaceholder.typicode.com/posts/1")
      .retrieve()
      .bodyToMono(String.class)
      .subscribe(response -> System.out.println("GET response: " + response));

// POST 请求
String json = "{\"title\":\"foo\",\"body\":\"bar\",\"userId\":1}";

client.post()
      .uri("https://jsonplaceholder.typicode.com/posts")
      .header("Content-Type", "application/json")
      .bodyValue(json)
      .retrieve()
      .bodyToMono(String.class)
      .subscribe(response -> System.out.println("POST response: " + response));

4. OkHttpClient

java 复制代码
OkHttpClient client = new OkHttpClient();

// GET 请求
Request getRequest = new Request.Builder()
        .url("https://jsonplaceholder.typicode.com/posts/1")
        .build();

Response getResponse = client.newCall(getRequest).execute();
System.out.println("GET response: " + getResponse.body().string());

// POST 请求
MediaType JSON = MediaType.get("application/json; charset=utf-8");
String json = "{\"title\":\"foo\",\"body\":\"bar\",\"userId\":1}";

RequestBody body = RequestBody.create(json, JSON);
Request postRequest = new Request.Builder()
        .url("https://jsonplaceholder.typicode.com/posts")
        .post(body)
        .build();

Response postResponse = client.newCall(postRequest).execute();
System.out.println("POST response: " + postResponse.body().string());

5. Apache HttpClient

java 复制代码
CloseableHttpClient client = HttpClients.createDefault();

// GET 请求
HttpGet getRequest = new HttpGet("https://jsonplaceholder.typicode.com/posts/1");
CloseableHttpResponse getResponse = client.execute(getRequest);
System.out.println("GET response: " + EntityUtils.toString(getResponse.getEntity()));

// POST 请求
HttpPost postRequest = new HttpPost("https://jsonplaceholder.typicode.com/posts");
postRequest.setHeader("Content-Type", "application/json");
StringEntity entity = new StringEntity("{\"title\":\"foo\",\"body\":\"bar\",\"userId\":1}");
postRequest.setEntity(entity);

CloseableHttpResponse postResponse = client.execute(postRequest);
System.out.println("POST response: " + EntityUtils.toString(postResponse.getEntity()));

6. Feign

java 复制代码
interface JsonPlaceholderClient {
    @RequestLine("GET /posts/1")
    String getPost();

    @RequestLine("POST /posts")
    @Headers("Content-Type: application/json")
    String createPost(String json);
}

JsonPlaceholderClient client = Feign.builder()
        .target(JsonPlaceholderClient.class, "https://jsonplaceholder.typicode.com");

// GET 请求
String getResponse = client.getPost();
System.out.println("GET response: " + getResponse);

// POST 请求
String json = "{\"title\":\"foo\",\"body\":\"bar\",\"userId\":1}";
String postResponse = client.createPost(json);
System.out.println("POST response: " + postResponse);

7. Retrofit

java 复制代码
public interface ApiService {
    @GET("posts/1")
    Call<Post> getPost();

    @POST("posts")
    Call<Post> createPost(@Body Post post);
}

Retrofit retrofit = new Retrofit.Builder()
        .baseUrl("https://jsonplaceholder.typicode.com/")
        .addConverterFactory(GsonConverterFactory.create())
        .build();

ApiService service = retrofit.create(ApiService.class);

// GET 请求
service.getPost().enqueue(new Callback<Post>() {
    public void onResponse(Call<Post> call, Response<Post> response) {
        System.out.println("GET response: " + response.body());
    }
    public void onFailure(Call<Post> call, Throwable t) {
        t.printStackTrace();
    }
});

// POST 请求
Post newPost = new Post("foo", "bar", 1);
service.createPost(newPost).enqueue(new Callback<Post>() {
    public void onResponse(Call<Post> call, Response<Post> response) {
        System.out.println("POST response: " + response.body());
    }
    public void onFailure(Call<Post> call, Throwable t) {
        t.printStackTrace();
    }
});

8. AsyncHttpClient

java 复制代码
AsyncHttpClient client = Dsl.asyncHttpClient();

// GET 请求
client.prepareGet("https://jsonplaceholder.typicode.com/posts/1")
      .execute()
      .toCompletableFuture()
      .thenAccept(response -> System.out.println("GET response: " + response.getResponseBody()))
      .join();

// POST 请求
String json = "{\"title\":\"foo\",\"body\":\"bar\",\"userId\":1}";

client.preparePost("https://jsonplaceholder.typicode.com/posts")
      .setHeader("Content-Type", "application/json")
      .setBody(json)
      .execute()
      .toCompletableFuture()
      .thenAccept(response -> System.out.println("POST response: " + response.getResponseBody()))
      .join();

9. Vert.x WebClient

Vert.x 是一个轻量级、响应式的应用框架,其 WebClient 是异步非阻塞的 HTTP 客户端,非常适合高并发和微服务场景。

java 复制代码
Vertx vertx = Vertx.vertx();
WebClient client = WebClient.create(vertx);

// GET 请求
client.getAbs("https://jsonplaceholder.typicode.com/posts/1")
      .send(ar -> {
          if (ar.succeeded()) {
              System.out.println("GET response: " + ar.result().bodyAsString());
          } else {
              ar.cause().printStackTrace();
          }
      });

// POST 请求
JsonObject json = new JsonObject()
        .put("title", "foo")
        .put("body", "bar")
        .put("userId", 1);

client.postAbs("https://jsonplaceholder.typicode.com/posts")
      .putHeader("Content-Type", "application/json")
      .sendJsonObject(json, ar -> {
          if (ar.succeeded()) {
              System.out.println("POST response: " + ar.result().bodyAsString());
          } else {
              ar.cause().printStackTrace();
          }
      });

10. Jetty HttpClient

Jetty 提供的 HTTP 客户端,支持异步和 HTTP/2,适合嵌入式和高性能场景。

java 复制代码
HttpClient client = new HttpClient();
client.start();

// GET 请求
ContentResponse getResponse = client.GET("https://jsonplaceholder.typicode.com/posts/1");
System.out.println("GET response: " + getResponse.getContentAsString());

// POST 请求
Request postRequest = client.POST("https://jsonplaceholder.typicode.com/posts");
postRequest.header("Content-Type", "application/json");
postRequest.content(new StringContentProvider("{\"title\":\"foo\",\"body\":\"bar\",\"userId\":1}"));

ContentResponse postResponse = postRequest.send();
System.out.println("POST response: " + postResponse.getContentAsString());

client.stop();

4.结语

随着 Java 生态的发展,HTTP 客户端的选择也愈发丰富和多样。无论是 JDK 自带的现代 HttpClient,还是功能强大的第三方库如 OkHttp、Apache HttpClient,以及适合响应式编程的 WebClient,都各有优势,满足不同场景需求。

选择合适的 HTTP 客户端,能极大提升开发效率和应用性能。希望本文的汇总与示例,能帮助你快速掌握各类客户端的基本用法,并根据项目需求做出最佳选择。

如果你有更多使用心得或想了解更深入的高级功能,欢迎留言交流,我们一起成长!

相关推荐
程序员张33 小时前
Maven编译和打包插件
java·spring boot·maven
ybq195133454314 小时前
Redis-主从复制-分布式系统
java·数据库·redis
weixin_472339465 小时前
高效处理大体积Excel文件的Java技术方案解析
java·开发语言·excel
小毛驴8505 小时前
Linux 后台启动java jar 程序 nohup java -jar
java·linux·jar
枯萎穿心攻击5 小时前
响应式编程入门教程第二节:构建 ObservableProperty<T> — 封装 ReactiveProperty 的高级用法
开发语言·unity·c#·游戏引擎
DKPT6 小时前
Java桥接模式实现方式与测试方法
java·笔记·学习·设计模式·桥接模式
Eiceblue7 小时前
【免费.NET方案】CSV到PDF与DataTable的快速转换
开发语言·pdf·c#·.net
好奇的菜鸟7 小时前
如何在IntelliJ IDEA中设置数据库连接全局共享
java·数据库·intellij-idea
m0_555762907 小时前
Matlab 频谱分析 (Spectral Analysis)
开发语言·matlab
DuelCode8 小时前
Windows VMWare Centos Docker部署Springboot 应用实现文件上传返回文件http链接
java·spring boot·mysql·nginx·docker·centos·mybatis