32 Question: PUT vs. POST in REST

question créée à Sat, Jul 22, 2017 12:00 AM

Selon les spécifications HTTP /1.1:

  

La méthode POST est utilisée pour demander au serveur d'origine d'accepter l'entité incluse dans la demande en tant que nouveau subordonné de la ressource identifiée par le Request-URI dans Request-Line

.

En d'autres termes, POST est utilisé pour créer .

  

La méthode PUT demande que l'entité incluse soit stockée sous le Request-URI fourni. Si le Request-URI fait référence à une ressource déjà existante, l'entité incluse DEVRAIT être considérée comme une version modifiée de celle résidant sur le serveur d'origine. Si le Request-URI ne pointe pas vers une ressource existante et que cet URI peut être défini en tant que nouvelle ressource par l'agent utilisateur demandeur, le serveur d'origine peut créer la ressource avec cet URI. "

En d'autres termes, PUT est utilisé pour créer ou mettre à jour .

Alors, lequel devrait être utilisé pour créer une ressource? Ou faut-il supporter les deux?

    
4996
  1. Il pourrait être utile d’utiliser les définitions de HTTPbis - Roy a mis beaucoup de travail à faire pour les clarifier. Voir: tools.ietf.org/html/…
    2011-10-23 21: 03: 06Z
  2. Juste pour apporter le commentaire de @ MarkNottingham à la dernière révision, voici POST et PUT , tel que défini sur HTTPbis.
    2012-11-18 01: 58: 46Z
  3. Il me semble que ce débat est né de la pratique courante consistant à simplifier à l'excès REST en décrivant les méthodes HTTP en termes d'opérations CRUD.
    2013-02-14 17: 05: 15Z
  4. Malheureusement, les premières réponses sont fausses sur le POST. Vérifiez ma réponse pour une meilleure explication des différences: stackoverflow.com/a/18243587/2458234
    2013-11-25 05: 21: 37Z
  5. PUT et POST sont deux méthodes peu sûres. Cependant, PUT est idempotent, tandis que POST ne l’est pas. - Plus d'informations sur: restcookbook.com/HTTP%20Methods/put-vs-post /…
    2014-01-10 20: 26: 49Z
30 réponses                              30                         

Dans l'ensemble:

PUT et POST peuvent être utilisés pour créer.

Vous devez demander "à quoi effectuez-vous l'action?" pour distinguer ce que vous devriez utiliser. Supposons que vous concevez une API pour poser des questions. Si vous voulez utiliser POST, vous feriez cela avec une liste de questions. Si vous souhaitez utiliser PUT, vous pouvez le faire pour une question particulière.

Les deux peuvent être utilisés. Lequel puis-je utiliser dans ma conception RESTful:

Vous n'avez pas besoin de prendre en charge à la fois PUT et POST.

Ce qui est utilisé est laissé à vous. Mais n'oubliez pas d'utiliser le bon en fonction de l'objet que vous référencez dans la requête.

Quelques considérations:

  • Nommez-vous explicitement les objets URL que vous avez créés ou laissez-vous le serveur décider? Si vous les nommez, utilisez PUT. Si vous laissez le serveur décider, utilisez POST.
  • PUT est idempotent, donc si vous mettez un objet deux fois, cela n’a aucun effet. Ceci est une belle propriété, donc je voudrais utiliser PUT lorsque cela est possible.
  • Vous pouvez mettre à jour ou créer une ressource avec PUT avec le même objet URL
  • Avec POST, vous pouvez recevoir 2 demandes en même temps qui modifient une URL et mettre à jour différentes parties de l'objet.

Un exemple:

J'ai écrit ce qui suit comme une partie d’une autre réponse sur l’objet de la SO concernant :

  

POST:

     

Utilisé pour modifier et mettre à jour une ressource

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

Notez que ce qui suit est une erreur:

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

Si l'URL n'est pas encore créée, vous   ne devrait pas utiliser POST pour le créer   en spécifiant le nom. Ceci devrait   résulte en une erreur 'ressource introuvable'   parce que <new_question> n'existe pas   encore. Vous devriez mettre le <new_question>   ressource sur le serveur en premier.

     

Vous pouvez cependant faire quelque chose comme   ceci pour créer des ressources en utilisant POST:

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

Notez que dans ce cas la ressource   nom n'est pas spécifié, les nouveaux objets   Le chemin d’URL vous serait renvoyé.

     

PUT:

     

Utilisé pour créer une ressource, ou   réécrit dessus. Pendant que vous spécifiez le   ressources nouvelle URL.

     

Pour une nouvelle ressource:

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

Pour écraser une ressource existante:

 
PUT /questions/<existing_question> HTTP/1.1
Host: www.example.com/
    
3941
2017-05-23 11: 55: 13Z
  1. Je pense qu'on ne saurait trop insister sur le fait que PUT est idempotent: si le réseau est bâclé et que le client ne sait pas si sa demande a été traitée, il peut simplement envoyer une seconde (ou centième) fois, et les spécifications HTTP garantissent que cela a exactement le même effet que d'envoyer une fois.
    2009-03-10 15: 17: 07Z
  2. @ Jörg W Mittag: Non nécessaire. La deuxième fois, 409 pourrait produire un conflit ou quelque chose si la demande a été modifiée entre-temps (par un autre utilisateur ou par la première demande elle-même, qui est passée).
    2011-11-27 23: 28: 22Z
  3. Si je ne me trompe pas, ce que nous devrions souligner, c'est que PUT est défini pour être idempotent. Vous devez toujours écrire votre serveur de telle manière que PUT se comporte correctement, oui? Il est peut-être préférable de dire "PUT fait en sorte que le transport assume une idempotence, ce qui peut affecter le comportement du transport, par exemple la mise en cache."
    2011-12-28 02: 05: 20Z
  4. @ JörgWMittag Idophotence? Que diriez-vous de "envoyer et envoyer et envoyer mon ami, cela ne fait aucune différence à la fin."
    2014-03-03 17: 13: 28Z
  5. Les considère comme: PUT = insert ou update; POST = insérer. Ainsi, lorsque vous effectuez deux PUT - vous obtenez le nouvel enregistrement, lorsque vous réalisez deux POST - vous obtenez deux nouveaux enregistrements.
    2016-08-22 09: 34: 34Z

Vous pouvez trouver sur le Web des assertions disant

Ni est tout à fait raison.

Mieux vaut choisir entre PUT et POST en fonction de la idempotence de l'action.

PUT implique de mettre une ressource - en remplaçant complètement tout ce qui est disponible à l'URL donnée par un élément différent. Par définition, un PUT est idempotent. Faites-le autant de fois que vous le souhaitez et le résultat est le même. x=5 est idempotent. Vous pouvez PUT une ressource si elle existait auparavant ou non (par exemple, pour créer ou pour mettre à jour)!

POST met à jour une ressource, ajoute une ressource auxiliaire ou provoque une modification. Un post n'est pas idempotent, de la même manière que x++ n'est pas idempotent.

Par cet argument, PUT sert à créer lorsque vous connaissez l'URL de la chose que vous allez créer. POST peut être utilisé pour créer lorsque vous connaissez l'URL de la "fabrique" ou du gestionnaire de la catégorie de choses que vous souhaitez créer.

alors:

 
POST /expense-report

ou:

 
PUT  /expense-report/10929
    
2075
2013-05-22 05: 56: 05Z
  1. Je suis d'accord, quel que soit le problème de idempotence, il devrait l'emporter sur tout autre problème, car le fait de se tromper peut causer de nombreux bogues inattendus.
    2010-10-26 05: 56: 09Z
  2. Si le POST peut mettre à jour une ressource, comment n'est-il pas idempotent? Si je modifie l'âge d'un élève à l'aide de PUT et que je le fais 10 fois, son âge est identique si je l'ai déjà fait une fois.
    2011-05-06 10: 54: 35Z
  3. @ Schneider, dans ce cas, votre serveur fait un effort supplémentaire pour garantir l'idempotence, mais il ne le fait pas de publicité. Les navigateurs avertiront toujours l'utilisateur s'ils tentent de recharger une telle requête POST.
    2012-01-06 10: 53: 35Z
  4. @ Schneider POST peut créer une ressource subsidiaire. par conséquent, vous pouvez POST pour la collecte, comme POST /rapports de dépenses et créerait autant d'entités (rapports de dépenses) sur votre serveur que le nombre de demandes que vous avez envoyées, même si elles sont complètement similaires . Considérez cela comme une insertion de la même ligne dans la table de base de données (/reports-reports) avec une clé primaire auto-incrémentée. Les données restent les mêmes, la clé (URI dans ce cas) est générée par le serveur et est différente pour chaque autre insertion (demande). Ainsi, l’effet POST peut être idempotent, mais également ne le peut pas. Par conséquent, POST n’est pas idempotent.
    2012-01-26 17: 32: 20Z
  5. Supposons que nous avons des entités pouvant avoir deux propriétés - name et date. Si nous avons une entité avec les name et date existants, mais que nous lui adressons ensuite des demandes spécifiant uniquement un name, le comportement correct de PUT consistera à effacer le date de l'entité, tandis que POST peut mettre à jour uniquement les propriétés spécifiées, en laissant les propriétés non spécifiées telles qu'elles étaient avant la demande. Cela vous semble-t-il correct /raisonnable ou s'agit-il d'une utilisation inappropriée de PUT (j'ai vu des références à PATCH , qui semblerait plus approprié, mais n'existe pas encore )?
    2013-05-08 18: 28: 14Z
  • POST sur une URL crée une ressource enfant sur une URL définie par le serveur .
  • PUT sur une URL crée /remplace intégralement la ressource à l'URL définie par le client .
  • PATCH vers une URL met à jour la partie de la ressource au niveau de l'URL définie par le client.

La spécification pertinente pour PUT et POST est RFC 2616 §9.5 ff.

POST crée une ressource enfant . POST pour /items crée donc une ressource située sous la ressource /items. Par exemple. /items/1. Envoyer deux fois le même paquet de messages créera deux ressources.

PUT permet de créer ou de remplacer une ressource à une URL connue du client .

Par conséquent: PUT n'est qu'un candidat pour CREATE où le client connaît déjà l'URL avant la création de la ressource. Par exemple. /blogs/nigel/entry/when_to_use_post_vs_put car le titre est utilisé comme clé de ressource

PUT remplace la ressource à l'URL connue, si elle existe déjà. Par conséquent, l'envoi de la même demande deux fois n'a aucun effet. En d'autres termes, les appels à PUT sont idempotents .

La RFC se lit comme suit:

  

La différence fondamentale entre les requêtes POST et PUT est reflétée dans la signification différente de l'URI de demande. L'URI dans une demande POST identifie la ressource qui gérera l'entité incluse. Cette ressource peut être un processus acceptant les données, une passerelle vers un autre protocole ou une entité distincte acceptant les annotations. En revanche, l'URI dans une demande PUT identifie l'entité jointe à la demande - l'agent d'utilisateur sait ce que l'URI est destiné et le serveur NE DOIT PAS tenter d'appliquer la demande à une autre ressource. Si le serveur souhaite que la demande soit appliquée à un autre URI,

Remarque: PUT a principalement été utilisé pour mettre à jour les ressources (en les remplaçant intégralement), mais récemment, l'utilisation de PATCH pour mettre à jour les ressources existantes a commencé à évoluer, car PUT spécifie qu'il remplace l'intégralité de la ressource. RFC 5789.

Mise à jour 2018 : Vous pouvez éviter le PUT dans certains cas. Voir "RESTE sans PUT"

  

Avec la technique «REST without PUT», l’idée est que les consommateurs sont   contraint d'afficher de nouvelles ressources de requête 'nomifiées'. Tel que discuté   plus tôt, changer l’adresse postale d’un client est un envoi postal à un nouveau   «ChangeOfAddress», pas le PUT d’une ressource «Client» avec un   valeur différente du champ d'adresse postale.

extrait de Conception d'API REST - Modélisation des ressources par Prakash Subramaniam of Thoughtworks

Cela oblige l'API à éviter les problèmes de transition d'état lorsque plusieurs clients mettent à jour une seule ressource et à mieux correspondre à la génération d'événements et à CQRS. Lorsque le travail est effectué de manière asynchrone, l’envoi de la transformation et l’attente de son application semble approprié.

    
652
2018-11-26 01: 52: 54Z
  1. Ou de l'autre côté de la clôture: PUT si le client détermine l'adresse de la ressource résultante, POST si le serveur le fait.
    2012-11-28 19: 47: 28Z
  2. Je pense que cette réponse devrait être modifiée de manière à préciser ce que @DanMan a indiqué de manière très simple. Ce que je trouve le plus précieux ici est la note à la fin, indiquant qu’un PUT ne devrait être utilisé que pour remplacer la totalité de la ressource.
    2013-11-26 22: 37: 51Z
  3. PATCH n'est pas une option réaliste pendant au moins quelques années, mais je suis d'accord avec l'idéologie.
    2014-10-03 17: 33: 08Z
  4. J'essaie de comprendre, mais utiliser PUT pour créer quelque chose n'aurait de sens que si le client sait à coup sûr que la ressource n'existe pas encore, n'est-ce pas? En suivant l'exemple du blog, supposons que vous ayez créé des centaines de blogs en quelques années, puis que vous choisissiez accidentellement le même titre que vous l'aviez fait il y a deux ans. Maintenant, vous êtes parti et avez remplacé ce poste, ce qui n'était pas prévu. Donc, utiliser PUT pour créer obligerait le client à suivre ce qui est pris et ce qui ne l’est pas, et pourrait entraîner des accidents et des effets secondaires non désirés, ainsi que des itinéraires effectuant deux choses totalement différentes?
    2015-01-30 09: 01: 22Z
  5. Vous avez raison. Placer un article de blog à la même URL qu'un article existant entraînerait une mise à jour de cet article (bien que vous puissiez évidemment vérifier d'abord avec un GET). Cela indique pourquoi ce serait une mauvaise idée d'utiliser uniquement le titre en tant qu'URL. Cela fonctionnerait cependant n'importe où il y aurait une clé naturelle dans les données… ce qui, selon mon expérience, est rare. Ou si vous avez utilisé des GUID
    2015-02-03 05: 20: 12Z

Résumé:

Créer:

Peut être exécuté à la fois avec PUT ou POST de la manière suivante:

  

PUT

     

Crée la LA nouvelle ressource avec newResourceId comme identifiant, sous l'URI /resources ou la collection .

 
PUT /resources/<newResourceId> HTTP/1.1 
     

POST

     

Crée une ressource dans l'URI /resources ou la collection . Généralement, l'identifiant est renvoyé par le serveur.

 
POST /resources HTTP/1.1

Mise à jour:

Peut-on seulement être exécuté avec PUT de la manière suivante:

  

PUT

     

Met à jour la ressource avec existingResourceId comme identifiant, sous l'URI /resources ou la collection .

 
PUT /resources/<existingResourceId> HTTP/1.1

Explication:

Lorsque vous traitez avec REST et URI en général, vous avez générique sur la gauche et spécifique sur la droite . Les génériques sont généralement appelés collections et les éléments spécifiques peuvent être appelés ressources . Notez qu'une ressource peut contenir une collection .

  

Exemples:

     

< - générique - spécifique - >

 
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

Lorsque vous utilisez le POST, vous faites toujours référence à une collection . Par conséquent, chaque fois que vous dites:

 
POST /users HTTP/1.1

vous publiez un nouvel utilisateur sur les utilisateurs de collection .

Si vous continuez et essayez quelque chose comme ceci:

 
POST /users/john HTTP/1.1

cela fonctionnera, mais vous dites sémantiquement que vous souhaitez ajouter une ressource à la john collection sous les utilisateurs collection .

Une fois que vous utilisez PUT, vous vous référez à une ressource ou à un seul élément, éventuellement dans une collection . Alors, quand vous dites:

 
PUT /users/john HTTP/1.1

vous indiquez à la mise à jour du serveur ou créez, si elle n’existe pas, la john ressource située sous les utilisateurs collection .

Spec:

Permettez-moi de souligner certaines parties importantes de la spécification:

POST

  

La méthode POST est utilisée pour demander au serveur d'origine d'accepter l'entité incluse dans la demande en tant que nouveau subordonné de la ressource identifiée par l'URI de la demande dans la ligne de la demande

Par conséquent, crée une nouvelle ressource sur une collection .

PUT

  

La méthode PUT demande que l'entité incluse soit stockée dans l'URI de demande fourni. Si l'URI de la demande fait référence à une ressource déjà existante , l'entité incluse DEVRAIT être considérée comme une version modifiée de celle résidant sur le serveur d'origine. Si l'URI de la demande ne pointe pas vers une ressource existante et que cet capable d'être défini comme une nouvelle ressource par l'agent utilisateur demandeur, le serveur d'origine peut créer la ressource avec cet URI. "

Par conséquent, créez ou mettez à jour en fonction de l'existence de la ressource .

Référence:

192
2016-02-09 18: 25: 43Z
  1. Ce message m'a aidé à comprendre que POST ajoute "quelque chose" en tant qu'enfant à la collection donnée (URI), alors que PUT définit explicitement le "quelque chose" à la emplacement URI donné.
    2013-11-23 16: 33: 19Z
  2. C'est la meilleure réponse, ici, je pense: rien de cela "le POST peut mettre à jour une ressource" n'a aucun sens. J'aime votre déclaration, "La mise à jour ne peut être effectuée qu'avec PUT".
    2015-05-28 13: 44: 40Z
  3. Non, PUT n'est pas pour la mise à jour ou la création. C'est pour remplacer. Notez que vous ne pouvez rien remplacer par quelque chose qui ait pour effet de créer.
    2015-06-08 08: 07: 28Z
  4. @ 7hi4g0 PUT est destiné à la mise à jour avec un remplacement complet, autrement dit, il remplace. Vous ne remplacez rien par quelque chose ou quelque chose par un tout nouveau. PUT ne sert pas à apporter une modification mineure (à moins que le client n’effectue cette modification mineure et fournisse la nouvelle version dans son intégralité, même si elle reste identique). PATCH est la méthode de choix pour les modifications partielles.
    2015-06-08 12: 57: 21Z
  5. @ thecoshman Vous pourriez le faire, mais il ne serait pas trop clair que create est également couvert. Dans ce cas, il vaut mieux être explicite.
    2015-06-09 20: 21: 12Z

J'aimerais ajouter mon conseil "pragmatique". Utilisez PUT lorsque vous connaissez "l'identifiant" permettant d'extraire l'objet que vous enregistrez. L'utilisation de PUT ne fonctionnera pas très bien si vous avez besoin, par exemple, d'un identifiant généré par une base de données à renvoyer pour que vous puissiez effectuer des recherches ou des mises à jour futures.

Donc: pour enregistrer un utilisateur existant ou un utilisateur dont l'ID est généré par le client et dont l'identité est unique:

 
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

Sinon, utilisez POST pour créer initialement l'objet et PUT pour le mettre à jour:

 
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
    
170
2011-05-25 03: 43: 05Z
  1. En fait, il devrait s'agir de POST /users. (Notez que /users est pluriel.) Cela a pour effet de créer un nouvel utilisateur et d'en faire une ressource enfant de la collection /users.
    2014-12-16 13: 54: 53Z
  2. @ DavidRR pour être juste, comment gérer les groupes est un tout autre débat. GET /users est logique, il se lit comme vous le souhaitez, mais je serais d'accord avec GET /user/<id> ou POST /user (avec la charge utile dudit nouvel utilisateur) car il lit correctement 'get me users 5' est impair, mais 'get me user 5' est plus Naturel. Je serais probablement encore tombé du côté de la pluralisation:)
    2015-06-08 07: 57: 14Z

POST signifie "créer un nouveau" comme dans "Voici l'entrée pour créer un utilisateur, créez-le pour moi".

PUT signifie "insérer, remplacer si existe déjà" comme dans "Voici les données pour l'utilisateur 5".

Vous POST sur example.com/users puisque vous ne connaissez pas encore l'URL de l'utilisateur, vous souhaitez que le serveur le crée.

Vous ALLEZ à example.com/users/id car vous souhaitez remplacer /créer un utilisateur spécifique .

POST deux fois avec les mêmes données signifie créer deux utilisateurs identiques avec des identifiants différents. PUTing deux fois avec les mêmes données crée le premier utilisateur et le remet au même état la deuxième fois (sans modification). Puisque vous vous retrouvez dans le même état après une opération PUT, peu importe le nombre de fois que vous l’effectuez, on dit qu’il est "tout aussi puissant" à chaque fois - idempotent. Ceci est utile pour réessayer automatiquement les demandes. Plus besoin d’être sûr de vouloir renvoyer le message lorsque vous appuyez sur le bouton Précédent du navigateur.

Un conseil général est d'utiliser POST lorsque vous avez besoin que le serveur contrôle la génération d'URL de vos ressources. Utilisez PUT autrement. Préfère PUT au POST.

    
163
2017-04-23 18: 13: 45Z
  1. Le manque de rigueur peut avoir pour conséquence qu'il est généralement appris qu'il n'y a que deux verbes dont vous avez besoin: GET et POST. OBTENIR d'obtenir, POST pour changer. Même PUT et DELETE ont été réalisés avec POST. Demander ce que PUT signifie vraiment 25 ans plus tard est peut-être un signe que nous avons mal compris au début. La popularité de REST a ramené les gens à la base, où nous devons maintenant désapprendre les mauvaises erreurs passées. Le POST a été surutilisé et est maintenant enseigné de manière incorrecte. La meilleure partie: "POST deux fois avec les mêmes données signifie créer deux [ressources] identiques". Excellent point!
    2014-09-01 19: 36: 14Z
  2. Comment pouvez-vous utiliser PUT pour créer un enregistrement par son ID, comme dans votre exemple user 5 s'il n'existe pas encore? Tu ne veux pas dire update, replace if already exists? ou quelque chose
    2014-11-28 12: 44: 13Z
  3. @ Coulton: Je voulais dire ce que j'ai écrit. Vous insérez l'utilisateur 5 si vous passez à /users /5 et # 5 n'existent pas encore.
    2014-11-28 15: 46: 33Z
  4. @ Coulton: Et PUT peut également être utilisé pour remplacer la valeur d'une ressource existante dans son intégralité.
    2014-12-16 14: 02: 34Z
  5. "Préférer le PUT au POST" ... faut-il justifier cela?
    2015-06-08 08: 04: 31Z

Utilisez POST pour créer et PUT pour mettre à jour. C’est comme ça que Ruby on Rails le fait, de toute façon.

 
PUT    /items/1      #=> update
POST   /items        #=> create
    
121
2017-09-16 20: 17: 08Z
  1. POST /items ajoute un nouvel élément à une ressource déjà définie ('item'). Comme le dit la réponse, cela ne signifie pas "créer un groupe". Je ne comprends pas pourquoi cela a 12 votes.
    2012-06-21 05: 26: 07Z
  2. Ceci est une directive juste, mais une simplification excessive. Comme le mentionnent les autres réponses, l'une ou l'autre méthode peut être utilisée pour créer et mettre à jour.
    2013-03-07 15: 55: 49Z
  3. Je suis d'accord avec la réponse avec une légère modification. Utilisez POST pour créer et PUT pour mettre à jour complètement la ressource. Pour les mises à jour partielles, nous pouvons utiliser PUT ou PATCH. Disons que nous voulons mettre à jour le statut d'un groupe. Nous pouvons utiliser PUT /groups /1 /status avec le statut correspondant à la charge utile de la requête ou PATCH /groupes /1 avec les détails de l’action dans la charge utile
    2014-10-06 06: 26: 04Z
  4. Il convient également de préciser que PUT /items/42 est également valable pour créer une ressource, mais uniquement si le client dispose du privilège de nommer la ressource . (Rails autorise-t-il ce client à attribuer ce privilège?)
    2014-12-16 14: 10: 00Z
  5. remplacer est meilleur mot pour le correctif PUT est pour la mise à jour
    2016-01-20 06: 59: 37Z

Les deux sont utilisés pour la transmission de données entre client et serveur, mais ils présentent des différences subtiles, à savoir:

 Entrez la description de l'image ici

Analogie:

  • PUT c'est-à-dire prendre et mettre à sa place.
  • POST comme envoi de courrier dans le post bureau.

 entrez la description de l'image ici

Analogie avec les réseaux sociaux:

  • Publier sur les réseaux sociaux: lorsque nous publions un message, cela crée un nouveau message.
  • Mettez (c'est-à-dire modifier) ​​pour le message que nous avons déjà posté.
96
2019-03-29 02: 54: 21Z
  1. Donc, en résumé: POST pour les insertions, PUT pour les mises à jour
    2015-09-22 12: 31: 19Z
  2. @ MobileMon Non, les méthodes REST ne sont pas CRUD.
    2016-01-08 19: 06: 38Z
  3. Je dirais PUT pour UPSERTS
    2018-11-26 11: 45: 16Z

REST est un concept de haut niveau très . En fait, il ne mentionne même pas HTTP du tout!

Si vous avez des doutes sur la manière d'implémenter REST dans HTTP, vous pouvez toujours jeter un coup d'œil à Spécification du protocole de publication Atom (AtomPub) . AtomPub est un standard pour l’écriture de services Web RESTful avec HTTP, développé par de nombreux experts HTTP et REST, avec l’aide de Roy Fielding, inventeur de REST et inventeur du HTTP lui-même.

En fait, vous pourriez même être en mesure d’utiliser AtomPub directement. Bien qu’il soit issu de la communauté des blogueurs, il n’est en aucun cas limité aux blogs: c’est un protocole générique pour RESTg avec des collections arbitraires (imbriquées) de ressources arbitraires via HTTP. Si vous pouvez représenter votre application comme une collection imbriquée de ressources, vous pouvez simplement utiliser AtomPub sans vous soucier d’utiliser PUT ou POST, les codes d’état HTTP à renvoyer et tous ces détails.

Voici ce qu'AtomPub a à dire sur la création de ressources (section 9.2):

  

Pour ajouter des membres à une collection, les clients envoient des demandes POST à ​​l'URI de la collection.

    
65
2018-07-27 14: 37: 27Z
  1. Il n'y a rien de mal à permettre à PUT de créer des ressources. Sachez simplement que cela signifie que le client fournit l’URL.
    2010-04-07 07: 47: 32Z
  2. Il est très erroné de permettre à PUT de créer des ressources: le client fournit l'URL. C'est le travail du serveur!
    2013-10-29 17: 33: 01Z
  3. @ Joshcodes Ce n'est pas toujours le cas que le travail du serveur consiste à créer des identifiants client. J'ai de plus en plus vu des conceptions permettant aux clients de générer une sorte d'UUID en tant qu'identifiant de ressource. Cette conception se prête particulièrement à l’agrandissement.
    2017-02-05 18: 26: 16Z
  4. @ JustinOhms Je suis d'accord avec votre argument concernant les identifiants générés par le client (remarque: tous les systèmes conçus par moi depuis environ 2008 exigent que le client crée l'identifiant sous la forme d'un UUID /Guid. ). Cela ne signifie pas que le client doit spécifier l'URL.
    2017-02-06 18: 24: 26Z
  5. Oui, si la ressource existe déjà, utilisez PUT. Cependant, dans presque tous les cas, les ressources doivent être créées avec POST et le client ne doit pas fournir l'URL. Roy Fielding est d’accord avec cette affirmation FWIW: roy.gbiv. com /untangled /2008 /rest-apis-doit-être-dirigé par l'hypertexte
    2017-02-07 01: 26: 05Z

La décision d'utiliser PUT ou POST pour créer une ressource sur un serveur avec une API HTTP + REST dépend de la personne qui possède la structure de l'URL. Le client doit savoir ou participer à la définition , la structure de l'URL est un couplage inutile apparenté aux couplages indésirables issus de la SOA. Les types de couplage qui s'échappent sont la raison pour laquelle REST est si populaire. Par conséquent, la méthode appropriée à utiliser est POST. Il existe des exceptions à cette règle qui surviennent lorsque le client souhaite conserver le contrôle de la structure d'emplacement des ressources qu'il déploie. Ceci est rare et signifie probablement que quelque chose ne va pas.

À ce stade, certaines personnes diront que si les URL RESTful sont utilisées, le client connaît l'URL de la ressource et, par conséquent, un PUT est acceptable. Après tout, c’est la raison pour laquelle les URL canoniques, normalisées, Ruby on Rails, Django sont importantes. Regardez l’API de Twitter… bla bla bla. Ces personnes doivent comprendre qu’il n’existe pas d’URL reposante et que Roy Fielding déclare lui-même que :

  

Une API REST ne doit pas définir de noms de ressources fixes ni de hiérarchies (une   couplage évident du client et du serveur). Les serveurs doivent avoir la liberté   pour contrôler leur propre espace de noms. Autoriser les serveurs à indiquer à la place   les clients sur la façon de construire des URI appropriés, comme en HTML   formulaires et modèles d'URI, en définissant ces instructions dans le support   types et relations de lien. [Un échec implique que les clients soient   en supposant une structure de ressources due à des informations hors bande, telles que   une norme de domaine spécifique, qui est l'équivalent orienté données de   Couplage fonctionnel de RPC].

     

http://roy.gbiv.com/untangled /2008 /rest-apis-doit-être-dirigé par l'hypertexte

L'idée d'une RESTful-URL est en réalité une violation de REST car le serveur est responsable de la structure de l'URL et devrait être libre de décider de son utilisation pour éviter le couplage. Si cela vous empêche de lire à propos du sisignification de la découverte de soi sur la conception des API.

L'utilisation de POST pour créer des ressources est un facteur de conception, car POST n'est pas idempotent. Cela signifie que répéter un POST plusieurs fois ne garantit pas le même comportement à chaque fois. Cela incite les gens à ne pas utiliser PUT pour créer des ressources alors qu'ils ne le devraient pas. Ils savent que c'est faux (POST est pour CREATE), mais ils le font quand même car ils ne savent pas comment résoudre ce problème. Cette préoccupation est démontrée dans la situation suivante:

  1. Le client envoie une nouvelle ressource au serveur.
  2. Le serveur traite la demande et envoie une réponse.
  3. Le client ne reçoit jamais la réponse.
  4. Le serveur ignore que le client n'a pas reçu la réponse.
  5. Le client n'a pas d'adresse URL pour la ressource (donc PUT n'est pas une option) et répète le POST.
  6. Le POST n’est pas idempotent et le serveur…

L'étape 6 est l'endroit où les gens se demandent souvent quoi faire. Cependant, il n'y a aucune raison de créer un kludge pour résoudre ce problème. HTTP peut plutôt être utilisé comme spécifié dans RFC 2616 et le serveur répond:

  

10.4.10 409 Conflit

     

La demande n'a pas pu être complétée en raison d'un conflit avec l'actuel   état de la ressource. Ce code n’est autorisé que dans les cas où   il est prévu que l’utilisateur pourra peut-être résoudre le conflit et   soumettre à nouveau la demande. Le corps de la réponse DEVRAIT en inclure suffisamment

     

informations permettant à l'utilisateur de reconnaître la source du conflit.   Idéalement, l'entité de réponse devrait inclure suffisamment d'informations pour que le   utilisateur ou agent d'utilisateur pour résoudre le problème; cependant, cela pourrait ne pas être   possible et n'est pas obligatoire.

     

Les conflits sont plus susceptibles de se produire en réponse à une demande PUT. Pour   exemple, si le versioning était utilisé et que l'entité était PUT   modifications apportées à une ressource qui sont en conflit avec celles apportées par un   demande précédente (tierce partie), le serveur peut utiliser la réponse 409   pour indiquer qu'il ne peut pas terminer la demande. Dans ce cas, le   l’entité de réponse contiendrait probablement une liste des différences entre   les deux versions dans un format défini par la réponse Content-Type.

Répondre avec un code de statut de 409 Le conflit est le bon recours car :

  • L'exécution d'un POST de données dont l'ID correspond à une ressource déjà présente dans le système est "un conflit avec l'état actuel de la ressource".
  • Puisque l’important est que le client comprenne que le serveur dispose de la ressource et prend les mesures appropriées. Il s'agit d'une «situation (s) dans laquelle l'utilisateur devrait pouvoir résoudre le conflit et soumettre à nouveau la demande."
  • Une réponse contenant l'URL de la ressource avec l'ID en conflit et les conditions préalables appropriées pour la ressource fournirait "suffisamment d'informations pour permettre à l'utilisateur ou à l'agent d'utilisateur de résoudre le problème", ce qui est le cas idéal selon RFC 2616.

Mise à jour basée sur la publication de la RFC 7231 pour remplacer 2616

La RFC 7231 est conçue pour remplacer 2616 et La section 4.3.3 décrit la réponse possible suivante pour un POST

  

Si le résultat du traitement d'un POST équivaut à un   représentation d'une ressource existante, un serveur d'origine PEUT rediriger   l'agent utilisateur à cette ressource en envoyant une réponse 303 (voir autre)   avec l'identifiant de la ressource existante dans le champ Emplacement. Ce   présente les avantages de fournir à l'agent d'utilisateur un identifiant de ressource   et transférer la représentation via une méthode plus facile à   mise en cache partagée, mais au prix d'une requête supplémentaire si l'utilisateur   l'agent n'a pas déjà la représentation en cache.

Il peut être tentant de renvoyer simplement un 303 au cas où un test POST serait répété. Cependant, le contraire est vrai. Renvoyer un 303 n'aurait de sens que si plusieurs demandes de création (créant des ressources différentes) renvoient le même contenu. Un exemple serait un "merci d'avoir envoyé votre message de demande" que le client n'a pas besoin de télécharger à nouveau à chaque fois. La RFC 7231 maintient toujours dans la section 4.2.2 que le POST ne doit pas être idempotent et continue à soutenir que le POST doit être utilisé pour la création.

Pour plus d'informations à ce sujet, lisez ceci article .

    
59
2017-10-2112: 39: 27Z
  1. Une réponse 409 Conflict serait-elle le code approprié pour quelque chose comme essayer de créer un nouveau compte avec un nom d'utilisateur déjà existant? J'utilise 409 spécifiquement pour les conflits de versions, mais après avoir lu votre réponse, je me demande si elle ne devrait pas être utilisée pour des demandes de duplication.
    2014-07-09 04: 43: 34Z
  2. @ EricB. Oui, dans la situation que vous décrivez "en raison d'un conflit avec l'état actuel de la ressource", l'opération échoue. De plus, il est raisonnable de s’attendre à ce que l’utilisateur puisse résoudre le conflit et le corps du message n’a qu’à informer l'utilisateur que le nom d'utilisateur existe déjà.
    2014-07-10 13: 25: 23Z
  3. @ Joshcodes pouvez-vous en dire plus sur le processus de résolution des conflits? Dans ce cas, si le nom d'utilisateur existe déjà, le client est-il censé demander à l'utilisateur final un autre nom d'utilisateur? Que se passe-t-il si le client essaie réellement d'utiliser POST pour changer le nom d'utilisateur? Les requêtes PUT doivent-elles toujours être utilisées pour la mise à jour des paramètres, alors que POST est utilisé pour créer des objets, un par un ou plusieurs? Merci.
    2015-01-22 22: 41: 13Z
  4. @ BFar2 si le nom d'utilisateur existe déjà, le client doit en informer l'utilisateur. Pour changer le nom d'utilisateur, en supposant que ce nom fait partie d'une ressource déjà créée qui doit être modifiée, PUT serait utilisé parce que vous avez raison, POST est utilisé pour créer, toujours et PUT pour les mises à jour.
    2015-01-23 01: 09: 44Z
  5. expliquer un langage court et efficace est également une compétence souhaitable
    2015-08-24 16: 27: 49Z

J'aime ce conseil, tiré de la Définition de PUT par la RFC 2616 :

  

La différence fondamentale entre les requêtes POST et PUT est reflétée dans la signification différente de l'URI de demande. L'URI dans une demande POST identifie la ressource qui gérera l'entité incluse. Cette ressource peut être un processus acceptant les données, une passerelle vers un autre protocole ou une entité distincte acceptant les annotations. En revanche, l'URI dans une demande PUT identifie l'entité jointe à la demande - l'agent utilisateur sait ce que l'URI est destiné et le serveur NE DOIT PAS tenter d'appliquer la demande à une autre ressource.

Cela correspond à l’autre conseil indiqué, à savoir que PUT s’applique mieux aux ressources qui ont déjà un nom et que POST est utile pour créer un nouvel objet sous une ressource existante (et laisser le nom du serveur le nommer).

J’interprète cela, ainsi que les conditions d’impuissance requises pour PUT, comme signifiant que:

  • POST est utile pour créer de nouveaux objets dans une collection (et la création n'a pas besoin d'être idempotente)
  • PUT est utile pour mettre à jour des objets existants (et la mise à jour doit être idempotente)
  • POST peut également être utilisé pour des mises à jour non idempotentes d'objets existants (notamment pour changer une partie d'un objet sans spécifier le tout. Si vous y réfléchissez, la création d'un nouveau membre d'une collection est en fait un cas particulier de ce genre de mise à jour, du point de vue de la collection)
  • PUT peut également être utilisé pour créer si et seulement si vous autorisez le client à nommer la ressource. Mais comme les clients REST ne sont pas supposés faire des hypothèses sur la structure des URL, cela est moins conforme à l’esprit des choses.
52
2012-01-11 17: 18: 54Z
  1. "POST peut également être utilisé pour les mises à jour non idempotentes d'objets existants (en particulier, changer une partie d'un objet sans spécifier le tout", c'est ce à quoi sert PATCH
    2012-05-04 22: 11: 24Z

En bref:

PUT est idempotent, l'état de la ressource sera le même si la même opération est exécutée une ou plusieurs fois.

POST n'est pas idempotent, l'état de la ressource pouvant devenir différent si l'opération est exécutée plusieurs fois par rapport à l'exécution d'une seule fois.

Analogie avec la requête de base de données

PUT Vous pouvez penser à une adresse similaire à "UPDATE STUDENT SET address =" abc "où id =" 123 ";

POST Vous pouvez penser à quelque chose comme "INSERT INTO STUDENT (nom, adresse) VALEURS (" abc "," xyzzz ");

L'identifiant de l'étudiant est généré automatiquement.

Avec PUT, si la même requête est exécutée plusieurs fois ou une fois, l'état de la table STUDENT reste identique.

En cas de POST, si la même requête est exécutée plusieurs fois, plusieurs enregistrements Student sont créés dans la base de données et l'état de la base de données est modifié à chaque exécution d'une requête "INSERT".

REMARQUE: PUT a besoin d'un emplacement de ressource (déjà ressource) sur lequel la mise à jour doit avoir lieu, alors que le POST n'en a pas besoin. Par conséquent, intuitivement, POST est destiné à la création d’une nouvelle ressource, alors que PUT est nécessaire à la mise à jour de la ressource existante.

Certaines personnes peuvent penser que les mises à jour peuvent être effectuées avec POST. Il n'y a pas de règle stricte à utiliser pour les mises à jour ou à créer. Encore une fois, ce sont des conventions, et intuitivement, je suis enclin à suivre le raisonnement mentionné ci-dessus et je le suis.

    
46
2017-10-21 12: 46: 45Z
  1. pour PUT est similaire à la requête INSERT ou UPDATE
    2016-08-22 09: 25: 53Z
  2. en fait PUT Vous pouvez penser à quelque chose de similaire à "UPDATE STUDENT SET adresse =" abc "où id =" 123 "; serait une instruction pour PATCH. address = "abc", name = "newname" où id = "123" serait une analogie correcte pour PUT
    2017-04-12 13: 24: 36Z
  3. Put peut également être utilisé pour INSERT. Par exemple, si votre serveur a détecté que vous tentiez de télécharger le même fichier plusieurs fois, votre requête serait idempotente. (Aucun nouveau fichier n’a été ajouté).
    2018-08-20 22: 46: 20Z

POST revient à poster une lettre dans une boîte aux lettres ou à envoyer un courrier électronique à une file d'attente. PUT est comme si vous mettiez un objet dans un trou ou un emplacement sur une étagère (il a une adresse connue).

Avec POST, vous publiez à l'adresse de la file d'attente ou de la collection. Avec PUT, vous mettez à l’adresse de l’ARTICLE.

PUT est idempotent. Vous pouvez envoyer la demande 100 fois et ce ne sera pas grave. Le POST n’est pas idempotent. Si vous envoyez la demande 100 fois, vous recevrez 100 courriels ou 100 lettres dans votre boîte aux lettres.

Une règle générale: si vous connaissez l'identifiant ou le nom de l'élément, utilisez PUT. Si vous souhaitez que l'identifiant ou le nom de l'élément soit attribué par la partie destinataire, utilisez POST.

POST contre PUT

    
42
2013-07-10 19: 52: 13Z
  1. Non, PUT implique que vous connaissiez l'URL. Si vous ne connaissez que l’ID, faites ensuite un POST avec cet ID pour obtenir l’URL.
    2013-10-29 17: 35: 20Z
  2. L'id fait partie de l'URL, alors oui, utilisez PUT si vous connaissez l'URL (qui inclut l'id).
    2013-10-29 22: 02: 53Z
  3. Non, l'URL est déterminée par le serveur et l'ID ne fait pas nécessairement partie de l'URL. Roy Fielding vous indiquerait le identique ou vous pouvez simplement lire sa thèse .
    2013-10-29 23: 06: 18Z
  4. @ Joshcodes, est-ce que cela suppose REST? Dans une architecture RESTful, l'id d'élément fait très certainement partie de l'URL, comme dans: /people /123. J'aime ce site pour REST: microformats.org/wiki/rest/urls
    2013-12-26 19: 10: 14Z
  5. @ Beez, le lien mircoformats suggère un bon moyen pour les serveurs de structurer leurs URL, mais le serveur détermine l'URL. . Le client le plus proche jamais. Voir ma réponse ou associée à article si vous ne le comprenez pas.
    2014-01-07 17: 11: 35Z

Nouvelle réponse (maintenant que je comprends mieux REST):

PUT est simplement une déclaration du contenu que le service devrait désormais utiliser pour restituer des représentations de la ressource identifiée par le client; POST est une déclaration du contenu que le service devrait désormais contenir (éventuellement dupliqué), mais il appartient au serveur de déterminer ce contenu.

PUT x (si x identifie une ressource ): "Remplacer le contenu de la ressource identifiée par x par mon contenu."

PUT x (si x n'identifie pas une ressource): "Créez une nouvelle ressource contenant mon contenu et utilisez x pour l'identifier."

POST x: "Stocker mon contenu et me donner un identifiant que je peux utiliser pour identifier une ressource (ancienne ou nouvelle) contenant ledit contenu (éventuellement mélangé à un autre contenu). Cette ressource doit être identique ou subordonnée à celle identifiée par x . " "La ressource de y est subordonnée à la ressource de x " est généralement mais pas nécessairement implémentée en faisant de y un sous-chemin de x (par exemple, x = /foo et y = /foo/bar) et en modifiant la (les) représentation (s) de la ressource de x pour refléter le existence d'une nouvelle ressource, par exemple avec un hyperlien vers la ressource de y et des métadonnées. Seule cette dernière solution est essentielle au bon design, car les URL sont opaques dans REST. Vous êtes donc censé utiliser hypermedia à la place. de la construction d'URL côté client pour traverser le service de toute façon.

En REST, une ressource contenant du "contenu" n'existe pas. J'appelle "contenu" les données que le service utilise pour restituer ses représentations de manière cohérente. Il consiste généralement en des lignes associées dans une base de données ou un fichier (par exemple, un fichier image). Il appartient au service de convertir le contenu de l'utilisateur en quelque chose que le service peut utiliser, par exemple. convertir une charge JSON en instructions SQL.

Réponse originale (la lecture pourrait être plus simple) :

PUT /something (si /something existe déjà): "Prenez tout ce que vous avez à /something et remplacez-le par ce que je vous ai donné."

PUT /something (si /something n’existe pas déjà): "Prenez ce que je vous ai donné et fixez-le à /something."

POST /something: "Prenez ce que je vous ai donné et collez-le où bon vous semble sous /something, à condition de me donner son URL lorsque vous avez terminé."

    
38
2017-05-23 11: 55: 13Z
  1. Mais comment utiliser PUT pour créer une nouvelle ressource si elle n'existe pas alors que votre méthode de génération d'identifiant est en incrémentation automatique? Habituellement, les ORM génèrent automatiquement l'ID, comme vous le souhaitez par exemple. Cela signifie-t-il que si vous souhaitez implémenter correctement PUT, vous devez modifier votre génération auto id? C'est gênant si la réponse est oui.
    2018-09-16 15: 28: 21Z
  2. @ RoniAxelrad: PUT est comme une instruction "INSERT OR UPDATE" de base de données dans laquelle vous incluez la clé dans l'instruction, donc uniquement applicable si vous ne pouvez garantir aucune collision. par exemple. votre domaine a une "clé naturelle" ou vous utilisez un GUID. Le POST est comme l’insertion dans une table avec une clé à incrémentation automatique. La base de données vous dira quel ID il a obtenu après son insertion. Notez que votre "INSERT OU MISE À JOUR" remplacera toutes les données précédentes si existed.
    2018-11-26 01: 33: 41Z
  3. @ NigelThorne Merci pour votre réponse. Donc, si par exemple j'essaye de PUT un identifiant de livre 10 avec un URI: PUT books /10. Si l'identifiant de livre 10 n'existe pas, je devrais créer un livre avec l'identifiant 10 non? mais je ne peux pas contrôler le numérateur d'ID de création, car il est incrémenté automatiquement. que dois-je faire dans cette situation?
    2018-11-27 20: 50: 43Z
  4. @ RoniAxelrad REST PUT à un ID inexistant est une demande adressée au serveur pour créer une ressource. Il appartient toujours au serveur de décider s’il le souhaite. Le serveur est en charge. Il peut répondre par "Non, je ne vais pas faire ça". Vous le faites déjà si l'utilisateur ne dispose pas de suffisamment d'autorisations ... etc. Le serveur peut dire "Non". REST est une convention qui nous permet de définir la signification de divers types de requêtes ... votre serveur décide quoi faire avec ces requêtes en fonction de votre logique métier :) Même si la réponse est "non", REST suit toujours:
    2018-12-03 07: 03: 30Z

Réponse courte:

Simple règle: utilisez POST pour créer, utilisez PUT pour mettre à jour.

Réponse longue:

POST:

  • POST est utilisé pour envoyer des données au serveur.
  • Utile lorsque l'URL de la ressource est inconnu

PUT:

  • PUT est utilisé pour transférer l'état sur le serveur
  • Utile lorsque l'URL d'une ressource est connue

Réponse plus longue:

Pour le comprendre, nous devons nous demander pourquoi PUT était nécessaire, quels étaient les problèmes que PUT essayait de résoudre et que POST ne pouvait pas.

Du point de vue de l'architecture REST, il n'y en a aucune qui compte. Nous aurions pu vivre sans PUT aussi. Mais du point de vue du développeur client, cela lui a beaucoup simplifié la vie.

Avant PUT, les clients ne pouvaient pas connaître directement l'URL générée par le serveur ou si tout avait été généré, ni si les données à envoyer au serveur étaient déjà mises à jour ou non. PUT a soulagé le développeur de tous ces maux de tête. PUT est idempotent, PUT gère les conditions de concurrence et PUT permet au client de choisir l'URL.

    
37
2017-10-21 13: 03: 18Z
  1. Votre réponse courte est peut-être TRES incorrecte. HTTP PUT est libre d'être répété par les proxies HTTP. Ainsi, si PUT exécute SQL INSERT, il pourrait échouer une deuxième fois, ce qui signifie que le résultat serait différent et que ce ne serait donc pas IDEMPOTENT (différence entre PUT et POST).
    2018-04-30 17: 27: 03Z

Ruby on Rails 4.0 utilisera la méthode "PATCH" au lieu de PUT pour effectuer des mises à jour partielles.

RFC 5789 dit à propos de PATCH (depuis 1995):

  

Une nouvelle méthode est nécessaire pour améliorer l'interopérabilité et prévenir      les erreurs. La méthode PUT est déjà définie pour écraser une ressource      avec un nouveau corps complet et ne peut pas être réutilisé pour effectuer des modifications partielles.      Sinon, les mandataires et les caches, et même les clients et les serveurs, pourraient      confus quant au résultat de l'opération. POST est déjà utilisé mais      sans large interopérabilité (pour l’un, il n’existe aucun moyen standard de      découvrir le support du format de patch). PATCH a déjà été mentionné dans HTTP      spécifications, mais pas complètement défini.

" Rails Edge: PATCH est la nouvelle méthode HTTP principale pour les mises à jour ", explique-t-il.

    
35
2017-09-16 20: 17: 52Z

Au risque de répéter ce qui a déjà été dit, il semble important de rappeler que PUT implique que le client contrôle ce que l'URL va être, quand creatune ressource. Une partie du choix entre PUT et POST consiste à déterminer dans quelle mesure vous pouvez faire confiance au client pour fournir des URL correctes et normalisées . cohérent avec votre schéma d'URL.

Si vous ne pouvez pas vraiment faire confiance au client pour qu'il agisse correctement, ce serait Il est plus approprié d’utiliser POST pour créer un nouvel élément, puis de renvoyer l’URL au client dans la réponse.

    
27
2014-08-28 09: 17: 34Z
  1. Je suis un peu en retard pour cela - mais quelqu'un qui dit quelque chose de similaire sur un autre site web l'a fait cliquer pour moi. Si vous créez une ressource et utilisez un identifiant auto-incrémenté en tant qu '"identifiant" au lieu du nom attribué à l'utilisateur, il doit s'agir d'un POST.
    2012-02-03 18: 51: 40Z
  2. Ce n'est pas tout à fait correct - PUT peut toujours créer une ressource en y faisant référence avec un nom non canonique, tant que le serveur retourne une En-tête Location que contient le nom de ressource canonique.
    2012-10-19 16: 08: 58Z
  3. @ Joshcodes n'oubliez pas que vous pouvez avoir plusieurs URI référençant la même ressource sous-jacente. Donc, ce qu’Ether dit est un conseil judicieux, le client peut passer à une URL (qui pourrait être plus sémantique, comme PUT /X-files/series/4/episodes/max) et le serveur répond avec un URI fournissant un court lien unique canonique vers cette nouvelle ressource (/X-Ffiles/episodes/91)
    2015-06-08 08: 02: 33Z
  4. @ thecoshman le problème est que la structure de l'URL n'appartient pas au client. Lire sur la découverte de soi (qui fait également partie de REST) ​​peut aider à clarifier cela.
    2015-06-08 17: 50: 32Z
  5. @ Joshcodes, un client ne doit jamais utiliser PUT pour créer car il ne devrait pas être concerné par la fourniture de l'URL. Eh bien ... à moins que le serveur ne fournisse une URL à PUT si le client veut y mettre ... quelque chose comme "PUT /comments /new" et le serveur pourrait répondre "204 /comments /234532" mais cela semble un peu RPC à moi, le client devrait simplement POST à ​​/commentaires ...
    2015-06-09 16: 18: 27Z

De manière très simple, je prends l'exemple de la chronologie de Facebook.

Cas 1: lorsque vous publiez quelque chose sur votre timeline, il s’agit d’une nouvelle entrée. Donc, dans ce cas, ils utilisent la méthode POST car celle-ci est non idempotente.

Cas 2: si votre ami commente la publication pour la première fois, cela créera également une nouvelle entrée dans la base de données afin que la méthode POST soit utilisée.

Cas 3: si votre ami modifie son commentaire, dans ce cas, il possède un identifiant de commentaire. Il met donc à jour un commentaire existant au lieu de créer une nouvelle entrée dans la base de données. Par conséquent, pour ce type d’opération, utilisez la méthode PUT car elle est idempotente. *

Sur une seule ligne, utilisez POST pour ajouter une nouvelle entrée dans la base de données et PUT pour mettre à jour . quelque chose dans la base de données.

    
22
2017-10-21 12: 49: 12Z
  1. Si le commentaire est un objet avec une propriété telle que l'ID utilisateur, la date de création, le commentaire-message, etc. et qu'au moment de la modification, seul le commentaire-message est mis à jour, Le PATCH devrait être fait ici?
    2017-08-12 10: 47: 45Z
  2. FB utilise le FB pour mettre à jour le commentaire car une ressource existante est mise à jour et c'est ce que fait PUT (met à jour une ressource). PUT se trouve être idempotent, contrairement à POST. Un verbe HTTP étant idempotent affecte la gestion des erreurs mais ne dicte pas l'utilisation. Voir ma réponse pour une explication plus détaillée: stackoverflow.com/questions/630453 /put-vs-post-in-rest /…
    2018-06-19 12: 57: 06Z

La fiabilité est la considération la plus importante. Si un message POST est perdu, l'état du système n'est pas défini. La récupération automatique est impossible. Pour les messages PUT, l'état n'est pas défini jusqu'à la première tentative réussie.

Par exemple, il peut ne pas être judicieux de créer des transactions par carte de crédit avec POST.

Si vous avez des URI générés automatiquement sur votre ressource, vous pouvez toujours utiliser PUT en transmettant un URI généré (pointant sur une ressource vide) au client.

Quelques autres considérations:

  • POST invalide les copies en cache de la totalité de la ressource contenant (meilleure cohérence)
  • Les réponses PUT ne peuvent pas être mises en cache, tandis que celles sous POST le sont (Requiert Content-Location et expiration)
  • PUT est moins pris en charge par exemple Java ME, anciens navigateurs, pare-feu
20
2012-02-10 05: 53: 13Z
  1. Ceci est incorrect. Pour POST, l'état est également non défini seulement jusqu'à la première tentative réussie. Ensuite, le serveur accepte le POST (message non arrivé), génère un conflit 409 pour un ID en double (message arrivé, la réponse a été perdue) ou toute autre réponse valide.
    2014-04-24 12: 13: 04Z
  2. En général, un agent utilisateur ne serait pas en mesure de relancer l'opération POST en toute sécurité, car l'opération POST ne garantit pas que deux opérations auront le même effet qu'une seule. Le terme "ID" n'a rien à voir avec HTTP. L'URI identifie la ressource.
    2014-07-25 05: 48: 18Z
  3. Un agent utilisateur peut "en toute sécurité" réessayer une opération POST autant de fois qu'il le souhaite. Il ne fera que recevoir une erreur d'identification en double (en supposant que la ressource possède un identifiant) ou une erreur en double (en supposant qu'il s'agisse d'un problème et que la ressource ne possède pas d'identifiant).
    2014-07-27 02: 10: 02Z
  4. se cogne la tête contre un mur. HTTP n’a pas de solution au problème de la fiabilité, ce qui n’est pas bien compris, n’a pas fait l’objet de beaucoup de discussions et n’est tout simplement pas pris en charge dans la grande majorité des applications Web. @ Joshcodes J'ai une réponse à cette question. Je suis essentiellement d'accord avec Hans. Il y a un problème.
    2018-06-13 08: 21: 20Z
  5. @ bbsimonbb, HTTP possède un ensemble de réponses d'erreur robustes et bien documentées. Ma réponse à cette question ( stackoverflow.com /questions /630453 /put-vs-post-in-rest /… ) explique comment utiliser http conformément aux spécifications pour assurer la cohérence.
    2018-06-19 12: 50: 19Z

Il semble toujours y avoir une certaine confusion quant au moment d'utiliser la méthode HTTP POST par rapport à la méthode HTTP PUT pour les services REST. La plupart des développeurs essaieront d'associer directement les opérations CRUD aux méthodes HTTP. Je dirai que ce n'est pas correct et que l'on ne peut pas simplement associer les concepts CRUD aux méthodes HTTP. C'est-à-dire:

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

Il est vrai que les opérations R (etrieve) et D (elete) des opérations CRUD peuvent être mappées directement aux méthodes HTTP GET et DELETE, respectivement. Cependant, la confusion réside dans les opérations C (reate) et U (update). Dans certains cas, on peut utiliser le PUT pour une création, alors que dans d'autres cas, un POST sera requis. L’ambiguïté réside dans la définition d’une méthode HTTP PUT par rapport à une méthode HTTP POST.

Selon les spécifications HTTP 1.1, les méthodes GET, HEAD, DELETE et PUT doivent être idempotentes et la méthode POST n'est pas idempotente. C'est-à-dire qu'une opération est idempotente si elle peut être effectuée sur une ressource une ou plusieurs fois et retourner toujours le même état de cette ressource. Considérant qu’une opération non idempotente peut renvoyer un état modifié de la ressource d’une demande àun autre. Par conséquent, dans une opération non idempotente, rien ne garantit que l’on obtiendra le même état d’une ressource.

Sur la base de la définition idempotente ci-dessus, mon approche de la méthode HTTP PUT par rapport à celle de HTTP POST pour les services REST est la suivante: Utilisez la méthode HTTP PUT lorsque:

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

Dans les deux cas, ces opérations peuvent être effectuées plusieurs fois avec les mêmes résultats. C'est-à-dire que la ressource ne sera pas modifiée en demandant l'opération plus d'une fois. Par conséquent, une véritable opération idempotente. Utilisez la méthode HTTP POST lorsque:

 
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.

Conclusion

Ne corrélez pas et ne mappez pas directement les opérations CRUD aux méthodes HTTP pour les services REST. L'utilisation d'une méthode HTTP PUT par rapport à une méthode HTTP POST doit être basée sur l'aspect idempotent de cette opération. Autrement dit, si l'opération est idempotente, utilisez la méthode HTTP PUT. Si l'opération n'est pas idempotente, utilisez la méthode HTTP POST.

    
14
2013-10-10 04: 18: 51Z
  1. Update = > HTTP POST: le POST n'est pas destiné à la mise à jour
    2016-01-30 00: 57: 59Z
Les nouveaux lecteurs de ce sujet seront frappés par les discussions sans fin sur ce que vous devriez faire et par l’absence relative de leçons tirées de l’expérience. Le fait que REST soit "préféré" par rapport à SOAP est, je suppose, un apprentissage de haut niveau par expérience, mais bonté avons-nous progressé à partir de là? Nous sommes en 2016. La thèse de Roy était en 2000. Qu'avons-nous développé? Était-ce amusant? Était-ce facile à intégrer? Soutenir? Acceptera-t-il la montée des smartphones et des connexions mobiles instables?

Selon moi, les réseaux de la vie réelle ne sont pas fiables. Délai d'expiration des demandes. Les connexions sont réinitialisées. Les réseaux sont en panne pendant des heures ou des jours à la fois. Les trains entrent dans des tunnels avec des utilisateurs mobiles à bord. Pour toute demande donnée (comme cela est parfois reconnu dans toutes les discussions), la demande peut tomber dans l'eau pendant son trajet ou la réponse peut tomber dans l'eau avant de revenir. Dans ces conditions, émettre des demandes PUT, POST et DELETE directement contre des ressources substantielles m'a toujours semblé un peu brutal et naïf.

HTTP ne fait rien pour assurer un achèvement fiable de la demande-réponse, et c'est très bien parce que c'est le travail d'applications qui prennent en charge le réseau. En développant une telle application, vous pouvez passer d’un cadre à l’autre pour utiliser PUT au lieu de POST, puis d’autres pour créer un certain type d’erreur sur le serveur si vous détectez des demandes en double. De retour chez le client, vous devez alors parcourir les étapes pour interpréter ces erreurs, récupérer, revalider et rediffuser.

Ou vous pouvez le faire : considérez vos demandes non sécurisées comme des ressources éphémères à utilisateur unique (appelons-les des actions). Les clients demandent une nouvelle "action" sur une ressource substantive avec un POST vide pour la ressource. POST sera utilisé uniquement pour cela. Une fois en possession de l’URI de l’action nouvellement créée, le client PUT la demande non sécurisée à l’URI de l’action, pas la ressource cible . La résolution de l'action et la mise à jour de la "vraie" ressource constituent le travail de votre API et sont ici découplées du réseau non fiable.

Le serveur gère les affaires, renvoie la réponse et la stocke contre l'URI d'action convenu . En cas de problème, le client répète la demande (comportement naturel!) Et, si le serveur l’a déjà vue, il répète la réponse stockée et ne fait rien d’autre .

Vous remarquerez rapidement la similitude avec les promesses: nous créons et nous retournons l’espace réservé pour le résultat avant d’agir. Également comme une promesse, une action peut réussir ou échouer une fois, mais son résultat peut être extrait à plusieurs reprises.

Mieux encore, nous donnons aux applications d'envoi et de réception une chance de lier l'action identifiée de manière unique à l'unicité dans leurs environnements respectifs. Et nous pouvons commencer à exiger et à appliquer !, un comportement responsable de la part des clients: répétez vos demandes autant de fois que vous le souhaitez, mais ne créez pas de nouvelle action tant que vous ne disposez pas du résultat définitif de l'existant.

Ainsi, de nombreux problèmes épineux disparaissent. Les demandes d'insertion répétées ne créent pas de doublons et nous ne créons pas la ressource réelle tant que nous ne sommes pas en possession des données. (les colonnes de la base de données peuvent rester non nullables). Les demandes de mise à jour répétées n'atteignent pas les états incompatibles et n'écrasent pas les modifications ultérieures. Les clients peuvent (ré) extraire et traiter de manière transparente la confirmation d'origine pour whatever raison (client s’est écrasé, réponse manquante, etc.).

Les demandes de suppression successives peuvent voir et traiter la confirmation d'origine, sans générer d'erreur 404. Si les choses prennent plus de temps que prévu, nous pouvons répondre provisoirement et le client peut consulter le résultat final. La plus belle partie de ce modèle est sa propriété Kung-Fu (Panda). Nous prenons une faiblesse, la propension des clients à répéter une demande chaque fois qu’ils ne comprennent pas la réponse, et la transformons en une force : -)

Avant de me dire que ce n’est pas RESTful, veuillez considérer les nombreuses manières dont les principes REST sont respectés. Les clients ne construisent pas d'URL. L'API reste découvrable, avec toutefois un peu de changement dans la sémantique. Les verbes HTTP sont utilisés de manière appropriée. Si vous pensez que c'est un énorme changement à mettre en œuvre, je peux vous dire d'expérience que ce n'est pas le cas.

Si vous pensez que vous avez des quantités énormes de données à stocker, parlons-en: une confirmation de mise à jour typique représente une fraction de kilo-octet. HTTP vous donne actuellement une minute ou deux pour répondre définitivement. Même si vous ne stockez que des actions pendant une semaine, les clients ont de grandes chances de les rattraper. Si vous avez des volumes très élevés, vous souhaiterez peut-être un magasin de valeurs de clé dédié compatible avec l'acide, ou une solution en mémoire.

    
14
2018-05-23 14: 06: 30Z
  1. La réponse stockée ne sera-t-elle pas comme si vous mainteniez une session? Ce qui causerait des problèmes d'échelle (horizontale).
    2018-08-21 17: 57: 34Z
  

le serveur d'origine peut créer la ressource avec cet URI

Vous utilisez donc POST et probablement, mais pas nécessairement, PUT pour la création de ressources. Vous n'êtes pas obligé de supporter les deux. Pour moi, POST suffit parfaitement. C’est donc une décision de conception.

Comme indiqué dans votre citation, vous utilisez PUT pour créer des ressources. Aucune ressource n'est affectée à un IRI et vous souhaitez néanmoins créer une ressource. Par exemple, PUT /users/123/password remplace généralement l'ancien mot de passe par un nouveau, mais vous pouvez l'utiliser pour créer un mot de passe s'il n'existe pas déjà (par exemple, par des utilisateurs récemment enregistrés ou par la restauration d'utilisateurs interdits).

    
13
2017-10-21 12: 41: 52Z
  1. Je pense que vous avez réussi à fournir l'un des rares bons exemples d'utilisation de PUT, bravo.
    2015-06-08 08: 13: 00Z

Outre les différences suggérées par d'autres, je souhaite en ajouter une de plus.

Dans la méthode POST , vous pouvez envoyer des paramètres de corps dans form-data

.

Dans la méthode PUT , vous devez envoyer des paramètres de corps dans x-www-form-urlencoded

.

En-tête Content-Type:application/x-www-form-urlencoded

Selon cela, vous ne pouvez pas envoyer de fichiers ou de données en plusieurs parties avec la méthode PUT

.

MODIFIER

  

Le type de contenu "application /x-www-form-urlencoded" est inefficace   pour l'envoi de grandes quantités de données binaires ou de texte contenant   caractères non-ASCII. Le type de contenu "multipart /form-data" devrait être   utilisé pour soumettre des formulaires contenant des fichiers, des données non-ASCII et   données binaires.

Ce qui signifie que vous devez soumettre

  

fichiers, données non-ASCII et données binaires

vous devez utiliser la méthode POST

    
12
2018-10-01 09: 33: 47Z
  1. Pourquoi cela n'a-t-il pas été voté? Si c'est vrai, c'est une distinction essentielle, n'est-ce pas?
    2018-09-29 03: 02: 01Z
  2. Je l'ai rencontré lors de la mise en œuvre de l'API pour la mise à jour du profil, ce qui inclut le téléchargement de photos de profil utilisateur. Puis je l’ai testé avec le postman, Ajax, PHP curl et laravel 5.6 comme back-end.
    2018-09-29 06: 54: 18Z

Je vais atterrir avec ce qui suit:

PUT fait référence à une ressource, identifiée par l'URI. Dans ce cas, vous le mettez à jour. C’est la partie des trois verbes qui fait référence aux ressources - supprimer et devenir les deux autres.

POST est fondamentalement un message de forme libre, sa signification étant définie par "hors bande". Si le message peut être interprété comme ajoutant une ressource à un répertoire, ce serait OK, mais vous devez comprendre le message que vous envoyez (publication) pour savoir ce qui se passera avec la ressource.

Etant donné que PUT, GET et DELETE font référence à une ressource, elles sont également, par définition, idempotentes.

POST peut exécuter les trois autres fonctions, mais la sémantique de la demande sera alors perdue pour les intermédiaires tels que les caches et les mandataires. Ceci s'applique également à la sécurisation de la ressource, car l'URI d'une publication n'indique pas nécessairement la ressource à laquelle elle s'applique (elle peut cependant).

Un PUT n'a pas besoin d'être une création; le service peut générer une erreur si la ressource n'est pas déjà créée, sinon mettez-la à jour. Ou vice versa - cela peut créer la ressource, mais pas autoriser les mises à jour. La seule chose requise à propos de PUT est qu’elle pointe vers une ressource spécifique et que sa charge utile soit la représentation de cette ressource. Un PUT réussi signifie (sauf interdiction) qu'un GET va récupérer la même ressource.

Éditer: Une dernière chose - un PUT peut créer, mais si c'est le cas, l'ID doit être un ID naturel - AKA une adresse électronique. De cette façon, lorsque vous mettez deux fois, la deuxième est une mise à jour de la première. Cela le rend idempotent .

Si l'ID est généré (un nouvel ID d'employé, par exemple), le second PUT avec la même URL créera un nouvel enregistrement, qui violera la règle idempotent. Dans ce cas, le verbe serait POST et le message (pas ressource) consisterait à créer une ressource en utilisant les valeurs définies dans ce message.

    
11
2017-10-21 12: 32: 49Z

La sémantique est supposée être différente, en ce sens que "PUT", comme "GET" est supposé être idempotent - cela signifie que vous pouvez demander la même requête PUT à plusieurs reprises et le résultat sera comme si vous ne l'exécutiez qu'une fois. .

Je vais décrire les conventions qui, à mon avis, sont les plus largement utilisées et les plus utiles:

Lorsque vous mettez une ressource sur une URL particulière, elle doit être enregistrée sur cette URL ou quelque chose du genre.

Lorsque vous publiez une requête sur une ressource à une URL particulière, vous publiez souvent des informations connexes sur cette URL. Cela implique que la ressource à l'URL existe déjà.

Par exemple, lorsque vous souhaitez créer un nouveau flux, vous pouvez le PUT sur une URL. Mais lorsque vous souhaitez poster un message dans un flux existant, vous en envoyez à son URL.

En ce qui concerne la modification des propriétés du flux, vous pouvez le faire avec PUT ou POST. Fondamentalement, utilisez uniquement "PUT" lorsque l'opération est idempotente - sinon, utilisez POST.

Notez cependant que tous les navigateurs modernes ne prennent pas en charge les verbes HTTP autres que GET ou POST.

    
9
2011-10-23 20: 07: 55Z
  1. Ce que vous décrivez comme POST est en fait le comportement que devrait avoir PATCH. POST est censé vouloir dire quelque chose de plus semblable à "ajouter" comme dans "publier sur une liste de diffusion".
    2014-11-28 15: 57: 25Z

La plupart du temps, vous les utiliserez comme ceci:

  • POST une ressource dans une collection
  • PUT une ressource identifiée par collection /: id

Par exemple:

  • POST /articles
  • PUT /items /1234

Dans les deux cas, le corps de la demande contient les données de la ressource à créer ou à mettre à jour. D'après les noms de route, il devrait être évident que POST n'est pas idempotent (si vous l'appelez 3 fois, 3 objets seront créés), alors que PUT est idempotent (si vous l'appelez 3 fois, le résultat est identique). PUT est souvent utilisé pour l'opération "upsert" (créer ou mettre à jour), mais vous pouvez toujoursEturn une erreur 404 si vous voulez seulement l’utiliser pour modifier.

Notez que POST "crée" un nouvel élément dans la collection et que PUT "remplace" un élément à une URL donnée, mais il est très courant d’utiliser PUT pour les modifications partielles, c’est-à-dire de le mettre à jour uniquement. ressources existantes et ne modifiez que les champs inclus dans le corps (en ignorant les autres champs). Ceci est techniquement incorrect. Si vous voulez être puriste REST, PUT doit remplacer la totalité de la ressource et vous devez utiliser PATCH pour la mise à jour partielle. Personnellement, cela m'est égal car le comportement est clair et cohérent sur tous vos points de terminaison d'API.

N'oubliez pas que REST est un ensemble de conventions et de consignes permettant de garder votre API simple. Si vous vous retrouvez avec une solution de contournement compliquée juste pour cocher la case "RESTfull", vous échouez alors;)

    
7
2017-06-21 17: 38: 44Z

Bien qu'il existe probablement une méthode agnostique pour les décrire, cela semble en contradiction avec diverses déclarations issues de réponses à des sites Web.

Soyons très clairs et directs ici. Si vous êtes un développeur .NET utilisant l'API Web, voici les faits (tirés de la documentation de l'API 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.

Bien sûr, vous "pouvez" utiliser "POST" pour mettre à jour, mais il suffit de suivre les conventions établies pour vous avec votre cadre donné. Dans mon cas, il s’agit de .NET /Web API. PUT est donc pour UPDATE , il n’ya pas de débat.

J'espère que cela aidera les développeurs Microsoft qui liront tous les commentaires avec les liens de sites Web Amazon et Sun /Java.

    
7
2017-07-22 11: 48: 51Z

Si vous connaissez les opérations de base de données, il y a

  1. Sélectionnez
  2. Insérer
  3. Mettre à jour
  4. Supprimer
  5. Fusionner (mettre à jour si déjà existant, sinon insérer)

J'utilise PUT pour les opérations de fusion et de mise à jour, mais POST pour les insertions.

    
6
2016-06-29 21: 13: 07Z

Voici une règle simple:

PUT sur une URL doit être utilisé pour mettre à jour ou créer la ressource pouvant être située sur cette URL.

Un POST sur une URL doit être utilisé pour mettre à jour ou créer une ressource située dans une autre URL ("subordonnée") ou non localisable via HTTP.

    
6
2017-09-16 20: 24: 31Z
  1. PUT n'est pas pour la mise à jour, mais pour le remplacer. Notez que pour créer, vous ne remplacez rien par quelque chose. POST n’est absolument pas à mettre à jour sous quelque forme que ce soit.
    2015-06-08 08: 10: 32Z
  2. La spécification http dit-elle cela? Ou basez-vous votre commentaire sur autre chose?
    2016-07-10 20: 41: 57Z
  3. C'est juste du bon sens, comment mettre à jour quelque chose quand on ne sait pas ce que l'on met à jour? POST sert à créer une nouvelle ressource.
    2016-07-27 09: 23: 42Z
  4. thecoshman - vous abusez de la sémantique ici - un remplacement peut être une mise à jour s'il s'agit de la même ressource avec quelques différences. Un remplacement n'est valide que pour put si remplacer est utilisé pour modifier la même ressource. Le remplacement par une nouvelle et différente ressource n'est pas valide (supprimer ancien et ajouter nouveau?), En particulier si la «nouvelle» ressource n'a pas d'identifiant naturel. POST, OTOH, est quelque chose qui peut créer, mettre à jour, remplacer et supprimer - utiliser post dépend de la présence ou non d'un message à interpréter,comme "appliquer la remise", qui peut ou non modifier la ressource en fonction de la logique.
    2016-12-28 16: 54: 04Z
  5. En ce qui concerne votre deuxième commentaire - que diriez-vous de "récupérer" la ressource, de modifier les champs dont vous avez besoin, puis de la restaurer? Ou si la ressource provient d’une source différente mais utilise un identifiant naturel (l’ID externe) - put mettrait naturellement à jour la ressource à l’URL lorsque les données originales seraient modifiées.
    2016-12-28 16: 56: 26Z

En pratique, le POST fonctionne bien pour la création de ressources. L'URL de la ressource nouvellement créée doit être renvoyée dans l'en-tête de réponse Location. PUT doit être utilisé pour mettre à jour complètement une ressource. Veuillez comprendre que ce sont les meilleures pratiques lors de la conception d'une API RESTful. La spécification HTTP en tant que telle ne restreint pas l'utilisation de PUT /POST avec quelques restrictions pour la création /mise à jour de ressources. Jetez un coup d’œil sur http://techoctave.com/c7/posts/71 -twitter-rest-api-disséqué qui résume les meilleures pratiques.

    
5
2014-10-13 09: 59: 32Z
  1. Pour la plupart, en lisant tout ce bruit, vous semblez sur la balle. Je dirais cependant que nous devrions parler de PUT comme méthode de remplacement plutôt que de créer /mettre à jour. Je pense que cela décrit mieux en un ce qu'il fait.
    2015-06-08 08: 15: 20Z
source placée ici