ඉල්ලීම් ශරීරය සමඟ HTTP GET

මම අපගේ යෙදුම සඳහා නව RESTful වෙබ් සේවාවක් සංවර්ධනය කරමින් සිටිමි.

ඇතැම් ආයතන පිළිබඳ GET එකක් කරන විට, සේවාදායකයින්ට ආයතනයේ අන්තර්ගතය ඉල්ලා සිටිය හැකිය. ඔවුන්ට පරාමිති කිහිපයක් එකතු කිරීමට අවශ්‍ය නම් (නිදසුනක් ලෙස ලැයිස්තුවක් වර්ග කිරීම) ඔවුන්ට මෙම පරාමිතීන් විමසුම් දාමයට එක් කළ හැකිය.

විකල්පයක් ලෙස ඉල්ලීම් ශරීරයේ මෙම පරාමිතීන් නියම කිරීමට මිනිසුන්ට හැකි වේවා. HTTP / 1.1 මෙය පැහැදිලිවම තහනම් කර ඇති බවක් නොපෙනේ. මෙය ඔවුන්ට තවත් තොරතුරු නියම කිරීමට ඉඩ සලසයි, සංකීර්ණ XML ඉල්ලීම් නියම කිරීම පහසු කරයි.

මගේ ප්‍රශ්න:

• මෙය මුළුමනින්ම හොඳ අදහසක්ද?
• GET ඉල්ලීමක් තුළ ඉල්ලීම් සිරුරු භාවිතා කිරීමේදී HTTP සේවාදායකයින්ට ගැටළු තිබේද?

http://tools.ietf.org/html/rfc2616

GET ඉල්ලීමක් සහිත ශරීරයක් ඇතුළත් කිරීම ගැන රෝයි ෆීල්ඩින්ගේ ප්‍රකාශය .

ඔව්. වෙනත් වචන වලින් කිවහොත්, ඕනෑම HTTP ඉල්ලීම් පණිවිඩයකට පණිවිඩ ශරීරයක් අඩංගු වීමට ඉඩ දී ඇති අතර එමඟින් පණිවිඩ මනසේ තබාගෙන විග්‍රහ කළ යුතුය. කෙසේ වෙතත්, GET සඳහා සේවාදායක අර්ථ නිරූපණයන් සීමා කර ඇති අතර එමඟින් ශරීරයකට ඉල්ලීමට අර්ථකථන අර්ථයක් නොමැත. විග්‍රහ කිරීම පිළිබඳ අවශ්‍යතා ක්‍රම අර්ථ නිරූපණයන්හි අවශ්‍යතාවයන්ගෙන් වෙන් වේ.

ඉතින්, ඔව්, ඔබට GET සමඟ ශරීරයක් යැවිය හැකි අතර, එසේ කිරීම කිසි විටෙකත් ප්‍රයෝජනවත් නොවේ.

මෙය HTTP / 1.1 හි ස්ථර සැකැස්මේ කොටසකි, එය පිරිවිතර කොටස් කළ පසු නැවත පැහැදිලි වනු ඇත (වැඩ කරමින් පවතී).

.... රෝයි

ඔව්, ඔබට GET සමඟ ඉල්ලීම් ආයතනයක් යැවිය හැකි නමුත් එයට කිසිදු අර්ථයක් නොතිබිය යුතුය. ඔබ එය සේවාදායකයේ විග්‍රහ කිරීමෙන් සහ එහි අන්තර්ගතය මත පදනම්ව ඔබේ ප්‍රතිචාරය වෙනස් කිරීමෙන් අර්ථයක් ලබා දෙන්නේ නම්, ඔබ මෙම නිර්දේශය HTTP / 1.1 පිරිවිතර, 4.3 කොටසෙහි නොසලකා හරිනු ලැබේ :

[...] ඉල්ලීම ක්රමය අස්තිත්වයක්-ශරීරය සඳහා අර්ථ semantics ඇතුළත් නොවේ නම්, එසේ නම් එම පණිවිඩය-ශරීරය යුත්තේ ඉල්ලීම සම්බන්ධයෙන් කටයුතු කරන විට පවසනු ලැබේ.

සහ HTTP / 1.1 පිරිවිතරයේ 9.3 වගන්තියේ GET ක්‍රමය පිළිබඳ විස්තරය :

GET ක්‍රමය යනු ඉල්ලීම- URI විසින් හඳුනාගෙන ඇති ඕනෑම තොරතුරක් ([...]) ලබා ගැනීමයි.

එහි සඳහන් වන්නේ ඉල්ලීම්-ශරීරය GET ඉල්ලීමක ඇති සම්පත් හඳුනා ගැනීමේ කොටසක් නොවන බවයි, ඉල්ලීම URI පමණි.

යාවත්කාලීන කිරීම "HTTP / 1.1 පිරිවිතර" ලෙස සඳහන් RFC2616 දැන් යල්පැන ඇත. 2014 දී එය RFCs 7230-7237 මගින් ප්‍රතිස්ථාපනය විය. "ඉල්ලීම හැසිරවීමේදී පණිවිඩ-ශරීරය නොසලකා හැරිය යුතුය" යන උපුටා ගැනීම මකා දමා ඇත. එය දැන් "ඉල්ලීම් පණිවිඩ සැකසීම ක්‍රමවේදය අර්ථ නිරූපණයෙන් ස්වාධීන වේ, ක්‍රමවේදය පණිවුඩ ශරීරයක් සඳහා කිසිදු භාවිතයක් නිර්වචනය නොකළද" 2 වන උපුටා දැක්වීම "GET ක්‍රමය යන්නෙන් අදහස් කරන්නේ ඕනෑම තොරතුරක් ලබා ගැනීමයි ... ඉල්ලීම-යූආර්අයි විසින් හඳුනා ගනු ලැබේ" මකා දමන ලදි. - අදහස් දැක්වීමකින්

ඔබට එය කළ හැකි අතර, එය HTTP පිරිවිතරයෙන් නිශ්චිතවම බැහැර කර නොමැති හෙයින්, මම යෝජනා කරන්නේ එය එසේ කිරීමට මිනිසුන් බලාපොරොත්තු නොවන නිසා එය වළක්වා ගැනීමට ය. HTTP ඉල්ලීම් දාමයක බොහෝ අදියරයන් ඇති අතර ඒවා "බොහෝ දුරට" HTTP පිරිවිතරයට අනුකූල වන අතර, ඔබට සහතික වී ඇති එකම දෙය නම් ඒවා සම්ප්‍රදායිකව වෙබ් බ්‍රව්සර් විසින් භාවිතා කරනු ඇති බවයි. (මම විනිවිද පෙනෙන ප්‍රොක්සි, ඇක්සලරේටර්, ඒ / වී මෙවලම් කට්ටල ආදිය ගැන සිතමින් සිටිමි)

දළ වශයෙන් මූලධර්මය පිටුපස ඇති ආත්මය මෙයයි. දළ වශයෙන් “ඔබ පිළිගන්නා දෙය තුළ ලිබරල් වන්න, සහ ඔබ යවන දේ තුළ ගතානුගතික වන්න”, හොඳ හේතුවක් නොමැතිව පිරිවිතරයක සීමාවන් තල්ලු කිරීමට ඔබට අවශ්‍ය නැත.

කෙසේ වෙතත්, ඔබට හොඳ හේතුවක් තිබේ නම්, ඒ සඳහා යන්න.

හැඹිලියෙන් ප්‍රයෝජන ගැනීමට ඔබ කවදා හෝ උත්සාහ කළහොත් ඔබට ගැටලු ඇති වේ. පරාමිතීන් ප්‍රතිචාරයට බලපෑමක් ඇති කරන්නේ දැයි බැලීමට ප්‍රොක්සි GET ශරීරය දෙස බැලීමට යන්නේ නැත.

වත් restclient හෝ බෝපාල් කොන්සෝලය සහයෝගය නමුත් curl කරන්නේ.

මෙම HTTP පිරිවිතර 4.3 කොටසේ පවසයි

ඉල්ලීම් ක්‍රමයේ පිරිවිතරයන් (5.1.1 වගන්තිය) ඉල්ලීම් තුළ වස්තුවක්-ශරීරයක් යැවීමට ඉඩ නොදෙන්නේ නම් පණිවිඩ-ශරීරයක් ඉල්ලීමකට ඇතුළත් නොකළ යුතුය.

5.1.1 වගන්තිය විවිධ ක්‍රම සඳහා 9.x කොටස වෙත අපව හරවා යවයි. ඔවුන්ගෙන් කිසිවෙකු පණිවුඩ ශරීරයක් ඇතුළත් කිරීම පැහැදිලිවම තහනම් කරයි. කෙසේවෙතත්...

5.2 වගන්තියේ සඳහන් වේ

අන්තර්ජාල ඉල්ලීමකින් හඳුනාගත් නිශ්චිත සම්පත තීරණය වන්නේ ඉල්ලීම්-යූආර්අයි සහ සත්කාරක ශීර්ෂ ක්ෂේත්‍රය යන දෙකම පරීක්ෂා කිරීමෙනි.

සහ 9.3 වගන්තියේ සඳහන් වේ

GET ක්‍රමය යනු ඉල්ලීම-යූආර්අයි විසින් හඳුනාගත් ඕනෑම තොරතුරක් (වස්තුවක ස්වරූපයෙන්) ලබා ගැනීමයි.

GET ඉල්ලීමක් සැකසීමේදී, ඉල්ලීම්- URI සහ ධාරක ශීර්ෂ ක්ෂේත්‍රය හැර වෙනත් කිසිවක් පරීක්ෂා කිරීමට සේවාදායකයෙකුට අවශ්‍ය නොවන බව මෙයින් යෝජනා කරයි .

සාරාංශයක් ලෙස, HTTP පිරිවිතර මඟින් ඔබට GET සමඟ පණිවුඩයක් යැවීම වළක්වන්නේ නැත, නමුත් ප්‍රමාණවත් අපැහැදිලි බවක් ඇත, එය සියලු සේවාදායකයන්ගේ සහය නොදක්වන්නේ නම් එය මා පුදුමයට පත් නොකරනු ඇත.

ප්‍රත්‍යාස්ථ සෙවුම ශරීරයක් සමඟ GET ඉල්ලීම් පිළිගනී. මෙය වඩාත් කැමති ක්‍රමය බව පෙනේ: ප්‍රත්‍යාස්ථතා මාර්ගෝපදේශය

සමහර ග්‍රාහක පුස්තකාලවලට (රූබි ඩ්‍රයිවර් වැනි) අ cry න්න විධානය සංවර්ධන මාදිලියේ ස්ථානගත කිරීම සඳහා ලොග් කළ හැකි අතර එය මෙම වාක්‍ය ඛණ්ඩය පුළුල් ලෙස භාවිතා කරයි.

ඔබ සාක්ෂාත් කර ගැනීමට උත්සාහ කරන දෙය දීර් common කාලයක් තිස්සේ වඩාත් පොදු ක්‍රමවේදයකින් සිදු කර ඇති අතර GET සමඟ ගෙවීමක් භාවිතා කිරීම මත රඳා නොපවතින එකක්.

ඔබට සරලවම ඔබේ නිශ්චිත සෙවුම් මාධ්‍යය ගොඩනගා ගත හැකිය, නැතහොත් ඔබට වඩාත් RESTful වීමට අවශ්‍ය නම්, OpenSearch වැනි දෙයක් භාවිතා කරන්න, සහ සේවාදායකයා උපදෙස් දුන් URI වෙත ඉල්ලීම තැපැල් කරන්න, කියන්න / සොයන්න. එවිට සේවාදායකයාට සෙවුම් ප්‍රති result ල ජනනය කිරීමට හෝ අවසාන යූආර්අයි ගොඩනඟා 303 භාවිතා කර යළි හරවා යැවිය හැකිය.

සාම්ප්‍රදායික පීආර්ජී ක්‍රමය අනුගමනය කිරීමේ වාසිය මෙය වන අතර, හැඹිලි අතරමැදියන්ට ප්‍රති results ල හැඹිලිගත කිරීමට උපකාරී වේ.

ඒ අනුව, ASCII නොවන ඕනෑම දෙයක් සඳහා URIs කෙසේ හෝ කේතනය කර ඇති අතර යෙදුම / x-www-form-urlencoded සහ බහුපාර්ට් / පෝරම-දත්ත ද වේ. ඔබේ අභිප්‍රාය ReSTful අවස්ථාවන්ට සහය දැක්වීම නම් තවත් අභිරුචි json ආකෘතියක් නිර්මාණය කරනවාට වඩා මෙය භාවිතා කිරීමට මම නිර්දේශ කරමි.

ඔබට ශරීරයක් සමඟ GET එකක් යැවිය හැකිය, නැතහොත් POST යවා නැවත ආගම්වාදය අත්හරින්න (එය එතරම් නරක නැත, මීට වසර 5 කට පෙර එම ඇදහිල්ලේ එක් සාමාජිකයෙකු පමණක් සිටියේය - ඔහුගේ අදහස් ඉහත සම්බන්ධ කර ඇත).

මේ දෙකම හොඳ තීරණ නොවේ, නමුත් GET ශරීරයක් යැවීම සමහර සේවාදායකයින්ට සහ සමහර සේවාදායකයින්ට ගැටළු වළක්වා ගත හැකිය.

POST කිරීම සමහර RESTish රාමු සමඟ බාධක ඇති විය හැකිය.

ජූලියන් රෙස්ච්කේ ඉහත යෝජනා කළේ “සෙර්ච්” වැනි සම්මත නොවන එච්ටීටීපී ශීර්ෂයක් භාවිතා කිරීම සඳහා අලංකාර විසඳුමක් විය හැකි අතර එය සහාය වීමට ඇති ඉඩකඩ අඩුය.

ඉහත එක් එක් කළ හැකි හා කළ නොහැකි සේවාදායකයින් ලැයිස්තුගත කිරීම වඩාත් tive ලදායී විය හැකිය.

ශරීරය සමඟ GET යැවිය නොහැකි සේවාදායකයින් (මා දන්නා):

• XmlHTTPRequest Fiddler

ශරීරය සමඟ GET යැවිය හැකි සේවාදායකයින්:

• බොහෝ බ්‍රව්සර්

GET වෙතින් ශරීරයක් ලබා ගත හැකි සේවාදායක සහ පුස්තකාල:

• අපාචි
• PHP

GET වෙතින් ශරීරයක් ඉවත් කරන සේවාදායකයන් (සහ ප්‍රොක්සි):

• ?

කුමන සේවාදායකයා එය නොසලකා හරිනු ඇත්ද? - fijiaaron අගෝස්තු 30 '12 at 21:27

උදාහරණයක් ලෙස ගූගල් එය නොසලකා හැරීමට වඩා නරක දෙයක් කරයි, එය දෝෂයක් ලෙස සලකනු ඇත !

සරල නෙට් කැට් එකකින් එය ඔබම උත්සාහ කරන්න:

$ netcat www.google.com 80
GET / HTTP/1.1
Host: www.google.com
Content-length: 6

1234

(1234 අන්තර්ගතය CR-LF අනුගමනය කරයි, එබැවින් එය බයිට් 6 කි)

එවිට ඔබට ලැබෙනු ඇත:

HTTP/1.1 400 Bad Request
Server: GFE/2.0
(....)
Error 400 (Bad Request)
400. That’s an error.
Your client has issued a malformed or illegal request. That’s all we know.

AkamaiGhost විසින් සපයනු ලබන Bing, Apple, ආදියෙන් ඔබට නරක ඉල්ලීම් 400 ක් ලැබෙනු ඇත.

එබැවින් ශරීර ආයතනයක් සමඟ GET ඉල්ලීම් භාවිතා කිරීමට මම උපදෙස් නොදෙමි.

මම මෙම ප්‍රශ්නය IETF HTTP WG වෙත යොමු කළෙමි. රෝයි ෆීල්ඩින් (1998 දී http / 1.1 ලේඛනයේ කතුවරයා) ගේ අදහස එයයි

"... ලැබුනහොත් එම සිරුර විග්‍රහ කිරීම සහ ඉවත දැමීම හැර වෙනත් දෙයක් කිරීමට ක්‍රියාත්මක කිරීමක් කැඩී යනු ඇත"

RFC 7213 (HTTPbis) මෙසේ පවසයි:

"GET ඉල්ලීම් පණිවිඩයක් තුළ ගෙවීම් සඳහා අර්ථකථන අර්ථකථන නොමැත;"

GET ඉල්ලීම් සිරුරු පිළිබඳ අර්ථකථන අර්ථය තහනම් කර ඇති බව දැන් පැහැදිලිව පෙනේ, එයින් අදහස් කරන්නේ ප්‍රති request ලයට බලපෑම් කිරීමට ඉල්ලීම් ශරීරය භාවිතා කළ නොහැකි බවයි.

ඔබ GET හි ශරීරයක් ඇතුළත් කළහොත් ඔබගේ ඉල්ලීම විවිධ ආකාරවලින් අනිවාර්යයෙන්ම බිඳ දැමිය හැකි ප්‍රොක්සි තිබේ .

එබැවින් සාරාංශයක් ලෙස, එය නොකරන්න.

සිට RFC 2616, කොටස 4.3 , "පණිවිඩ":

සේවාදායකයෙක් ඕනෑම ඉල්ලීමක් මත පණිවිඩයක් කියවා ඉදිරියට යැවිය යුතුය; ඉල්ලීම් ක්‍රමයට වස්තු-ශරීරයක් සඳහා අර්ථ දක්වා ඇති අර්ථකථන ඇතුළත් නොවේ නම්, ඉල්ලීම හැසිරවීමේදී පණිවිඩ-ශරීරය නොසලකා හැරිය යුතුය.

එනම්, සේවාදායකයින් සෑම විටම ජාලයෙන් ලබා දී ඇති ඕනෑම ඉල්ලීම් ආයතනයක් කියවිය යුතුය (අන්තර්ගතයේ දිග පරීක්ෂා කරන්න හෝ කැඩුණු සිරුරක් කියවන්න). එසේම, ප්‍රොක්සි විසින් තමන්ට ලැබෙන එවැනි ඉල්ලීම් ආයතනයක් ඉදිරිපත් කළ යුතුය. දී ඇති ක්‍රමය සඳහා ශරීරය සඳහා අර්ථ නිරූපණය RFC විසින් අර්ථ දක්වන්නේ නම්, ප්‍රතිචාරයක් ජනනය කිරීමේදී සේවාදායකයාට ඉල්ලීම් ශරීරය භාවිතා කළ හැකිය. කෙසේ වෙතත්, නේවාසික විදේශ ව්යවහාර මුදල් නම් නැත ශරීරය සඳහා semantics නිර්වචනය, එසේ නම් සේවාදායකය එය නොසලකා යුතුය.

මෙය ඉහත ෆීල්ඩින් වෙතින් උපුටා දැක්වීමට අනුකූල වේ.

9.3 , “GET”, GET ක්‍රමයේ අර්ථ නිරූපණයන් විස්තර කරන අතර ඉල්ලීම් ආයතන සඳහන් නොකරයි. එබැවින්, GET ඉල්ලීමක් මත සේවාදායකයාට ලැබෙන ඕනෑම ඉල්ලීම් ආයතනයක් නොසලකා හැරිය යුතුය.

ඔබට සැබවින්ම කැචබල් කළ හැකි JSON / XML බොඩි වෙබ් යෙදුමට යැවීමට අවශ්‍ය නම් ඔබේ දත්ත තැබිය හැකි එකම ස්ථානය RFC4648 සමඟ කේතනය කර ඇති විමසුම් දාමයකි: Base 64 URL සමඟ කේතීකරණය සහ ගොනු නාමය ආරක්ෂිත හෝඩිය . ඇත්ත වශයෙන්ම ඔබට JSON යූරෙන්කෝඩ් කර URL පරාමිතික අගයට දැමිය හැකිය, නමුත් Base64 කුඩා ප්‍රති .ල ලබා දෙයි. URL ප්‍රමාණයේ සීමාවන් ඇති බව මතක තබා ගන්න, බලන්න විවිධ බ්‍රව්සර්වල URL එකක උපරිම දිග කුමක්ද? .

=URL හි පරමාදර්ශී අගයට Base64 හි පෑඩින්ග් චරිතය නරක යැයි ඔබ සිතනු ඇත , කෙසේ වෙතත් එය නොපෙනේ - මෙම සාකච්ඡාව බලන්න: http://mail.python.org/pipermail/python-bugs-list/2007- පෙබරවාරි / 037195.html . කෙසේ වෙතත්, ඔබ පරාමිතික නාමයකින් තොරව කේතනය කළ දත්ත නොතැබිය යුතුය. මම ඒ වගේ දෙයක් පාවිච්චි කරනවා ?_b64=<encodeddata>.

XMLHttpRequest ට අනුව එය වලංගු නොවේ. සිට සම්මත :

4.5.6 send()ක්රමය

client . send([body = null])

ඉල්ලීම ආරම්භ කරයි. විකල්ප තර්කය මඟින් ඉල්ලීම් ආයතනය සපයයි. ඉල්ලීමේ ක්‍රමය GETහෝ නම් තර්කය නොසලකා හරිනු ලැබේ HEAD.

InvalidStateErrorඑක්කෝ රාජ්‍යය විවෘත කර නොමැති නම් හෝ send()ධජය සකසා ඇත්නම් ව්‍යතිරේකය විසි කරයි .

මෙම ක්රමය මෙම පියවර ක්රියාත්මක විය යුතුය:send(body)

1. රාජ්යය විවෘත කර නොමැති නම් , InvalidStateErrorව්යතිරේකයක් විසි කරන්න .
2. send()ධජය සකසා ඇත්නම් , InvalidStateErrorව්‍යතිරේකයක් විසි කරන්න .
3. ඉල්ලීමේ ක්‍රමය GETහෝ නම් HEAD, ශරීරය ශුන්‍ය ලෙස සකසන්න .
4. නම් ශරීරය ශූන්ය වේ, ඊළඟ පියවර වෙත යන්න.

කෙසේ වෙතත්, GET ඉල්ලීමට විශාල ශරීර අන්තර්ගතයක් අවශ්‍ය විය හැකි යැයි මම නොසිතමි.

එබැවින්, ඔබ බ්‍රව්සරයක XMLHttpRequest මත විශ්වාසය තබන්නේ නම්, එය ක්‍රියා නොකරනු ඇත.

මම මෙය අවවාද නොකරමි, එය සම්මත භාවිතයන්ට පටහැනි වන අතර, එතරම් ප්‍රතිලාභයක් ලබා නොදේ. ඔබට අවශ්‍ය වන්නේ ශරීරය අන්තර්ගතය සඳහා තබා ගැනීම මිස විකල්පයන් නොවේ.

පදනම් නොවන 64 කේතනය කළ ශීර්ෂයන් ගැන කුමක් කිව හැකිද? "SOMETHINGAPP-PARAMS: sdfSD45fdg45 / aS"

දිග සීමාවන් hm. ඔබගේ POST හැසිරවීම අර්ථයන් අතර වෙනස හඳුනා ගැනීමට ඔබට නොහැකිද? වර්ග කිරීම වැනි සරල පරාමිතීන් ඔබට අවශ්‍ය නම්, මෙය ගැටළුවක් වන්නේ මන්දැයි මම නොදනිමි. මම හිතන්නේ ඔබ කනස්සල්ලට පත්ව සිටින බව සහතිකයි.

ප්‍රොටෝකෝලය ලෙස REST OOP සඳහා සහය නොදක්වන බව මට කණගාටුයි Get ක්‍රමවේදය සනාථ කිරීම . විසඳුමක් ලෙස, ඔබට ඔබේ ඩීටීඕ එකක් JSON වෙත අනුක්‍රමික කර විමසුම් නූලක් සෑදිය හැකිය. සේවාදායක පැත්තෙන් ඔබට විමසුම් දාමය ඩීටීඕ වෙත යොමු කළ හැකිය.

බලන්න:

• සර්විස්ටැක් හි පණිවිඩ පදනම් කරගත් සැලසුම
• WCF සමඟ RESTful පණිවිඩ පදනම් කරගත් වෙබ් සේවා ගොඩනැගීම

Get method limit විසඳීමට පණිවුඩ පදනම් කරගත් ප්‍රවේශය ඔබට උපකාරී වේ. ඉල්ලීම් ආයතනය මෙන් ඔබට ඕනෑම ඩීටීඕ එකක් යැවිය හැකිය

නෙලිබර් වෙබ් සේවා රාමුව මඟින් ඔබට භාවිතා කළ හැකි ක්‍රියාකාරිත්වය සපයයි

var client = new JsonServiceClient(Settings.Default.ServiceAddress);
var request = new GetClientRequest
    {
        Id = new Guid("2217239b0e-b35b-4d32-95c7-5db43e2bd573")
    };
var response = client.Get<GetClientRequest, ClientResponse>(request);

as you can see, the GetClientRequest was encoded to the following query string

http://localhost/clients/GetWithResponse?type=GetClientRequest&data=%7B%22Id%22:%2217239b0e-b35b-4d32-95c7-5db43e2bd573%22%7D

උදාහරණයක් ලෙස, එය Curl, Apache සහ PHP සමඟ ක්‍රියා කරයි.

PHP ගොනුව:

<?php
echo $_SERVER['REQUEST_METHOD'] . PHP_EOL;
echo file_get_contents('php://input') . PHP_EOL;

කොන්සෝල විධානය:

$ curl -X GET -H "Content-Type: application/json" -d '{"the": "body"}' 'http://localhost/test/get.php'

ප්‍රතිදානය:

GET
{"the": "body"}

IMHO ඔබට JSONසංකේතාත්මක (එනම්. encodeURIComponent) යවනු ලැබිය හැකිය URL, මේ ආකාරයෙන් ඔබ HTTPපිරිවිතර උල්ලං do නය නොකර ඔබේ JSONසේවාදායකයට ලබා ගත හැකිය .

GET සමඟ ඉල්ලීම් ආයතනයක් භාවිතා කිරීමට වඩා හොඳ විකල්ප ලැයිස්තුවක් ඔබ සතුව ඇත.

එක් එක් කාණ්ඩය සඳහා ඔබට කාණ්ඩ සහ අයිතම ඇති බව උපකල්පනය කරමු. දෙකම හැඳුනුම්පතකින් හඳුනාගත යුතුය (මෙම උදාහරණය සඳහා "catid" / "itemid"). නිශ්චිත "අනුපිළිවෙලකට" "sortby" යන තවත් පරාමිතියකට අනුව වර්ග කිරීමට ඔබට අවශ්‍යය. ඔබට "sortby" සහ "order" සඳහා පරාමිතීන් සම්මත කිරීමට අවශ්‍යය:

ඔයාට පුළුවන්:

1. විමසුම් නූල් භාවිතා කරන්න, උදා example.com/category/{catid}/item/{itemid}?sortby=itemname&order=asc
2. මාර්ග සඳහා mod_rewrite (හෝ ඊට සමාන) භාවිතා කරන්න: example.com/category/{catid}/item/{itemid}/{sortby}/{order}
3. ඉල්ලීම සමඟ ඔබ සමත් තනි HTTP ශීර්ෂ භාවිතා කරන්න
4. සම්පතක් ලබා ගැනීමට වෙනත් ක්‍රමයක් භාවිතා කරන්න, උදා: POST.

සියල්ලටම ඒවායේ අවාසි ඇත, නමුත් ශරීරයක් සමඟ GET භාවිතා කිරීමට වඩා හොඳය.

ජනප්‍රිය මෙවලමක් මෙය භාවිතා කළත්, මෙම පිටුවේ නිතර සඳහන් කර ඇති පරිදි, පිරිවිතරයෙන් තහනම් කර නොතිබුණද, එය තවමත් විදේශීය වීම තරමක් නරක අදහසක් යැයි මම සිතමි.

බොහෝ අතරමැදි යටිතල ව්‍යුහයන් එවැනි ඉල්ලීම් ප්‍රතික්ෂේප කළ හැකිය.

උදාහරණයක් වන විට, මේ වගේ, ඔබේ වෙබ් අඩවිය ඉදිරිපිට තිබෙන පස්වරුවේදී පහරදී තිබේ සමහර භාවිතා කරන ආකාරය පිළිබඳව අමතක එක් :

නරඹන්නාගේ GETඉල්ලීමට ශරීරයක් ඇතුළත් නම්, CloudFront විසින් HTTP තත්ව කේතය 403 (තහනම්) නරඹන්නාට ලබා දෙයි.

ඔව්, මෙම අදහස් දැක්වීමේදී වාර්තා කර ඇති පරිදි ඔබේ සේවාදායක පුස්තකාල එවැනි ඉල්ලීම් විමෝචනය කිරීමට සහාය නොදක්වයි .

මම මගේ සේවාදායක වැඩසටහනේ වසන්ත රාමුවේ රෙස්ට් ටෙම්ප්ලේට් භාවිතා කරන අතර, සේවාදායක පැත්තෙන්, මම ජේසන් බොඩි සමඟ GET ඉල්ලීමක් අර්ථ දැක්වුවෙමි. මගේ මූලික පරමාර්ථය ඔබේ අරමුණු වලට සමාන ය: ඉල්ලීමට පරාමිතීන් රාශියක් ඇති විට, ඒවා ශරීරයේ තැබීම දිගු URI නූලට දැමීමට වඩා පිළිවෙලට පෙනේ. ඔව්?

නමුත්, කනගාටුවට කරුණක් නම්, එය ක්‍රියාත්මක නොවීමයි! සේවාදායක පාර්ශවය පහත සඳහන් ව්‍යතිරේකය විසි කළේය:

org.springframework.http.converter.HttpMessageNotReadableException: අවශ්‍ය ඉල්ලීම් ශරීරය අස්ථානගත වී ඇත ...

නමුත් මට විශ්වාසයි පණිවුඩ ශරීරය මගේ සේවාදායක කේතය මගින් නිවැරදිව ලබා දී ඇති බව, එබැවින් වැරැද්ද කුමක්ද?

මම RestTemplate.exchange () ක්‍රමයට පිවිස පහත සඳහන් දේ සොයා ගතිමි.

// SimpleClientHttpRequestFactory.class
public class SimpleClientHttpRequestFactory implements ClientHttpRequestFactory, AsyncClientHttpRequestFactory {
    ...
    protected void prepareConnection(HttpURLConnection connection, String httpMethod) throws IOException {
        ...
        if (!"POST".equals(httpMethod) && !"PUT".equals(httpMethod) && !"PATCH".equals(httpMethod) && !"DELETE".equals(httpMethod)) {
            connection.setDoOutput(false);
        } else {
            connection.setDoOutput(true);
        }
        ...
    }
}

// SimpleBufferingClientHttpRequest.class
final class SimpleBufferingClientHttpRequest extends AbstractBufferingClientHttpRequest {
    ...
    protected ClientHttpResponse executeInternal(HttpHeaders headers, byte[] bufferedOutput) throws IOException {
        ...
        if (this.connection.getDoOutput() && this.outputStreaming) {
            this.connection.setFixedLengthStreamingMode(bufferedOutput.length);
        }

        this.connection.connect();
        if (this.connection.getDoOutput()) {
            FileCopyUtils.copy(bufferedOutput, this.connection.getOutputStream());
        } else {
            this.connection.getResponseCode();
        }
        ...
    }
}

ExecuteInternal () ක්‍රමයේදී ආදාන තර්කය 'bufferedOutput' හි මගේ කේතය මඟින් සපයන ලද පණිවිඩ ශරීරය අඩංගු බව කරුණාවෙන් සලකන්න. මම එය නිදොස්කරණය හරහා දුටුවෙමි.

කෙසේ වෙතත්, සූදානම් වීමේ සම්බන්ධතාවය () හේතුවෙන්, ක්‍රියාත්මක කිරීමේ ඉන්ටර්නල් () හි getDoOutput () සෑම විටම අසත්‍යයක් ලබා දෙන අතර එමඟින් ස්වාරක්ෂක ප්‍රතිදානය සම්පූර්ණයෙන්ම නොසලකා හරිනු ඇත! එය ප්‍රතිදාන ප්‍රවාහයට පිටපත් නොවේ.

එහි ප්‍රති, ලයක් වශයෙන්, මගේ සේවාදායක වැඩසටහනට පණිවිඩ පණිවිඩයක් නොලැබුණු අතර එම ව්‍යතිරේකය විසි කළේය.

මෙය වසන්ත රාමුවේ RestTemplate පිළිබඳ උදාහරණයකි. කාරණය වන්නේ, පණිවුඩ ආයතනය තවදුරටත් HTTP පිරිවිතරයෙන් තහනම් කර නොතිබුණද, සමහර සේවාදායකයින් හෝ සේවාදායක පුස්තකාල හෝ රාමු තවමත් පැරණි පිරිවිතරයන්ට අනුකූල විය හැකි අතර GET ඉල්ලීමෙන් පණිවිඩ ශරීරය ප්‍රතික්ෂේප කළ හැකිය.