HTTP POST utilisant JSON en Java

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

Disons que l'URL est www.site.com

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

Comment créerais-je la syntaxe du POST?

Je n'arrive pas non plus à trouver une méthode POST dans les Javadocs JSON.

Voici ce que tu dois faire:

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

Le code ressemble à peu près (vous devrez toujours le déboguer et 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(); 
}

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 selon l'exemple ci-dessus

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

devient

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

une fois que vous avez défini les variables dans la classe pojo1, vous pouvez envoyer cela 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;

Réponse de @ momo pour Apache HttpClient, version 4.3.1 ou ultérieure. J'utilise JSON-Javapour créer 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();
}

Il est probablement plus simple d'utiliser HttpURLConnection .

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

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

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

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

J'ai trouvé cette question à la recherche d'une solution sur la façon d'envoyer une demande de publication du client java à Google Endpoints. Au-dessus des réponses, très probablement correctes, mais ne fonctionnent pas dans le cas de Google Endpoints.

Solution pour Google Endpoints.

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

2. L'en-tête du 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 json ) 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(json.getBytes(charset));
     }
   
     InputStream response = connection.getInputStream();
   }

   Cela peut certainement être fait en utilisant HttpClient.

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

Pour Java 11, vous pouvez utiliser un nouveau 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 l'éditeur de InputStream, String, File. Vous pouvez convertir JSON en String ou IS avec Jackson.

Java 8 avec apache httpClient 4

CloseableHttpClient client = HttpClientBuilder.create().build();
HttpPost httpPost = new HttpPost("www.site.com");


String json = "details={\"name\":\"myname\",\"age\":\"20\"} ";

        try {
            StringEntity entity = new StringEntity(json);
            httpPost.setEntity(entity);

            // set your POST request headers to accept json contents
            httpPost.setHeader("Accept", "application/json");
            httpPost.setHeader("Content-type", "application/json");

            try {
                // your closeablehttp response
                CloseableHttpResponse response = client.execute(httpPost);

                // print your status code from the response
                System.out.println(response.getStatusLine().getStatusCode());

                // take the response body as a json formatted string 
                String responseJSON = EntityUtils.toString(response.getEntity());

                // convert/parse the json formatted string to a json object
                JSONObject jobj = new JSONObject(responseJSON);

                //print your response body that formatted into json
                System.out.println(jobj);

            } catch (IOException e) {
                e.printStackTrace();
            } catch (JSONException e) {

                e.printStackTrace();
            }

        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }

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 souhaitez envoyer JSONle corps de la demande, vous pouvez:

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

Je recommande vivement de lire la documentation avant utilisation.