laten we aannemen dat deze URL…
http://www.example.com/page.php?id=10
(Hier moet een id worden verzonden in een POST-verzoek)
Ik wil de id = 10naar de page.phpvan de server sturen, die deze accepteert in een POST-methode.
Hoe kan ik dit vanuit Java doen?
Ik heb dit geprobeerd:
URL aaa = new URL("https://www.example.com/page.php");
URLConnection ccc = aaa.openConnection();
Maar ik weet nog steeds niet hoe ik het via POST moet verzenden
Antwoord 1, autoriteit 100%
Bijgewerkt antwoord:
Aangezien sommige klassen in het oorspronkelijke antwoord verouderd zijn in de nieuwere versie van Apache HTTP Components, plaats ik deze update.
Trouwens, je hebt toegang tot de volledige documentatie voor meer voorbeelden 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
}
}
Oorspronkelijk antwoord:
Ik raad aan om Apache HttpClient te gebruiken. het is sneller en gemakkelijker te implementeren.
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.
check voor meer informatie deze url: http://hc.apache.org/
Antwoord 2, autoriteit 61%
Het verzenden van een POST-verzoek is eenvoudig in vanilla Java. Beginnend met een URL, hoeven we deze niet te converteren naar een URLConnectionmet behulp van url.openConnection();. Daarna moeten we het casten naar een HttpURLConnection, zodat we toegang hebben tot de setRequestMethod()methode om onze methode in te stellen. We zeggen eindelijk dat we gegevens over de verbinding gaan verzenden.
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);
We moeten dan aangeven wat we gaan verzenden:
Een eenvoudig formulier verzenden
Een normale POST afkomstig van een http-formulier heeft een goed gedefinieerdeformaat. We moeten onze invoer naar dit formaat converteren:
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;
We kunnen dan de inhoud van ons formulier met de juiste headers aan het http-verzoek toevoegen en het verzenden.
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()
JSON verzenden
We kunnen json ook verzenden met java, dit is ook gemakkelijk:
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()
Houd er rekening mee dat verschillende servers verschillende inhoudstypen voor json accepteren, zie dezevraag.
Bestanden verzenden met Java-post
Het verzenden van bestanden kan als lastiger worden beschouwd omdat het formaat complexer is. We gaan ook ondersteuning toevoegen voor het verzenden van de bestanden als een string, omdat we het bestand niet volledig in het geheugen willen bufferen.
Hiervoor definiëren we enkele hulpmethoden:
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));
}
We kunnen vervolgens deze methoden gebruiken om een Multipart-postverzoek als volgt te maken:
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()
Antwoord 3, autoriteit 29%
String rawData = "id=10";
String type = "application/x-www-form-urlencoded";
String encodedData = URLEncoder.encode( rawData, "UTF-8" );
URL u = new URL("https://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());
Antwoord 4, autoriteit 7%
Het eerste antwoord was geweldig, maar ik moest try/catch toevoegen om Java-compilerfouten te voorkomen.
Ik had ook problemen om erachter te komen hoe ik de HttpResponsemet Java-bibliotheken moest lezen.
Hier is de meer volledige 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();
}
Antwoord 5, autoriteit 5%
Een eenvoudige manier om Apache HTTP Components te gebruiken is
Request.Post("http://www.example.com/page.php")
.bodyForm(Form.form().add("id", "10").build())
.execute()
.returnContent();
Bekijk de Fluent API
Antwoord 6
eenvoudigste manier om parameters te verzenden met het postverzoek:
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);
Je hebt het gedaan. nu kunt u responsePOSTgebruiken.
Ontvang reactie-inhoud als tekenreeks:
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.
}
Antwoord 7
Bel HttpURLConnection.setRequestMethod("POST")en HttpURLConnection.setDoOutput(true);Eigenlijk is alleen de laatste nodig, aangezien POST dan de standaardmethode wordt.
p>
Antwoord 8
Ik raad aan om http-requestgebouwd op apache http api te gebruiken.
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();
}
Antwoord 9
Ik raad aan om Postman te gebruiken om de verzoekcode te genereren. Dien eenvoudig het verzoek in met Postman en klik vervolgens op het codetabblad:
Vervolgens krijg je het volgende venster om te kiezen in welke taal je de aanvraagcode wilt hebben:
