Hoe POST ik JSON-gegevens met cURL?

Ik gebruik Ubuntu en heb er cURLop geïnstalleerd. Ik wil mijn Spring REST-toepassing testen met cURL. Ik schreef mijn POST-code aan de Java-kant. Ik wil het echter testen met cURL. Ik probeer een JSON-gegevens te posten. Voorbeeldgegevens zijn als volgt:

{"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}

Ik gebruik dit commando:

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

Het geeft deze fout:

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

De foutbeschrijving is deze:

De server heeft dit verzoek geweigerd omdat de verzoekentiteit een indeling heeft die niet wordt ondersteund door de gevraagde bron voor de gevraagde methode ().

Tomcat-logboek:
“POST /ui/webapp/conf/clear HTTP/1.1” 415 1051

Wat is het juiste formaat van het cURL-commando?

Dit is mijn Java-side PUT-code (ik heb GET en DELETE getest en ze werken):

@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;
}

Antwoord 1, autoriteit 100%

U moet uw inhoudstype instellen op application/json. Maar -d(of --data) verzendt de Content-Type application/x-www-form-urlencoded, die aan de kant van Spring niet wordt geaccepteerd.

Als ik naar de curl-manpaginakijk, denk ik dat je -H(of --header):

-H "Content-Type: application/json"

Volledig voorbeeld:

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

(-His een afkorting voor --header, -dvoor --data)

Merk op dat -request POSToptioneelis als u -dgebruikt, zoals de vlag -daangeeft een POST-verzoek.


In Windows zijn de zaken iets anders. Zie de reactiethread.


Antwoord 2, autoriteit 13%

Probeer uw gegevens in een bestand te plaatsen, zeg body.jsonen gebruik vervolgens

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

Antwoord 3, autoriteit 2%

Voor Windows werkte het hebben van een enkel aanhalingsteken voor de waarde -dniet voor mij, maar het werkte wel nadat ik het had gewijzigd in dubbele aanhalingstekens. Ook moest ik dubbele aanhalingstekens tussen accolades vermijden.

Dat wil zeggen, het volgende werkte niet:

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

Maar het volgende werkte:

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

Antwoord 4, autoriteit 2%

Misschien vindt u resty nuttig:
https://github.com/micha/resty

Het is een wrapper rond CURL die REST-verzoeken op de opdrachtregel vereenvoudigt. U verwijst het naar uw API-eindpunt en het geeft u PUT- en POST-opdrachten. (Voorbeelden aangepast van de startpagina)

$ 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

Bovendien is het vaak nog steeds nodig om de Content Type-headers toe te voegen. U kunt dit echter één keer doen om een ​​standaard in te stellen, of configuratiebestanden per methode per site toe te voegen: Standaard RESTY-opties instellen


Antwoord 5, autoriteit 2%

Het werkte voor mij met:

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

Het was gelukkig toegewezen aan de Spring-controller:

@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";
}

IdOnlyis een eenvoudige POJOmet een id-eigenschap.


Antwoord 6

Maak bijvoorbeeld een JSON-bestand, params.json, en voeg deze inhoud eraan toe:

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

Vervolgens voer je dit commando uit:

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

Antwoord 7

Je kunt postbode gebruiken om te converteren naar CURLvoer hier de afbeeldingsbeschrijving in

voer hier de afbeeldingsbeschrijving in


Antwoord 8

Ik loop net tegen hetzelfde probleem aan. Ik zou het kunnen oplossen door op te geven

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

Antwoord 9

Dit werkte goed voor mij.

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

Waar,

-XBetekent het http-werkwoord.

--dataBetekent de gegevens die u wilt verzenden.


Antwoord 10

Je kunt Postmanmet zijn intuïtieve GUI gebruiken om je curlcommando.

  1. Installeer en start Postman
  2. Typ uw URL, berichttekst, verzoekheaders enz. pp.
  3. Klik op Code
  4. Selecteer curlin de vervolgkeuzelijst
  5. kopieer & plak je curl-opdracht

Opmerking: er zijn verschillende opties voor het automatisch genereren van verzoeken in de vervolgkeuzelijst, daarom dacht ik dat mijn bericht in de eerste plaats nodig was.


Antwoord 11

Gebruik CURL Windows, probeer dit:

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

Antwoord 12

HTTPieis een aanbevolen alternatief voor curlomdat je gewoon

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

Het spreekt standaard JSON en zal zowel de benodigde header voor u instellen als gegevens coderen als geldige JSON. Er is ook:

Some-Header:value

voor kopteksten, en

name==value

voor queryreeksparameters. Als je een groot stuk gegevens hebt, kun je het ook uit een bestand lezen dat JSON-gecodeerd is:

[email protected]

Antwoord 13

Als je veel JSON-verzend-/antwoorden test tegen een REST-interface, kun je de Postmanplug-in voor Chrome (waarmee u handmatig webservicetests kunt definiëren) en zijn op Node.js gebaseerde Newmancommand-line companion (waarmee je tests tegen “verzamelingen” van Postman-tests kunt automatiseren.) Zowel gratis als open!


Antwoord 14

Dit werkte goed voor mij, bovendien met BASIC-authenticatie:

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

Natuurlijk moet je BASIC-authenticatie nooit gebruiken zonder SSL en een gecontroleerd certificaat.

Ik kwam dit vandaag weer tegen, met behulp van Cygwin’s cURL 7.49.1 voor Windows… En bij het gebruik van --dataof --data-binarymet een JSON argument, cURL raakte in de war en interpreteerde de {}in de JSON als een URL-sjabloon. Het toevoegen van een -gargument om cURL globbing uit te schakelen loste dat op.

Zie ook Een URL met haakjes doorgeven om te krullen.


Antwoord 15

U kunt uw JSON-inhoud ook in een bestand plaatsen en het doorgeven aan curl met de optie --upload-filevia standaardinvoer, zoals dit:

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

Antwoord 16

Dit werkte voor mij:

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

Antwoord 17

Ik weet het, er is veel op deze vraag beantwoord, maar ik wilde delen waar ik het probleem had van:

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

Zie je wel, ik heb alles goed gedaan, Slechts één ding – “@” ik miste vóór het JSON-bestandspad.

Ik heb een relevant document gevonden op internet – https://gist.github.com/subfuzion /08c5d85437d5d4f00e58

Ik hoop dat dat de weinigen kan helpen. bedankt


Antwoord 18

Hier is een andere manier om dit te doen, als u dynamische gegevens wilt opnemen.

#!/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"

Antwoord 19

Ik gebruik het onderstaande formaat om te testen met een webserver.

use -F 'json data'

Laten we aannemen dat dit JSON dict-formaat:

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

Volledig voorbeeld

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

Antwoord 20

Gebruik -d optie om lading toe te voegen

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

Bovendien:

gebruik -X POST om de POST-methode te gebruiken

gebruik -H ‘Accept: application/json’ om header van het type accept toe te voegen

gebruik -H ‘Content-Type: application/json’ om koptekst van het inhoudstype toe te voegen


Antwoord 21

Dit werkte voor mij op Windows10

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

Antwoord 22

Ik heb hiervoor een tool gemaakt met de naam fetcher. Het kan verzoeken verzenden en krulfragmenten opmaken:

Hier is een voorbeeld:

voer hier de afbeeldingsbeschrijving in

Voorbeelduitvoer:

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"

Antwoord 23

Als u de SWAGGER configureert voor uw spring boot-toepassing en een willekeurige API van uw toepassing daar aanroept, kunt u dat CURL-verzoek ook zien.

Ik denk dat dit de gemakkelijke manier is om de verzoeken via de CURL te genereren.


Antwoord 24

Op basis van https://stackoverflow.com/a/57369772/2391795antwoord, hier is wat ik heb gedaan om dit op GitHub-acties. Het was een beetje lastig vanwege de EOF-tag.

Mijn doel was om een ​​HTTP-aanroep te verzenden zodra een Vercel-implementatie is voltooid (vergelijkbaar met een webhook).

In de hoop dat dit voorbeeld uit de praktijkkan andere mensen helpen.

 send-webhook-callback-once-deployment-ready:
    name: Invoke webhook callback url defined by the customer (Ubuntu 18.04)
    runs-on: ubuntu-18.04
    needs: await-for-vercel-deployment
    steps:
      - uses: actions/[email protected] # Get last commit pushed - See https://github.com/actions/checkout
      - name: Expose GitHub slug/short variables # See https://github.com/rlespinasse/github-slug-action#exposed-github-environment-variables
        uses: rlespinasse/[email protected] # See https://github.com/rlespinasse/github-slug-action
      - name: Expose git environment variables and call webhook (if provided)
        # Workflow overview:
        #  - Resolves webhook url from customer config file
        #  - If a webhook url was defined, send a
        run: |
          MANUAL_TRIGGER_CUSTOMER="${{ github.event.inputs.customer}}"
          CUSTOMER_REF_TO_DEPLOY="${MANUAL_TRIGGER_CUSTOMER:-$(cat vercel.json | jq --raw-output '.build.env.NEXT_PUBLIC_CUSTOMER_REF')}"
          VERCEL_DEPLOYMENT_COMPLETED_WEBHOOK=$(cat vercel.$CUSTOMER_REF_TO_DEPLOY.staging.json | jq --raw-output '.build.env.VERCEL_DEPLOYMENT_COMPLETED_WEBHOOK')
          # Checking if a webhook url is defined
          if [ -n "$VERCEL_DEPLOYMENT_COMPLETED_WEBHOOK" ]; then
            # Run script that populates git-related variables as ENV variables
            echo "Running script populate-git-env.sh"
            . ./scripts/populate-git-env.sh
            echo "Resolved git variables:"
            echo "'GIT_COMMIT_SHA': $GIT_COMMIT_SHA"
            echo "'GIT_COMMIT_REF': $GIT_COMMIT_REF"
            echo "'GIT_COMMIT_TAGS': $GIT_COMMIT_TAGS"
            # Generates JSON using a bash function - See https://stackoverflow.com/a/57369772/2391795
            # "End Of File" must be at the beginning of the line with no space/tab before or after - See https://stackoverflow.com/a/12909284/2391795
            # But, when executed by GitHub Action, it must be inside the "run" section instead
            generate_post_data() {
              cat <<EOF
            {
              "MANUAL_TRIGGER_CUSTOMER": "${MANUAL_TRIGGER_CUSTOMER}",
              "CUSTOMER_REF": "${CUSTOMER_REF_TO_DEPLOY}",
              "STAGE": "staging",
              "GIT_COMMIT_SHA": "${GIT_COMMIT_SHA}",
              "GIT_COMMIT_REF": "${GIT_COMMIT_REF}",
              "GIT_COMMIT_TAGS": "${GIT_COMMIT_TAGS}",
              "GITHUB_REF_SLUG": "${GITHUB_REF_SLUG}",
              "GITHUB_HEAD_REF_SLUG": "${GITHUB_HEAD_REF_SLUG}",
              "GITHUB_BASE_REF_SLUG": "${GITHUB_BASE_REF_SLUG}",
              "GITHUB_EVENT_REF_SLUG": "${GITHUB_EVENT_REF_SLUG}",
              "GITHUB_REPOSITORY_SLUG": "${GITHUB_REPOSITORY_SLUG}",
              "GITHUB_REF_SLUG_URL": "${GITHUB_REF_SLUG_URL}",
              "GITHUB_HEAD_REF_SLUG_URL": "${GITHUB_HEAD_REF_SLUG_URL}",
              "GITHUB_BASE_REF_SLUG_URL": "${GITHUB_BASE_REF_SLUG_URL}",
              "GITHUB_EVENT_REF_SLUG_URL": "${GITHUB_EVENT_REF_SLUG_URL}",
              "GITHUB_REPOSITORY_SLUG_URL": "${GITHUB_REPOSITORY_SLUG_URL}",
              "GITHUB_SHA_SHORT": "${GITHUB_SHA_SHORT}"
            }
          EOF
            }
            echo "Print generate_post_data():"
            echo "$(generate_post_data)"
            echo "Calling webhook at '$VERCEL_DEPLOYMENT_COMPLETED_WEBHOOK'"
            echo "Sending HTTP request (curl):"
            curl POST \
              "$VERCEL_DEPLOYMENT_COMPLETED_WEBHOOK" \
              -vs \
              --header "Accept: application/json" \
              --header "Content-type: application/json" \
              --data "$(generate_post_data)" \
              2>&1 | sed '/^* /d; /bytes data]$/d; s/> //; s/< //'
            # XXX See https://stackoverflow.com/a/54225157/2391795
            # -vs - add headers (-v) but remove progress bar (-s)
            # 2>&1 - combine stdout and stderr into single stdout
            # sed - edit response produced by curl using the commands below
            #   /^* /d - remove lines starting with '* ' (technical info)
            #   /bytes data]$/d - remove lines ending with 'bytes data]' (technical info)
            #   s/> // - remove '> ' prefix
            #   s/< // - remove '< ' prefix
          else
            echo "No webhook url defined in 'vercel.$CUSTOMER_REF_TO_DEPLOY.staging.json:.build.env.VERCEL_DEPLOYMENT_COMPLETED_WEBHOOK' (found '$VERCEL_DEPLOYMENT_COMPLETED_WEBHOOK')"
          fi

Antwoord 25

U kunt de extensie van het gewenste formaat doorgeven aan het einde van de url.
zoals http://localhost:8080/xx/xxx/xxxx.json

of

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

Opmerking: je moet jackson- en jaxb maven-afhankelijkheden toevoegen aan je pom.

Other episodes