Senden einer HTTP-POST-Anforderung in Java

Lesezeit: 9 Minuten

Senden einer HTTP POST Anforderung in Java
Jazz

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 senden id = 10 zum Server page.phpdie es in einer POST-Methode akzeptiert.

Wie kann ich dies in Java tun?

Ich habe das versucht:

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

Aber ich weiß immer noch nicht, wie ich es per POST verschicken soll

  • Beantwortet das deine Frage? Verwendung von java.net.URLConnection zum Auslösen und Verarbeiten von HTTP-Anforderungen

    – Mahozad

    31. Dezember 2021 um 19:12 Uhr

1646633834 508 Senden einer HTTP POST Anforderung in Java
mhshams

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 auf die vollständige Dokumentation für weitere Beispiele zugreifen Hier.

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

Ursprüngliche Antwort:

Ich empfehle die Verwendung von Apache HttpClient. es ist 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/

  • Nachdem ich eine Weile versucht habe, meine Hände zu bekommen PostMethod Es scheint, dass es jetzt tatsächlich heißt HttpPost gemäß stackoverflow.com/a/9242394/1338936 – nur für alle, die diese Antwort so finden wie ich 🙂

    – Martin Lyne

    28. Oktober 2012 um 20:43 Uhr


  • @Juan (und Martin Lyne) danke für die Kommentare. Ich habe gerade die Antwort aktualisiert.

    – mhshams

    3. Januar 2013 um 17:08 Uhr

  • Sie sollten die importierten Bibliotheken hinzufügen

    – gouchaoer

    22. Februar 2017 um 4:03 Uhr

  • Und es wird auch ein Fehler ausgegeben, der getEntity () nicht auflösen kann

    – Adarsh ​​Singh

    28. Mai 2020 um 21:43 Uhr

  • Für alle, die das gleiche Problem wie @AdarshSingh haben, habe ich nach dem Betrachten eine Lösung gefunden Das geliefertes Beispiel. Ändern Sie einfach HttpClient in CloseableHttpClient und HttpResponse in CloseableHttpResponse!

    – mega12345mega

    12. August 2020 um 22:14 Uhr

Senden einer HTTP POST Anforderung in Java
Fährgroß

Das Senden einer POST-Anforderung ist in Vanilla Java einfach. Beginnend mit a URLwir müssen es nicht in a umwandeln URLConnection verwenden url.openConnection();. Danach müssen wir es in a umwandeln HttpURLConnectiondamit wir darauf zugreifen können setRequestMethod() Methode, um unsere Methode festzulegen. Wir sagen schließlich, 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:

Senden eines einfachen Formulars

Ein normaler POST, der von einem http-Formular kommt, hat a 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;

Wir können dann unseren Formularinhalt mit den richtigen Headern an die http-Anforderung anhängen und 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 json auch 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 Inhaltstypen für JSON akzeptieren, siehe diese Frage.


Senden von Dateien mit Java-Post

Das Senden von Dateien kann als schwieriger zu handhaben angesehen werden, da das Format komplexer ist. Wir werden auch Unterstützung für das Senden der Dateien als Zeichenfolge hinzufügen, da wir die Datei nicht vollständig im Speicher puffern möchten.

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

Wir können diese Methoden dann verwenden, um eine mehrteilige Post-Anforderung wie folgt zu 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()

  • Dieser Beitrag ist nützlich, aber ziemlich fehlerhaft. Ich habe 2 Tage gebraucht, bis es funktionierte. Damit es funktioniert, müssen Sie StandartCharsets.UTF8 durch StandardCharsets.UTF_8 ersetzen. borderBytes und finishBoundaryBytes müssen zwei zusätzliche Bindestriche erhalten, die NICHT im Content-Type übertragen werden, also borderBytes = (“–” + border + “\r\n”).get… Sie müssen auch die borderBytes einmal übertragen VOR dem ersten Feld oder das erste Feld wird ignoriert!

    – Algomann

    22. März 2016 um 12:48 Uhr


  • Warum out.write(finishBoundaryBytes); Linie brauchen? http.connect(); wird das Senden von POST durchführen, nicht wahr?

    – Janos

    30. Juni 2016 um 17:31 Uhr

  • Es ist relativ einfacher als ich erwartet hatte, wenn man bedenkt, dass es Java ist 🙂

    – shaahin

    28. Mai 2018 um 20:56 Uhr

  • rätselhaft \r\n\r\n bedeutet CRLF CRLF (Wagenrücklauf + Zeilenvorschub). Es erstellt 2x neue Zeile. Die erste neue Zeile soll die aktuelle Zeile beenden. Die zweite Zeile dient der Unterscheidung zwischen HTTP-Header und HTTP-Body in einer Anfrage. HTTP ist ein ASCII-basiertes Protokoll. Dies ist die Regel für das Einfügen von \r\n.

    – Mitja Gustin

    27. November 2018 um 15:31 Uhr


  • „Einfach“ In anderen Sprachen ist dies wie ein Anruf auf einer Leitung. Warum sind es 8-12 Zeilen in Java? qr.ae/TWAQA6

    – Pawel Komarow

    18. Oktober 2019 um 15:50 Uhr

Senden einer HTTP POST Anforderung in 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());

  • Wichtig zu beachten: Die Verwendung von etwas anderem als String.getBytes() scheint nicht zu funktionieren. Beispielsweise schlägt die Verwendung eines PrintWriter völlig fehl.

    – Kleine Bobby-Tische

    16. Dezember 2011 um 8:35 Uhr

  • und wie stelle ich 2 Postdaten ein? Durch Doppelpunkt, Komma trennen?

    – laute Katze

    18. März 2012 um 9:17 Uhr

  • encode(String) ist veraltet. Sie müssen verwenden encode(String, String), die den Codierungstyp angibt. Beispiel: encode(rawData, "UTF-8").

    – sudo

    3. Juni 2014 um 17:29 Uhr

  • Vielleicht möchten Sie am Ende folgen. Dies würde sicherstellen, dass die Anfrage abgeschlossen ist und der Server die Antwort verarbeiten kann: conn.getResponseCode();

    – Szymon Jachim

    22. Juni 2014 um 12:49 Uhr


  • Codieren Sie nicht die gesamte Zeichenfolge. Sie müssen nur den Wert jedes Parameters codieren

    – Benutzer2914191

    18. Mai 2017 um 20:14 Uhr

1646633837 450 Senden einer HTTP POST Anforderung in Java
März Cnu

Die erste Antwort war großartig, aber ich musste try/catch hinzufügen, um Java-Compilerfehler zu vermeiden.
Außerdem hatte ich Schwierigkeiten, herauszufinden, wie ich das lesen sollte HttpResponse mit Java-Bibliotheken.

Hier ist der vollständigere 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();
}

1646633838 21 Senden einer HTTP POST Anforderung in Java
Matthias Bak

Eine einfache Möglichkeit, Apache HTTP-Komponenten zu verwenden, 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

1646633838 859 Senden einer HTTP POST Anforderung in Java
Hani

Ich schlage vor, Postman zu verwenden, um den Anforderungscode zu generieren. Stellen Sie einfach die Anfrage mit Postman und klicken Sie dann auf die Registerkarte Code:

Code-Tab

Dann erhalten Sie das folgende Fenster, in dem Sie auswählen können, in welcher Sprache Ihr Anfragecode sein soll:
Codegenerierung anfordern

Der einfachste Weg, Parameter mit dem Post-Request zu senden:

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

Du hast gemacht. jetzt können Sie verwenden responsePOST. Antwortinhalt als String erhalten:

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

963500cookie-checkSenden einer HTTP-POST-Anforderung in Java

This website is using cookies to improve the user-friendliness. You agree by using the website further.

Privacy policy