Jak przesłać dane JSON za pomocą cURL?

Używam Ubuntu i zainstalowałem na nim cURL . Chcę przetestować moją wiosenną aplikację REST za pomocą cURL. Napisałem mój kod POST po stronie Java. Chcę jednak przetestować to za pomocą cURL. Próbuję opublikować dane JSON. Przykładowe dane są takie:

{"value":"30","type":"Tip 3","targetModule":"Target 3","configurationGroup":null,"name":"Configuration Deneme 3","description":null,"identity":"Configuration Deneme 3","version":0,"systemId":3,"active":true}

Używam tego polecenia:

curl -i \
    -H "Accept: application/json" \
    -H "X-HTTP-Method-Override: PUT" \
    -X POST -d "value":"30","type":"Tip 3","targetModule":"Target 3","configurationGroup":null,"name":"Configuration Deneme 3","description":null,"identity":"Configuration Deneme 3","version":0,"systemId":3,"active":true \
    http://localhost:8080/xx/xxx/xxxx

Zwraca ten błąd:

HTTP/1.1 415 Unsupported Media Type
Server: Apache-Coyote/1.1
Content-Type: text/html;charset=utf-8
Content-Length: 1051
Date: Wed, 24 Aug 2011 08:50:17 GMT

Opis błędu jest następujący:

Serwer odrzucił to żądanie, ponieważ jednostka żądania ma format nieobsługiwany przez żądany zasób dla żądanej metody ().

Dziennik Tomcat: „POST / ui / webapp / conf / clear HTTP / 1.1” 415 1051

Jaki jest prawidłowy format polecenia cURL?

To jest mój PUTkod boczny Java (przetestowałem GET i DELETE i działają):

@RequestMapping(method = RequestMethod.PUT)
public Configuration updateConfiguration(HttpServletResponse response, @RequestBody Configuration configuration) { //consider @Valid tag
    configuration.setName("PUT worked");
    //todo If error occurs response.sendError(HttpServletResponse.SC_NOT_FOUND);
    return configuration;
}

Musisz ustawić typ zawartości na application / json. Ale -dwysyła Content-Type application/x-www-form-urlencoded, który nie jest akceptowany po stronie Springa.

Patrząc na stronę podręcznika curl , myślę, że możesz użyć -H:

-H "Content-Type: application/json"

Pełny przykład:

curl --header "Content-Type: application/json" \
  --request POST \
  --data '{"username":"xyz","password":"xyz"}' \
  http://localhost:3000/api/login

( -Hjest skrótem od --header, -ddla --data)

Pamiętaj, że -request POSTjest to opcjonalne, jeśli używasz -d, ponieważ -dflaga oznacza żądanie POST.

W systemie Windows sprawy wyglądają nieco inaczej. Zobacz temat komentarza.

Spróbuj umieścić swoje dane w pliku, powiedz, body.jsona następnie użyj

curl -H "Content-Type: application/json" --data @body.json http://localhost:8080/ui/webapp/conf

Może być przydatny: https://github.com/micha/resty

Jest to okrągły CURL, który upraszcza żądania REST wiersza poleceń. Wskazujesz go na punkt końcowy interfejsu API, a on daje komendy PUT i POST. (Przykłady dostosowane ze strony głównej)

$ resty http://127.0.0.1:8080/data #Sets up resty to point at your endpoing
$ GET /blogs.json                  #Gets http://127.0.0.1:8080/data/blogs.json
                                   #Put JSON
$ PUT /blogs/2.json '{"id" : 2, "title" : "updated post", "body" : "This is the new."}'
                                   # POST JSON from a file
$ POST /blogs/5.json < /tmp/blog.json

Ponadto często konieczne jest dodawanie nagłówków typu zawartości. Możesz to zrobić tylko raz, aby ustawić domyślną wartość dodawania plików konfiguracyjnych dla poszczególnych metod dla witryny: Ustawianie domyślnych opcji RESTY

W systemie Windows posiadanie pojedynczego cudzysłowu dla tej -dwartości nie działało dla mnie, ale działało po zmianie na podwójny cudzysłów. Musiałem także uniknąć podwójnych cudzysłowów w nawiasach klamrowych.

Oznacza to, że następujące działania nie działały:

curl -i -X POST -H "Content-Type: application/json" -d '{"key":"val"}' http://localhost:8080/appname/path

Ale następujące działały:

curl -i -X POST -H "Content-Type: application/json" -d "{\"key\":\"val\"}" http://localhost:8080/appname/path

Działa dla mnie przy użyciu:

curl -H "Accept: application/json" -H "Content-type: application/json" -X POST -d '{"id":100}' http://localhost/api/postJsonReader.do

Na szczęście został zmapowany do kontrolera Spring:

@RequestMapping(value = "/postJsonReader", method = RequestMethod.POST)
public @ResponseBody String processPostJsonData(@RequestBody IdOnly idOnly) throws Exception {
        logger.debug("JsonReaderController hit! Reading JSON data!"+idOnly.getId());
        return "JSON Received";
}

IdOnlyjest prostym POJO z właściwością id.

Na przykład utwórz plik JSON, params.json i dodaj do niego następującą treść:

[
    {
        "environment": "Devel",
        "description": "Machine for test, please do not delete!"
    }
]

Następnie uruchom to polecenie:

curl -v -H "Content-Type: application/json" -X POST --data @params.json -u your_username:your_password http://localhost:8000/env/add_server

Właśnie napotkałem ten sam problem. Mógłbym to rozwiązać, określając

-H "Content-Type: application/json; charset=UTF-8"

To działało dla mnie dobrze.

curl -X POST --data @json_out.txt http://localhost:8080/

Gdzie,

-X Oznacza czasownik http.

--data Oznacza dane, które chcesz wysłać.

Możesz użyć Postmana z intuicyjnym GUI, aby skompletować swoje cURLpolecenie.

1. Zainstaluj i uruchom Listonosza
2. Wpisz swój adres URL, treść postu, nagłówki żądania itp. Pp.
3. Kliknij Code
4. Wybierz cURL z rozwijanej listy
5. skopiuj i wklej swoje cURLpolecenie

Uwaga: Istnieje kilka opcji automatycznego generowania żądań na liście rozwijanej, dlatego właśnie uważałem, że mój post jest konieczny.

Korzystając z CURL Windows, spróbuj tego:

curl -X POST -H "Content-Type:application/json" -d "{\"firstName\": \"blablabla\",\"lastName\": \"dummy\",\"id\": \"123456\"}" http-host/_ah/api/employeeendpoint/v1/employee

Możesz użyć listonosza, aby przekonwertować na CURL

HTTPie jest zalecaną alternatywą, curlponieważ możesz to zrobić

$ http POST http://example.com/some/endpoint name=value name1=value1

Domyślnie mówi JSON i obsłuży zarówno ustawienie niezbędnego nagłówka, jak i kodowanie danych jako prawidłowego JSON. Jest również:

Some-Header:value

dla nagłówków i

name==value

dla parametrów ciągu zapytania. Jeśli masz dużą część danych, możesz także odczytać je z pliku, jeśli ma być zakodowany w JSON:

 field=@file.txt

Jeśli testujesz wiele wysyłanych / odpowiedzi JSON na interfejsie RESTful, możesz wypróbować wtyczkę Postman dla Chrome (która pozwala ręcznie definiować testy usług internetowych) i jej komendę Newman opartą na Node.js -line towarzysz (który pozwala zautomatyzować testy względem „kolekcji” testów Listonosza). Zarówno darmowy, jak i otwarty!

Działa to dla mnie dobrze, wykorzystując dodatkowo uwierzytelnianie BASIC:

curl -v --proxy '' --basic -u Administrator:password -X POST -H "Content-Type: application/json"
        --data-binary '{"value":"30","type":"Tip 3","targetModule":"Target 3","configurationGroup":null,"name":"Configuration Deneme 3","description":null,"identity":"Configuration Deneme 3","version":0,"systemId":3,"active":true}'
        http://httpbin.org/post

Oczywiście nigdy nie należy używać uwierzytelniania BASIC bez SSL i sprawdzonego certyfikatu.

Znowu się z tym spotkałem, używając cURL 7.49.1 Cygwina dla Windows ... A kiedy używałem --datalub --data-binaryz argumentem JSON, cURL się pomylił i zinterpretowałby to {}w JSON jako szablon URL. -gNaprawiono to, dodając argument wyłączający globowanie cURL.

Zobacz także Przekazywanie adresu URL z nawiasami do zwijania się .

Możesz także umieścić swoją zawartość JSON w pliku i przekazać ją do zwijania za pomocą --file-uploadopcji za pomocą standardowego wejścia, jak poniżej:

 echo 'my.awesome.json.function({"do" : "whatever"})' | curl -X POST "http://url" -T -

To działało dla mnie:

curl -H "Content-Type: application/json" -X POST -d @./my_json_body.txt http://192.168.1.1/json

Korzystam z poniższego formatu do testowania na serwerze WWW.

use -F 'json data'

Załóżmy ten format dict JSON:

{
    'comment': {
        'who':'some_one',
        'desc' : 'get it'
    }
}

Pełny przykład

curl -XPOST your_address/api -F comment='{"who":"some_one", "desc":"get it"}'

Użyj opcji -d, aby dodać ładunek

curl -X POST \
http://<host>:<port>/<path> \
-H 'Accept: application/json' \
-H 'Content-Type: application/json' \
-d '{
"foo": "bar",
"lorem": "ipsum"
}'

Dodatkowo:

użyj -X POST, aby użyć metody POST

użyj -H 'Accept: application / json', aby dodać nagłówek typu accept

użyj -H „Content-Type: application / json”, aby dodać nagłówek typu zawartości

To działało dla mnie na Windows10

curl -d "{"""owner""":"""sasdasdasdasd"""}" -H "Content-Type: application/json" -X  PUT http://localhost:8080/api/changeowner/CAR4

Sprawdź to narzędzie . Pomaga w łatwym tworzeniu fragmentów curl.

curl -XGET -H "Accept: application/json" -d "{\"value\":\"30\",\"type\":\"Tip 3\",\"targetModule\":\"Target 3\",\"configurationGroup\":null,\"name\":\"Configuration Deneme 3\",\"description\":null,\"identity\":\"Configuration Deneme 3\",\"version\":0,\"systemId\":3,\"active\":true}" "http://localhost:8080/xx/xxx/xxxx"

Oto inny sposób na zrobienie tego, jeśli chcesz uwzględnić dane dynamiczne.

#!/bin/bash

version=$1
text=$2
branch=$(git rev-parse --abbrev-ref HEAD)
repo_full_name=$(git config --get remote.origin.url | sed 's/.*:\/\/github.com\///;s/.git$//')
token=$(git config --global github.token)

generate_post_data()
{
  cat <<EOF
{
  "tag_name": "$version",
  "target_commitish": "$branch",
  "name": "$version",
  "body": "$text",
  "draft": false,
  "prerelease": false
}
EOF
}

echo "Create release $version for repo: $repo_full_name branch: $branch"
curl --data "$(generate_post_data)" "https://api.github.com/repos/$repo_full_name/releases?access_token=$token"

Wiem, wiele odpowiedzi na to pytanie, ale chciałem się podzielić, gdzie miałem problem:

curl -X POST http: // your-server-end-point -H "Content-Type: application / json" -d @ path-of-your-json-file.json

Widzisz, zrobiłem wszystko dobrze, tylko jedna rzecz - „@” Przegapiłem przed ścieżką do pliku JSON.

Znalazłem jeden odpowiedni dokument w Internecie - https://gist.github.com/subfuzion/08c5d85437d5d4f00e58

Mam nadzieję, że to może pomóc nielicznym. dzięki

Jeśli skonfigurujesz SWAGGER do aplikacji wiosennego rozruchu i wywołasz tam dowolny interfejs API ze swojej aplikacji, zobaczysz również Żądanie CURL.

Myślę, że jest to łatwy sposób generowania żądań za pomocą CURL.

Możesz przekazać rozszerzenie żądanego formatu jako koniec adresu URL. jak http: // localhost: 8080 / xx / xxx / xxxx .json

lub

http: // localhost: 8080 / xx / xxx / xxxx .xml

Uwaga: musisz dodać zależności pomnika jackson i jaxb do pom.