Enviando solicitação HTTP POST em Java

vamos supor este URL …

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

(Aqui id precisa ser enviado em uma solicitação POST)

Eu quero enviar o id = 10 para page.php do servidor, que aceita em um método POST.

Como posso fazer isso de dentro do Java?

Eu tentei isso:

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

Mas ainda não consigo descobrir como enviá-lo via POST

    Resposta Atualizada:

    Como algumas das classs, na resposta original, estão obsoletas na versão mais recente do Apache HTTP Components, estou postando esta atualização.

    By the way, você pode acessar a documentação completa para mais exemplos aqui .

     HttpClient httpclient = HttpClients.createDefault(); HttpPost httppost = new HttpPost("http://www.a-domain.com/foo/"); // Request parameters and other properties. List params = new ArrayList(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) { InputStream instream = entity.getContent(); try { // do something useful } finally { instream.close(); } } 

    Resposta Original:

    Eu recomendo usar o Apache HttpClient. é mais rápido e mais fácil de implementar.

     PostMethod post = new PostMethod("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 mais informações, acesse este url: http://hc.apache.org/

    Enviar uma solicitação POST é fácil no Java Java. Começando com um URL , precisamos convertê-lo para um URLConnection usando url.openConnection(); . Depois disso, precisamos HttpURLConnection lo em um HttpURLConnection , para que possamos acessar seu método setRequestMethod() para definir nosso método. Finalmente, dizemos que vamos enviar dados pela conexão.

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

    Então precisamos declarar o que vamos enviar:

    Enviando um formulário simples

    Um POST normal proveniente de um formulário http possui um formato bem definido . Precisamos converter nossa input para este formato:

     Map arguments = new HashMap<>(); arguments.put("username", "root"); arguments.put("password", "sjh76HSn!"); // This is a fake password obviously StringJoiner sj = new StringJoiner("&"); for(Map.Entry 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; 

    Podemos, então, append o conteúdo do formulário à solicitação http com headers adequados e enviá-lo.

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

    Enviando JSON

    Nós também podemos enviar json usando java, isso também é 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() 

    Lembre-se que diferentes servidores aceitam diferentes tipos de conteúdo para json, veja esta questão.


    Envio de arquivos com postagem em java

    O envio de arquivos pode ser considerado mais desafiador para lidar, pois o formato é mais complexo. Também vamos adicionar suporte para enviar os arquivos como uma string, já que não queremos armazenar o arquivo completamente na memory.

    Para isso, definimos alguns methods 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)); } 

    Podemos então usar esses methods para criar uma solicitação de postagem multipartes da seguinte maneira:

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

    A primeira resposta foi ótima, mas tive que adicionar try / catch para evitar erros do compilador Java.
    Além disso, tive problemas para descobrir como ler o HttpResponse com bibliotecas Java.

    Aqui está o código mais completo:

     /* * Create the POST request */ HttpClient httpClient = new DefaultHttpClient(); HttpPost httpPost = new HttpPost("http://example.com/"); // Request parameters and other properties. List params = new ArrayList(); 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(); } 

    Uma maneira simples de usar o Apache HTTP Components é

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

    Dê uma olhada na API do Fluent

    maneira mais simples de enviar parâmetros com o pedido de postagem:

     String postURL = "http://www.example.com/page.php"; HttpPost post = new HttpPost(postURL); List params = new ArrayList(); 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); 

    Você fez. agora você pode usar o responsePOST . Obter o conteúdo da resposta como string:

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

    Eu recomendo usar http-request construído em apache http api.

     HttpRequest httpRequest = HttpRequestBuilder.createPost("http://www.example.com/page.php", String.class) .responseDeserializer(ResponseDeserializer.ignorableDeserializer()).build(); public void send(){ String response = httpRequest.execute("id", "10").get(); } 

    Chame HttpURLConnection.setRequestMethod("POST") e HttpURLConnection.setDoOutput(true); Na verdade, apenas o último é necessário, pois o POST se torna o método padrão.