分享
为什么问答平台  ›  专栏  ›  技术社区  ›  BalusC

如何使用java.net.urlconnection触发和处理HTTP请求 - How to use java.net.URLConnection to fire and handle HTTP requests

  •  1827
  • BalusC  · 技术社区  · 2 月前

    使用 java.net.URLConnection 经常在这里被问到, Oracle tutorial 简明扼要。

    该教程基本上只显示了如何触发GET请求和读取响应。它不解释在任何地方如何使用它来执行POST请求、设置请求头、读取响应头、处理cookie、提交HTML表单、上载文件等。

    那么,我怎么用呢 java.net.url连接 启动并处理“高级”HTTP请求?

    11 回复  |  直到 6 月前
        1
  •  2599
  •   BalusC    10 月前

    首先是免责声明:发布的代码片段都是基本的例子。你需要处理一些琐碎的事情 IOException S和 RuntimeException 类的 NullPointerException , ArrayIndexOutOfBoundsException 和你自己结伴。


    准备

    我们首先至少需要知道URL和字符集。参数是可选的,取决于功能需求。

    String url = "http://example.com";
    String charset = "UTF-8";  // Or in Java 7 and later, use the constant: java.nio.charset.StandardCharsets.UTF_8.name()
    String param1 = "value1";
    String param2 = "value2";
    // ...
    
    String query = String.format("param1=%s&param2=%s", 
         URLEncoder.encode(param1, charset), 
         URLEncoder.encode(param2, charset));
    

    查询参数必须在 name=value 格式和连接方式 & . 你通常也会 URL-encode 使用指定字符集的查询参数 URLEncoder#encode() .

    这个 String#format() 只是为了方便。当我需要字符串连接操作符时,我更喜欢它 + 两次以上。


    发射A HTTP GET 带(可选)查询参数的请求

    这是一项微不足道的任务。这是默认的请求方法。

    URLConnection connection = new URL(url + "?" + query).openConnection();
    connection.setRequestProperty("Accept-Charset", charset);
    InputStream response = connection.getInputStream();
    // ...
    

    任何查询字符串都应使用 ? . 这个 Accept-Charset 头可能提示服务器参数的编码方式。如果不发送任何查询字符串,则可以离开 接受字符集 报头离开。如果不需要设置任何头,则甚至可以使用 URL#openStream() 快捷方式。

    InputStream response = new URL(url).openStream();
    // ...
    

    不管怎样,如果另一边是 HttpServlet 然后 doGet() 方法和参数将通过 HttpServletRequest#getParameter() .

    出于测试目的,您可以将响应正文打印到stdout,如下所示:

    try (Scanner scanner = new Scanner(response)) {
        String responseBody = scanner.useDelimiter("\\A").next();
        System.out.println(responseBody);
    }
    

    发射A HTTP POST 带查询参数的请求

    设置 URLConnection#setDoOutput() true 隐式地将请求方法设置为Post。与Web表单一样,标准HTTP Post的类型为 application/x-www-form-urlencoded 其中,查询字符串被写入请求主体。

    URLConnection connection = new URL(url).openConnection();
    connection.setDoOutput(true); // Triggers POST.
    connection.setRequestProperty("Accept-Charset", charset);
    connection.setRequestProperty("Content-Type", "application/x-www-form-urlencoded;charset=" + charset);
    
    try (OutputStream output = connection.getOutputStream()) {
        output.write(query.getBytes(charset));
    }
    
    InputStream response = connection.getInputStream();
    // ...
    

    注意:每当您想以编程方式提交HTML表单时,不要忘记使用 名称=值 任意配对 <input type="hidden"> 元素到查询字符串中,当然还有 名称=值 一对 <input type="submit"> 您希望以编程方式“按下”的元素(因为通常在服务器端使用它来区分按钮是否被按下,如果被按下,是哪个按钮)。

    你也可以将获得的 URLConnection HttpURLConnection 并使用它 HttpURLConnection#setRequestMethod() 相反。但是,如果您试图使用输出的连接,您仍然需要设置 URL连接setdooutput() .

    HttpURLConnection httpConnection = (HttpURLConnection) new URL(url).openConnection();
    httpConnection.setRequestMethod("POST");
    // ...
    

    不管怎样,如果另一边是 HTTPSServices 然后 doPost() 方法和参数将通过 httpservletrequest getParameter()) .


    实际触发HTTP请求

    您可以使用 URLConnection#connect() ,但当您希望获取有关HTTP响应的任何信息(如使用 URLConnection#getInputStream() 等等。上面的例子就是这样的,所以 connect() 呼叫实际上是多余的。


    正在收集HTTP响应信息

    1. HTTP response status :

      你需要一个 可设定代理 在这里。如有必要,先浇铸。

      int status = httpConnection.getResponseCode();
      
    2. HTTP response headers :

      for (Entry<String, List<String>> header : connection.getHeaderFields().entrySet()) {
          System.out.println(header.getKey() + "=" + header.getValue());
      }
      
    3. HTTP response encoding :

      Content-Type 包含一个 charset 参数,那么响应主体可能是基于文本的,我们希望使用服务器端指定的字符编码来处理响应主体。

      String contentType = connection.getHeaderField("Content-Type");
      String charset = null;
      
      for (String param : contentType.replace(" ", "").split(";")) {
          if (param.startsWith("charset=")) {
              charset = param.split("=", 2)[1];
              break;
          }
      }
      
      if (charset != null) {
          try (BufferedReader reader = new BufferedReader(new InputStreamReader(response, charset))) {
              for (String line; (line = reader.readLine()) != null;) {
                  // ... System.out.println(line) ?
              }
          }
      } else {
          // It's likely binary content, use InputStream/OutputStream.
      }
      

    维护会议

    服务器端会话通常由cookie支持。某些Web表单要求您登录和/或由会话跟踪。你可以使用 CookieHandler API维护cookie。你需要准备一个 CookieManager 用一个 CookiePolicy 属于 ACCEPT_ALL 在发送所有HTTP请求之前。

    // First set the default cookie manager.
    CookieHandler.setDefault(new CookieManager(null, CookiePolicy.ACCEPT_ALL));
    
    // All the following subsequent URLConnections will use the same cookie manager.
    URLConnection connection = new URL(url).openConnection();
    // ...
    
    connection = new URL(url).openConnection();
    // ...
    
    connection = new URL(url).openConnection();
    // ...
    

    请注意,在所有情况下,这并不总是能正常工作。如果失败了,那么最好是手动收集和设置cookie头。你基本上需要抓住所有 Set-Cookie 来自登录响应或第一个 GET 请求,然后通过后续请求传递。

    // Gather all cookies on the first request.
    URLConnection connection = new URL(url).openConnection();
    List<String> cookies = connection.getHeaderFields().get("Set-Cookie");
    // ...
    
    // Then use the same cookies on all subsequent requests.
    connection = new URL(url).openConnection();
    for (String cookie : cookies) {
        connection.addRequestProperty("Cookie", cookie.split(";", 2)[0]);
    }
    // ...
    

    这个 split(";", 2)[0] 是否需要去掉与服务器端无关的cookie属性,比如 expires , path 或者,您也可以使用 cookie.substring(0, cookie.indexOf(';')) 而不是 split() .


    流模式

    这个 可设定代理 默认情况下将缓冲 整个的 在实际发送前请求正文,无论您是否已使用 connection.setRequestProperty("Content-Length", contentLength); . 这可能导致 OutOfMemoryException s当您同时发送大型邮件请求(例如上载文件)时。为了避免这种情况,您要设置 HttpURLConnection#setFixedLengthStreamingMode() .

    httpConnection.setFixedLengthStreamingMode(contentLength);
    

    但是,如果内容长度事先确实不知道,那么可以通过设置 HttpURLConnection#setChunkedStreamingMode() 因此。这将设置HTTP Transfer-Encoding 报头到 chunked 这将强制请求主体以块的形式发送。下面的示例将以1KB为单位发送正文。

    httpConnection.setChunkedStreamingMode(1024);
    

    用户代理

    可能会这样 a request returns an unexpected response, while it works fine with a real web browser . 服务器端可能正在阻止基于 User-Agent 请求头。这个 URL连接 将默认设置为 Java/1.6.0_19 最后一部分显然是JRE版本。您可以按如下方式覆盖:

    connection.setRequestProperty("User-Agent", "Mozilla/5.0 (Windows NT 6.1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/41.0.2228.0 Safari/537.36"); // Do as if you're using Chrome 41 on Windows 7.
    

    使用用户代理字符串 recent browser .


    错误处理

    如果HTTP响应代码是 4nn (客户端错误)或 5nn (服务器错误),则可能需要读取 HttpURLConnection#getErrorStream() 查看服务器是否发送了任何有用的错误信息。

    InputStream error = ((HttpURLConnection) connection).getErrorStream();
    

    如果HTTP响应代码是-1,那么连接和响应处理出现问题。这个 可设定代理 实现是在旧的JRE中进行的,这有点让连接保持活动。您可以通过设置 http.keepAlive 系统属性到 false . 您可以通过以下方式在应用程序的开头以编程方式执行此操作:

    System.setProperty("http.keepAlive", "false");
    

    上传文件

    你通常会用 multipart/form-data 混合post内容的编码(二进制和字符数据)。编码在中有更详细的描述。 RFC2388 .

    String param = "value";
    File textFile = new File("/path/to/file.txt");
    File binaryFile = new File("/path/to/file.bin");
    String boundary = Long.toHexString(System.currentTimeMillis()); // Just generate some unique random value.
    String CRLF = "\r\n"; // Line separator required by multipart/form-data.
    URLConnection connection = new URL(url).openConnection();
    connection.setDoOutput(true);
    connection.setRequestProperty("Content-Type", "multipart/form-data; boundary=" + boundary);
    
    try (
        OutputStream output = connection.getOutputStream();
        PrintWriter writer = new PrintWriter(new OutputStreamWriter(output, charset), true);
    ) {
        // Send normal param.
        writer.append("--" + boundary).append(CRLF);
        writer.append("Content-Disposition: form-data; name=\"param\"").append(CRLF);
        writer.append("Content-Type: text/plain; charset=" + charset).append(CRLF);
        writer.append(CRLF).append(param).append(CRLF).flush();
    
        // Send text file.
        writer.append("--" + boundary).append(CRLF);
        writer.append("Content-Disposition: form-data; name=\"textFile\"; filename=\"" + textFile.getName() + "\"").append(CRLF);
        writer.append("Content-Type: text/plain; charset=" + charset).append(CRLF); // Text file itself must be saved in this charset!
        writer.append(CRLF).flush();
        Files.copy(textFile.toPath(), output);
        output.flush(); // Important before continuing with writer!
        writer.append(CRLF).flush(); // CRLF is important! It indicates end of boundary.
    
        // Send binary file.
        writer.append("--" + boundary).append(CRLF);
        writer.append("Content-Disposition: form-data; name=\"binaryFile\"; filename=\"" + binaryFile.getName() + "\"").append(CRLF);
        writer.append("Content-Type: " + URLConnection.guessContentTypeFromName(binaryFile.getName())).append(CRLF);
        writer.append("Content-Transfer-Encoding: binary").append(CRLF);
        writer.append(CRLF).flush();
        Files.copy(binaryFile.toPath(), output);
        output.flush(); // Important before continuing with writer!
        writer.append(CRLF).flush(); // CRLF is important! It indicates end of boundary.
    
        // End of multipart/form-data.
        writer.append("--" + boundary + "--").append(CRLF).flush();
    }
    

    如果另一面是 HTTPSServices 然后 DOPSTOST() 方法将被调用,部件将由 HttpServletRequest#getPart() (注: getParameter() 等等!. The getPart() 然而,该方法相对较新,它在servlet 3.0(Glassfish 3、Tomcat 7等)中介绍。在servlet 3.0之前,您的最佳选择是使用 Apache Commons FileUpload 解析一个 多部分/表单数据 请求。也看到 this answer 例如fileupload和servelt 3.0方法。


    处理不可信或配置错误的HTTPS站点

    有时候你需要连接一个https URL,也许是因为你在写一个web scraper。在这种情况下,你可能会面临 javax.net.ssl.SSLException: Not trusted server certificate 在一些不保持其SSL证书最新的HTTPS站点上,或 java.security.cert.CertificateException: No subject alternative DNS name matching [hostname] found javax.net.ssl.SSLProtocolException: handshake alert: unrecognized_name 在一些配置错误的https站点上。

    以下一次性运行 static Web scraper类中的初始值设定项应使 HttpsURLConnection 对那些HTTPS站点更为宽容,因此不再抛出这些异常。

    static {
        TrustManager[] trustAllCertificates = new TrustManager[] {
            new X509TrustManager() {
                @Override
                public X509Certificate[] getAcceptedIssuers() {
                    return null; // Not relevant.
                }
                @Override
                public void checkClientTrusted(X509Certificate[] certs, String authType) {
                    // Do nothing. Just allow them all.
                }
                @Override
                public void checkServerTrusted(X509Certificate[] certs, String authType) {
                    // Do nothing. Just allow them all.
                }
            }
        };
    
        HostnameVerifier trustAllHostnames = new HostnameVerifier() {
            @Override
            public boolean verify(String hostname, SSLSession session) {
                return true; // Just allow them all.
            }
        };
    
        try {
            System.setProperty("jsse.enableSNIExtension", "false");
            SSLContext sc = SSLContext.getInstance("SSL");
            sc.init(null, trustAllCertificates, new SecureRandom());
            HttpsURLConnection.setDefaultSSLSocketFactory(sc.getSocketFactory());
            HttpsURLConnection.setDefaultHostnameVerifier(trustAllHostnames);
        }
        catch (GeneralSecurityException e) {
            throw new ExceptionInInitializerError(e);
        }
    }
    

    最后的话

    这个 Apache HttpComponents HttpClient 许多的 更方便的是:)


    分析和提取HTML

    如果您只需要解析和提取HTML中的数据,那么最好使用类似于 Jsoup

        2
  •  87
  •   Paal Thorstensen    5 年前

    使用HTTP时,几乎总是更有用的 HttpURLConnection 而不是基类 URLConnection (自 URL连接 当你要求的时候是抽象类 URLConnection.openConnection() 在一个HTTP URL上,这就是你将要得到的结果)。

    那你就不用依赖了 URLConnection#setDoOutput(true) 将请求方法隐式设置为 代替做 httpURLConnection.setRequestMethod("POST") 其中一些可能会发现更自然(并且还允许您指定其他请求方法,例如 , 删除 ,……)

    它还提供了有用的HTTP常量,因此您可以执行以下操作:

    int responseCode = httpURLConnection.getResponseCode();
    
    if (responseCode == HttpURLConnection.HTTP_OK) {
    
        3
  •  50
  •   David Chandler    6 年前

    受此和其他问题的启发,我创建了一个最小的开放源代码 basic-http-client 这体现了这里发现的大多数技术。

    google-http-java-client 也是一个很好的开源资源。

        4
  •  23
  •   Utkash Bhatt    2 年前

    有两个选项可以用于HTTP URL命中:get/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);
    System.out.println(String.valueOf(http_conn.getResponseCode()));
    

    职位要求:

    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()));
    
        5
  •  21
  •   fernandohur    4 年前

    我建议你看一下密码 kevinsawicki/http-request 它基本上是一个包装在 HttpUrlConnection 它提供了一个更简单的API,以防您现在只想发出请求,或者您可以查看源(它不太大),以了解如何处理连接。

    例子:制作 GET 内容类型为的请求 application/json 以及一些查询参数:

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

    我也受到了这种反应的启发。

    我经常在需要做一些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();
        }
    }
    
    
    @Test
    public void testHappy() throws Exception {
    
        HttpServer server = HttpServer.create(new InetSocketAddress(9212), 0);
        server.createContext("/test", new MyHandler());
        server.setExecutor(null); // creates a default executor
        server.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);
    
    
    }
    
    @Test
    public void testPostBody() throws Exception {
    
        HttpServer server = HttpServer.create(new InetSocketAddress(9220), 0);
        server.createContext("/test", new MyHandler());
        server.setExecutor(null); // creates a default executor
        server.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 executor
        server.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

    我的目标是提供人们希望以一种更简单的方式去做的事情。

        7
  •  18
  •   Ali Dehghani    1 年前

    更新

    新的HTTP客户端用Java 9进行传输,但作为 孵化器模块命名 jdk.incubator.httpclient . 孵化器模块 一种将非最终API交给开发人员的方法,而 API在将来完成或删除方面的进展 释放。

    在Java 9中,可以发送 GET 请求如下:

    // GET
    HttpResponse 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客户端在 java.httpclient jdk.孵化器.httpclient 模块,您应该在 module-info.java 文件:

    module com.foo.bar {
        requires jdk.incubator.httpclient;
    }
    
        8
  •  15
  •   Ravindra babu    1 年前

    起初我被这个误导了 article 哪些有利条件 HttpClient .

    后来我意识到 HttpURLConnection 不会再这样了 article

    根据谷歌博客 :

    ApacheHTTP客户端在eclair和froyo上的bug更少。它是这些版本的最佳选择。对于姜饼来说,httpurlconnection是最好的选择。它的API简单,体积小,非常适合安卓系统。

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

    读后 this article 还有其他一些堆积如山的问题,我相信 可设定代理 会停留更长的时间。

    一些支持的SE问题 HttpURLConnections :

    On Android, make a POST request with URL Encoded Form data without using UrlEncodedFormEntity

    HttpPost works in Java project, not in Android

        9
  •  12
  •   yegor256    5 年前

    您也可以使用 JdkRequest jcabi-http (我是一名开发人员),它为您完成所有这些工作,包括修饰httpurlconnection、触发HTTP请求和解析响应,例如:

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

    查看此日志了解更多信息: http://www.yegor256.com/2014/04/11/jcabi-http-intro.html

        10
  •  12
  •   Ali Dehghani    3 年前

    也有 OkHttp ,默认情况下是一个高效的HTTP客户端:

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

    首先创建的实例 OkHttpClient :

    OkHttpClient client = new OkHttpClient();
    

    那么,准备好你的 GET 请求:

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

    最后,使用 OKHTTP客户端 发送准备好的 Request :

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

    有关更多详细信息,请参阅 OkHttp's documentation

        11
  •  11
  •   Nison Cheruvathur    1 年前

    如果使用HTTP GET,请删除此行

    urlConnection.setDoOutput(true);