webentwicklung-frage-antwort-db.com.de

Senden von HTTP POST Anforderung in Java

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 den id = 10 an den page.php des Servers senden, der ihn in einer POST Methode akzeptiert.

Wie kann ich das aus Java heraus machen?

Ich habe es versucht:

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

Aber ich kann immer noch nicht herausfinden, wie ich es per POST verschicken soll

270
Jazz

Aktualisierte Antwort:

Da einige der Klassen in der ursprünglichen Antwort in der neueren Version von Apache HTTP Components veraltet sind, veröffentliche 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, Apache HttpClient zu verwenden. 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 folgender URL: http://hc.Apache.org/

314
mhshams

Das Senden einer POST -Anforderung ist in Vanilla Java ganz einfach. Beginnend mit einem URL müssen wir es nicht mit url.openConnection(); in ein URLConnection konvertieren. Danach müssen wir es in eine HttpURLConnection umwandeln, damit wir auf die setRequestMethod() -Methode zugreifen können, 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 normales POST, das aus einem http-Formular stammt, hat das Format gut definiert . 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 Überschriften an die http-Anfrage 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 this question.


Senden von Dateien mit Java post

Das Senden von Dateien kann als schwieriger angesehen werden, da das Format komplexer ist. Wir werden auch die Unterstützung für das Senden der Dateien als Zeichenfolge hinzufügen, da die Datei nicht vollständig im Speicher zwischengespeichert werden soll.

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

Mit diesen Methoden können wir dann eine mehrteilige Post-Anfrage 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()
176
Ferrybig
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());
98
DuduAlul

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

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();
}
22
Mar Cnu

Eine einfache Möglichkeit, Apache HTTP Components zu verwenden, ist

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

Schauen Sie sich die Fluent API an

15
Mathias Bak

einfachste Möglichkeit, Parameter mit der Post-Anfrage zu versenden:

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 responsePOST verwenden. Antwortinhalt als String abrufen:

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.
}
5
chandan kumar

Rufen Sie HttpURLConnection.setRequestMethod("POST") und HttpURLConnection.setDoOutput(true); auf. Eigentlich wird nur letzteres benötigt, da POST dann zur Standardmethode wird.

1
user207421

Ich empfehle die Verwendung von http-request auf Apache http api.

HttpRequest<String> 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();
}
1
Beno Arakelyan