web-dev-qa-db-fra.com

Envoi de HTTP POST Request In Java

supposons que cette URL ...

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

(Ici, l'identifiant doit être envoyé dans une demande POST)

Je souhaite envoyer le id = 10 au page.php du serveur, qui l'accepte dans une méthode POST.

Comment puis-je faire cela depuis Java?

J'ai essayé ceci:

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

Mais je n'arrive toujours pas à comprendre comment l'envoyer via POST

javahttppost
270
Jazz

Réponse mise à jour:

Étant donné que certaines des classes, dans la réponse d'origine, sont obsolètes dans la version la plus récente d'Apache HTTP Components, je publie cette mise à jour.

En passant, vous pouvez accéder à la documentation complète pour plus d'exemples ici .

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

Réponse originale:

Je recommande d'utiliser Apache HttpClient. c'est plus rapide et plus facile à mettre en œuvre.

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.

pour plus d'informations, consultez cette URL: http://hc.Apache.org/

314
mhshams

L'envoi d'une demande POST est facile avec Vanilla Java. En commençant par URL, nous devons le convertir en URLConnection avec url.openConnection();. Après cela, nous devons le convertir en HttpURLConnection pour pouvoir accéder à sa méthode setRequestMethod() afin de définir notre méthode. Nous disons enfin que nous allons envoyer des données via la connexion.

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

Nous devons ensuite indiquer ce que nous allons envoyer:

Envoi d'un formulaire simple

Un POST normal provenant d'un formulaire http a un format bien défini . Nous devons convertir nos entrées dans ce format:

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;

Nous pouvons ensuite joindre le contenu de notre formulaire à la demande http avec les en-têtes appropriés et l'envoyer.

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

Envoi de JSON

Nous pouvons aussi envoyer json en Java, c'est aussi facile:

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

Rappelez-vous que différents serveurs acceptent différents types de contenu pour JSON, voir this question.

Envoi de fichiers avec Java post

L'envoi de fichiers peut être considéré comme plus difficile à gérer car le format est plus complexe. Nous allons également ajouter un support pour l'envoi des fichiers sous forme de chaîne, car nous ne voulons pas mettre le fichier complètement en mémoire tampon dans la mémoire.

Pour cela, nous définissons des méthodes d'assistance:

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

Nous pouvons ensuite utiliser ces méthodes pour créer une demande de publication en plusieurs parties, comme suit:

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

La première réponse a été excellente, mais j'ai dû ajouter try/catch pour éviter les erreurs de compilation de Java.
De plus, j'ai eu du mal à comprendre comment lire les bibliothèques HttpResponse avec Java.

Voici le code le plus complet:

/*
 * 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

Une façon simple d’utiliser Apache HTTP Components est de:

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

Jetez un coup d'œil à la API Fluent

15
Mathias Bak

moyen le plus simple d’envoyer des paramètres avec la demande de publication:

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

Vous avez fait. vous pouvez maintenant utiliser responsePOST. Obtenir le contenu de la réponse sous forme de chaîne:

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

Appelez HttpURLConnection.setRequestMethod("POST") et HttpURLConnection.setDoOutput(true); En fait, seul ce dernier est nécessaire, car POST devient alors la méthode par défaut.

1
user207421

Je recommande d'utiliser http-request construit sur 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