L'envoi de la Requête POST HTTP En Java

L'envoi d'une requête POST est facile de vanille dans Java. En commençant par un URL, nous avons besoin de t de les convertir en un URLConnection à l'aide de url.openConnection();. Après cela, nous avons besoin de la convertir en une HttpURLConnection, afin que nous puissions accéder à ses setRequestMethod() méthode pour définir notre méthode. Nous avons finalement dire 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 avons ensuite besoin de préciser ce que nous allons envoyer:

L'envoi d'un formulaire simple

Un POSTE normal venant d'un formulaire http a un bien défini format. Nous avons besoin de convertir notre contribution à 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;

On peut associer à notre formulaire le contenu de la requête http avec les bons en-têtes et de 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 JSON

Nous pouvons aussi envoyer json à l'aide de java, c'est aussi simple:

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

Rappeler que les différents serveurs d'accepter les différents types de contenu json, voir cette question.

---

L'envoi de fichiers avec java post

L'envoi de fichiers peut être considérée comme plus difficile à gérer que le format est plus complexe. Nous allons aussi ajouter le support pour l'envoi de fichiers comme une chaîne de caractères, car nous ne voulons pas de la mémoire tampon du fichier à fond dans la mémoire.

Pour cela, on définit 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 un multi-parties de la requête post 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()

La première réponse a été grande, mais j'ai dû ajouter un try/catch pour éviter les erreurs du compilateur Java.

Aussi, j'ai eu de la misère à comprendre comment lire les HttpResponse avec les bibliothèques Java.

Voici le code 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();
}

façon la plus simple pour envoyer des paramètres à la requête post:

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

Que vous avez fait. maintenant, vous pouvez utiliser responsePOST.
Obtenir le contenu de la réponse comme une chaîne de caractères:

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

Je vous conseille d'utiliser http-request construit sur un serveur 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();
}