Senden einer HTTP POST-Anfrage in Java

Question

Nehmen wir diese URL an...

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

(Hier muss die ID in einer POST-Anfrage gesendet werden)

Ich möchte die id = 10 zum Server der page.php die es in einer POST-Methode akzeptiert.

Wie kann ich dies von Java aus tun?

Ich habe das ausprobiert:

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

Aber ich kann immer noch nicht herausfinden, wie ich sie per POST versenden kann.

Answer 1

Aktualisierte Antwort:

Da einige der Klassen in der ursprünglichen Antwort in der neueren Version von Apache HTTP Components veraltet sind, poste ich dieses Update.

Übrigens können Sie die vollständige Dokumentation für weitere Beispiele aufrufen aquí .

HttpClient httpclient = HttpClients.createDefault();
HttpPost httppost = new HttpPost("http://www.a-domain.example/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
    }
}

Original-Antwort:

Ich empfehle, Apache HttpClient zu verwenden. seine schneller und einfacher zu implementieren.

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.

Weitere Informationen finden Sie unter dieser URL: http://hc.apache.org/

Answer 2

Das Senden einer POST-Anfrage ist in Vanilla Java einfach. Beginnend mit einer URL müssen wir sie in eine URLConnection mit url.openConnection(); . Danach müssen wir es in eine HttpURLConnection so können wir auf seine setRequestMethod() Methode, um unsere Methode festzulegen. Schließlich sagen wir, dass wir Daten über die Verbindung senden werden.

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

Wir müssen dann angeben, was wir senden werden:

Versenden eines einfachen Formulars

Ein normales POST, das von einem http-Formular kommt, hat eine gut definiert Format. Wir müssen unsere Eingabe in dieses Format konvertieren:

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;

Dann können wir den Inhalt unseres Formulars mit den richtigen Kopfzeilen an die http-Anfrage anhängen und diese senden.

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

---

Senden von JSON

Wir können auch json mit java senden, das ist auch einfach:

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

Denken Sie daran, dass verschiedene Server unterschiedliche Content-Typen für json akzeptieren, siehe 今 Frage.

---

Versenden von Dateien mit Java Post

Das Versenden von Dateien kann als schwieriger angesehen werden, da das Format komplexer ist. Wir werden auch Unterstützung für das Senden von Dateien als String hinzufügen, da wir die Datei nicht vollständig in den Speicher puffern wollen.

Zu diesem Zweck definieren wir einige Hilfsmethoden:

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

Mit diesen Methoden können wir dann eine mehrteilige Postanforderung wie folgt erstellen:

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

Answer 3

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

Answer 4

Die erste Antwort war gut, aber ich musste try/catch hinzufügen, um Java-Compilerfehler zu vermeiden.
Außerdem hatte ich Probleme, herauszufinden, wie man die HttpResponse mit Java-Bibliotheken.

Hier ist der vollständige Code:

/*
 * 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();
}

Answer 5

Ein einfacher Weg unter Verwendung von Apache HTTP Components ist

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

Werfen Sie einen Blick auf die Fließende API