दिलचस्प पोस्ट
जावा: sun.security.provider.certpath.SunCertPathBuilderException: अनुरोधित लक्ष्य के लिए वैध प्रमाणीकरण पथ खोजने में असमर्थ एंड्रॉइड स्टूडियो के साथ आप गिटहब के लिए परियोजनाओं को कैसे सिंक्रनाइज़ करते हैं? लूप करते समय आप कैसे विभिन्न वैरिएबल नाम बनाते हैं? (अजगर) एक आदिम फ्लोट मान -0.0 कैसे हो सकता है? इसका क्या मतलब है? मैं पायथन से अतुल्यकालिक रूप से एक बाहरी कमांड कैसे चला सकता हूं? सी ++ में make_shared और सामान्य shared_ptr में अंतर VB.NET या C # में itextsharp डीएलएल के साथ पीडीएफ सामग्री पढ़ना बाएं संरेखण के रूप में UIButton का शीर्षक कैसे सेट करें? LINQ: फ़िल्टरिंग मापदंड के साथ एकल ऑर डिफॉल्ट बनाम फर्स्टऑरफॉल्ट () का उपयोग कब किया जाए आपकी इकाई परीक्षण कितनी गहरी हैं? हायफनेटेड नाम के साथ मैं इस ऑब्जेक्ट प्रॉपर्टी का उपयोग कैसे करूं? एएसपी.नेट एमवीसी आंशिक दृश्य: इनपुट नाम उपसर्ग ईआर आरेखों में सुपर- और उपप्रकार के संबंध तालिकाओं के रूप में कैसे प्रदर्शित होते हैं? UIView पर कस्टम राउंडिंग कोने सी प्रीप्रोसेसर से एक संदेश को प्रिंट करने का एक पोर्टेबल तरीका है?

REST में बनाम पोस्ट करें

HTTP / 1.1 युक्ति के अनुसार:

अनुरोध विधि अनुरोध अनुरोध Request-URI द्वारा पहचान की गई संसाधन के एक नए अधीनस्थ के रूप में अनुरोध में संलग्न इकाई को स्वीकार करने वाली इकाई को स्वीकार करने के लिए उपयोग किया जाता है

दूसरे शब्दों में, POST बनाने के लिए उपयोग किया जाता है

PUT विधि अनुरोध है कि संलग्न इकाई को आपूर्ति Request-URI तहत संग्रहीत किया जाएगा। यदि Request-URI पहले से मौजूद संसाधन को संदर्भित करता है, तो संलग्न इकाई को मूल सर्वर पर रहने वाले किसी के संशोधित संस्करण के रूप में माना जाना चाहिए। यदि Request-URI किसी मौजूदा संसाधन को इंगित नहीं करता है, और यह यूआरआई अनुरोधकर्ता उपयोगकर्ता एजेंट द्वारा नए संसाधन के रूप में परिभाषित होने में सक्षम है, तो मूल सर्वर उस यूआरआई के साथ संसाधन बना सकता है। "

यही है, PUT को बनाने या अपडेट करने के लिए उपयोग किया जाता है

तो, जो एक संसाधन बनाने के लिए इस्तेमाल किया जाना चाहिए? या दोनों को समर्थन करने की आवश्यकता है?

वेब के समाधान से एकत्रित समाधान "REST में बनाम पोस्ट करें"

कुल मिलाकर:

PUT और POST दोनों का निर्माण करने के लिए उपयोग किया जा सकता है

आपको पूछना है कि "आप क्या कर रहे हैं?" यह जानने के लिए कि आपको क्या उपयोग करना चाहिए। मान लें कि आप प्रश्न पूछने के लिए एपीआई तैयार कर रहे हैं। यदि आप POST का उपयोग करना चाहते हैं, तो आप प्रश्नों की एक सूची के लिए ऐसा करेंगे अगर आप पुट का उपयोग करना चाहते हैं, तो आप किसी विशेष प्रश्न के लिए ऐसा करेंगे।

दोनों का इस्तेमाल किया जा सकता है, इसलिए मुझे अपने रेंजर डिज़ाइन में कौन सा उपयोग करना चाहिए?

आपको पुट और पोस्ट दोनों का समर्थन करने की आवश्यकता नहीं है।

इसका उपयोग करने के लिए आपको छोड़ दिया गया है। लेकिन सिर्फ अनुरोध पर आपके द्वारा संदर्भित ऑब्जेक्ट के आधार पर सही का उपयोग करने के लिए याद रखें।

कुछ विचार:

  • क्या आप अपने URL ऑब्जेक्ट्स को स्पष्ट रूप से बनाते हैं, या सर्वर को तय करने दें? अगर आप उन्हें नाम दें तो PUT का उपयोग करें। यदि आप सर्वर को तय करने दें तो POST का उपयोग करें।
  • PUT idempotent है, इसलिए यदि आप एक ऑब्जेक्ट दो बार दबाएं, इसका कोई प्रभाव नहीं है। यह एक अच्छी संपत्ति है, इसलिए मैं जब संभव हो तो पीयूटी का इस्तेमाल करेगा
  • आप उसी ऑब्जेक्ट URL के साथ PUT के साथ एक संसाधन को अपडेट या बना सकते हैं
  • POST के साथ आपको 2 अनुरोध एक ही समय में यूआरएल में संशोधन करने में आते हैं, और वे ऑब्जेक्ट के विभिन्न हिस्सों को अपडेट कर सकते हैं।

एक उदाहरण:

मैंने इसके बारे में अन्य उत्तर के एक हिस्से के रूप में निम्नलिखित लिखा :

पद:

किसी संसाधन को संशोधित करने और अपडेट करने के लिए उपयोग किया जाता है

 POST /questions/<existing_question> HTTP/1.1 Host: www.example.com/ 

ध्यान दें कि निम्नलिखित त्रुटि है:

 POST /questions/<new_question> HTTP/1.1 Host: www.example.com/ 

यदि यूआरएल अभी तक बना नहीं है, तो आपको नाम निर्दिष्ट करते समय इसे बनाने के लिए POST का उपयोग नहीं करना चाहिए। इसका परिणाम 'संसाधन नहीं मिला' त्रुटि में होना चाहिए क्योंकि <new_question> अभी तक मौजूद नहीं है आपको पहले <new_question> संसाधन को सर्वर पर रखना चाहिए

आप POST का उपयोग कर एक संसाधन बनाने के लिए ऐसा कुछ कर सकते हैं:

 POST /questions HTTP/1.1 Host: www.example.com/ 

ध्यान दें कि इस मामले में संसाधन नाम निर्दिष्ट नहीं किया गया है, नई ऑब्जेक्ट यूआरएल पथ आपको वापस कर दिया जाएगा।

डाल:

एक संसाधन बनाने के लिए उपयोग किया जाता है, या उसे अधिलेखित करता है। जब आप संसाधनों को नया यूआरएल निर्दिष्ट करते हैं

एक नए संसाधन के लिए:

 PUT /questions/<new_question> HTTP/1.1 Host: www.example.com/ 

मौजूदा संसाधन को अधिलेखित करने के लिए:

 PUT /questions/<existing_question> HTTP/1.1 Host: www.example.com/ 

आप कहते हैं कि वेब पर दावा मिल सकता है

  • एक संसाधन बनाने के लिए POST का उपयोग किया जाना चाहिए, और एक को संशोधित करने के लिए PUT का उपयोग किया जाना चाहिए
  • PUT को संसाधन बनाने के लिए उपयोग किया जाना चाहिए, और एक को संशोधित करने के लिए POST का उपयोग किया जाना चाहिए

न तो काफी सही है


बेहतर कार्रवाई के idempotence पर आधारित PUT और POST के बीच चयन करना है।

पुट का अर्थ है एक संसाधन डालने – अलग-अलग चीज़ के साथ दिए गए यूआरएल पर जो कुछ भी उपलब्ध है उसे पूरी तरह से बदल दिया जाए। परिभाषा के अनुसार, एक पुट idempotent है। जितनी बार आप चाहें उतना बार करें, और परिणाम एक ही है x=5 idempotent है आप पहले से मौजूद है, या नहीं (उदाहरण के लिए, बनाने के लिए या अद्यतन करने के लिए) एक संसाधन रख सकते हैं!

पोस्ट एक संसाधन अपडेट करता है, सहायक संसाधन जोड़ता है, या परिवर्तन का कारण बनता है एक पोस्ट idempotent नहीं है, जिस तरह से x++ idempotent नहीं है


इस तर्क से, PUT बनाने के लिए है, जब आप उस चीज के यूआरएल को जान लेंगे जो आप पैदा करेंगे। पोस्ट बनाने के लिए इस्तेमाल किया जा सकता है जब आप "फ़ैक्ट्री" के यूआरएल को जानते हैं या उन चीजों की श्रेणी के लिए प्रबंधक जिन्हें आप बनाना चाहते हैं

इसलिए:

 POST /expense-report 

या:

 PUT /expense-report/10929 
  • यूआरएल के लिए पोस्ट सर्वर परिभाषित यूआरएल पर एक बाल संसाधन बनाता है
  • किसी यूआरएल को बनाए रखने के लिए ग्राहक को परिभाषित यूआरएल पर संसाधन पूरी तरह से बदलता है
  • उस यूआरएल को पैच करें जो उस क्लाइंट की परिभाषित यूआरएल पर संसाधन का हिस्सा होता है

पुट और पोस्ट के लिए प्रासंगिक विनिर्देश आरएफसी 2616 § 9.5। एफएफ है

POST एक बाल संसाधन बनाता है , इसलिए /items को पोस्ट /items संसाधन के तहत रहता संसाधनों बनाता है उदाहरण के लिए। /items/1 उसी पोस्ट पैकेट को दो बार भेजना दो संसाधन बनाती है

PUT ग्राहक द्वारा ज्ञात यूआरएल पर एक संसाधन बनाने या बदलने के लिए है

इसलिए: PUT केवल एक उम्मीदवार है, जहां ग्राहक पहले ही यूआरएल को संसाधन से पहले बनाया जाता है। उदाहरण के लिए। /blogs/nigel/entry/when_to_use_post_vs_put शीर्षक के रूप में संसाधन कुंजी के रूप में उपयोग किया जाता है

PUT ज्ञात url पर मौजूद संसाधन को बदल देता है, अगर यह पहले से मौजूद है, तो दो बार अनुरोध भेजने से कोई प्रभाव नहीं पड़ता। दूसरे शब्दों में, PUT को कॉल idempotent हैं

आरएफसी इस तरह पढ़ता है:

POST और PUT अनुरोधों के बीच मूलभूत अंतर अनुरोध-यूआरआई के विभिन्न अर्थों में परिलक्षित होता है। पोस्ट अनुरोध में यूआरआर संसाधन को पहचानता है जो संलग्न इकाई को संभालता है। यह संसाधन एक डेटा-स्वीकार करने की प्रक्रिया हो सकता है, किसी अन्य प्रोटोकॉल का प्रवेश द्वार या एक अलग इकाई जो एनोटेशन स्वीकार करता है। इसके विपरीत, PUT अनुरोध में यूआरआर अनुरोध के साथ संलग्न इकाई की पहचान करता है – उपयोगकर्ता एजेंट जानता है कि यूआरआई क्या करना है और सर्वर को किसी अन्य संसाधन के अनुरोध को लागू करने का प्रयास नहीं करना चाहिए। यदि सर्वर चाहता है कि अनुरोध को एक अलग यूआरआई पर लागू किया जाए,

नोट: PUT ज्यादातर संसाधनों को अद्यतन करने के लिए उपयोग किया गया है (उन्हें अपनी पूर्णता में बदलकर), लेकिन हाल ही में मौजूदा संसाधनों को अपडेट करने के लिए पैच का उपयोग करने की दिशा में आंदोलन है, क्योंकि पुट बताता है कि यह पूरे संसाधन की जगह है। आरएफसी 5789

मैं अपना "व्यावहारिक" सलाह जोड़ना चाहता हूं PUT का प्रयोग करें जब आप "आईडी" को जानते हैं जिसके द्वारा आप बचत कर रहे वस्तु पुनः प्राप्त कर सकते हैं। PUT का उपयोग करना बहुत अच्छी तरह से काम नहीं करेगा यदि आपको इसकी आवश्यकता है, कहते हैं, आपके लिए भविष्य में देखने या अपडेट करने के लिए एक डेटाबेस जनरेटेड आईडी वापस किया जाएगा।

इसलिए: किसी मौजूदा उपयोगकर्ता को बचाने के लिए, या एक ग्राहक जहां आईडी बनाता है और यह सत्यापित किया गया है कि आईडी अद्वितीय है:

 PUT /user/12345 HTTP/1.1 <-- create the user providing the id 12345 Host: mydomain.com GET /user/12345 HTTP/1.1 <-- return that user Host: mydomain.com 

अन्यथा, वस्तु का अद्यतन करने के लिए शुरुआत में ऑब्जेक्ट बनाने के लिए POST का उपयोग करें, और PUT का उपयोग करें:

 POST /user HTTP/1.1 <--- create the user, server returns 12345 Host: mydomain.com PUT /user/12345 HTTP/1.1 <--- update the user Host: mydomain.com 

सारांश:

सर्जन करना:

निम्नलिखित तरीके से PUT या POST दोनों के साथ किया जा सकता है:

डाल

नए संसाधनों के साथ नए संसाधन को पहचानकर्ता के रूप में / संसाधन यूआरआई, या संग्रह के तहत बनाता है।

 PUT /resources/<newResourceId> HTTP/1.1 

पद

/ संसाधन यूआरआई, या संग्रह के तहत एक नया संसाधन बनाता है। आमतौर पर पहचानकर्ता को सर्वर द्वारा लौटा दिया जाता है

 POST /resources HTTP/1.1 

अद्यतन करें:

केवल निम्नलिखित तरीके से PUT के साथ किया जा सकता है:

डाल

/ संसाधन यूआरआई, या संग्रह के तहत, पहचानकर्ता के रूप में मौजूदा रिसोर्सआईडी के साथ संसाधन को अद्यतन करता है।

 PUT /resources/<existingResourceId> HTTP/1.1 

स्पष्टीकरण:

जब सामान्य रूप में REST और URI के साथ काम करना है, तो आपके पास बाएं और सामान्य पर दाईं ओर सामान्य है जेनेरिक को आमतौर पर संग्रह कहा जाता है और अधिक विशिष्ट वस्तुओं को संसाधन कहा जा सकता है । ध्यान दें कि किसी संसाधन में संग्रह हो सकता है

उदाहरण:

<- सामान्य-विशिष्ट ->

 URI: website.com/users/john website.com - whole site users - collection of users john - item of the collection, or a resource URI:website.com/users/john/posts/23 website.com - whole site users - collection of users john - item of the collection, or a resource posts - collection of posts from john 23 - post from john with identifier 23, also a resource 

जब आप POST का उपयोग करते हैं तो आप हमेशा एक संग्रह के लिए संदर्भ देते हैं, इसलिए जब भी आप कहते हैं:

 POST /users HTTP/1.1 

आप उपयोगकर्ताओं के संग्रह में एक नया उपयोगकर्ता पोस्ट कर रहे हैं।

यदि आप चलते हैं और ऐसा कुछ करने का प्रयास करें:

 POST /users/john HTTP/1.1 

यह काम करेगा, लेकिन अर्थपूर्ण रूप से आप यह कह रहे हैं कि आप उपयोगकर्ता संग्रह के तहत जॉन संग्रह के लिए एक संसाधन जोड़ना चाहते हैं।

एक बार जब आप PUT का उपयोग कर रहे हैं तो आप किसी संसाधन या एकल आइटम को संदर्भित कर रहे हैं, संभवत: एक संग्रह के अंदर। तो जब आप कहते हैं:

 PUT /users/john HTTP/1.1 

आप सर्वर अपडेट के लिए कह रहे हैं, या यदि यह मौजूद नहीं है, तो उपयोगकर्ता संग्रह के तहत जॉन संसाधन

युक्ति:

मुझे इस बात के कुछ महत्वपूर्ण हिस्सों पर प्रकाश डालें:

पद

अनुरोध विधि अनुरोध अनुरोध यूआरआई द्वारा पहचान की गई संसाधन के एक नए अधीनस्थ के रूप में अनुरोध में संलग्न इकाई को स्वीकार करने वाली इकाई को स्वीकार करने के लिए उपयोग किया जाता है

इसलिए, संग्रह पर एक नया संसाधन बनाता है

डाल

पुट विधि अनुरोध है कि संलग्न इकाई को आपूर्ति अनुरोध- URI के तहत संग्रहीत किया जाएगा। यदि अनुरोध- URI पहले से मौजूद संसाधन को संदर्भित करता है, तो संलग्न इकाई को मूल सर्वर पर रहने वाले किसी के संशोधित संस्करण के रूप में माना जाना चाहिए। यदि अनुरोध-यूआरआइ किसी मौजूदा संसाधन को इंगित नहीं करता है, और यह यूआरआई अनुरोधकर्ता उपयोगकर्ता एजेंट द्वारा नए संसाधन के रूप में परिभाषित होने में सक्षम है, तो मूल सर्वर उस यूआरआई के साथ संसाधन बना सकता है। "

इसलिए, संसाधन के अस्तित्व के आधार पर बना या अपडेट करें।

संदर्भ:

  • HTTP / 1.1 युक्ति
  • विकिपीडिया – आराम
  • यूनिफ़ॉर्म रिसोर्स पहचानकर्ता (यूआरआई): जेनेरिक सिंटैक्स और सिमेंटिक्स

POST का अर्थ है "नया बनाएं" जैसा कि "यहां उपयोगकर्ता बनाने के लिए इनपुट है, मेरे लिए इसे बनाएं"

PUT का अर्थ है "सम्मिलित करें, पहले से मौजूद है अगर बदलें" जैसा कि "यहां उपयोगकर्ता 5 के लिए डेटा है" में है।

आप example.com/users पर पोस्ट करते हैं क्योंकि आप अभी तक यूजर का यूआरएल नहीं जानते, आप चाहते हैं सर्वर इसे बनाने के लिए।

जब आप विशिष्ट उपयोगकर्ता को प्रतिस्थापित करना चाहते हैं, तो example.com/users/id पर जाएं।

एक ही डेटा के साथ दो बार पोस्टिंग का मतलब है कि अलग-अलग आईडी वाले दो समान उपयोगकर्ता बनाएं। एक ही डेटा के साथ दो बार का उपयोग करने से उपयोगकर्ता को पहले बनाया जाता है और दूसरी बार (कोई परिवर्तन नहीं) उसी स्थिति में उसे अपडेट करता है। चूंकि आप पीट के बाद एक ही स्थिति के साथ समाप्त होते हैं, इससे कोई फर्क नहीं पड़ता कि आप इसे कितनी बार करते हैं, यह हर बार "उतना ही शक्तिशाली" कहा जाता है – idempotent स्वचालित रूप से अनुरोध पुन: प्रयास करने के लिए यह उपयोगी है। जब आप ब्राउज़र पर बैक बटन दबाते हैं तो अब और नहीं 'आप वाकई फिर से भेजना चाहते हैं'

एक सामान्य सलाह है कि जब आप अपने संसाधनों के यूआरएल के निर्माण के नियंत्रण में सर्वर की ज़रूरत होती है, तब पोस्ट का उपयोग करना है। अन्यथा प्रयोग करें का प्रयोग करें पोस्ट को आगे बढ़ाएं।

बनाने के लिए पोस्ट का उपयोग करें, और अपडेट करने के लिए PUT का उपयोग करें इसी तरह रेल पर रूबी ऐसा कर रही है, वैसे भी।

 PUT /items/1 #=> update POST /items #=> create 

आराम एक बहुत ही उच्च स्तरीय अवधारणा है वास्तव में, यह बिल्कुल भी HTTP का उल्लेख नहीं करता है!

यदि आपको HTTP में REST को कार्यान्वित करने के बारे में कोई संदेह है, तो आप हमेशा एटम प्रकाशन प्रोटोकॉल (AtomPub) विनिर्देश पर एक नजर डाल सकते हैं। एटम पब्स, एचटीटीपी के साथ रीस्टाइनल वेबस्वाइसेस लिखने के लिए एक मानक है, जिसे रॉय फील्डिंग से कुछ इनपुट के साथ, कई एचटीटीपी और रीस्ट दिग्गजियों द्वारा विकसित किया गया था, रेस्ट के आविष्कारक और एचटीटीपी स्वयं के (सह-) आविष्कारक।

वास्तव में, आप सीधे AtomPub का उपयोग करने में सक्षम हो सकते हैं हालांकि यह ब्लॉगिंग समुदाय से बाहर आ गया है, यह ब्लॉगिंग के लिए प्रतिबंधित नहीं है: यह एचटीटीपी के माध्यम से मनमाने ढंग से संसाधनों के मनमानी (नेस्टेड) ​​संकलन के साथ पुन: बातचीत करने के लिए एक सामान्य प्रोटोकॉल है। यदि आप संसाधनों के नेस्टेड संग्रह के रूप में अपने आवेदन का प्रतिनिधित्व कर सकते हैं, तो आप केवल AtomPub का उपयोग कर सकते हैं और चिंतित नहीं कर सकते कि क्या PUT या POST का उपयोग करें, क्या वापस करने के लिए HTTP स्थिति कोड और उन सभी विवरण।

संसाधन बनाने के बारे में AtomPub को यही कहना है :

एक संग्रह में सदस्यों को जोड़ने के लिए, ग्राहक संग्रह के यूआरआई को पोस्ट अनुरोध भेजते हैं।

मुझे यह सलाह पसंद है, पुट की आरएफसी 2616 की परिभाषा से :

POST और PUT अनुरोधों के बीच मूलभूत अंतर अनुरोध-यूआरआई के विभिन्न अर्थों में परिलक्षित होता है। पोस्ट अनुरोध में यूआरआर संसाधन को पहचानता है जो संलग्न इकाई को संभालता है। यह संसाधन एक डेटा-स्वीकार करने की प्रक्रिया हो सकता है, किसी अन्य प्रोटोकॉल का प्रवेश द्वार या एक अलग इकाई जो एनोटेशन स्वीकार करता है। इसके विपरीत, PUT अनुरोध में यूआरआर अनुरोध के साथ संलग्न इकाई की पहचान करता है – उपयोगकर्ता एजेंट जानता है कि यूआरआई क्या करना है और सर्वर को किसी अन्य संसाधन के अनुरोध को लागू करने का प्रयास नहीं करना चाहिए।

यहां पर अन्य सलाह के साथ यह है कि, PUT सबसे अच्छा संसाधनों पर लागू होता है जो पहले से ही एक नाम रखता है, और POST मौजूदा संसाधन (और इसे सर्वर नाम दें) के तहत एक नया ऑब्जेक्ट बनाने के लिए अच्छा है।

मैं यह व्याख्या करता हूं, और पुट पर इडेमपोटेंसी की आवश्यकता, इसका मतलब यह है कि:

  • पोस्ट संग्रह के तहत नई ऑब्जेक्ट बनाने के लिए अच्छा है (और बनाने के लिए idempotent की आवश्यकता नहीं है)
  • PUT मौजूदा वस्तुओं को अपडेट करने के लिए अच्छा है (और अपडेट को idempotent की आवश्यकता है)
  • पोस्ट को गैर-idempotent अद्यतनों के लिए मौजूदा ऑब्जेक्ट्स (विशेष रूप से वस्तु के कुछ हिस्सों को निर्दिष्ट किए बिना बदलकर – यदि आप इसके बारे में सोचते हैं, तो एक संग्रह का एक नया सदस्य बनाने के लिए वास्तव में इस प्रकार का विशेष मामला है। अद्यतन, संग्रह के नजरिए से)
  • PUT का भी उपयोग करने के लिए इस्तेमाल किया जा सकता है अगर केवल और अगर आप ग्राहक को संसाधन का नाम दें लेकिन चूंकि REST क्लाइंट यूआरएल संरचना के बारे में धारणा नहीं करना चाहते हैं, इसलिए चीजों की इच्छित भावना में यह कम है।

किसी HTTP / REST एपीआई के साथ किसी सर्वर पर संसाधन बनाने के लिए पुट या पोस्ट का उपयोग करने का निर्णय यह है कि यूआरएल संरचना का मालिक कौन है ग्राहक को पता है, या परिभाषित करने में भाग लेने के लिए, यूआरएल संरचना एक अनावश्यक युग्मन है जो एसओए से उत्पन्न अनैच्छिक युग्मज के समान है। कूप्सिंग के प्रकार से बचने का कारण REST इतना लोकप्रिय है। इसलिए, उपयोग करने के लिए उचित विधि POST है। इस नियम के अपवाद हैं और वे तब होते हैं जब क्लाइंट संसाधनों के स्थान संरचना पर नियंत्रण बनाए रखना चाहता है जो यह तैनात करता है। यह दुर्लभ है और इसका मतलब है कि कुछ और गलत है।

इस बिंदु पर कुछ लोग यह तर्क देंगे कि यदि हां, तो यूआरएल का उपयोग किया जाता है, ग्राहक संसाधन के यूआरएल को जानता है और इसलिए पीयूटी स्वीकार्य है। सब के बाद, यही वजह है कि प्रामाणिक, सामान्यीकृत, रेलवे पर रूबी, डीजेंगो यूआरएल महत्वपूर्ण हैं, ट्विटर एपीआई … ब्ला ब्ला ब्ला देखें। उन लोगों को यह समझने की ज़रूरत है कि एक विशुद्ध-यूआरएल जैसी कोई चीज नहीं है और रॉय फील्डिंग खुद बताती है कि :

एक REST एपीआई निश्चित संसाधन नामों या पदानुक्रम (क्लाइंट और सर्वर का एक स्पष्ट संयोजन) को परिभाषित नहीं करना चाहिए। सर्वर को अपने नामस्थान को नियंत्रित करने की स्वतंत्रता होनी चाहिए। इसके बजाय, ग्राहकों को उचित यूआरआई का निर्माण करने के लिए क्लाइंट को निर्देश देने की अनुमति दें, जैसे कि एचटीएमएल फॉर्म और यूआरआई टेम्प्लेट में किया जाता है, मीडिया निर्देशों और लिंक संबंधों के भीतर उन निर्देशों को परिभाषित करके। [असफलता का अर्थ है कि क्लाइंट एक आउटसोर्सिंग बैंड सूचना, जैसे कि डोमेन-विशिष्ट मानक के कारण संसाधन संरचना को मानते हैं, जो डेटा-उन्मुख आरपीसी के कार्यात्मक युग्मन के बराबर है)।

http://roy.gbiv.com/untangled/2008/rest-apis-must-be-hypertext-driven

एक शोकहारा-यूआरएल का विचार वास्तव में REST का उल्लंघन है क्योंकि सर्वर यूआरएल संरचना के प्रभारी है और युग्मन से बचने के लिए इसका उपयोग करने के निर्णय लेने के लिए स्वतंत्र होना चाहिए। यदि यह आपको एपीआई डिजाइन पर स्वयं की खोज के महत्व के बारे में पढ़ता है,

संसाधनों का निर्माण करने के लिए POST का उपयोग डिज़ाइन पर विचार के साथ आता है क्योंकि पोस्ट IDempotent नहीं है। इसका मतलब यह है कि एक पोस्ट दोहराते हुए कई बार हर बार उसी व्यवहार की गारंटी नहीं देता है। इससे लोगों को डराने के लिए संसाधनों का निर्माण करने के लिए PUT का इस्तेमाल किया जाता है जब उन्हें नहीं करना चाहिए। उन्हें पता है कि यह गलत है (पोस्ट बनाने के लिए है) लेकिन वे वैसे भी ऐसा करते हैं क्योंकि उन्हें नहीं पता कि इस समस्या को कैसे हल किया जाए। यह चिंता निम्नलिखित स्थिति में प्रदर्शित होती है:

  1. ग्राहक सर्वर पर एक नया संसाधन पोस्ट करें।
  2. सर्वर अनुरोध पर प्रक्रिया करता है और एक प्रतिक्रिया भेजता है।
  3. ग्राहक कभी प्रतिक्रिया प्राप्त नहीं करता है
  4. सर्वर अनजान है, ग्राहक ने प्रतिक्रिया प्राप्त नहीं की है।
  5. ग्राहक के संसाधन के लिए यूआरएल नहीं है (इसलिए PUT एक विकल्प नहीं है) और डाक को दोहराता है
  6. पोस्ट idempotent और सर्वर नहीं है …

चरण 6 है, जहां लोगों को आम तौर पर क्या करना है, इसके बारे में भ्रमित हो जाते हैं। हालांकि, इस मुद्दे को सुलझाने के लिए एक कड़ी बनाने का कोई कारण नहीं है। इसके बजाय, HTTP का उपयोग RFC 2616 में निर्दिष्ट के रूप में किया जा सकता है और सर्वर जवाब:

10.4.10 40 9 संघर्ष

संसाधन की वर्तमान स्थिति के साथ संघर्ष के कारण अनुरोध पूर्ण नहीं किया जा सका इस कोड को उन स्थितियों में ही अनुमति दी जाती है जहां यह उम्मीद की जाती है कि उपयोगकर्ता संघर्ष का समाधान कर सकता है और अनुरोध पुनः सबमिट कर सकता है। प्रतिक्रिया शरीर में पर्याप्त शामिल होना चाहिए

उपयोगकर्ता के लिए संघर्ष के स्रोत को पहचानने के लिए जानकारी आदर्श रूप में, प्रतिक्रिया इकाई में उपयोगकर्ता या उपयोगकर्ता एजेंट के लिए समस्या को ठीक करने के लिए पर्याप्त जानकारी शामिल होगी; हालांकि, यह संभव नहीं है और आवश्यक नहीं है।

PUT अनुरोध के जवाब में संघर्ष सबसे अधिक होने की संभावना है। उदाहरण के लिए, यदि वर्जनिंग का इस्तेमाल किया जा रहा है और इकाई को एक संसाधन में परिवर्तन शामिल है जो पहले के (तृतीय-पक्ष) अनुरोध द्वारा बनाए गए लोगों के साथ विरोधाभासी है, तो सर्वर यह अनुरोध को पूरा करने के लिए 409 प्रतिक्रिया का उपयोग कर सकता है । इस स्थिति में, प्रतिक्रिया इकाई में प्रतिक्रिया सामग्री द्वारा निर्धारित प्रारूप में दो संस्करणों के बीच अंतर की एक सूची होगी।

40 9 के एक स्थिति कोड के साथ जवाब देना सही सहारा है क्योंकि :

  • डेटा का एक पोस्ट करना जिसमें एक आईडी है जो सिस्टम में पहले से ही एक संसाधन से मेल खाता है "संसाधन की वर्तमान स्थिति के साथ एक संघर्ष है।"
  • चूंकि महत्वपूर्ण हिस्सा ग्राहक को समझने के लिए है कि संसाधन में संसाधन है और उचित कार्रवाई करने के लिए। यह एक ऐसी स्थिति है जहां उम्मीद की जाती है कि उपयोगकर्ता संघर्ष का समाधान कर सके और अनुरोध को पुनः सबमिट कर सके। "
  • एक प्रतिक्रिया जिसमें परस्पर विरोधी आईडी के साथ संसाधन के यूआरएल शामिल हैं और संसाधन के लिए उपयुक्त प्रीडंडिशन "समस्या को ठीक करने के लिए प्रयोक्ता या उपयोगकर्ता एजेंट के लिए पर्याप्त जानकारी" प्रदान करेगा जो कि आरएफसी 2616 प्रति आदर्श मामला है।

2616 को बदलने के लिए आरएफसी 7231 के रिलीज के आधार पर अद्यतन

आरएफसी 7231 2616 को बदलने के लिए डिज़ाइन किया गया है और धारा 4.3.3 में पोस्ट के लिए संभावित प्रतिक्रिया का पालन करने का वर्णन किया गया है

यदि किसी पोस्ट को संसाधित करने का नतीजा मौजूदा संसाधन के प्रतिनिधित्व के बराबर होगा, तो एक मूल सर्वर उपयोगकर्ता के एजेंट को उस संसाधन को स्थान फ़ील्ड में मौजूदा संसाधन के पहचानकर्ता के साथ एक 303 (अन्य देखें) प्रतिक्रिया भेजकर रीडायरेक्ट कर सकता है। This has the benefits of providing the user agent a resource identifier and transferring the representation via a method more amenable to shared caching, though at the cost of an extra request if the user agent does not already have the representation cached.

It now may be tempting to simply return a 303 in the event that a POST is repeated. However, the opposite is true. Returning a 303 would only make sense if multiple create requests (creating different resources) return the same content. An example would be a "thank you for submitting your request message" that the client need not re-download each time. RFC 7231 still maintains in section 4.2.2 that POST is not to be idempotent and continues to maintain that POST should be used for create.

For more information about this, read this article .

POST is like posting a letter to a mailbox or posting an email to an email queue. PUT is like when you put an object in a cubby hole or a place on a shelf (it has a known address).

With POST, you're posting to the address of the QUEUE or COLLECTION. With PUT, you're putting to the address of the ITEM.

PUT is idempotent. You can send the request 100 times and it will not matter. POST is not idempotent. If you send the request 100 times, you'll get 100 emails or 100 letters in your postal box.

A general rule: if you know the id or name of the item, use PUT. If you want the id or name of the item to be assigned by the receiving party, use POST.

POST versus PUT

New answer (now that I understand REST better):

PUT is merely a statement of what content the service should, from now on, use to render representations of the resource identified by the client; POST is a statement of what content the service should, from now on, contain (possibly duplicated) but it's up to the server how to identify that content.

PUT x (if x identifies a resource ): "Replace the content of the resource identified by x with my content."

PUT x (if x does not identify a resource): "Create a new resource containing my content and use x to identify it."

POST x : "Store my content and give me an identifier that I can use to identify a resource (old or new) containing said content (possibly mixed with other content). Said resource should be identical or subordinate to that which x identifies." " y 's resource is subordinate to x 's resource" is typically but not necessarily implemented by making y a subpath of x (eg x = /foo and y = /foo/bar ) and modifying the representation(s) of x 's resource to reflect the existence of a new resource, eg with a hyperlink to y 's resource and some metadata. Only the latter is really essential to good design, as URLs are opaque in REST — you're supposed to use hypermedia instead of client-side URL construction to traverse the service anyways.

In REST, there's no such thing as a resource containing "content". I refer as "content" to data that the service uses to render representations consistently. It typically consists of some related rows in a database or a file (eg an image file). It's up to the service to convert the user's content into something the service can use, eg converting a JSON payload into SQL statements.

Original answer (might be easier to read) :

PUT /something (if /something already exists): "Take whatever you have at /something and replace it with what I give you."

PUT /something (if /something does not already exist): "Take what I give you and put it at /something ."

POST /something : "Take what I give you and put it anywhere you want under /something as long as you give me its URL when you're done."

Ruby on Rails 4.0 will use the 'PATCH' method instead of PUT to do partial updates.

RFC 5789 says about PATCH (since 1995):

A new method is necessary to improve interoperability and prevent errors. The PUT method is already defined to overwrite a resource with a complete new body, and cannot be reused to do partial changes. Otherwise, proxies and caches, and even clients and servers, may get confused as to the result of the operation. POST is already used but without broad interoperability (for one, there is no standard way to discover patch format support). PATCH was mentioned in earlier HTTP specifications, but not completely defined.

" Edge Rails: PATCH is the new primary HTTP method for updates " explains it.

संक्षेप में:

PUT is idempotent, where the resource state will be the same if the same operation is executed one time or multiple times.

POST is non-idempotent, where the resource state may become different if the operation is executed multiple times as compared to executing a single time.

Analogy with database query

PUT You can think of similar to "UPDATE STUDENT SET address = "abc" where id="123";

POST You can think of something like "INSERT INTO STUDENT(name, address) VALUES ("abc", "xyzzz");

Student Id is auto generated.

With PUT, if the same query is executed multiple times or one time, the STUDENT table state remains the same.

In case of POST, if the same query is executed multiple times then multiple Student records get created in the database and the database state changes on each execution of an "INSERT" query.

NOTE: PUT needs a resource location (already-resource) on which update needs to happen, whereas POST doesn't require that. Therefore intuitively POST is meant for creation of a new resource, whereas PUT is needed for updating the already existing resource.

Some may come up with that updates can be performed with POST. There is no hard rule which one to use for updates or which one to use for create. Again these are conventions, and intuitively I'm inclined with the above mentioned reasoning and follow it.

Both are used for data transmission between client to server, but there are subtle differences between them, which are:

यहां छवि विवरण दर्ज करें

At the risk of restating what has already been said, it seems important to remember that PUT implies that the client controls what the URL is going to end up being, when creating a resource. So part of the choice between PUT and POST is going to be about how much you can trust the client to provide correct, normalized URL that are coherent with whatever your URL scheme is.

When you can't fully trust the client to do the right thing, it would be more appropriate to use POST to create a new item and then send the URL back to the client in the response.

The most important consideration is reliability . If a POST message gets lost the state of the system is undefined. Automatic recovery is impossible. For PUT messages, the state is undefined only until the first successful retry.

For instance, it may not be a good idea to create credit card transactions with POST.

If you happen to have auto generated URI's on your resource you can still use PUT by passing a generated URI (pointing to an empty resource) to the client.

Some other considerations:

  • POST invalidates cached copies of the entire containing resource (better consistency)
  • PUT responses are not cacheable while POST ones are (Require Content-Location and expiration)
  • PUT is less supported by eg Java ME, older browsers, firewalls

the origin server can create the resource with that URI

So you use POST and probably, but not necessary PUT for resource creation. You don't have to support both. For me POST is perfectly enough. So it is a design decision.

As your quote mentioned, you use PUT for creation of there is no resource assigned to an IRI, and you want to create a resource anyway. For example, PUT /users/123/password usually replaces the old password with a new one, but you can use it to create a password if it does not exist already (for example, by freshly registered users or by restoring banned users).

There seems to always be some confusion as to when to use the HTTP POST versus the HTTP PUT method for REST services. Most developers will try to associate CRUD operations directly to HTTP methods. I will argue that this is not correct and one can not simply associate the CRUD concepts to the HTTP methods. That is:

 Create => HTTP PUT Retrieve => HTTP GET Update => HTTP POST Delete => HTTP DELETE 

It is true that the R(etrieve) and D(elete) of the CRUD operations can be mapped directly to the HTTP methods GET and DELETE respectively. However, the confusion lies in the C(reate) and U(update) operations. In some cases, one can use the PUT for a create while in other cases a POST will be required. The ambiguity lies in the definition of an HTTP PUT method versus an HTTP POST method.

According to the HTTP 1.1 specifications the GET, HEAD, DELETE, and PUT methods must be idempotent, and the POST method is not idempotent. That is to say that an operation is idempotent if it can be performed on a resource once or many times and always return the same state of that resource. Whereas a non idempotent operation can return a modified state of the resource from one request to another. Hence, in a non idempotent operation, there is no guarantee that one will receive the same state of a resource.

Based on the above idempotent definition, my take on using the HTTP PUT method versus using the HTTP POST method for REST services is: Use the HTTP PUT method when:

 The client includes all aspect of the resource including the unique identifier to uniquely identify the resource. Example: creating a new employee. The client provides all the information for a resource to be able to modify that resource.This implies that the server side does not update any aspect of the resource (such as an update date). 

In both cases, these operations can be performed multiple times with the same results. That is the resource will not be changed by requesting the operation more than once. Hence, a true idempotent operation. Use the HTTP POST method when:

 The server will provide some information concerning the newly created resource. For example, take a logging system. A new entry in the log will most likely have a numbering scheme which is determined on the server side. Upon creating a new log entry, the new sequence number will be determined by the server and not by the client. On a modification of a resource, the server will provide such information as a resource state or an update date. Again in this case not all information was provided by the client and the resource will be changing from one modification request to the next. Hence a non idempotent operation. 

निष्कर्ष

Do not directly correlate and map CRUD operations to HTTP methods for REST services. The use of an HTTP PUT method versus an HTTP POST method should be based on the idempotent aspect of that operation. That is, if the operation is idempotent, then use the HTTP PUT method. If the operation is non idempotent, then use the HTTP POST method.

The semantics are supposed be different, in that "PUT", like "GET" is supposed to be idempotent — meaning, you can the same exact PUT request multiple times and the result will be as if you executed it only once.

I will describe the conventions which I think are most widely used and are most useful:

When you PUT a resource at a particular URL what happens is that it should get saved at that URL, or something along those lines.

When you POST to a resource at a particular URL, often you are posting a related piece of information to that URL. This implies that the resource at the URL already exists.

For example, when you want to create a new stream, you can PUT it to some URL. But when you want to POST a message to an existing stream, you POST to its URL.

As for modifying the properties of the stream, you can do that with either PUT or POST. Basically, only use "PUT" when the operation is idempotent – otherwise use POST.

Note, however, that not all modern browsers support HTTP verbs other than GET or POST.

In a very simple way I'm taking the example of the Facebook timeline.

Case 1: When you post something on your timeline, it's a fresh new entry. So in this case they use the POST method because the POST method is non-idempotent.

Case 2: If your friend comment on your post the first time, that also will create a new entry in the database so the POST method used.

Case 3: If your friend edits his comment, in this case, they had a comment id, so they will update an existing comment instead of creating a new entry in the database. Therefore for this type of operation use the PUT method because it is idempotent.*

In a single line, use POST to add a new entry in the database and PUT to update something in the database.

I'm going to land with the following:

PUT refers to a resource, identified by the URI. In this case, you are updating it. It is the part of the three verbs referring to resources — delete and get being the other two.

POST is basically a free form message, with its meaning being defined 'out of band'. If the message can be interpreted as adding a resource to a directory, that would be OK, but basically you need to understand the message you are sending (posting) to know what will happen with the resource.


Because PUT and GET and DELETE refer to a resource, they are also by definition idempotent.

POST can perform the other three functions, but then the semantics of the request will be lost on the intermediaries such as caches and proxies. This also applies to providing security on the resource, since a post's URI doesn't necessarily indicate the resource it is applying to (it can though).

A PUT doesn't need to be a create; the service could error if the resource isn't already created, but otherwise update it. Or vice versa — it may create the resource, but not allow updates. The only thing required about PUT is that it points to a specific resource, and its payload is the representation of that resource. A successful PUT means (barring interference) that a GET would retrieve the same resource.


Edit: One more thing — a PUT can create, but if it does then the ID has to be a natural ID — AKA an email address. That way when you PUT twice, the second put is an update of the first. This makes it idempotent .

If the ID is generated (a new employee ID, for example), then the second PUT with the same URL would create a new record, which violates the idempotent rule. In this case the verb would be POST, and the message (not resource) would be to create a resource using the values defined in this message.

While there is probably an agnostic way to describe these, it does seem to be conflicting with various statements from answers to websites.

Let's be very clear and direct here. If you are a .NET developer working with Web API, the facts are (from the Microsoft API documentation), http://www.asp.net/web-api/overview/creating-web-apis/creating-a-web-api-that-supports-crud-operations :

 1. PUT = UPDATE (/api/products/id) 2. MCSD Exams 2014 - UPDATE = PUT, there are **NO** multiple answers for that question period. 

Sure you "can" use "POST" to update, but just follow the conventions laid out for you with your given framework. In my case it is .NET / Web API, so PUT is for UPDATE there is no debate.

I hope this helps any Microsoft developers that read all comments with Amazon and Sun/Java website links.

If you are familiar with database operations, there are

  1. Select
  2. सम्मिलित करें
  3. Update
  4. Delete
  5. Merge (Update if already existing, else insert)

I use PUT for Merge and update like operations and use POST for Insertions.

Most of the time, you will use them like this:

  • POST a resource into a collection
  • PUT a resource identified by collection/:id

उदाहरण के लिए:

  • POST /items
  • PUT /items/1234

In both cases, the request body contains the data for the resource to be created or updated. It should be obvious from the route names that POST is not idempotent (if you call it 3 times it will create 3 objects), but PUT is idempotent (if you call it 3 times the result is the same). PUT is often used for "upsert" operation (create or update), but you can always return a 404 error if you only want to use it to modify.

Note that POST "creates" a new element in the collection, and PUT "replaces" an element at a given URL, but it is a very common practice to use PUT for partial modifications, that is, use it only to update existing resources and only modify the included fields in the body (ignoring the other fields). This is technically incorrect, if you want to be REST-purist, PUT should replace the whole resource and you should use PATCH for the partial update. I personally don't care much as far as the behavior is clear and consistent across all your API endpoints.

Remember, REST is a set of conventions and guidelines to keep your API simple. If you end up with a complicated work-around just to check the "RESTfull" box then you are defeating the purpose 😉

Short Answer:

Simple rule of thumb: Use POST to create, use PUT to update.

Long Answer:

POST:

  • POST is used to send data to server.
  • Useful when the resource's URL is unknown

PUT:

  • PUT is used to transfer state to the server
  • Useful when a resource's URL is known

Longer Answer:

To understand it we need to question why PUT was required, what were the problems PUT was trying to solve that POST couldn't.

From a REST architecture's point of view there is none that matters. We could have lived without PUT as well. But from a client developer's point of view it made his/her life a lot simpler.

Prior to PUT, clients couldn't directly know the URL that the server generated or if all it had generated any or whether the data to be sent to the server is already updated or not. PUT relieved the developer of all these headaches. PUT is idempotent, PUT handles race conditions, and PUT lets the client choose the URL.

In practice, POST works well for creating resources. The URL of the newly created resource should be returned in the Location response header. PUT should be used for updating a resource completely. Please understand that these are the best practices when designing a RESTful API. HTTP specification as such does not restrict using PUT/POST with a few restrictions for creating/updating resources. Take a look at http://techoctave.com/c7/posts/71-twitter-rest-api-dissected that summarizes the best practices.

Here's a simple rule:

PUT to a URL should be used to update or create the resource that can be located at that URL.

POST to a URL should be used to update or create a resource which is located at some other ("subordinate") URL, or is not locatable via HTTP.

Readers new to this topic will be struck by the endless discussion about what you should do, and the relative absence of lessons from experience. The fact that REST is "preferred" over SOAP is, I suppose, a high-level learning from experience, but goodness we must have progressed from there? It's 2016. Roy's dissertation was in 2000. What have we developed? Was it fun? Was it easy to integrate with? To support? Will it handle the rise of smartphones and flaky mobile connections?

According to ME, real-life networks are unreliable. Requests timeout. Connections are reset. Networks go down for hours or days at a time. Trains go into tunnels with mobile users aboard. For any given request (as occasionally acknowledged in all this discussion) the request can fall in the water on its way, or the response can fall in the water on its way back. In these conditions, issuing PUT, POST and DELETE requests directly against substantive resources has always struck me as a little brutal and naive.

HTTP does nothing to ensure reliable completion of the request-response, and that's just fine because this is properly the job of network-aware applications. Developing such an application, you can jump through hoops to use PUT instead of POST, then more hoops to give a certain kind of error on the server if you detect duplicate requests. Back at the client, you then have to jump through hoops to interpret these errors, refetch, revalidate and repost.

Or you can do this : consider your unsafe requests (actions) as ephemeral single-user resources. Clients request a new "action" on a substantive resource with an empty POST to the resource. POST will be used only for this. Once safely in possession of the URI of the freshly minted action, the client PUTs the unsafe request to the action URI, not the target resource . Resolving the action and updating the "real" resource is properly the job of your API, and is here decoupled from the unreliable network.

The server does the business, returns the response and stores it against the agreed action URI . If anything goes wrong, the client repeats the request (natural behaviour!), and if the server has already seen it, it repeats the stored response and does nothing else .

You will quickly spot the similarity with promises: we create and return the placeholder for the result before doing anything. Also like a promise, an action can succeed or fail one time, but its result can be fetched repeatedly.

Best of all, we give sending and receiving applications a chance to link the uniquely identified action to uniqueness in their respective environments. And we can start to demand, and enforce!, responsible behaviour from clients: repeat your requests as much as you like, but don't go generating a new action until you're in possession of a definitive result from the existing one.

As such, numerous thorny problems go away. Repeated insert requests won't create duplicates, and we don't create the real resource until we're in possession of the data. (database columns can stay not-nullable). Repeated update requests won't hit incompatible states and won't overwrite subsequent changes. Clients can (re)fetch and seamlessy process the original confirmation for whatever reason (client crashed, response went missing, etc.).

Successive delete requests can see and process the original confirmation, without hitting a 404 error. If things take longer than expected, we can respond provisionally, and we have a place where the client can check back for the definitive result. The nicest part of this pattern is its Kung-Fu (Panda) property. We take a weakness, the propensity for clients to repeat a request any time they don't understand the response, and turn it into a strength 🙂

Before telling me this is not RESTful, please consider the numerous ways in which REST principles are respected. Clients don't construct URLs. The API stays discoverable, albeit with a little change in semantics. HTTP verbs are used appropriately. If you think this is a huge change to implement, I can tell you from experience that it's not.

If you think you'll have huge amounts of data to store, let's talk volumes: a typical update confirmation is a fraction of a kilobyte. HTTP currently gives you a minute or two to respond definitively. Even if you only store actions for a week, clients have ample chance to catch up. If you have very high volumes, you may want a dedicated acid-compliant key value store, or an in-memory solution. If you still need convincing, I have a little Google Docs document here .

POST: Use it for creating new resources. It's like INSERT (SQL statement) with an auto-incremented ID. In the response part it contains a new generated Id.

POST is also used for updating a record.

PUT: Use it for creating a new resource, but here I know the identity key. It's like INSERT (SQL statement) where I know in advance the identity key. In the response part it sends nothing.

PUT is also used for updating a resource