[http] REST में बनाम पोस्ट बनाओ

14 Answers

आप वेब पर दावा कर सकते हैं जो कहता है

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

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

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

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

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


POST /expense-report


PUT  /expense-report/10929

HTTP / 1.1 स्पेक के अनुसार:

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

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

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

यही है, PUT का निर्माण या अद्यतन करने के लिए प्रयोग किया जाता है।

तो, संसाधन बनाने के लिए किस का उपयोग किया जाना चाहिए? या किसी को दोनों का समर्थन करने की जरूरत है?

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 ;)

संक्षेप में:

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.

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.

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.

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


सर्जन करना:

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


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

PUT /resources/<newResourceId> HTTP/1.1 


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

POST /resources HTTP/1.1

अद्यतन करें:

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


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

PUT /resources/<existingResourceId> HTTP/1.1


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


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

URI: website.com/users/john
website.com  - whole site
users        - collection of users
john         - item of the collection, or a resource

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

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


मुझे spec के कुछ महत्वपूर्ण हिस्सों को हाइलाइट करने दें:


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

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


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

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


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. अर्थात्:

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

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.

I like this advice, from RFC 2616's definition of PUT :

The fundamental difference between the POST and PUT requests is reflected in the different meaning of the Request-URI. The URI in a POST request identifies the resource that will handle the enclosed entity. That resource might be a data-accepting process, a gateway to some other protocol, or a separate entity that accepts annotations. In contrast, the URI in a PUT request identifies the entity enclosed with the request -- the user agent knows what URI is intended and the server MUST NOT attempt to apply the request to some other resource.

This jibes with the other advice here, that PUT is best applied to resources that already have a name, and POST is good for creating a new object under an existing resource (and letting the server name it).

I interpret this, and the idempotency requirements on PUT, to mean that:

  • POST is good for creating new objects under a collection (and create does not need to be idempotent)
  • PUT is good for updating existing objects (and update needs to be idempotent)
  • POST can also be used for non-idempotent updates to existing objects (especially, changing part of an object without specifying the whole thing -- if you think about it, creating a new member of a collection is actually a special case of this kind of update, from the collection's perspective)
  • PUT can also be used for create if and only if you allow the client to name the resource. But since REST clients aren't supposed to make assumptions about URL structure, this is less in the intended spirit of things.

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

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

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

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

संसाधन निर्माण के बारे में एटमपब को यही कहना है :

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

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.

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.

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.

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

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

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

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

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

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