web-dev-qa-db-fra.com

HTTP POST utilisant JSON dans Java

Je voudrais faire un simple HTTP POST en utilisant JSON en Java.

Disons que l'URL est www.site.com

et il prend la valeur {"name":"myname","age":"20"} nommée 'details' par exemple.

Comment pourrais-je créer la syntaxe pour le POST?

De plus, je n'arrive pas à trouver une méthode POST dans les Javadocs JSON.

javajsonhttppost
171
asdf007

Voici ce que tu dois faire:

  1. Obtenez le Apache HttpClient, cela vous permettrait de faire la demande requise
  2. Créez une demande HttpPost avec elle et ajoutez l'en-tête "application/x-www-form-urlencoded"
  3. Créez une StringEntity que vous lui passerez en JSON
  4. Exécuter l'appel

Le code ressemble à peu près (vous aurez toujours besoin de le déboguer et de le faire fonctionner)

//Deprecated
//HttpClient httpClient = new DefaultHttpClient(); 

HttpClient httpClient = HttpClientBuilder.create().build(); //Use this instead 

try {

    HttpPost request = new HttpPost("http://yoururl");
    StringEntity params =new StringEntity("details={\"name\":\"myname\",\"age\":\"20\"} ");
    request.addHeader("content-type", "application/x-www-form-urlencoded");
    request.setEntity(params);
    HttpResponse response = httpClient.execute(request);

    //handle response here...

}catch (Exception ex) {

    //handle exception here

} finally {
    //Deprecated
    //httpClient.getConnectionManager().shutdown(); 
}
156
momo

Vous pouvez utiliser la bibliothèque Gson pour convertir vos classes Java en objets JSON.

Créez une classe pojo pour les variables que vous souhaitez envoyer, comme indiqué ci-dessus. Exemple

{"name":"myname","age":"20"}

devient

class pojo1
{
   String name;
   String age;
   //generate setter and getters
}

une fois que vous définissez les variables dans la classe pojo1, vous pouvez l’envoyer en utilisant le code suivant

String       postUrl       = "www.site.com";// put in your url
Gson         gson          = new Gson();
HttpClient   httpClient    = HttpClientBuilder.create().build();
HttpPost     post          = new HttpPost(postUrl);
StringEntity postingString = new StringEntity(gson.toJson(pojo1));//gson.tojson() converts your pojo to json
post.setEntity(postingString);
post.setHeader("Content-type", "application/json");
HttpResponse  response = httpClient.execute(post);

et ce sont les importations

import org.Apache.http.HttpEntity;
import org.Apache.http.HttpResponse;
import org.Apache.http.client.HttpClient;
import org.Apache.http.client.methods.HttpPost;
import org.Apache.http.entity.StringEntity;
import org.Apache.http.impl.client.HttpClientBuilder;

et pour GSON

import com.google.gson.Gson;
86
Prakash

La réponse de @ momo pour Apache HttpClient, version 4.3.1 ou ultérieure. J'utilise JSON-Java pour construire mon objet JSON:

JSONObject json = new JSONObject();
json.put("someKey", "someValue");    

CloseableHttpClient httpClient = HttpClientBuilder.create().build();

try {
    HttpPost request = new HttpPost("http://yoururl");
    StringEntity params = new StringEntity(json.toString());
    request.addHeader("content-type", "application/json");
    request.setEntity(params);
    httpClient.execute(request);
// handle response here...
} catch (Exception ex) {
    // handle exception here
} finally {
    httpClient.close();
}
41
Cigano Morrison Mendez

Il est probablement plus facile à utiliser HttpURLConnection .

http://www.xyzws.com/Javafaq/how-to-use-httpurlconnection-post-data-to-web-server/139

Vous utiliserez JSONObject ou tout ce que vous voudrez pour construire votre JSON, mais pas pour gérer le réseau; vous devez le sérialiser, puis le transmettre à un HttpURLConnection to POST.

19
Alex Churchill
protected void sendJson(final String play, final String prop) {
     Thread t = new Thread() {
     public void run() {
        Looper.prepare(); //For Preparing Message Pool for the childThread
        HttpClient client = new DefaultHttpClient();
        HttpConnectionParams.setConnectionTimeout(client.getParams(), 1000); //Timeout Limit
        HttpResponse response;
        JSONObject json = new JSONObject();

            try {
                HttpPost post = new HttpPost("http://192.168.0.44:80");
                json.put("play", play);
                json.put("Properties", prop);
                StringEntity se = new StringEntity(json.toString());
                se.setContentType(new BasicHeader(HTTP.CONTENT_TYPE, "application/json"));
                post.setEntity(se);
                response = client.execute(post);

                /*Checking response */
                if (response != null) {
                    InputStream in = response.getEntity().getContent(); //Get the data in the entity
                }

            } catch (Exception e) {
                e.printStackTrace();
                showMessage("Error", "Cannot Estabilish Connection");
            }

            Looper.loop(); //Loop in the message queue
        }
    };
    t.start();
}
14
Medo

Essayez ce code:

HttpClient httpClient = new DefaultHttpClient();

try {
    HttpPost request = new HttpPost("http://yoururl");
    StringEntity params =new StringEntity("details={\"name\":\"myname\",\"age\":\"20\"} ");
    request.addHeader("content-type", "application/json");
    request.addHeader("Accept","application/json");
    request.setEntity(params);
    HttpResponse response = httpClient.execute(request);

    // handle response here...
}catch (Exception ex) {
    // handle exception here
} finally {
    httpClient.getConnectionManager().shutdown();
}
14
Sonu Dhakar

J'ai trouvé cette question à la recherche d'une solution sur la manière d'envoyer une demande de publication du client Java aux points finaux Google. Les réponses ci-dessus sont très probablement correctes, mais ne fonctionnent pas dans le cas des points de terminaison Google.

Solution for Google Endpoints.

  1. Le corps de la demande doit contenir uniquement une chaîne JSON, pas une paire nom = valeur.

  2. En-tête de type de contenu doit être défini sur "application/json".

    post("http://localhost:8888/_ah/api/langapi/v1/createLanguage",
                   "{\"language\":\"russian\", \"description\":\"dsfsdfsdfsdfsd\"}");



public static void post(String url, String param ) throws Exception{
  String charset = "UTF-8"; 
  URLConnection connection = new URL(url).openConnection();
  connection.setDoOutput(true); // Triggers POST.
  connection.setRequestProperty("Accept-Charset", charset);
  connection.setRequestProperty("Content-Type", "application/json;charset=" + charset);

  try (OutputStream output = connection.getOutputStream()) {
    output.write(param.getBytes(charset));
  }

  InputStream response = connection.getInputStream();
}

    Cela peut également être fait en utilisant HttpClient.

9
yurin

Vous pouvez utiliser le code suivant avec Apache HTTP:

String payload = "{\"name\": \"myname\", \"age\": \"20\"}";
post.setEntity(new StringEntity(payload, ContentType.APPLICATION_JSON));

response = client.execute(request);

De plus, vous pouvez créer un objet JSON et insérer des champs dans l'objet comme ceci

HttpPost post = new HttpPost(URL);
JSONObject payload = new JSONObject();
payload.put("name", "myName");
payload.put("age", "20");
post.setEntity(new StringEntity(payload.toString(), ContentType.APPLICATION_JSON));
5
TMO

Pour Java 11, vous pouvez utiliser new client HTTP :

 HttpClient client = HttpClient.newHttpClient();
    HttpRequest request = HttpRequest.newBuilder()
        .uri(URI.create("http://localhost/api"))
        .header("Content-Type", "application/json")
        .POST(ofInputStream(() -> getClass().getResourceAsStream(
            "/some-data.json")))
        .build();

    client.sendAsync(request, BodyHandlers.ofString())
        .thenApply(HttpResponse::body)
        .thenAccept(System.out::println)
        .join();

Vous pouvez utiliser publisher à partir de InputStream, String, File. Conversion de JSON en chaîne ou IS possible avec Jackson.

1
user3359592

Je recommande http-request construit sur Apache http api.

HttpRequest<String> httpRequest = HttpRequestBuilder.createPost(yourUri, String.class)
    .responseDeserializer(ResponseDeserializer.ignorableDeserializer()).build();

public void send(){
   ResponseHandler<String> responseHandler = httpRequest.execute("details", yourJsonData);

   int statusCode = responseHandler.getStatusCode();
   String responseContent = responseHandler.orElse(null); // returns Content from response. If content isn't present returns null. 
}

Si vous voulez envoyer JSON comme corps de requête, vous pouvez:

  ResponseHandler<String> responseHandler = httpRequest.executeWithBody(yourJsonData);

Je recommande vivement de lire la documentation avant utilisation.

0
Beno Arakelyan