Comment utiliser java.net.URLConnection pour lancer et traiter les requêtes HTTP

lorsque vous travaillez avec HTTP, il est presque toujours plus utile de faire référence à HttpURLConnection plutôt qu'à la classe de base URLConnection (puisque URLConnection est une classe abstraite quand vous demandez URLConnection.openConnection() sur une URL HTTP qui est ce que vous obtiendrez de toute façon).

alors vous pouvez au lieu de compter sur URLConnection#setDoOutput(true) pour implicitement définir la méthode de requête à POST au lieu de 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 , DELETE , ...).

il fournit également des constantes HTTP utiles de sorte que vous pouvez le faire:

int responseCode = httpURLConnection.getResponseCode();

if (responseCode == HttpURLConnection.HTTP_OK) {

inspiré par ceci et d'autres questions sur SO, j'ai créé un open source minimal basic-http-client qui incarne la plupart des techniques trouvées ici.

google-http-java-client est aussi un grand open source de ressources.

il y a 2 options que vous pouvez utiliser avec les URL Hits HTTP: 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()));

je vous suggère de jeter un coup d'oeil au code sur kevinsawicki/requête http , c'est essentiellement un wrapper en haut de HttpUrlConnection il fournit une API beaucoup plus simple au cas où vous voulez juste faire les requêtes maintenant ou vous pouvez jeter un oeil aux sources (ce n'est pas trop grand) pour jeter un oeil à la façon dont les connexions sont traitées.

exemple: faire une requête GET avec le type de contenu application/json et quelques 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 été très inspiré par cette réponse.

je suis souvent sur des projets où j'ai besoin de faire un peu de HTTP, et je ne veux peut-être pas apporter beaucoup de dépendances de tiers (qui apportent d'autres et ainsi de suite et ainsi de suite, 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 {

puis 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 postez...

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 comprenez l'idée....

Voici les épreuves:

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 d'incubateur nommé jdk.incubator.httpclient . Les modules d'incubateur sont: un moyen de mettre les API non-finales dans les mains des développeurs tandis que le Api progrès vers soit de finalisation ou de retrait, dans un avenir publier.

en Java 9, Vous pouvez envoyer une GET demande comme:

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

alors vous pouvez examinez le retour HttpResponse :

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

puisque ce nouveau Client HTTP est java.httpclient jdk.incubator.httpclient module, 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 été réalisé que HttpURLConnection va rester de ce article

comme sur le Blog de Google :

le client HTTP Apache a moins de bogues 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 de petite taille le rend idéal pour Android.

compression transparente et Cache réponse réduire l'utilisation du réseau, améliorer la vitesse et économiser 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 quelques autres questions sur la pile sur l'écoulement, je suis convaincu que HttpURLConnection va rester pour de plus longues durées.

certaines de ces questions favorisant HttpURLConnections :

sur Android, faire une demande de poste avec des données de forme encodées URL sans utiliser UrlEncodedFormEntity

HttpPost travaille dans le projet Java, pas dans Android

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

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

voir ce billet 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:

• le support HTTP/2 permet à toutes les requêtes vers le même hôte de partager une socket.
• pooling de Connexion réduit la demande de latence (si HTTP/2 n'est pas disponible).
• Transparent GZIP se rétrécit en taille de téléchargement.
• la mise en cache de la réponse évite le réseau complètement pour les demandes répétées.

créer D'abord une instance de OkHttpClient :

OkHttpClient client = new OkHttpClient();

alors, préparez votre GET demande:

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

enfin, utiliser OkHttpClient pour envoyer Request :

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

pour plus de détails, vous pouvez consulter la documentation D'OkHttp

si vous utilisez http get s'il vous plaît supprimer cette ligne

urlConnection.setDoOutput(true);