මම JSON දත්ත CURL සමඟ තැපැල් කරන්නේ කෙසේද?

මම උබුන්ටු භාවිතා කර එය මත කර්ල් ස්ථාපනය කර ඇත්තෙමි . මගේ වසන්ත REST යෙදුම CURL සමඟ පරීක්ෂා කිරීමට මට අවශ්‍යය. මම මගේ POST කේතය ජාවා පැත්තේ ලිව්වා. කෙසේ වෙතත්, මට එය CURL සමඟ පරීක්ෂා කිරීමට අවශ්‍යයි. මම JSON දත්ත පළ කිරීමට උත්සාහ කරමි. උදාහරණ දත්ත මේ වගේ ය:

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

මම මෙම විධානය භාවිතා කරමි:

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

එය මෙම දෝෂය නැවත ලබා දෙයි:

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

දෝෂ විස්තරය මෙයයි:

ඉල්ලුම් කරන ලද ක්‍රමය () සඳහා ඉල්ලුම් කරන ලද සම්පත සහාය නොදක්වන ආකෘතියක ඇති බැවින් සේවාදායකයා මෙම ඉල්ලීම ප්‍රතික්ෂේප කළේය.

ටොම්කාට් ලොග්: "POST / ui / webapp / conf / clear HTTP / 1.1" 415 1051

CURL විධානයෙහි නිවැරදි ආකෘතිය කුමක්ද?

මෙය මගේ ජාවා පැති PUTකේතයයි (මම GET සහ DELETE පරීක්ෂා කර ඇති අතර ඒවා ක්‍රියාත්මක වේ):

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

ඔබගේ අන්තර්ගත වර්ගය යෙදුම / json ලෙස සැකසිය යුතුය. නමුත් වසන්තයේ පැත්තෙන් නොපිළිගන්නා -dඅන්තර්ගත වර්ගය යවයි application/x-www-form-urlencoded.

Curl man පිටුව දෙස බලන විට , ඔබට භාවිතා කළ හැකි යැයි මම සිතමි -H:

-H "Content-Type: application/json"

සම්පූර්ණ උදාහරණය:

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

( -Hසඳහා කෙටි වේ --header, -dසඳහා --data)

ධජය POST ඉල්ලීමක් ඇඟවුම් කරන පරිදි, ඔබ භාවිතා කරන්නේ නම් -request POSTඑය අත්‍යවශ්‍ය නොවන බව සලකන්න .-d-d

වින්ඩෝස් වල, දේවල් තරමක් වෙනස් ය. අදහස් දැක්වීමේ ත්‍රෙඩ් එක බලන්න.

ඔබගේ දත්ත ගොනුවකට දැමීමට උත්සාහ කරන්න, කියන්න body.jsonසහ භාවිතා කරන්න

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

ඔබට විවේක ගැනීම ප්‍රයෝජනවත් විය හැකිය: https://github.com/micha/resty

එය විධාන රේඛා REST ඉල්ලීම් සරල කරන වටකුරු වටය. ඔබ එය ඔබගේ API අන්ත ලක්ෂ්‍යයට යොමු කරන අතර එය ඔබට PUT සහ POST විධානයන් ලබා දෙයි. (මුල් පිටුවෙන් අනුවර්තනය කරන ලද උදාහරණ)

$ 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

එසේම, බොහෝ විට අන්තර්ගතයේ ශීර්ෂ එකතු කිරීම අවශ්‍ය වේ. පෙරනිමියෙන් සැකසීමට ඔබට එක් වරක් එක් ක්‍රමයකට වින්‍යාස ගොනු එක් කිරීම කළ හැකිය: පෙරනිමි RESTY විකල්ප සැකසීම

වින්ඩෝස් සඳහා, -dවටිනාකම සඳහා තනි උපුටා දැක්වීමක් තිබීම මට ප්‍රයෝජනවත් නොවීය, නමුත් එය ද්විත්ව මිල ගණන් වලට වෙනස් කිරීමෙන් පසුව ක්‍රියාත්මක විය. කැරලි වරහන් තුළ ද්විත්ව උපුටා දැක්වීම් වලින් ගැලවීමට මට අවශ්‍ය විය.

එනම්, පහත සඳහන් දෑ ක්‍රියාත්මක නොවීය:

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

නමුත් පහත සඳහන් කරුණු ක්‍රියාත්මක විය:

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

එය මට භාවිතා කළේ:

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

එය සතුටින් වසන්ත පාලකය වෙත සිතියම් ගත කරන ලදී:

@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හැඳුනුම්පත් දේපලක් සහිත සරල POJO වේ.

උදාහරණයක් ලෙස, JSON ගොනුවක්, params.json නිර්මාණය කර මෙම අන්තර්ගතය එයට එක් කරන්න:

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

එවිට ඔබ මෙම විධානය ක්‍රියාත්මක කරයි:

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

මම එකම ගැටලුවකට දුවමි. මට එය විසඳා ගත හැකිය

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

මෙය මට හොඳින් ක්‍රියාත්මක විය.

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

කොහෙද,

-X Http ක්‍රියා පදය අදහස් කරයි.

--data ඔබට යැවීමට අවශ්‍ය දත්ත අදහස් කරයි.

ඔබේ විධානය එකලස් කිරීම සඳහා ඔබට තැපැල්කරුට එහි බුද්ධිමත් GUI සමඟ භාවිතා කළ හැකිය cURL.

1. ස්ථාපනය කර ආරම්භ කරන්න තැපැල්කරු
2. ඔබගේ URL, තැපැල් ශරීරය, ඉල්ලීම් ශීර්ෂ යනාදිය ටයිප් කරන්න.
3. මත ක්ලික් කරන්න Code
4. තෝරන්න cURL පහළ ලැයිස්තුවෙන්
5. ඔබේ cURLවිධානය පිටපත් කර අලවන්න

සටහන: පතන ලැයිස්තුවේ ස්වයංක්‍රීය ඉල්ලීම් උත්පාදනය සඳහා විකල්ප කිහිපයක් තිබේ, ඒ නිසා මගේ තනතුර මුලින් අවශ්‍ය නොවන බව මම සිතුවෙමි.

CURL වින්ඩෝස් භාවිතා කරමින්, මෙය උත්සාහ කරන්න:

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

CURL වෙත පරිවර්තනය කිරීම සඳහා ඔබට තැපැල්කරු භාවිතා කළ හැකිය

HTTPie යනු curlඔබට කළ හැකි දේ සඳහා නිර්දේශිත විකල්පයකි

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

එය පෙරනිමියෙන් JSON කථා කරන අතර ඔබට අවශ්‍ය ශීර්ෂකය සැකසීම මෙන්ම වලංගු JSON ලෙස දත්ත කේතනය කිරීම යන දෙකම පාලනය කරයි. එසේම ඇත:

Some-Header:value

ශීර්ෂ සඳහා, සහ

name==value

විමසුම් නූල් පරාමිතීන් සඳහා. ඔබ සතුව විශාල දත්ත ප්‍රමාණයක් තිබේ නම්, එය JSON කේතනය කර ඇති ගොනුවකින්ද කියවිය හැකිය:

 field=@file.txt

RESTful අතුරුමුහුණතකට එරෙහිව ඔබ බොහෝ JSON යැවීම් / ප්‍රතිචාර පරීක්ෂා කරන්නේ නම්, ඔබට ක්‍රෝම් සඳහා තැපැල්කරු ප්ලග් ඉන් (වෙබ් සේවා පරීක්ෂණ අතින් නිර්වචනය කිරීමට ඉඩ සලසයි) සහ එහි Node.js මත පදනම් වූ නිව්මන් විධානය පරීක්ෂා කිරීමට අවශ්‍ය විය හැකිය. -ලයින් සහකාරිය (තැපැල්කරු පරීක්ෂණවල "එකතු කිරීම්" වලට එරෙහිව පරීක්ෂණ ස්වයංක්‍රීය කිරීමට ඔබට ඉඩ සලසයි.) නොමිලේ සහ විවෘතව!

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

ඇත්ත වශයෙන්ම, ඔබ කිසි විටෙකත් SSL සහ පරීක්ෂා කළ සහතිකයක් නොමැතිව BASIC සත්‍යාපනය භාවිතා නොකළ යුතුය.

වින්ඩෝස් සඳහා සිග්වින්ගේ CURL 7.49.1 භාවිතා කරමින් මම අද නැවතත් මෙය වෙතට දිව ගියෙමි ... තවද JSON තර්කයක් භාවිතා කරන විට --dataහෝ භාවිතා කරන විට, CURL --data-binaryව්‍යාකූල වී {}ඇති අතර JSON හි ඇති URL අච්චුවක් ලෙස අර්ථ නිරූපණය කරනු ඇත. එකතු කිරීම a-gCURL globbing අක්‍රිය තර්කයක් නිවැරදි විය.

කරකැවීම සඳහා වරහන් සහිත URL එකක් යැවීමද බලන්න .

ඔබට ඔබේ JSON අන්තර්ගතය ගොනුවකට දමා --file-uploadසම්මත ආදානය හරහා විකල්පය භාවිතා කරමින් එය කරකැවිය හැක.

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

මෙය මට ප්‍රයෝජනවත් විය:

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

වෙබ් සේවාදායකයක් සමඟ පරීක්ෂා කිරීම සඳහා මම පහත ආකෘතිය භාවිතා කරමි.

use -F 'json data'

මෙම JSON dict ආකෘතිය උපකල්පනය කරමු:

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

සම්පූර්ණ උදාහරණය

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

ගෙවීම් එකතු කිරීමට -d විකල්පය භාවිතා කරන්න

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

අතිරෙකව:

POST ක්‍රමය භාවිතා කිරීමට -X POST භාවිතා කරන්න

පිළිගැනීමේ වර්ගයේ ශීර්ෂකය එක් කිරීමට -H 'පිළිගන්න: යෙදුම / json' භාවිතා කරන්න

අන්තර්ගත ආකාරයේ ශීර්ෂයක් එක් කිරීමට -H 'අන්තර්ගත වර්ගය: යෙදුම / ජේසන්' භාවිතා කරන්න

කරුණාකර මෙම මෙවලම පරීක්ෂා කරන්න . එය පහසුවෙන් කරකැවෙන ස්නිපෙට් නිර්මාණය කිරීමට උපකාරී වේ.

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"

ඔබට ගතික දත්ත ඇතුළත් කිරීමට තිබේ නම් එය කිරීමට තවත් ක්‍රමයක් මෙන්න.

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

මෙය වින්ඩෝස් 10 හි මා වෙනුවෙන් වැඩ කළේය

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

මම දනිමි, මෙම ප්‍රශ්නයට බොහෝ පිළිතුරු ලැබී ඇති නමුත් මට මෙම ගැටලුව ඇති තැන බෙදා ගැනීමට අවශ්‍ය විය:

curl -X POST http: // your-server-end-point -H "අන්තර්ගත වර්ගය: යෙදුම / json" -d @ path-of-your-json-file.json

බලන්න, මම සෑම දෙයක්ම නිවැරදිව කළා, එක දෙයක් පමණයි - "@" මට JSON ගොනු මාර්ගයට පෙර මග හැරුණි.

අන්තර්ජාලයට අදාළ එක් ලේඛනයක් මට හමු විය - https://gist.github.com/subfuzion/08c5d85437d5d4f00e58

එය ස්වල්ප දෙනෙකුට උපකාර කරනු ඇතැයි සිතමි. ස්තූතියි

ඔබ ඔබේ වසන්ත ඇරඹුම් යෙදුමට SWAGGER වින්‍යාස කර, සහ ඔබගේ යෙදුමෙන් ඕනෑම API එකක් ඉල්ලුවහොත් ඔබට එම CURL ඉල්ලීමද දැකිය හැකිය.

මම හිතන්නේ මෙය CURL හරහා ඉල්ලීම් ජනනය කිරීමේ පහසුම ක්‍රමයයි.

ඔබට අවශ්‍ය ආකෘතියේ දිගුව යූආර්එල් හි අවසානය ලෙස සම්මත කළ හැකිය. වැනි : // localhost: 8080 / xx යන්න / xxx යන්න / xxxx http .json

හෝ

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

සටහන: ඔබ ඔබේ පොම් තුළ ජැක්සන් සහ ජැක්ස් මේවන් පරායත්තයන් එකතු කළ යුතුය.