¿Cómo publico datos JSON con cURL?

Debe establecer su tipo de contenido en application / json. Pero -d (o --data) envía el tipo de contenido application/x-www-form-urlencoded, que no se acepta por parte de Spring.

En cuanto al página de manual de curl, Creo que puedes usar -H (o --header):

-H "Content-Type: application/json"

Ejemplo completo:

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

(-H es la abreviatura de --header, -d es --data)

Tenga en cuenta que -request POST is opcional si usas -d, Como el -d bandera implica una solicitud POST.

En Windows, las cosas son ligeramente diferentes. Vea el hilo de comentarios.

Intente poner sus datos en un archivo, digamos body.json Y luego usar

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

Para Windows, tener una cotización única para -d value no funcionó para mí, pero funcionó después de cambiar a comillas dobles. También necesitaba escapar de las comillas dobles dentro de los corchetes.

Es decir, lo siguiente no funcionó:

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

Pero lo siguiente funcionó:

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

Puede que el resty le resulte útil: https://github.com/micha/resty

Es un CURL redondo envolvente que simplifica las solicitudes REST de la línea de comandos. Lo apuntas a tu punto final de API y te da los comandos PUT y POST. (Ejemplos adaptados de la página de inicio)

$ 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

Además, a menudo es necesario agregar los encabezados de Tipo de contenido. Sin embargo, puede hacer esto una vez para establecer un valor predeterminado de agregar archivos de configuración por método por sitio: Configuración de las opciones de RESTY predeterminadas

Me funcionó usando:

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

Felizmente se asignó al controlador 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";
}

IdOnly es un simple POJO con una propiedad id.

Como ejemplo, cree un archivo JSON, params.json, y agréguele este contenido:

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

Luego ejecuta este comando:

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

Puedes usar cartero para convertir a CURL

Simplemente me encuentro con el mismo problema. Podría resolverlo especificando

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

Esto funcionó bien para mí.

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

Dónde,

-X Significa el verbo http.

--data Significa los datos que desea enviar.

Puedes usar Cartero con su GUI intuitiva para ensamblar su cURL mando.

1. Instalar y comenzar Cartero
2. Escriba su URL, cuerpo de la publicación, encabezados de solicitud, etc. págs.
3. Haga clic en Code
4. Seleccione cURL de la lista desplegable
5. copia y pega tu cURL comando

Nota: Hay varias opciones para la generación automática de solicitudes en la lista desplegable, por lo que pensé que mi publicación era necesaria en primer lugar.

Usando CURL Windows, intente esto:

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

HTTPie es una alternativa recomendada a curl porque puedes hacer solo

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

Habla JSON de forma predeterminada y manejará tanto la configuración del encabezado necesario como la codificación de datos como JSON válido. También hay:

Some-Header:value

para encabezados, y

name==value

para los parámetros de la cadena de consulta. Si tiene una gran cantidad de datos, también puede leerlos desde un archivo codificado en JSON:

 field=@file.txt

Si está probando muchos envíos / respuestas JSON en una interfaz RESTful, es posible que desee consultar el Cartero complemento para Chrome (que le permite definir manualmente las pruebas de servicios web) y su basado en Node.js Newman compañero de línea de comandos (que le permite automatizar pruebas contra "colecciones" de pruebas de Postman). ¡Tanto gratis como abierto!

Esto funcionó bien para mí, además de usar la autenticación BÁSICA:

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

Por supuesto, nunca debe usar la autenticación BÁSICA sin SSL y un certificado verificado.

Me encontré con esto nuevamente hoy, usando Cygwin's cURL 7.49.1 para Windows ... Y al usar --data or --data-binary con un argumento JSON, cURL se confundió e interpretaría el {} en JSON como plantilla de URL. Añadiendo un -g El argumento para desactivar el globbing cURL solucionó eso.

Vea también Pasando una URL con corchetes para curl.

También puede poner su contenido JSON en un archivo y pasarlo a curl usando el --upload-file opción a través de entrada estándar, así:

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

Esto funcionó para mí:

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

Lo sé, se ha respondido mucho a esta pregunta, pero quería compartir dónde tuve el problema de:

enrollamiento -X POST http://your-server-end-point -H "Tipo de contenido: aplicación / json" -d @ ruta-de-su-archivo-json.json

Mira, hice todo bien Solo una cosa: "@" me perdí antes de la ruta del archivo JSON.

Encontré un documento de referencia relevante en Internet: https://gist.github.com/subfuzion/08c5d85437d5d4f00e58

Espero que pueda ayudar a unos pocos. Gracias

Aquí hay otra forma de hacerlo, si tiene datos dinámicos para incluir.

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

Estoy usando el siguiente formato para probar con un servidor web.

use -F 'json data'

Asumamos este formato de dictado JSON:

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

Ejemplo completo

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

Use la opción -d para agregar carga útil

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

En adición:

use -X POST para usar el método POST

use -H 'Aceptar: aplicación / json' para agregar el encabezado del tipo de aceptación

use -H 'Content-Type: application / json' para agregar encabezado de tipo de contenido

Esto funcionó para mí en Windows10

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

Hice una herramienta llamada captador para esto. Puede enviar solicitudes y formatear fragmentos de curl:

He aquí un ejemplo:

Ejemplo de salida:

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"

Si configura el SWAGGER para su aplicación de arranque de primavera e invoca cualquier API desde su aplicación allí, también puede ver esa solicitud CURL.

Creo que esta es la forma fácil de generar solicitudes a través de CURL.

Para powershell he usado:

curl.exe -H "Content-Type: application/json" --data "@content.json" http://localhost:8080/appname/path

Donde content.json era el nombre del archivo json en mi local que contiene la solicitud, y curl.exe en lugar de solo curl no utilizar el alias para Invoke-WebRequest.

Basado en https://stackoverflow.com/a/57369772/2391795 respuesta, esto es lo que hice en GitHub Actions. Fue un poco complicado debido a la EOF etiqueta.

Mi objetivo era enviar una llamada HTTP una vez finalizada la implementación de Vercel (similar a un webhook).

Esperando esto ejemplo del mundo real podría ayudar a otras personas.

  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/checkout@v1 # 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/github-slug-action@v3.x # 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

Puede pasar la extensión del formato que desee al final de la URL. igual que http://localhost:8080/xx/xxx/xxxxjson

or

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

Nota: debe agregar las dependencias jackson y jaxb maven en su archivo pom.