HTTP POST mit JSON in Java

Ich möchte einen einfachen HTTP-POST mit JSON in Java erstellen.

Angenommen, die URL lautet www.site.com

und es nimmt den {"name":"myname","age":"20"}wie 'details'zum Beispiel gekennzeichneten Wert an .

Wie würde ich die Syntax für den POST erstellen?

Ich kann auch keine POST-Methode in den JSON-Javadocs finden.

Folgendes müssen Sie tun:

1. Holen Sie sich den Apache HttpClient, damit Sie die erforderliche Anfrage stellen können
2. Erstellen Sie damit eine HttpPost-Anfrage und fügen Sie den Header "application / x-www-form-urlencoded" hinzu.
3. Erstellen Sie eine StringEntity, an die Sie JSON übergeben
4. Führen Sie den Anruf aus

Der Code sieht ungefähr so ​​aus (Sie müssen ihn noch debuggen und zum Laufen bringen).

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

Sie können die Gson-Bibliothek verwenden, um Ihre Java-Klassen in JSON-Objekte zu konvertieren.

Erstellen Sie eine Pojo-Klasse für Variablen, die Sie wie im obigen Beispiel senden möchten

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

wird

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

Sobald Sie die Variablen in der Klasse pojo1 festgelegt haben, können Sie diese mit dem folgenden Code senden

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

und das sind die Importe

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;

und für GSON

import com.google.gson.Gson;

@ momos Antwort für Apache HttpClient, Version 4.3.1 oder höher. Ich verwende JSON-Javazum Erstellen meines JSON-Objekts:

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

Es ist wahrscheinlich am einfachsten, HttpURLConnection zu verwenden .

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

Sie verwenden JSONObject oder was auch immer, um Ihren JSON zu erstellen, aber nicht, um das Netzwerk zu verwalten. Sie müssen es serialisieren und dann an eine HttpURLConnection an POST übergeben.

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

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

Ich fand diese Frage auf der Suche nach einer Lösung zum Senden einer Post-Anfrage vom Java-Client an Google Endpoints. Die obigen Antworten sind sehr wahrscheinlich korrekt, funktionieren jedoch bei Google Endpoints nicht.

Lösung für Google Endpoints.

1. Der Anforderungshauptteil darf nur eine JSON-Zeichenfolge enthalten, kein Name = Wert-Paar.

2. Der Inhaltstyp-Header muss auf "application / json" gesetzt sein.

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

   Dies kann sicher auch mit HttpClient erfolgen.

Sie können den folgenden Code mit Apache HTTP verwenden:

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

response = client.execute(request);

Außerdem können Sie ein JSON-Objekt erstellen und Felder wie folgt in das Objekt einfügen

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

Für Java 11 können Sie einen neuen HTTP-Client verwenden :

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

Sie können Publisher aus InputStream, String, File verwenden. Konvertieren Sie JSON in den String oder IS, den Sie mit Jackson können.

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

Ich empfehle http-Anfrage auf Apache http API gebaut.

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

Wenn Sie als Anfragetext senden möchten, JSONkönnen Sie:

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

Ich empfehle dringend, die Dokumentation vor dem Gebrauch zu lesen.