Jak używać java.net.URLConnection do odpalania i obsługi żądań HTTP?

Podczas pracy z HTTP prawie zawsze bardziej przydatne jest odwoływanie się do HttpURLConnection, a nie do klasy bazowej URLConnection (ponieważ URLConnection jest klasą abstrakcyjną, gdy poprosisz o URLConnection.openConnection() na URL HTTP, to i tak dostaniesz z powrotem).

Wtedy możesz zamiast polegać na URLConnection#setDoOutput(true) domyślnie ustawić metodę żądania na POST zamiast tego zrobić httpURLConnection.setRequestMethod("POST"), która może być bardziej naturalna (i która pozwala również określić inne metody żądania, takie jak PUT, DELETE , ...).

Dostarcza również użyteczne stałe HTTP, dzięki czemu można to zrobić:

int responseCode = httpURLConnection.getResponseCode();

if (responseCode == HttpURLConnection.HTTP_OK) {

Zainspirowany tym i innymi pytaniami na SO, stworzyłem minimalny open source basic-http-client , który ucieleśnia większość technik znalezionych tutaj.

Google-http-java-client jest również świetnym zasobem open source.

Proponuję rzucić okiem na kod na kevinsawicki/http-request , jest to w zasadzie wrapper na górze HttpUrlConnection zapewnia znacznie prostsze API w przypadku, gdy chcesz tylko złożyć żądania teraz lub możesz spojrzeć na źródła (nie jest zbyt duże), aby spojrzeć na to, jak połączenia są obsługiwane.

Przykład: Wyślij zapytanie GET z typem zawartości application/json i niektórymi parametrami zapytania:

// 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);

Update

Nowy klient HTTP dostarczony z Javą 9, ale jako część Moduł inkubatora o nazwie jdk.incubator.httpclient. Moduły inkubatora to sposób oddania niekończących się API w ręce programistów, podczas gdy Postępy w kierunku finalizacji lub usunięcia interfejsów API w przyszłości uwolnij.

W Javie 9 możesz wysłać GET zapytanie typu:

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

Następnie możesz sprawdzić zwrócony HttpResponse:

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

Ponieważ ten nowy klient HTTP jest w java.httpclient jdk.incubator.httpclient moduł, powinieneś zadeklarować tę zależność w swoim pliku module-info.java:

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

Istnieją 2 opcje, które możesz wybrać z http URL Hits: GET / POST

GET Request: -

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 request: -

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()));

Zainspirowała mnie również ta odpowiedź.

Często jestem w projektach, w których muszę wykonać jakiś HTTP, i mogę nie chcieć wprowadzać wielu zależności od stron trzecich (które wprowadzają inne itd. itd.).)

Zacząłem pisać własne narzędzia na podstawie niektórych z tej rozmowy (nie gdzie zrobione):

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 {

Wtedy jest tylko kilka metod statycznych.

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;
    }
}

Następnie post...

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;
}

Oto testy:

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);


}

Resztę znajdziesz tutaj:

Https://github.com/RichardHightower/boon

Moim celem jest zapewnienie wspólnych rzeczy, które chcieliby zrobić w nieco łatwiejszy sposób....

Początkowo zostałem wprowadzony w błąd przez ten Artykuł , który faworyzuje HttpClient.

Później zdałem sobie sprawę, że HttpURLConnection pozostanie z tego artykułu

Jak na blogu Google :

Klient HTTP Apache ma mniej błędów na Eclair i Froyo. Jest to najlepszy wybór dla tych wydawnictw. W przypadku Piernika najlepszym wyborem jest HttpURLConnection. Jego prosty API i mały rozmiar sprawiają, że świetnie pasuje do Androida.

Przezroczysta kompresja i odpowiedź buforowanie zmniejsz zużycie sieci, popraw prędkość i oszczędzaj baterię. Nowe aplikacje powinny korzystać z HttpURLConnection; to tam będziemy wydawać naszą energię w przyszłości.

Po przeczytaniu tego artykułu i kilku innych pytań stack over flow, jestem przekonany, że HttpURLConnection zostanie na dłużej.

Niektóre z pytań SE HttpURLConnections:

Na Androidzie wykonaj żądanie POST z zakodowanym adresem URL danych formularza bez użycia UrlEncodedFormEntity

HttpPost działa w projekcie Java, a nie w Androidzie

Istnieje również OkHttp , który jest klientem HTTP, który jest domyślnie wydajny:

• obsługa HTTP / 2 pozwala wszystkim żądaniom do tego samego hosta na współdzielenie gniazda.
• łączenie połączeń zmniejsza opóźnienie żądania (jeśli HTTP/2 nie jest dostępny).
• przezroczysty GZIP zmniejsza rozmiary pobierania.
• buforowanie odpowiedzi unika sieci CAŁKOWICIE dla powtarzających się żądań.

Najpierw Utwórz instancję OkHttpClient:

OkHttpClient client = new OkHttpClient();

Następnie przygotuj swoją GET prośbę:

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

Na koniec użyj OkHttpClient Aby wysłać przygotowany Request:

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

Aby uzyskać więcej informacji, zapoznaj się z dokumentacją OkHttp

Możesz również użyć JdkRequest z jcabi-http (jestem programistą), który robi to wszystko za Ciebie, dekorując HttpURLConnection, uruchamiając żądania HTTP i analizując odpowiedzi, na przykład:

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

Sprawdź ten wpis na blogu, aby uzyskać więcej informacji: http://www.yegor256.com/2014/04/11/jcabi-http-intro.html

Jeśli używasz HTTP get usuń ten wiersz

urlConnection.setDoOutput(true);