Come utilizzare java. net. URLConnection per attivare e gestire le richieste HTTP

Quando si lavora con HTTP è quasi sempre più utile fare riferimento a HttpURLConnection piuttosto che alla classe base URLConnection (poiché URLConnection è una classe astratta quando si chiede URLConnection.openConnection() su un URL HTTP che è ciò che si otterrà comunque).

Quindi puoi invece di affidarti a URLConnection#setDoOutput(true) per impostare implicitamente il metodo di richiesta su POST invece di fare httpURLConnection.setRequestMethod("POST") che alcuni potrebbero trovare più naturale (e che consente anche di specificare altri metodi di richiesta come PUT, SOPPRIMERE , ...).

Fornisce anche costanti HTTP utili in modo da poter fare:

int responseCode = httpURLConnection.getResponseCode();

if (responseCode == HttpURLConnection.HTTP_OK) {

Ispirato da questa e da altre domande su SO, ho creato un open source minimo basic-http-client che incarna la maggior parte delle tecniche trovate qui.

Google-http-java-client è anche una grande risorsa open source.

Ci sono 2 opzioni che puoi andare con gli accessi URL HTTP: GET / POST

OTTIENI richiesta:-

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

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

Ti suggerisco di dare un'occhiata al codice su kevinsawicki/http-request, è fondamentalmente un wrapper sopra HttpUrlConnection fornisce un'API molto più semplice nel caso in cui tu voglia solo fare le richieste in questo momento o puoi dare un'occhiata alle fonti (non è troppo grande) per dare un'occhiata a come vengono gestite le connessioni.

Esempio: Fare una richiesta GET con il tipo di contenuto application/json e alcuni parametri di query:

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

Sono stato anche molto ispirato da questa risposta.

Sono spesso su progetti in cui ho bisogno di fare un po ' di HTTP, e potrei non voler portare molte dipendenze di 3rd party (che portano altri e così via e così via, ecc.)

Ho iniziato a scrivere le mie utility in base ad alcune di questa conversazione (non nessuna dove fatto):

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 {

Quindi ci sono solo un gruppo o metodi statici.

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

Quindi pubblica...

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

Bene si ottiene l'idea....

Ecco i prove:

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


}

Puoi trovare il resto qui:

Https://github.com/RichardHightower/boon

Il mio obiettivo è quello di fornire le cose comuni che si vorrebbe fare in un modo un po ' più semplice allora....

Aggiornare

Il nuovo client HTTP fornito con Java 9 ma come parte di un Modulo incubatore denominato jdk.incubator.httpclient. I moduli incubatori sono un mezzo per mettere le API non finali nelle mani degli sviluppatori mentre il Le API progrediscono verso la finalizzazione o la rimozione in un futuro rilasciare.

In Java 9, è possibile inviare una richiesta GET come:

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

Quindi puoi esaminare il HttpResponse restituito:

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

Poiché questo nuovo client HTTP è in java.httpclient modulo jdk.incubator.httpclient, dovresti dichiarare questa dipendenza nel tuo file module-info.java:

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

Inizialmente sono stato ingannato da questo articolo che favorisce HttpClient.

Più tardi mi sono reso conto che {[1] } rimarrà da questo articolo

Come per il blog di Google:

Il client HTTP Apache ha meno bug su Eclair e Froyo. È la scelta migliore per queste versioni. Per il pan di zenzero , HttpURLConnection è la scelta migliore. La sua API semplice e di piccole dimensioni lo rende ideale per Android.

Compressione trasparente e caching di risposta ridurre l'uso della rete, migliorare la velocità e risparmiare la batteria. Le nuove applicazioni dovrebbero utilizzare HttpURLConnection; è dove spenderemo le nostre energie andando avanti.

Dopo aver letto questo articolo e alcune altre domande di stack over flow, sono convinto che HttpURLConnection rimarrà per durate più lunghe.

Alcune delle domande della SE che favoriscono HttpURLConnections:

Su Android, effettuare una richiesta POST con i dati del modulo codificati URL senza utilizzare UrlEncodedFormEntity

HttpPost funziona nel progetto Java, non in Android

Puoi anche usare JdkRequest da jcabi-http (sono uno sviluppatore), che fa tutto questo lavoro per te, decorando HttpURLConnection, attivando richieste HTTP e analizzando le risposte, ad esempio:

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

Controlla questo post del blog per maggiori informazioni: http://www.yegor256.com/2014/04/11/jcabi-http-intro.html

C'è anche OkHttp , che è un client HTTP efficiente per impostazione predefinita:

• Il supporto HTTP/2 consente a tutte le richieste allo stesso host di condividere un socket.
• Il pool di connessioni riduce la latenza della richiesta (se HTTP/2 non è disponibile).
• GZIP trasparente riduce le dimensioni del download.
• Il caching delle risposte evita completamente la rete per le richieste ripetute.

Creare prima un'istanza di OkHttpClient:

OkHttpClient client = new OkHttpClient();

Quindi, prepara la tua richiesta GET:

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

Infine, usa OkHttpClient per inviare Request preparato:

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

Per maggiori dettagli, è possibile consultare la documentazione di OkHttp

Se si utilizza http get rimuovere questa riga

urlConnection.setDoOutput(true);