Java类发送POST请求至远程Web服务的方法及HttpURLConnection替代方案

嘿，针对你问的这两个Java对接远程服务的问题，我来给你梳理下实际项目里常用的方案，都是我自己踩过坑后觉得好用的：

你提到的HttpURLConnection是Java原生方案，不需要额外依赖，适合轻量场景，先给你一个完整的可运行示例：

import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.Scanner;

public class NativePostExample {
    public static void main(String[] args) throws Exception {
        // 替换成你的目标服务地址
        URL targetUrl = new URL("https://your-remote-service.com/api/endpoint");
        HttpURLConnection conn = (HttpURLConnection) targetUrl.openConnection();
        
        // 配置请求参数
        conn.setRequestMethod("POST");
        conn.setDoOutput(true); // 允许发送请求体
        conn.setRequestProperty("Content-Type", "application/json"); // 声明请求体格式
        
        // 构造JSON请求体
        String requestBody = "{\"username\": \"test\", \"password\": \"123456\"}";
        
        // 发送请求体
        try (OutputStream os = conn.getOutputStream()) {
            byte[] inputBytes = requestBody.getBytes("utf-8");
            os.write(inputBytes, 0, inputBytes.length);
        }
        
        // 处理响应
        int responseCode = conn.getResponseCode();
        System.out.println("请求状态码：" + responseCode);
        
        // 读取响应内容（区分成功/错误流）
        Scanner responseScanner;
        if (responseCode >= 200 && responseCode < 300) {
            responseScanner = new Scanner(conn.getInputStream());
        } else {
            responseScanner = new Scanner(conn.getErrorStream());
        }
        String responseBody = responseScanner.useDelimiter("\\A").next();
        responseScanner.close();
        System.out.println("响应内容：" + responseBody);
        
        conn.disconnect();
    }
}

不过原生HttpURLConnection代码确实有点繁琐，实际项目里我更推荐这些更简洁的替代方案：

• OkHttp：Square出品的轻量HTTP客户端，我做非Spring项目时首选它，代码清爽还支持异步请求，示例如下（需要先引入Maven/Gradle依赖）：

import okhttp3.MediaType;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.RequestBody;
import okhttp3.Response;

public class OkHttpPostDemo {
    private static final MediaType JSON_TYPE = MediaType.get("application/json; charset=utf-8");
    private final OkHttpClient client = new OkHttpClient();

    public String sendPost(String url, String jsonBody) throws Exception {
        RequestBody body = RequestBody.create(jsonBody, JSON_TYPE);
        Request request = new Request.Builder()
                .url(url)
                .post(body)
                .build();
        
        try (Response response = client.newCall(request).execute()) {
            return response.body().string();
        }
    }

    public static void main(String[] args) throws Exception {
        OkHttpPostDemo demo = new OkHttpPostDemo();
        String response = demo.sendPost("https://your-remote-service.com/api/endpoint", "{\"key\": \"value\"}");
        System.out.println(response);
    }
}

• Java 11+ HttpClient：Java 11开始内置的官方HTTP客户端，比HttpURLConnection好用太多，支持同步/异步，不用加依赖：

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Java11HttpDemo {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();
        String requestBody = "{\"key\": \"value\"}";

        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("https://your-remote-service.com/api/endpoint"))
                .header("Content-Type", "application/json")
                .POST(HttpRequest.BodyPublishers.ofString(requestBody))
                .build();

        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println("状态码：" + response.statusCode());
        System.out.println("响应体：" + response.body());
    }
}

• Spring RestTemplate：如果是Spring/Spring Boot项目，直接用RestTemplate最贴合生态，还能自动处理JSON序列化/反序列化：

import org.springframework.web.client.RestTemplate;
import java.util.HashMap;
import java.util.Map;

public class SpringPostDemo {
    public static void main(String[] args) {
        RestTemplate restTemplate = new RestTemplate();
        String url = "https://your-remote-service.com/api/endpoint";

        // 用Map构造请求参数，也可以直接用自定义实体类
        Map<String, Object> requestParams = new HashMap<>();
        requestParams.put("key", "value");
        requestParams.put("count", 10);

        // 发送请求并直接接收字符串响应
        String response = restTemplate.postForObject(url, requestParams, String.class);
        System.out.println(response);
    }
}

核心就是把响应体的JSON字符串解析成Java对象，常用的解析库是Jackson（Spring默认使用）和Gson，我结合上面的例子给你演示：

第一步：定义和JSON结构匹配的实体类 #

假设远程服务返回的JSON格式是：

{
  "code": 200,
  "msg": "请求成功",
  "data": {"id": 1001, "name": "测试数据"}
}

对应的Java实体类（可以用Lombok简化getter/setter）：

public class ServiceResponse {
    private int code;
    private String msg;
    private Data data;

    // 内部类对应嵌套的data结构
    public static class Data {
        private int id;
        private String name;

        // getter和setter
        public int getId() { return id; }
        public void setId(int id) { this.id = id; }
        public String getName() { return name; }
        public void setName(String name) { this.name = name; }
    }

    // getter和setter
    public int getCode() { return code; }
    public void setCode(int code) { this.code = code; }
    public String getMsg() { return msg; }
    public void setMsg(String msg) { this.msg = msg; }
    public Data getData() { return data; }
    public void setData(Data data) { this.data = data; }
}

第二步：结合请求方式解析JSON #

用Jackson解析（推荐）

先引入Jackson依赖，然后在请求后添加解析逻辑：

import com.fasterxml.jackson.databind.ObjectMapper;

// 承接之前HttpURLConnection的示例，读取到responseBody后：
ObjectMapper objectMapper = new ObjectMapper();
ServiceResponse responseObj = objectMapper.readValue(responseBody, ServiceResponse.class);
System.out.println("响应码：" + responseObj.getCode());
System.out.println("数据名称：" + responseObj.getData().getName());

用Gson解析

引入Gson依赖后，解析代码更简洁：

import com.google.gson.Gson;

Gson gson = new Gson();
ServiceResponse responseObj = gson.fromJson(responseBody, ServiceResponse.class);

Spring RestTemplate直接解析

如果用RestTemplate，甚至不用手动处理，直接指定返回类型为实体类：

ServiceResponse responseObj = restTemplate.postForObject(url, requestParams, ServiceResponse.class);

总结一下：轻量场景选Java 11+ HttpClient或原生HttpURLConnection；非Spring项目优先OkHttp；Spring项目直接用RestTemplate。JSON解析选Jackson（适配Spring）或Gson（语法更简洁）都可以。

内容的提问来源于stack exchange，提问作者elik