http - example - rest put e post




PUT vs. POST in REST (20)

Secondo la specifica HTTP / 1.1:

Il metodo POST viene utilizzato per richiedere che il server di origine accetti l'entità inclusa nella richiesta come nuovo subordinato della risorsa identificata Request-URI di Request-Line

In altre parole, il POST è usato per creare .

Il metodo PUT richiede che l'entità inclusa sia archiviata Request-URI fornito. Se l' Request-URI della Request-URI riferisce a una risorsa già esistente, l'entità inclusa DOVREBBE essere considerata come una versione modificata di quella che risiede sul server di origine. Se l' Request-URI della Request-URI non punta a una risorsa esistente e quell'URI può essere definito come una nuova risorsa dall'agente utente richiedente, il server di origine può creare la risorsa con quell'URI. "

Cioè, PUT è usato per creare o aggiornare .

Quindi, quale dovrebbe essere usato per creare una risorsa? O uno deve supportare entrambi?


il server di origine può creare la risorsa con quell'URI

Quindi usi POST e probabilmente, ma non necessario PUT per la creazione di risorse. Non devi supportare entrambi. Per me POST è perfettamente sufficiente. Quindi è una decisione di progettazione.

Come la tua citazione menzionata, tu usi PUT per la creazione di non ci sono risorse assegnate a un IRI, e tu vuoi comunque creare una risorsa. Ad esempio, in PUT /users/123/passwordgenere sostituisce la vecchia password con una nuova, ma è possibile utilizzarla per creare una password se non esiste già (ad esempio, da utenti appena registrati o ripristinando utenti bannati).


Sommario:

Creare:

Può essere eseguito con PUT o POST nel modo seguente:

METTERE

Crea la nuova risorsa con newResourceId come identificatore, sotto l'URI / risorse o raccolta .

PUT /resources/<newResourceId> HTTP/1.1 

INVIARE

Crea una nuova risorsa sotto l'URI / risorse o raccolta . Di solito l'identificatore viene restituito dal server.

POST /resources HTTP/1.1

Aggiornare:

Può essere eseguito solo con PUT nel seguente modo:

METTERE

Aggiorna la risorsa con existingResourceId come identificatore, sotto l'URI / risorse o raccolta .

PUT /resources/<existingResourceId> HTTP/1.1

Spiegazione:

Quando si ha a che fare con REST e URI come generale, si ha un generico a sinistra e uno specifico a destra . I generici sono di solito chiamati collezioni e gli oggetti più specifici possono essere chiamati risorse . Si noti che una risorsa può contenere una raccolta .

Esempi:

<- generico - specifico ->

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

Quando usi il POST ti riferisci sempre a una raccolta , quindi ogni volta che dici:

POST /users HTTP/1.1

stai postando un nuovo utente alla raccolta degli utenti .

Se vai avanti e prova qualcosa del genere:

POST /users/john HTTP/1.1

funzionerà, ma semanticamente stai dicendo che vuoi aggiungere una risorsa alla raccolta john sotto la collezione degli utenti .

Una volta che si utilizza PUT, si fa riferimento a una risorsa oa un singolo oggetto, eventualmente all'interno di una raccolta . Quindi quando dici:

PUT /users/john HTTP/1.1

stai dicendo all'aggiornamento del server, o crea se non esiste, la risorsa john sotto la collezione degli utenti .

Spec:

Permettetemi di evidenziare alcune parti importanti delle specifiche:

INVIARE

Il metodo POST viene utilizzato per richiedere che il server di origine accetti l'entità inclusa nella richiesta come nuovo subordinato della risorsa identificata dall'URI di richiesta nella riga di richiesta

Quindi, crea una nuova risorsa in una raccolta .

METTERE

Il metodo PUT richiede che l'entità inclusa sia archiviata nell'URI di richiesta fornito. Se l'URI della richiesta si riferisce a una risorsa già esistente , l'entità inclusa DOVREBBE essere considerata come una versione modificata di quella che risiede sul server di origine. Se l'URI della richiesta non punta a una risorsa esistente e quell'URI può essere definito come una nuova risorsa dall'agente utente richiedente, il server di origine può creare la risorsa con quell'URI. "

Quindi, creare o aggiornare in base all'esistenza della risorsa .

Riferimento:


Mi piacerebbe aggiungere il mio consiglio "pragmatico". Usa PUT quando conosci l'"id" con il quale l'oggetto che stai salvando può essere recuperato. L'utilizzo di PUT non funzionerà molto bene se è necessario, ad esempio, un ID generato da un database da restituire per consentire future ricerche o aggiornamenti.

Quindi: per salvare un utente esistente o uno in cui il client genera l'ID e si è verificato che l'ID è univoco:

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

Altrimenti, usa POST per creare inizialmente l'oggetto e PUT per aggiornare l'oggetto:

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

POST significa "crea nuovo" come in "Ecco l'input per creare un utente, crearlo per me".

PUT significa "inserisci, sostituisci se già esiste" come in "Ecco i dati per l'utente 5".

POST a example.com/users poiché non conosci ancora l'URL dell'utente, vuoi che il server lo crei.

Metti su example.com/users/id poiché vuoi sostituire / creare un utente specifico .

POSTARE due volte con gli stessi dati significa creare due utenti identici con ID diversi. METTENDO due volte con gli stessi dati crea l'utente il primo e lo aggiorna allo stesso stato la seconda volta (senza modifiche). Poiché si finisce con lo stesso stato dopo un PUT, non importa quante volte lo si esegue, si dice che sia "ugualmente potente" ogni volta - idempotente. Questo è utile per riprovare automaticamente le richieste. Non è più "sei sicuro di voler inviare nuovamente" quando premi il pulsante Indietro sul browser.

Un consiglio generale è di usare il POST quando hai bisogno che il server controlli la generazione di URL delle tue risorse. Usa PUT altrimenti. Preferisci PUT su POST.


REST è un concetto di altissimo livello. In effetti, non menziona nemmeno l'HTTP!

Se hai dei dubbi su come implementare REST in HTTP, puoi sempre dare un'occhiata alle specifiche Atom Publication Protocol (AtomPub) . AtomPub è uno standard per la scrittura di servizi web RESTful con HTTP sviluppato da molti luminari HTTP e REST, con alcuni input da Roy Fielding, l'inventore di REST e (co-) inventore dello stesso HTTP.

In effetti, potresti anche essere in grado di utilizzare direttamente AtomPub. Anche se è uscito dalla comunità dei blog, non è in alcun modo limitato al blogging: è un protocollo generico per interagire RESTfully con raccolte arbitrarie (nidificate) di risorse arbitrarie via HTTP. Se è possibile rappresentare la propria applicazione come raccolta nidificata di risorse, è sufficiente utilizzare AtomPub e non preoccuparsi se utilizzare PUT o POST, quali codici di stato HTTP restituire e tutti quei dettagli.

Questo è ciò che AtomPub ha da dire sulla creazione di risorse (sezione 9.2):

Per aggiungere membri a una raccolta, i client inviano richieste POST all'URI della raccolta.


Usa POST per creare e PUT per aggiornare. È così che lo fa Ruby on Rails, comunque.

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

La decisione se utilizzare PUT o POST per creare una risorsa su un server con un'API HTTP + REST è basata su chi possiede la struttura dell'URL. Avere il cliente a conoscenza o partecipare alla definizione, la struttura dell'URL è un accoppiamento non necessario simile agli accoppiamenti indesiderati che sono sorti dalla SOA. La fuga di tipi di accoppiamenti è la ragione per cui REST è così popolare. Pertanto, il metodo corretto da utilizzare è POST. Esistono eccezioni a questa regola e si verificano quando il cliente desidera mantenere il controllo sulla struttura delle risorse delle risorse che distribuisce. Questo è raro e probabilmente significa che qualcos'altro è sbagliato.

A questo punto alcune persone sosterranno che se vengono utilizzati gli URL RESTful , il client conosce l'URL della risorsa e quindi un PUT è accettabile. Dopo tutto, questo è il motivo per cui sono canonici, normalizzati, Ruby on Rails, gli URL di Django sono importanti, guarda l'API di Twitter ... blah blah blah. Queste persone hanno bisogno di capire che non esiste un URL riposante e che lo stesso Roy Fielding afferma :

Un'API REST non deve definire nomi o gerarchie di risorse fisse (un accoppiamento ovvio tra client e server). I server devono avere la libertà di controllare il proprio spazio dei nomi. Invece, consentire ai server di istruire i clienti su come costruire URI appropriati, come avviene nei moduli HTML e nei modelli URI, definendo tali istruzioni all'interno dei tipi di media e delle relazioni di collegamento. [L'insuccesso qui implica che i clienti stiano assumendo una struttura di risorse a causa di informazioni fuori banda, come uno standard specifico del dominio, che è l'equivalente orientato ai dati dell'accoppiamento funzionale di RPC].

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

L'idea di un URL RESTful è in realtà una violazione di REST poiché il server è responsabile della struttura dell'URL e dovrebbe essere libero di decidere come utilizzarlo per evitare l'accoppiamento. Se questo ti confonde, leggi l'importanza della scoperta di sé sul design dell'API.

L'uso di POST per creare risorse viene fornito con una considerazione di progettazione perché il POST non è idempotente. Ciò significa che ripetere un POST diverse volte non garantisce lo stesso comportamento ogni volta. Questo spaventa le persone a usare PUT per creare risorse quando non dovrebbero. Sanno che è sbagliato (il POST è per CREATE) ma lo fanno comunque perché non sanno come risolvere questo problema. Questa preoccupazione è dimostrata nella seguente situazione:

  1. Il client invia una nuova risorsa al server.
  2. Il server elabora la richiesta e invia una risposta.
  3. Il client non riceve mai la risposta.
  4. Il server non è a conoscenza del fatto che il client non abbia ricevuto la risposta.
  5. Il client non ha un URL per la risorsa (quindi PUT non è un'opzione) e ripete il POST.
  6. Il POST non è idempotente e il server ...

Il punto 6 è dove le persone si confondono comunemente su cosa fare. Tuttavia, non vi è alcun motivo per creare un kludge per risolvere questo problema. Invece, HTTP può essere utilizzato come specificato in RFC 2616 e il server risponde:

10.4.10 409 Conflitto

La richiesta non può essere completata a causa di un conflitto con lo stato corrente della risorsa. Questo codice è consentito solo in situazioni in cui è previsto che l'utente possa risolvere il conflitto e inviare nuovamente la richiesta. Il corpo della risposta DOVREBBE includere abbastanza

informazioni per l'utente per riconoscere l'origine del conflitto. Idealmente, l'entità di risposta includerebbe informazioni sufficienti per l'utente o l'agente utente per risolvere il problema; tuttavia, ciò potrebbe non essere possibile e non è richiesto.

È più probabile che si verifichino conflitti in risposta a una richiesta PUT. Ad esempio, se si utilizzava il controllo delle versioni e l'entità che si trova PUT includeva le modifiche a una risorsa che è in conflitto con quelle effettuate da una richiesta precedente (di terze parti), il server potrebbe utilizzare la risposta 409 per indicare che non può completare la richiesta . In questo caso, l'entità di risposta probabilmente conterrebbe un elenco delle differenze tra le due versioni in un formato definito dalla risposta Content-Type.

Rispondere con un codice di stato di 409 Conflitto è il ricorso corretto perché :

  • L'esecuzione di un POST di dati con un ID che corrisponde a una risorsa già presente nel sistema è "un conflitto con lo stato corrente della risorsa".
  • Poiché la parte importante è che il client comprenda che il server ha la risorsa e che intraprende le azioni appropriate. Questa è una "situazione / i in cui è previsto che l'utente possa essere in grado di risolvere il conflitto e inviare nuovamente la richiesta".
  • Una risposta che contiene l'URL della risorsa con l'ID in conflitto e le precondizioni appropriate per la risorsa fornirebbe "informazioni sufficienti per l'utente o l'agente utente per risolvere il problema", che è il caso ideale per RFC 2616.

Aggiornamento basato sul rilascio di RFC 7231 su Sostituisci 2616

RFC 7231 è progettato per sostituire 2616 e nella Sezione 4.3.3 descrive la possibile risposta successiva per un POST

Se il risultato dell'elaborazione di un POST equivale a una rappresentazione di una risorsa esistente, un server di origine PU MAY reindirizzare l'agente utente a tale risorsa inviando una risposta 303 (Vedi Altro) con l'identificatore della risorsa esistente nel campo Posizione. Ciò ha il vantaggio di fornire all'agente utente un identificatore di risorsa e di trasferire la rappresentazione tramite un metodo più suscettibile alla memorizzazione nella cache condivisa, sebbene al costo di una richiesta aggiuntiva se l'agente utente non ha già la rappresentazione nella cache.

Ora potrebbe essere tentato di restituire semplicemente un 303 nel caso in cui un POST venga ripetuto. Comunque, l'opposto è vero. Restituire un 303 avrebbe senso solo se più richieste di creazione (creando risorse diverse) restituiscono lo stesso contenuto. Un esempio potrebbe essere un "ringraziamento per aver inviato il messaggio di richiesta" che il cliente non deve scaricare nuovamente ogni volta. RFC 7231 mantiene ancora nella sezione 4.2.2 che il POST non deve essere idempotente e continua a sostenere che il POST dovrebbe essere usato per creare.

Per maggiori informazioni a riguardo, leggi questo article .


Nuova risposta (ora che ho capito meglio il REST):

PUT è semplicemente una dichiarazione di quale contenuto il servizio dovrebbe, d'ora in poi, utilizzare per rappresentare la risorsa identificata dal cliente; POST è una dichiarazione di quale contenuto il servizio dovrebbe, d'ora in poi, contenere (possibilmente duplicato) ma spetta al server come identificare quel contenuto.

PUT x(se xidentifica una resource ): "Sostituisci il contenuto della risorsa identificata dal xmio contenuto."

PUT x(se xnon identifica una risorsa): "Crea una nuova risorsa contenente il mio contenuto e utilizzala xper identificarla."

POST x: "Archivia il mio contenuto e forniscimi un identificatore che posso utilizzare per identificare una risorsa (vecchia o nuova) contenente detto contenuto (eventualmente mescolata ad altri contenuti). Detta risorsa dovrebbe essere identica o subordinata a quella che xidentifica." " La risorsa di y è subordinata alla risorsa di x " tipicamente ma non necessariamente implementata facendo di y un sotto percorso di x (es. x = /fooe y = /foo/bar) e modificando la rappresentazione (s) della risorsa x per riflettere l'esistenza di una nuova risorsa, ad es. con un collegamento ipertestuale a yLa risorsa e alcuni metadati. Solo il secondo è davvero essenziale per un buon design, dato che gli URL sono opachi in REST: si suppone che si debba usare hypermedia invece della costruzione URL lato client per attraversare comunque il servizio.

In REST, non esiste una risorsa contenente "contenuto". Mi riferisco come "contenuto" ai dati che il servizio utilizza per rappresentare coerentemente le rappresentazioni. Solitamente consiste in alcune righe correlate in un database o in un file (ad es. Un file immagine). Spetta al servizio convertire il contenuto dell'utente in qualcosa che il servizio può utilizzare, ad esempio la conversione di un carico utile JSON in istruzioni SQL.

Risposta originale (potrebbe essere più facile da leggere) :

PUT /something(se /somethinggià esiste): "Prendi quello che hai /somethinge sostituiscilo con quello che ti do".

PUT /something(se /somethingnon esiste già): "Prendi ciò che ti do e lo metti /something".

POST /something: "Prendi quello che ti do e mettilo ovunque tu voglia /somethingfinché mi dai il suo URL quando hai finito."


Ecco una semplice regola:

PUT a un URL dovrebbe essere usato per aggiornare o creare la risorsa che può essere localizzata in quell'URL.

Il POST di un URL deve essere utilizzato per aggiornare o creare una risorsa che si trova in qualche altro URL ("subordinato") o non localizzabile via HTTP.


Entrambi sono usati per la trasmissione dei dati tra client e server, ma ci sono sottili differenze tra loro, che sono:

Analogia:

  • PUT cioè prendi e metti dove era.
  • POST come inviare la posta in posta ufficio.


Il più delle volte, li userete in questo modo:

  • POSTARE una risorsa in una raccolta
  • Metti una risorsa identificata dalla collezione /: id

Per esempio:

  • POST / articoli
  • PUT / items / 1234

In entrambi i casi, il corpo della richiesta contiene i dati per la risorsa da creare o aggiornare. Dovrebbe essere ovvio dai nomi delle rotte che il POST non è idempotente (se lo chiami 3 volte creerà 3 oggetti), ma PUT è idempotente (se lo chiami 3 volte il risultato è lo stesso). PUT viene spesso utilizzato per l'operazione "upsert" (creazione o aggiornamento), ma è sempre possibile restituire un errore 404 se si desidera utilizzarlo solo per la modifica.

Nota che POST "crea" un nuovo elemento nella collezione e PUT "sostituisce" un elemento in un dato URL, ma è una pratica molto comune usare PUT per le modifiche parziali, cioè usarlo solo per aggiornare le risorse esistenti e modificare solo i campi inclusi nel corpo (ignorando gli altri campi). Questo è tecnicamente scorretto, se vuoi essere purista di REST, PUT dovrebbe sostituire l'intera risorsa e dovresti usare PATCH per l'aggiornamento parziale. Personalmente non mi interessa molto di quanto il comportamento sia chiaro e coerente su tutti i tuoi endpoint API.

Ricorda, REST è un insieme di convenzioni e linee guida per mantenere la tua API semplice. Se finisci con un complicato work-around solo per controllare la casella "RESTfull", allora stai sconfiggendo lo scopo;)


In un modo molto semplice sto prendendo l'esempio della timeline di Facebook.

Caso 1: quando pubblichi qualcosa sulla tua timeline, è una nuova entrata. Quindi in questo caso usano il metodo POST perché il metodo POST non è idempotente.

Caso 2: se il tuo amico commenta il tuo post per la prima volta, anche questo creerà una nuova voce nel database in modo tale da utilizzare il metodo POST.

Caso 3: se il tuo amico modifica il suo commento, in questo caso ha un ID commento, quindi aggiornerà un commento esistente anziché creare una nuova voce nel database. Pertanto per questo tipo di operazione utilizzare il metodo PUT perché è idempotente. *

In una singola riga, utilizzare POST per aggiungere una nuova voce nel database e PUT per aggiornare qualcosa nel database.


Mentre c'è probabilmente un modo agnostico per descriverli, sembra essere in conflitto con varie affermazioni dalle risposte ai siti web.

Siamo molto chiari e diretti qui. Se sei uno sviluppatore .NET che lavora con Web API, i fatti sono (dalla documentazione dell'API di Microsoft), 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.

Certo, "puoi" usare "POST" per aggiornare, ma segui semplicemente le convenzioni stabilite per te con il tuo framework. Nel mio caso è .NET / Web API, quindi PUT è per UPDATE non c'è dibattito.

Spero che questo aiuti tutti gli sviluppatori Microsoft che leggono tutti i commenti con i link di Amazon e Sun / Java.


Oltre alle differenze suggerite da altri, voglio aggiungerne un'altra.

Nel metodo POST puoi inviare i parametri del corpo inform-data

Nel metodo PUT devi inviare i parametri del corpo inx-www-form-urlencoded

Intestazione Content-Type:application/x-www-form-urlencoded

In base a questo, non è possibile inviare file o dati multiparte nel metodo PUT

MODIFICARE

Il tipo di contenuto "application / x-www-form-urlencoded" è inefficiente per l'invio di grandi quantità di dati binari o di testo contenenti caratteri non ASCII. Il tipo di contenuto "multipart / form-data" deve essere utilizzato per inviare moduli che contengono file, dati non ASCII e dati binari.

Il che significa se devi presentare

file, dati non ASCII e dati binari

dovresti usare il metodo POST


Se hai familiarità con le operazioni del database, ci sono

  1. Selezionare
  2. Inserire
  3. Aggiornare
  4. Elimina
  5. Unisci (aggiorna se già esistente, altrimenti inserisci)

Io uso PUTper Unisci e aggiorno le operazioni come e uso POSTper Inserimenti.


A rischio di riaffermare ciò che è già stato detto, sembra importante ricordare che PUT implica che il client controlla l' URL che sta per finire quando crea una risorsa. Quindi parte della scelta tra PUT e POST riguarderà quanto puoi fidarti del cliente per fornire URL corretti e normalizzati che siano coerenti con qualunque sia lo schema URL.

Quando non ci si può fidare completamente del client per fare la cosa giusta, sarebbe più appropriato usare POST per creare un nuovo oggetto e quindi inviare l'URL al client nella risposta.


In pratica, il POST funziona bene per la creazione di risorse. L'URL della risorsa appena creata deve essere restituito nell'intestazione della risposta Location. PUT dovrebbe essere usato per aggiornare completamente una risorsa. Si prega di comprendere che queste sono le migliori pratiche durante la progettazione di un'API RESTful. Le specifiche HTTP in quanto tali non limitano l'utilizzo di PUT / POST con alcune restrizioni per la creazione / aggiornamento delle risorse. Dai un'occhiata a http://techoctave.com/c7/posts/71-twitter-rest-api-dissected che riassume le migliori pratiche.


La considerazione più importante è l' affidabilità . Se un messaggio POST viene perso, lo stato del sistema non è definito. Il recupero automatico è impossibile. Per i messaggi PUT, lo stato non è definito solo fino al primo tentativo riuscito.

Ad esempio, potrebbe non essere una buona idea creare transazioni con carta di credito con POST.

Se ti capita di avere URI generati automaticamente sulla tua risorsa, puoi comunque utilizzare PUT passando un URI generato (che punta a una risorsa vuota) al client.

Alcune altre considerazioni:

  • Il POST invalida le copie memorizzate nella cache dell'intera risorsa contenente (migliore consistenza)
  • Le risposte PUT non sono memorizzabili nella cache mentre quelle POST sono (Richiedi Content-Location and expiration)
  • PUT è meno supportato da es. Java ME, browser più vecchi, firewall

POST è come inviare una lettera a una casella di posta o inviare un'e-mail a una coda di posta elettronica. PUT è come quando metti un oggetto in una tana o in un posto su uno scaffale (ha un indirizzo conosciuto).

Con POST, stai postando all'indirizzo della CODA o della RACCOLTA. Con PUT, stai inserendo l'indirizzo dell'ITEM.

PUT è idempotente. Puoi inviare la richiesta 100 volte e non importa. POST non è idempotente. Se invii la richiesta 100 volte, riceverai 100 e-mail o 100 lettere nella tua casella postale.

Una regola generale: se conosci l'ID o il nome dell'articolo, usa PUT. Se si desidera che l'ID o il nome dell'articolo sia assegnato dalla parte ricevente, utilizzare POST.


Sembra esserci sempre una certa confusione su quando utilizzare il POST HTTP rispetto al metodo PUT HTTP per i servizi REST. La maggior parte degli sviluppatori proverà ad associare le operazioni CRUD direttamente ai metodi HTTP. Discuterò che questo non è corretto e non si può semplicemente associare i concetti CRUD ai metodi HTTP. Questo è:

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

È vero che R (etrieve) e D (elete) delle operazioni CRUD possono essere mappati direttamente ai metodi HTTP GET e DELETE rispettivamente. Tuttavia, la confusione si trova nelle operazioni C (reate) e U (aggiornamento). In alcuni casi, è possibile utilizzare il PUT per creare mentre in altri casi sarà richiesto un POST. L'ambiguità risiede nella definizione di un metodo PUT HTTP rispetto a un metodo POST HTTP.

In base alle specifiche HTTP 1.1 i metodi GET, HEAD, DELETE e PUT devono essere idempotenti e il metodo POST non è idempotente. Vale a dire che un'operazione è idempotente se può essere eseguita su una risorsa una o più volte e restituire sempre lo stesso stato di quella risorsa. Mentre un'operazione non idempotente può restituire uno stato modificato della risorsa da una richiesta all'altra. Quindi, in un'operazione non idempotente, non vi è alcuna garanzia che si riceverà lo stesso stato di una risorsa.

In base alla suddetta definizione idempotente, il mio modo di utilizzare il metodo PUT HTTP rispetto al metodo POST HTTP per i servizi REST è: Utilizzare il metodo PUT HTTP quando:

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 entrambi i casi, queste operazioni possono essere eseguite più volte con gli stessi risultati. Questa è la risorsa non verrà modificata richiedendo l'operazione più di una volta. Quindi, una vera operazione idempotente. Usa il metodo POST HTTP quando:

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.

Conclusione

Non correlare e mappare direttamente le operazioni CRUD ai metodi HTTP per i servizi REST. L'uso di un metodo PUT HTTP rispetto a un metodo POST HTTP dovrebbe essere basato sull'aspetto idempotente di tale operazione. Cioè, se l'operazione è idempotente, quindi utilizzare il metodo HTTP PUT. Se l'operazione non è idempotente, utilizzare il metodo HTTP POST.





put