如何使用java.net.URLConnection触发和处理HTTP请求

当使用HTTP时，引用HttpURLConnection而不是基类URLConnection几乎总是更有用（因为URLConnection是一个抽象类，当你在HTTP URL上请求URLConnection.openConnection()时，这就是你会得到的）。

然后，您可以不依赖于URLConnection#setDoOutput(true)将请求方法隐式设置为POST，而是执行httpURLConnection.setRequestMethod("POST")，这可能会更自然（并且还允许您指定其他请求方法，例如把、删除、…）。

它还提供了有用的HTTP常量，因此您可以执行：

int responseCode = httpURLConnection.getResponseCode();
if (responseCode == HttpURLConnection.HTTP_OK) {

受Stack Overflow上的这个问题和其他问题的启发，我创建了一个最小的开源超文本传输协议，它体现了这里找到的大多数技术。

谷歌-超文本传输协议-java-客户端也是一个很好的开源资源。

我也被这一回应所鼓舞。

我经常在需要做一些HTTP的项目中，我可能不想引入很多第三方依赖项（这些依赖项会引入其他依赖项等等）。

我开始根据这些对话编写自己的实用程序（没有任何地方完成）：

package org.boon.utils;
import java.io.IOException;import java.io.InputStream;import java.net.HttpURLConnection;import java.net.URL;import java.net.URLConnection;import java.util.Map;
import static org.boon.utils.IO.read;
public class HTTP {

然后只有一堆或静态方法。

public static String get(final String url) {
Exceptions.tryIt(() -> {URLConnection connection;connection = doGet(url, null, null, null);return extractResponseString(connection);});return null;}
public static String getWithHeaders(final String url,final Map<String, ? extends Object> headers) {URLConnection connection;try {connection = doGet(url, headers, null, null);return extractResponseString(connection);} catch (Exception ex) {Exceptions.handle(ex);return null;}}
public static String getWithContentType(final String url,final Map<String, ? extends Object> headers,String contentType) {URLConnection connection;try {connection = doGet(url, headers, contentType, null);return extractResponseString(connection);} catch (Exception ex) {Exceptions.handle(ex);return null;}}public static String getWithCharSet(final String url,final Map<String, ? extends Object> headers,String contentType,String charSet) {URLConnection connection;try {connection = doGet(url, headers, contentType, charSet);return extractResponseString(connection);} catch (Exception ex) {Exceptions.handle(ex);return null;}}

然后发布…

public static String postBody(final String url,final String body) {URLConnection connection;try {connection = doPost(url, null, "text/plain", null, body);return extractResponseString(connection);} catch (Exception ex) {Exceptions.handle(ex);return null;}}
public static String postBodyWithHeaders(final String url,final Map<String, ? extends Object> headers,final String body) {URLConnection connection;try {connection = doPost(url, headers, "text/plain", null, body);return extractResponseString(connection);} catch (Exception ex) {Exceptions.handle(ex);return null;}}

public static String postBodyWithContentType(final String url,final Map<String, ? extends Object> headers,final String contentType,final String body) {
URLConnection connection;try {connection = doPost(url, headers, contentType, null, body);
return extractResponseString(connection);
} catch (Exception ex) {Exceptions.handle(ex);return null;}
}

public static String postBodyWithCharset(final String url,final Map<String, ? extends Object> headers,final String contentType,final String charSet,final String body) {
URLConnection connection;try {connection = doPost(url, headers, contentType, charSet, body);
return extractResponseString(connection);
} catch (Exception ex) {Exceptions.handle(ex);return null;}}
private static URLConnection doPost(String url, Map<String, ? extends Object> headers,String contentType, String charset, String body) throws IOException {URLConnection connection;/* Handle output. */connection = new URL(url).openConnection();connection.setDoOutput(true);manageContentTypeHeaders(contentType, charset, connection);
manageHeaders(headers, connection);
IO.write(connection.getOutputStream(), body, IO.CHARSET);return connection;}
private static void manageHeaders(Map<String, ? extends Object> headers, URLConnection connection) {if (headers != null) {for (Map.Entry<String, ? extends Object> entry : headers.entrySet()) {connection.setRequestProperty(entry.getKey(), entry.getValue().toString());}}}
private static void manageContentTypeHeaders(String contentType, String charset, URLConnection connection) {connection.setRequestProperty("Accept-Charset", charset == null ? IO.CHARSET : charset);if (contentType!=null && !contentType.isEmpty()) {connection.setRequestProperty("Content-Type", contentType);}}
private static URLConnection doGet(String url, Map<String, ? extends Object> headers,String contentType, String charset) throws IOException {URLConnection connection;/* Handle output. */connection = new URL(url).openConnection();manageContentTypeHeaders(contentType, charset, connection);
manageHeaders(headers, connection);
return connection;}
private static String extractResponseString(URLConnection connection) throws IOException {/* Handle input. */HttpURLConnection http = (HttpURLConnection)connection;int status = http.getResponseCode();String charset = getCharset(connection.getHeaderField("Content-Type"));
if (status==200) {return readResponseBody(http, charset);} else {return readErrorResponseBody(http, status, charset);}}
private static String readErrorResponseBody(HttpURLConnection http, int status, String charset) {InputStream errorStream = http.getErrorStream();if ( errorStream!=null ) {String error = charset== null ? read( errorStream ) :read( errorStream, charset );throw new RuntimeException("STATUS CODE =" + status + "\n\n" + error);} else {throw new RuntimeException("STATUS CODE =" + status);}}
private static String readResponseBody(HttpURLConnection http, String charset) throws IOException {if (charset != null) {return read(http.getInputStream(), charset);} else {return read(http.getInputStream());}}
private static String getCharset(String contentType) {if (contentType==null)  {return null;}String charset = null;for (String param : contentType.replace(" ", "").split(";")) {if (param.startsWith("charset=")) {charset = param.split("=", 2)[1];break;}}charset = charset == null ? IO.CHARSET : charset;
return charset;}

好吧，你明白了……

以下是测试：

static class MyHandler implements HttpHandler {public void handle(HttpExchange t) throws IOException {
InputStream requestBody = t.getRequestBody();String body = IO.read(requestBody);Headers requestHeaders = t.getRequestHeaders();body = body + "\n" + copy(requestHeaders).toString();t.sendResponseHeaders(200, body.length());OutputStream os = t.getResponseBody();os.write(body.getBytes());os.close();}}

@Testpublic void testHappy() throws Exception {
HttpServer server = HttpServer.create(new InetSocketAddress(9212), 0);server.createContext("/test", new MyHandler());server.setExecutor(null); // creates a default executorserver.start();
Thread.sleep(10);
Map<String,String> headers = map("foo", "bar", "fun", "sun");
String response = HTTP.postBodyWithContentType("http://localhost:9212/test", headers, "text/plain", "hi mom");
System.out.println(response);
assertTrue(response.contains("hi mom"));assertTrue(response.contains("Fun=[sun], Foo=[bar]"));
response = HTTP.postBodyWithCharset("http://localhost:9212/test", headers, "text/plain", "UTF-8", "hi mom");
System.out.println(response);
assertTrue(response.contains("hi mom"));assertTrue(response.contains("Fun=[sun], Foo=[bar]"));
response = HTTP.postBodyWithHeaders("http://localhost:9212/test", headers, "hi mom");
System.out.println(response);
assertTrue(response.contains("hi mom"));assertTrue(response.contains("Fun=[sun], Foo=[bar]"));
response = HTTP.get("http://localhost:9212/test");
System.out.println(response);
response = HTTP.getWithHeaders("http://localhost:9212/test", headers);
System.out.println(response);
assertTrue(response.contains("Fun=[sun], Foo=[bar]"));
response = HTTP.getWithContentType("http://localhost:9212/test", headers, "text/plain");
System.out.println(response);
assertTrue(response.contains("Fun=[sun], Foo=[bar]"));
response = HTTP.getWithCharSet("http://localhost:9212/test", headers, "text/plain", "UTF-8");
System.out.println(response);
assertTrue(response.contains("Fun=[sun], Foo=[bar]"));
Thread.sleep(10);
server.stop(0);}
@Testpublic void testPostBody() throws Exception {
HttpServer server = HttpServer.create(new InetSocketAddress(9220), 0);server.createContext("/test", new MyHandler());server.setExecutor(null); // creates a default executorserver.start();
Thread.sleep(10);
Map<String,String> headers = map("foo", "bar", "fun", "sun");
String response = HTTP.postBody("http://localhost:9220/test", "hi mom");
assertTrue(response.contains("hi mom"));
Thread.sleep(10);
server.stop(0);}
@Test(expected = RuntimeException.class)public void testSad() throws Exception {
HttpServer server = HttpServer.create(new InetSocketAddress(9213), 0);server.createContext("/test", new MyHandler());server.setExecutor(null); // creates a default executorserver.start();
Thread.sleep(10);
Map<String,String> headers = map("foo", "bar", "fun", "sun");
String response = HTTP.postBodyWithContentType("http://localhost:9213/foo", headers, "text/plain", "hi mom");
System.out.println(response);
assertTrue(response.contains("hi mom"));assertTrue(response.contains("Fun=[sun], Foo=[bar]"));
Thread.sleep(10);
server.stop(0);}

你可以在这里找到其余的：

https://github.com/RichardHightower/boon

我的目标是以更简单的方式提供人们想要做的常见事情。

您还可以使用JCabi-超文本传输协议中的#0（我是开发人员），它为您完成所有这些工作，装饰HttpURLConnection，触发HTTP请求并解析响应，例如：

String html = new JdkRequest("http://www.google.com").fetch().body();

查看此博客文章了解更多信息：http://www.yegor256.com/2014/04/11/jcabi-http-intro.html

我建议你看看凯文的wicki/超文本传输协议-请求上的代码，它基本上是HttpUrlConnection之上的一个包装器，它提供了一个更简单的API，以防你现在只想发出请求，或者你可以看看源代码（它不太大）来看看如何处理连接。

示例：使用内容类型application/json和一些查询参数发出GET请求：

// GET http://google.com?q=baseball%20gloves&size=100String response = HttpRequest.get("http://google.com", true, "q", "baseball gloves", "size", 100).accept("application/json").body();System.out.println("Response was: " + response);

有两个选项可以使用HTTP URL Hits：GET/POST

GET请求：

HttpURLConnection.setFollowRedirects(true); // Defaults to true
String url = "https://name_of_the_url";URL request_url = new URL(url);HttpURLConnection http_conn = (HttpURLConnection)request_url.openConnection();http_conn.setConnectTimeout(100000);http_conn.setReadTimeout(100000);http_conn.setInstanceFollowRedirects(true);System.out.println(String.valueOf(http_conn.getResponseCode()));

POST请求：

HttpURLConnection.setFollowRedirects(true); // Defaults to true
String url = "https://name_of_the_url"URL request_url = new URL(url);HttpURLConnection http_conn = (HttpURLConnection)request_url.openConnection();http_conn.setConnectTimeout(100000);http_conn.setReadTimeout(100000);http_conn.setInstanceFollowRedirects(true);http_conn.setDoOutput(true);PrintWriter out = new PrintWriter(http_conn.getOutputStream());if (urlparameter != null) {out.println(urlparameter);}out.close();out = null;System.out.println(String.valueOf(http_conn.getResponseCode()));

最初我被这篇文章误导了，它倾向于HttpClient。

后来我意识到HttpURLConnection将留在这篇文章。

根据Google博客：

Apache HTTP客户端在Eclair和Froyo上的错误较少。它是这些版本的最佳选择。对于Ginger面包，HttpURLConnection是最佳选择。其简单的API和小尺寸使其非常适合Android。

透明的压缩和响应缓存减少了网络使用、提高了速度并节省了电池。新应用程序应该使用HttpURLConnection；这是我们未来将花费精力的地方。

在阅读了这篇文章和其他一些堆栈超过流程的问题之后，我确信HttpURLConnection将持续更长的时间。

一些有利于HttpURLConnections的SE问题：

在Android上，使用URL编码表单数据发出POST请求，而不使用UrlEncodedFormEntity

HttpPost适用于Java项目，但不适用于Android

还有好的，它是一个默认高效的HTTP客户端：

• HTTP/2支持允许对同一主机的所有请求共享一个套接字。
• 连接池减少了请求延迟（如果HTTP/2不可用）。
• 透明GZIP缩小下载大小。
• 响应缓存完全避免了网络重复请求。

首先创建一个OkHttpClient的实例：

OkHttpClient client = new OkHttpClient();

然后，准备您的GET请求：

Request request = new Request.Builder().url(url).build();

最后，使用OkHttpClient发送准备好的Request：

Response response = client.newCall(request).execute();

有关详细信息，您可以参考OkHttp的留档

如果您使用的是HTTPget，请删除这一行：

urlConnection.setDoOutput(true);

更新

新的HTTP客户端随Java9一起提供，但作为孵化器模块命名为jdk.incubator.httpclient。孵化器模块是一种将非最终API交到开发人员手中的方法，同时API在未来最终确定或删除方面的进展释放。

在Java9中，您可以发送GET请求，如下所示：

// GETHttpResponse response = HttpRequest.create(new URI("http://www.stackoverflow.com")).headers("Foo", "foovalue", "Bar", "barvalue").GET().response();

然后您可以检查返回的HttpResponse：

int statusCode = response.statusCode();String responseBody = response.body(HttpResponse.asString());

由于这个新的HTTP客户端位于#0jdk.incubator.httpclient模块中，因此您应该在module-info.java文件中声明此依赖项：

module com.foo.bar {requires jdk.incubator.httpclient;}

如果您使用的是Java11（除了Android），而不是传统的对应的HttpUrlConnection链接地址类，您可以使用Java11 newHTTP客户端接口。

示例get请求：

var uri = URI.create("https://httpbin.org/get?age=26&isHappy=true");var client = HttpClient.newHttpClient();var request = HttpRequest.newBuilder().uri(uri).header("accept", "application/json").GET().build();var response = client.send(request, HttpResponse.BodyHandlers.ofString());System.out.println(response.statusCode());System.out.println(response.body());

相同的请求异步执行：

var responseAsync = client.sendAsync(request, HttpResponse.BodyHandlers.ofString()).thenApply(HttpResponse::body).thenAccept(System.out::println);// responseAsync.join(); // Wait for completion

示例POST请求：

var request = HttpRequest.newBuilder().uri(uri).version(HttpClient.Version.HTTP_2).timeout(Duration.ofMinutes(1)).header("Content-Type", "application/json").header("Authorization", "Bearer fake").POST(BodyPublishers.ofString("{ title: 'This is cool' }")).build();var response = client.send(request, HttpResponse.BodyHandlers.ofString());

要以multipart（multipart/form-data）或url编码（application/x-www-form-urlencoded）格式发送表单数据，请参阅这个解决方案。

有关HTTP客户端API的示例和更多信息，请参阅这篇文章。

旁白

有关Java标准库HTTP服务器，请参阅这篇文章。