Envío de solicitud HTTP POST en Java

9 minutos de lectura

Envio de solicitud HTTP POST en Java
Jazz

supongamos que esta URL…

http://www.example.com/page.php?id=10            

(Aquí la identificación debe enviarse en una solicitud POST)

quiero enviar el id = 10 al del servidor page.phpque lo acepta en un método POST.

¿Cómo puedo hacer esto desde Java?

Intenté esto:

URL aaa = new URL("http://www.example.com/page.php");
URLConnection ccc = aaa.openConnection();

Pero todavía no puedo averiguar cómo enviarlo a través de POST

  • ¿Responde esto a tu pregunta? Cómo usar java.net.URLConnection para disparar y manejar solicitudes HTTP

    – Mahozad

    31 de diciembre de 2021 a las 19:12

1646960410 139 Envio de solicitud HTTP POST en Java
mhshams

Respuesta actualizada:

Dado que algunas de las clases, en la respuesta original, están obsoletas en la versión más reciente de los componentes HTTP de Apache, publico esta actualización.

Por cierto, puedes acceder a la documentación completa para ver más ejemplos. aquí.

HttpClient httpclient = HttpClients.createDefault();
HttpPost httppost = new HttpPost("http://www.a-domain.com/foo/");

// Request parameters and other properties.
List<NameValuePair> params = new ArrayList<NameValuePair>(2);
params.add(new BasicNameValuePair("param-1", "12345"));
params.add(new BasicNameValuePair("param-2", "Hello!"));
httppost.setEntity(new UrlEncodedFormEntity(params, "UTF-8"));

//Execute and get the response.
HttpResponse response = httpclient.execute(httppost);
HttpEntity entity = response.getEntity();

if (entity != null) {
    try (InputStream instream = entity.getContent()) {
        // do something useful
    }
}

Respuesta original:

Recomiendo usar Apache HttpClient. es más rápido y fácil de implementar.

HttpPost post = new HttpPost("http://jakarata.apache.org/");
NameValuePair[] data = {
    new NameValuePair("user", "joe"),
    new NameValuePair("password", "bloggs")
};
post.setRequestBody(data);
// execute method and handle any error responses.
...
InputStream in = post.getResponseBodyAsStream();
// handle response.

para más información consulta esta url: http://hc.apache.org/

  • Después de intentar por un tiempo poner mis manos en PostMethod parece que ahora se llama HttpPost según stackoverflow.com/a/9242394/1338936 – solo para cualquiera que encuentre esta respuesta como yo 🙂

    – Martín Lyne

    28/10/2012 a las 20:43


  • @Juan (y Martin Lyne) gracias por los comentarios. Acabo de actualizar la respuesta.

    – mhshams

    3 de enero de 2013 a las 17:08

  • debe agregar las bibliotecas importadas

    – gouchaoer

    22 de febrero de 2017 a las 4:03

  • Y también da un error que no puede resolver getEntity()

    – Adarsh ​​Singh

    28 mayo 2020 a las 21:43

  • Para cualquiera que tenga el mismo problema que @AdarshSingh, encontré una solución después de mirar esta ejemplo proporcionado. Simplemente cambie HttpClient a CloseableHttpClient y HttpResponse a CloseableHttpResponse.

    – mega12345mega

    12 de agosto de 2020 a las 22:14

Envio de solicitud HTTP POST en Java
transbordador

Enviar una solicitud POST es fácil en Java estándar. Comenzando con un URLnecesitamos convertirlo a un URLConnection utilizando url.openConnection();. Después de eso, tenemos que lanzarlo a un HttpURLConnectionpara que podamos acceder a su setRequestMethod() method para establecer nuestro método. Finalmente decimos que vamos a enviar datos a través de la conexión.

URL url = new URL("https://www.example.com/login");
URLConnection con = url.openConnection();
HttpURLConnection http = (HttpURLConnection)con;
http.setRequestMethod("POST"); // PUT is another valid option
http.setDoOutput(true);

A continuación, tenemos que indicar lo que vamos a enviar:

Envío de un formulario sencillo

Un POST normal proveniente de un formulario http tiene un bien definido formato. Necesitamos convertir nuestra entrada a este formato:

Map<String,String> arguments = new HashMap<>();
arguments.put("username", "root");
arguments.put("password", "sjh76HSn!"); // This is a fake password obviously
StringJoiner sj = new StringJoiner("&");
for(Map.Entry<String,String> entry : arguments.entrySet())
    sj.add(URLEncoder.encode(entry.getKey(), "UTF-8") + "=" 
         + URLEncoder.encode(entry.getValue(), "UTF-8"));
byte[] out = sj.toString().getBytes(StandardCharsets.UTF_8);
int length = out.length;

Luego podemos adjuntar el contenido de nuestro formulario a la solicitud http con los encabezados adecuados y enviarlo.

http.setFixedLengthStreamingMode(length);
http.setRequestProperty("Content-Type", "application/x-www-form-urlencoded; charset=UTF-8");
http.connect();
try(OutputStream os = http.getOutputStream()) {
    os.write(out);
}
// Do something with http.getInputStream()

Envío de JSON

También podemos enviar json usando java, esto también es fácil:

byte[] out = "{\"username\":\"root\",\"password\":\"password\"}" .getBytes(StandardCharsets.UTF_8);
int length = out.length;

http.setFixedLengthStreamingMode(length);
http.setRequestProperty("Content-Type", "application/json; charset=UTF-8");
http.connect();
try(OutputStream os = http.getOutputStream()) {
    os.write(out);
}
// Do something with http.getInputStream()

Recuerde que diferentes servidores aceptan diferentes tipos de contenido para json, consulte esta pregunta.


Envío de archivos con java post

El envío de archivos puede considerarse más difícil de manejar ya que el formato es más complejo. También agregaremos soporte para enviar los archivos como una cadena, ya que no queremos almacenar el archivo en el búfer completo en la memoria.

Para esto, definimos algunos métodos auxiliares:

private void sendFile(OutputStream out, String name, InputStream in, String fileName) {
    String o = "Content-Disposition: form-data; name=\"" + URLEncoder.encode(name,"UTF-8") 
             + "\"; filename=\"" + URLEncoder.encode(filename,"UTF-8") + "\"\r\n\r\n";
    out.write(o.getBytes(StandardCharsets.UTF_8));
    byte[] buffer = new byte[2048];
    for (int n = 0; n >= 0; n = in.read(buffer))
        out.write(buffer, 0, n);
    out.write("\r\n".getBytes(StandardCharsets.UTF_8));
}

private void sendField(OutputStream out, String name, String field) {
    String o = "Content-Disposition: form-data; name=\"" 
             + URLEncoder.encode(name,"UTF-8") + "\"\r\n\r\n";
    out.write(o.getBytes(StandardCharsets.UTF_8));
    out.write(URLEncoder.encode(field,"UTF-8").getBytes(StandardCharsets.UTF_8));
    out.write("\r\n".getBytes(StandardCharsets.UTF_8));
}

Luego podemos usar estos métodos para crear una solicitud de publicación de varias partes de la siguiente manera:

String boundary = UUID.randomUUID().toString();
byte[] boundaryBytes = 
           ("--" + boundary + "\r\n").getBytes(StandardCharsets.UTF_8);
byte[] finishBoundaryBytes = 
           ("--" + boundary + "--").getBytes(StandardCharsets.UTF_8);
http.setRequestProperty("Content-Type", 
           "multipart/form-data; charset=UTF-8; boundary=" + boundary);

// Enable streaming mode with default settings
http.setChunkedStreamingMode(0); 

// Send our fields:
try(OutputStream out = http.getOutputStream()) {
    // Send our header (thx Algoman)
    out.write(boundaryBytes);

    // Send our first field
    sendField(out, "username", "root");

    // Send a seperator
    out.write(boundaryBytes);

    // Send our second field
    sendField(out, "password", "toor");

    // Send another seperator
    out.write(boundaryBytes);

    // Send our file
    try(InputStream file = new FileInputStream("test.txt")) {
        sendFile(out, "identification", file, "text.txt");
    }

    // Finish the request
    out.write(finishBoundaryBytes);
}


// Do something with http.getInputStream()

  • Esta publicación es útil, pero bastante defectuosa. Me tomó 2 días hacerlo funcionar. Entonces, para que funcione, debe reemplazar StandartCharsets.UTF8 con StandardCharsets.UTF_8. borderBytes y finishBoundaryBytes necesitan obtener dos guiones adicionales que NO se transmiten en el tipo de contenido, por lo que borderBytes = (“–” + límite + “\r\n”).obtener… También necesita transmitir los borderBytes una vez ¡ANTES se ignorará el primer campo o el primer campo!

    – Algomán

    22 de marzo de 2016 a las 12:48


  • Por qué out.write(finishBoundaryBytes); necesidad de línea? http.connect(); realizará el envío de POST, ¿no es así?

    – János

    30 de junio de 2016 a las 17:31

  • Es relativamente más fácil de lo que esperaba considerando que es Java 🙂

    – shaahiin

    28 mayo 2018 a las 20:56

  • enigmático \r\n\r\n significa CRLF CRLF (retorno de carro + salto de línea). Crea 2x nueva línea. La primera línea nueva es para terminar la línea actual. La segunda línea es para distinguir el encabezado http del cuerpo http en una solicitud. HTTP es un protocolo basado en ASCII. Esta es la regla para insertar \r\n.

    – Mitja Gustin

    27 de noviembre de 2018 a las 15:31


  • “Fácil” En otros idiomas esto es como una llamada de una sola línea. ¿Por qué son 8-12 líneas en Java? qr.ae/TWAQA6

    – Pavel Komárov

    18 oct 2019 a las 15:50

Envio de solicitud HTTP POST en Java
DuduAlul

String rawData = "id=10";
String type = "application/x-www-form-urlencoded";
String encodedData = URLEncoder.encode( rawData, "UTF-8" ); 
URL u = new URL("http://www.example.com/page.php");
HttpURLConnection conn = (HttpURLConnection) u.openConnection();
conn.setDoOutput(true);
conn.setRequestMethod("POST");
conn.setRequestProperty( "Content-Type", type );
conn.setRequestProperty( "Content-Length", String.valueOf(encodedData.length()));
OutputStream os = conn.getOutputStream();
os.write(encodedData.getBytes());

  • Importante tener en cuenta: usar cualquier otra cosa que no sea String.getBytes() no parece funcionar. Por ejemplo, el uso de un PrintWriter falla totalmente.

    – Mesas Little Bobby

    16 de diciembre de 2011 a las 8:35

  • y cómo configurar 2 datos de publicación? Separar por dos puntos, coma?

    – gato ruidoso

    18 de marzo de 2012 a las 9:17

  • encode(String) es obsoleto. tienes que usar encode(String, String), que especifica el tipo de codificación. Ejemplo: encode(rawData, "UTF-8").

    – sudo

    3 de junio de 2014 a las 17:29

  • Es posible que desee seguir al final. Esto aseguraría que la solicitud finalice y el servidor tenga la oportunidad de procesar la respuesta: conn.getResponseCode();

    – Szymon Jachim

    22 de junio de 2014 a las 12:49


  • no codifiques toda la cadena… tienes que codificar solo el valor de cada parámetro

    – usuario2914191

    18 mayo 2017 a las 20:14

1646960412 412 Envio de solicitud HTTP POST en Java
Mar Cnu

La primera respuesta fue excelente, pero tuve que agregar try/catch para evitar errores del compilador de Java.
Además, tuve problemas para descifrar cómo leer el HttpResponse con bibliotecas Java.

Aquí está el código más completo:

/*
 * Create the POST request
 */
HttpClient httpClient = new DefaultHttpClient();
HttpPost httpPost = new HttpPost("http://example.com/");
// Request parameters and other properties.
List<NameValuePair> params = new ArrayList<NameValuePair>();
params.add(new BasicNameValuePair("user", "Bob"));
try {
    httpPost.setEntity(new UrlEncodedFormEntity(params, "UTF-8"));
} catch (UnsupportedEncodingException e) {
    // writing error to Log
    e.printStackTrace();
}
/*
 * Execute the HTTP Request
 */
try {
    HttpResponse response = httpClient.execute(httpPost);
    HttpEntity respEntity = response.getEntity();

    if (respEntity != null) {
        // EntityUtils to get the response content
        String content =  EntityUtils.toString(respEntity);
    }
} catch (ClientProtocolException e) {
    // writing exception to log
    e.printStackTrace();
} catch (IOException e) {
    // writing exception to log
    e.printStackTrace();
}

1646960413 330 Envio de solicitud HTTP POST en Java
Mathias Bak

Una forma sencilla de usar los componentes HTTP de Apache es

Request.Post("http://www.example.com/page.php")
            .bodyForm(Form.form().add("id", "10").build())
            .execute()
            .returnContent();

Echa un vistazo a la API fluida

1646960414 998 Envio de solicitud HTTP POST en Java
Hani

Sugiero usar Postman para generar el código de solicitud. Simplemente haga la solicitud usando Postman y luego presione la pestaña de código:

pestaña de código

Luego obtendrá la siguiente ventana para elegir en qué idioma desea que esté su código de solicitud:
solicitud de generación de código

forma más sencilla de enviar parámetros con la solicitud posterior:

String postURL = "http://www.example.com/page.php";

HttpPost post = new HttpPost(postURL);

List<NameValuePair> params = new ArrayList<NameValuePair>();
params.add(new BasicNameValuePair("id", "10"));

UrlEncodedFormEntity ent = new UrlEncodedFormEntity(params, "UTF-8");
post.setEntity(ent);

HttpClient client = new DefaultHttpClient();
HttpResponse responsePOST = client.execute(post);

Has hecho. ahora puedes usar responsePOST. Obtenga el contenido de la respuesta como una cadena:

BufferedReader reader = new BufferedReader(new  InputStreamReader(responsePOST.getEntity().getContent()), 2048);

if (responsePOST != null) {
    StringBuilder sb = new StringBuilder();
    String line;
    while ((line = reader.readLine()) != null) {
        System.out.println(" line : " + line);
        sb.append(line);
    }
    String getResponseString = "";
    getResponseString = sb.toString();
//use server output getResponseString as string value.
}

¿Ha sido útil esta solución?

Esta web utiliza cookies propias y de terceros para su correcto funcionamiento y para fines analíticos y para mostrarte publicidad relacionada con sus preferencias en base a un perfil elaborado a partir de tus hábitos de navegación. Al hacer clic en el botón Aceptar, acepta el uso de estas tecnologías y el procesamiento de tus datos para estos propósitos. Configurar y más información
Privacidad