Comment utiliser java. net. URLConnection pour déclencher et gérer les requêtes HTTP

Lorsque vous travaillez avec HTTP, il est presque toujours plus utile de se référer à HttpURLConnection plutôt qu'à la classe de base URLConnection (puisque URLConnection est une classe abstraite lorsque vous demandez URLConnection.openConnection() sur une URL HTTP, c'est ce que vous récupérerez de toute façon).

Alors vous pouvez au lieu de compter sur URLConnection#setDoOutput(true) pour définir implicitement la méthode de requête sur POST à la place faire httpURLConnection.setRequestMethod("POST") que certains pourraient trouver plus naturel (et qui vous permet également de spécifier d'autres méthodes de requête telles que PUT, SUPPRIMER, ...).

Il fournit également des constantes HTTP utiles afin que vous puissiez faire:

int responseCode = httpURLConnection.getResponseCode();

if (responseCode == HttpURLConnection.HTTP_OK) {

Inspiré par cette question et d'autres sur SO, j'ai créé un open source minimalbasic-http-client qui incarne la plupart des techniques trouvées ici.

Google-http-java-client est également une excellente ressource open source.

Il y a 2 options que vous pouvez utiliser avec les résultats d'URL HTTP: GET / POST

OBTENIR la demande: -

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

Requête 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()));

Je vous suggère de jeter un oeil au code sur kevinsawicki/http-request, c'est essentiellement un wrapper au-dessus de HttpUrlConnection il fournit une API beaucoup plus simple au cas où vous voudriez simplement faire les demandes en ce moment ou vous pouvez jeter un oeil aux sources (ce n'est pas trop grand) pour jeter un

Exemple: Faire une requête GET avec le type de contenu application/json et certains paramètres de requête:

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

J'ai également été très inspiré par cette réponse.

Je suis souvent sur des projets où j'ai besoin de faire du HTTP, et je ne veux peut-être pas apporter beaucoup de dépendances tierces (qui en apportent d'autres, etc.), etc.)

J'ai commencé à écrire mes propres utilitaires basés sur une partie de cette conversation (pas n'importe où fait):

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 {

Alors il y a juste un tas ou des méthodes statiques.

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

Puis poster...

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

Eh bien, vous avez l'idée....

Voici les essais:

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


}

, Vous pouvez trouver le reste ici:

Https://github.com/RichardHightower/boon

Mon but est de fournir les choses communes que l'on voudrait faire d'une manière un peu plus facile alors....

Mise à jour

Le nouveau client HTTP livré avec Java 9 mais dans le cadre d'un Module incubateur nommé jdk.incubator.httpclient. Les modules incubateurs sont un moyen de mettre les API non finales entre les mains des développeurs tout en Les API progressent vers la finalisation ou la suppression à l'avenir publier.

Dans Java 9, vous pouvez envoyer une requête GET comme:

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

Ensuite, vous pouvez examiner le HttpResponse retourné:

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

Puisque ce nouveau client HTTP est java.httpclient Module jdk.incubator.httpclient, vous devez déclarer cette dépendance dans votre fichier module-info.java:

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

Au départ, j'ai été induit en erreur par cet article qui favorise HttpClient.

Plus Tard, j'ai réalisé que HttpURLConnection va rester de cette article

Selon le blog de Google:

Le client HTTP Apache a moins de bugs sur Eclair et Froyo. C'est le meilleur choix pour ces versions. Pour le pain d'épice , HttpURLConnection est le meilleur choix. Son API simple et sa petite taille le rendent idéal pour Android.

Compression transparente et la mise en cache des réponses réduit l'utilisation du réseau, améliore la vitesse et économise la batterie. Les nouvelles applications devraient utiliser HttpURLConnection; c'est là que nous dépenserons notre énergie à l'avenir.

Après avoir lu cet article et d'autres questions de pile sur flux, je suis convaincu que HttpURLConnection va rester plus longtemps.

Quelques-unes des questions SE favorisant HttpURLConnections:

Sur Android, effectuez une requête POST avec des données de formulaire codées par URL sans utiliser UrlEncodedFormEntity

HttpPost travaille dans le projet Java, pas dans Android

Vous pouvez également utiliser JdkRequest de jcabi-http (je suis un développeur), qui fait tout ce travail pour vous, décorant HttpURLConnection, déclenchant des requêtes HTTP et analysant les réponses, par exemple:

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

Consultez cet article de blog pour plus d'informations: http://www.yegor256.com/2014/04/11/jcabi-http-intro.html

Il y a aussi OkHttp , qui est un client HTTP efficace par défaut:

• La prise en charge de HTTP/2 permet à toutes les requêtes adressées au même hôte de partager un socket.
• Le regroupement de connexions réduit la latence des requêtes (si HTTP/2 n'est pas disponible).
• Transparent GZIP rétrécit les tailles de téléchargement.
• La mise en cache des réponses évite complètement le réseau pour les demandes répétées.

Créez d'abord une instance de OkHttpClient:

OkHttpClient client = new OkHttpClient();

Ensuite, préparez votre demande GET:

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

Enfin, utilisez OkHttpClient pour envoyer Request préparé:

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

Pour plus de détails, vous pouvez consulter la documentation OkHttp

Si vous utilisez http get veuillez supprimer cette ligne

urlConnection.setDoOutput(true);