Cómo utilizar java.net.URLConnection para disparar y manejar las peticiones HTTP

Cuando se trabaja con HTTP es casi siempre más útil referirse a HttpURLConnection en lugar de la clase base URLConnection (ya que URLConnection es una clase abstracta cuando se pide URLConnection.openConnection() en una URL HTTP que es lo que obtendrá de todos modos).

Entonces, en lugar de confiar en URLConnection#setDoOutput(true) para establecer implícitamente el método de solicitud a POST en lugar de hacer httpURLConnection.setRequestMethod("POST") que algunos podrían encontrar más natural (y que también le permite especificar otros métodos de solicitud como PUT, SUPRÍMASE , ...).

También proporciona constantes HTTP útiles para que pueda hacer:

int responseCode = httpURLConnection.getResponseCode();

if (responseCode == HttpURLConnection.HTTP_OK) {

Inspirado por esta y otras preguntas sobre SO, he creado un código abierto mínimo basic-http-client que encarna la mayoría de las técnicas que se encuentran aquí.

Google-http-java-client es también un gran recurso de código abierto.

Hay 2 opciones que puede ir con HTTP URL Hits: GET / POST

Solicitud GET: -

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

Te sugiero que eches un vistazo al código en kevinsawicki/http-request, es básicamente una envoltura encima de HttpUrlConnection proporciona una API mucho más simple en caso de que solo quieras hacer las solicitudes ahora mismo o puedes echar un vistazo a las fuentes (no es demasiado grande) para echar un vistazo a cómo se manejan las conexiones.

Ejemplo: Haga una solicitud GET con el tipo de contenido application/json y algunos parámetros de consulta:

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

También me sentí muy inspirado por esta respuesta.

A menudo estoy en proyectos donde necesito hacer algo de HTTP, y puede que no quiera traer muchas dependencias de terceros (que traen otros, etc., etc.).)

Comencé a escribir mis propias utilidades basadas en parte de esta conversación (no en ninguna parte):

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 {

Entonces hay solo un montón o métodos estáticos.

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

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

Bueno, ya tienes la idea....

Aquí están los pruebas:

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


}

Puedes encontrar el resto aquí:

Https://github.com/RichardHightower/boon

Mi objetivo es proporcionar las cosas comunes que uno querría hacer de una manera un poco más fácil entonces....

Actualizar

El nuevo cliente HTTP enviado con Java 9 pero como parte de un Módulo de incubadora llamado jdk.incubator.httpclient. Los módulos de incubadora son un medio de poner las API no finales en manos de los desarrolladores, mientras que el El progreso de las API hacia la finalización o eliminación en un futuro lanzar.

En Java 9, puede enviar una solicitud GET como:

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

Luego puedes examinar el HttpResponse devuelto:

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

Dado que este nuevo cliente HTTP está en java.httpclient módulo jdk.incubator.httpclient, debe declarar esta dependencia en su archivo module-info.java:

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

Inicialmente me engañó este artículo que favorece HttpClient.

Más tarde me he dado cuenta de que HttpURLConnection se va a quedar de este artículo

Según el blog de Google :

El cliente HTTP Apache tiene menos errores en Eclair y Froyo. Es la mejor opción para estos lanzamientos. Para el pan de jengibre , HttpURLConnection es la mejor opción. Su sencilla API y su pequeño tamaño lo hacen ideal para Android.

Compresión transparente y el almacenamiento en caché de respuesta reduce el uso de la red, mejora la velocidad y ahorra batería. Las nuevas aplicaciones deben utilizar HttpURLConnection; es donde vamos a gastar nuestra energía en el futuro.

Después de leer este artículo y algunas otras preguntas de stack over flow, estoy convencido de que HttpURLConnection se va a quedar por períodos más largos.

Algunas de las preguntas SE favoreciendo HttpURLConnections:

En Android, realiza una solicitud POST con datos de formulario codificados en URL sin usar UrlEncodedFormEntity

HttpPost funciona en Java project, no en Android

También puede utilizar JdkRequest desde jcabi-http (soy un desarrollador), que hace todo este trabajo por ti, decorando HttpURLConnection, disparando solicitudes HTTP y analizando respuestas, por ejemplo:

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

Revisa esta entrada del blog para más información: http://www.yegor256.com/2014/04/11/jcabi-http-intro.html

También está OkHttp , que es un cliente HTTP que es eficiente por defecto:

• El soporte HTTP/2 permite que todas las solicitudes al mismo host compartan un socket.
• La agrupación de conexiones reduce la latencia de la solicitud (si HTTP/2 no está disponible).
• El GZIP transparente reduce el tamaño de las descargas.
• El almacenamiento en caché de respuestas evita completamente la red para solicitudes repetidas.

Primero crea una instancia de OkHttpClient:

OkHttpClient client = new OkHttpClient();

Luego, prepare su GET solicitud:

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

Finalmente, use OkHttpClient para enviar preparado Request:

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

Para más detalles, puede consultar la documentación de OkHttp

Si está utilizando http get, elimine esta línea

urlConnection.setDoOutput(true);