Mettre vs. POST dans le repos

selon la spécification HTTP/1.1:

la méthode POST est utilisée pour demander que le serveur d'origine accepte l'entité contenue dans la requête comme un nouveau subordonné de la ressource identifiée par le Request-URI dans le Request-Line

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

le PUT la méthode exige que l'entité contenue soit stockée sous le Request-URI fourni . Si le Request-URI fait référence à une ressource déjà existante, l'entité incluse doit être considérée comme une version modifiée de celle qui réside sur le serveur d'origine. Si le Request-URI ne pointe pas vers une ressource existante, et que l'URI peut être définie comme une nouvelle ressource à la demande de l'agent utilisateur, le serveur d'origine peut créer la ressource avec qui URI."

, C'est-à-dire PUT est utilisé pour créer ou mettre à jour .

Alors, lequel doit être utilisé pour créer une ressource? Ou l'on se doit de les soutenir à la fois?

4573
demandé sur Peter Mortensen 2009-03-10 17:25:20
la source

30 ответов

total:

à la fois PUT et POST peuvent être utilisés pour la création.

vous devez Vous demander "de quoi êtes-vous d'effectuer l'action?"pour distinguer ce que vous devez utiliser. Supposons que vous concevez une API pour poser des questions. Si vous voulez utiliser POST alors vous feriez cela à une liste de questions. Si vous voulez utiliser PUT alors vous feriez cela à une question particulière.

grande les deux peuvent être utilisés, de sorte que celui que je devrais utiliser dans mon design reposant:

vous n'avez pas besoin de soutenir à la fois PUT et POST.

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

Quelques considérations:

  • nommez-vous vos objets URL que vous créez explicitement, ou laissez le serveur décider? Si vous nommez - les puis utilisez PUT. Si vous laissez le serveur décider, utilisez POST.
  • mettre est idempotent, donc si vous mettez un objet deux fois, il n'a pas d'effet. C'est une belle propriété, donc J'utiliserais PUT quand c'est possible.
  • vous pouvez mettre à jour ou créer une ressource avec PUT avec la même URL d'objet
  • avec POST vous pouvez avoir 2 requêtes venant en même temps faisant des modifications à une URL, et ils peuvent mettre à jour différentes parties de l'objet.

un exemple:

j'ai écrit ce qui suit dans le cadre D'une autre réponse sur SO concernant ce :

POST:

utilisé pour modifier et mettre à jour une ressource

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

noter que ce qui suit est une erreur:

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

si L'URL est n'est pas encore créé, vous ne devrait pas utiliser POST pour le créer tout en spécifiant le nom. Cela devrait suite à une "ressource non trouvée' erreur parce que <new_question> n'existe pas encore. Vous devriez mettre le <new_question> ressource sur le serveur d'abord.

vous pourriez faire quelque chose comme ceci pour créer une ressource en utilisant POST:

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

Notez que dans ce cas, la ressource le nom n'est pas spécifié, les nouveaux objets Chemin d'accès d'URL serait retourné à vous.

:

Utilisé pour créer une ressource, ou l'écraser. Alors que vous spécifiez ressources new URL.

pour une nouvelle ressource:

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

Pour remplacer une ressource existante:

PUT /questions/<existing_question> HTTP/1.1
Host: www.example.com/
3591
répondu Brian R. Bondy 2017-05-23 14:55:13
la source

vous pouvez trouver des affirmations sur le web qui disent

ni l'un ni l'autre n'est tout à fait raison.


mieux est de choisir entre PUT et POST basé sur 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 une chose différente. Par définition, un PUT est idempotent. Faire autant de fois que vous le souhaitez, et le résultat est le même. x=5 est idempotent. Vous pouvez mettre une ressource si elle existe déjà, ou non (par exemple, pour créer, ou pour mettre à jour)!

POST met à jour une ressource, ajoute une ressource subsidiaire, ou provoque un changement. Un POST n'est pas la quantité, de façon que x++ n'est pas idempotent.


par cet argument, PUT est pour créer quand vous savez L'URL de la chose que vous allez créer. POST peut être utilisé pour créer lorsque vous connaissez L'URL de l '"usine" ou le gestionnaire pour la catégorie des choses que vous voulez créer.

:

POST /expense-report

ou:

PUT  /expense-report/10929
1918
répondu Cheeso 2013-05-22 09:56:05
la source
  • POST URL crée un enfant ressource à un serveur défini de l'URL.
  • METTRE URL crée/remplace la ressource dans son intégralité à la client défini de l'URL.
  • PATCH URL mises à jour partie de la ressource à L'URL définie par le client.

la spécification pertinente pour PUT and POST est RFC 2616 §9.5 ff.

POST crée un enfant ressource , donc POST à /items crée une ressources qui vit sous le /items des ressources. Par exemple. /items/1 . Envoyer le même paquet postal deux fois créera deux ressources.

PUT sert à créer ou à remplacer une ressource à une URL connue par le client .

par conséquent: PUT est seulement un candidat pour créer où le client connaît déjà l'url avant que la ressource soit créée. Par exemple. /blogs/nigel/entry/when_to_use_post_vs_put comme le titre est utilisé comme clé de ressource

METTRE remplace la ressource à l'url connue si elle existe déjà, donc envoyer la même demande à deux reprises pas d'effet. En d'autres termes, les appels à mettre sont idempotent .

Le RFC se lit comme suit:

la différence fondamentale entre les demandes de poste et les demandes de PUT se reflète dans le sens différent de la demande-URI. L'URI dans une requête POST identifie la ressource qui traitera l'entité incluse. Cette ressource pourrait être un processus d'acceptation des données, une passerelle vers un autre protocole ou une entité distincte qui accepte les annotations. En revanche, L'URI d'une requête PUT identifie l'entité contenue dans la requête -- l'agent utilisateur sait à quoi L'URI est destinée et le serveur ne doit pas tenter d'appliquer la requête à une autre ressource. Si le serveur souhaite que la requête soit appliquée à un URI différent,

Note: PUT a été principalement utilisé pour mettre à jour les ressources (en les remplaçant dans leurs entireties), mais récemment, il ya un mouvement towards using PATCH for updating existing resources, as PUT spécifie qu'il remplace l'ensemble de la ressource. RFC 5789.

573
répondu Nigel Thorne 2014-10-14 01:58:15
la source

résumé:

créer:

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

PUT

crée la nouvelle ressource avec newResourceId comme identifiant, sous le /Ressources URI, ou collection .

PUT /resources/<newResourceId> HTTP/1.1 

POST

Crée Un nouvelle ressource dans le cadre du /des ressources URI, ou collection . Habituellement, l'identifiant est retourné par le serveur.

POST /resources HTTP/1.1

mise à jour:

Peut seulement être effectuée avec METTRE de la façon suivante:

PUT

met à jour la ressource avec existingResourceId comme Identificateur, sous le /resources URI, ou collection .

PUT /resources/<existingResourceId> HTTP/1.1

explication:

en ce qui concerne le repos et L'URI en général, vous avez Générique sur le gauche et spécifique sur le droit . Le génériques sont généralement appelés collections et le plus spécifique éléments peut être appelé ressource . À noter 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

quand vous utilisez POST vous êtes toujours faisant référence à une collection , donc chaque fois que vous dites:

POST /users HTTP/1.1

vous affichez un nouvel utilisateur sur le utilisateurs collection .

Si vous allez sur et essayer quelque chose comme ceci:

POST /users/john HTTP/1.1

cela va fonctionner, mais sémantiquement vous dites que vous voulez ajouter une ressource à la john collection sous la rubrique utilisateurs collection .

une fois que vous utilisez PUT, vous faites référence à une ressource ou à un seul article, peut-être à l'intérieur d'une collection . Donc quand vous dites:

PUT /users/john HTTP/1.1

vous dites à la mise à jour du serveur, ou créer si elle n'existe pas, le john ressource sous le utilisateurs collection .

Spec:

Permettez-moi de souligner quelques parties importantes du spec:

POST

la méthode POST est utilisée pour demander que le serveur d'origine accepte l'entité contenue dans la requête comme une entité subordonnée 1519540920" nouvelle de la ressource identifiée par l'URI de la Requête dans la Ligne de Requête

ainsi, crée une nouvelle ressource sur une collection .

PUT

la méthode PUT demande que l'entité incluse soit stockée dans le cadre de la requête-URI fournie. Si L'URI-requête fait référence à un déjà existante ressource, l'entité ci-jointe doit être considérée comme une version modifiée de celle qui réside sur le serveur d'origine. Si L'URI-requête ne ne pointe pas vers une ressource existante, et que L'URI est capable d'être défini comme un nouveau ressource par l'agent utilisateur requérant, le serveur d'origine peut créer le ressource avec cette URI."

donc, créer ou mettre à jour basé sur l'existence de la ressource .

référence:

172
répondu 7hi4g0 2016-02-09 21:25:43
la source

j'aimerais ajouter mon conseil" pragmatique". Utilisez PUT lorsque vous connaissez le "id" par lequel l'objet que vous sauvegardez peut être récupéré. L'utilisation de PUT ne fonctionnera pas très bien si vous avez besoin, par exemple, d'un id généré par la base de données à retourner pour que vous puissiez effectuer des recherches ou des mises à jour futures.

donc: pour sauver un utilisateur existant, ou un où le client génère l'id et il a été vérifié que l'id 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 objet, et mettre à jour l'objet:

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
157
répondu ThaDon 2011-05-25 07:43:05
la source

POST signifie "créer nouveau", comme dans "Ici est l'entrée pour la création d'un utilisateur, en créer un pour moi".

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

vous postez à example.com/users comme vous ne connaissez pas encore L'URL de l'utilisateur, vous voulez que le serveur le crée.

vous mettez à example.com/users/id depuis que vous voulez remplacer/créer un utilisateur spécifique .

afficher deux fois les mêmes données signifie créer deux utilisateurs identiques avec des identifiants différents. Le fait de couper deux fois avec les mêmes données crée l'utilisateur le premier et le met à jour dans le même état la deuxième fois (aucun changement). Puisque vous finissez avec le même état après un PUT peu importe combien de fois vous l'effectuez, il est dit pour être "également puissant" chaque fois - idempotent. Ceci est utile pour retracer automatiquement les requêtes. Plus de "êtes-vous sûr de vouloir renvoyer" quand vous appuyez sur le bouton de retour sur le navigateur.

un conseil général est d'Utiliser POST lorsque vous avez besoin que le serveur soit en contrôle de la génération D'URL de vos ressources. Utilisez le METTRE autrement. Je préfère mettre plutôt que POST.

148
répondu Alexander Torstling 2017-04-23 21:13:45
la source

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

PUT    /items/1      #=> update
POST   /items        #=> create
109
répondu Tim Sullivan 2017-09-16 23:17:08
la source

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

si vous avez des doutes sur la façon d'implémenter REST dans HTTP, vous pouvez toujours jeter un oeil à la spécification Atom Publication Protocol (AtomPub) . AtomPub est une norme pour l'écriture de RESTful webservices avec HTTP qui a été développé par de nombreux luminaires HTTP et REST, avec quelques entrées de Roy Fielding, l'inventeur de REST et (co-)inventeur de 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: il s'agit d'un protocole générique pour interagir avec sérénité avec des collections arbitraires (imbriquées) de ressources arbitraires via HTTP. Si vous pouvez représenter votre application comme une collection emboîtée de ressources, alors vous pouvez juste utiliser AtomPub et ne vous inquiétez pas de savoir si utiliser PUT ou POST, quels codes de statut HTTP à retour et tous ces détails.

C'est 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 de poste à L'URI de la Collection.

58
répondu Jörg W Mittag 2018-07-27 17:37:27
la source

la décision d'utiliser PUT ou POST pour créer une ressource sur un serveur avec une API HTTP + REST est basée sur qui possède la structure URL. avoir le client au courant, ou participer à la définition, de la structure de L'URL est un couplage inutile qui s'apparente aux couplages indésirables qui proviennent de SOA. Échapper aux types d'accouplements est la raison pour laquelle le repos est si populaire. Par conséquent, la méthode appropriée à utiliser est POST. il y a des exceptions à cette règle et ils se produisent lorsque le client souhaite garder le contrôle sur la structure de localisation des ressources qu'il déploie. C'est rare et signifie probablement quelque chose d'autre est mauvais.

à ce point, certaines personnes vont faire valoir que si RESTful-URL sont utilisés, le client ne connaît L'URL de la ressource et donc un PUT est acceptable. Après tout, c'est pourquoi canonique, normalisé, Ruby sur Rails, les URL Django sont importants, regardez L'API Twitter ... bla bla bla blah. Ces personnes ont besoin de comprendre il n'y a pas une telle chose comme un Reposful-URL et que Roy Fielding lui-même déclare que :

une API REST ne doit pas définir de noms ou de hiérarchies de ressources fixes (an couplage évident du client et du serveur). Les serveurs doivent avoir la liberté pour contrôler leur propre espace de noms. Au lieu de cela, permettez aux serveurs d'instruire les clients sur la façon de construire des URI appropriés, comme c'est fait en HTML formulaires et gabarits D'URI, en définissant ces instructions dans les médias types et relations de lien. [Échec ici implique que les clients sont en présumant une structure de ressources en raison de renseignements hors bande, comme: une norme propre au domaine, qui est l'équivalent orienté vers les données Couplage fonctionnel de RPC].

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

L'idée d'un RESTful-URL est en fait une violation de REST car le serveur est en charge de la structure URL et devrait être libre de décider comment l'utiliser pour éviter le couplage. Si cela vous confond, vous pouvez lire sur la signification de la découverte de soi sur la conception de L'API.

Utiliser POST pour créer des ressources vient avec une considération de conception parce que POST n'est pas idempotent. cela signifie que répéter plusieurs fois un message ne garantit pas le même comportement chaque fois. Cela fait peur aux gens d'utiliser PUT pour créer des ressources alors qu'ils ne devraient pas. ils savent que C'est mal (POST est pour CREATE) mais ils le font de toute façon parce qu'ils ne savent pas comment résoudre ce problème. Cette préoccupation se manifeste dans la situation suivante:

  1. le client affiche une nouvelle ressource sur le serveur.
  2. le serveur traite La requête et envoie une réponse.
  3. le client ne reçoit jamais la réponse.
  4. le serveur ne sait pas que le client n'a pas reçu la réponse.
  5. le client n'a pas d'URL pour la ressource (donc PUT n'est pas une option) et répète le message.
  6. POST n'est pas idempotent et le serveur...""

L'Étape 6 est celle où les gens sont souvent confus au sujet de ce qu'ils doivent faire. Toutefois, il n'y a aucune raison de créer un kludge pour résoudre ce problème. À la place, HTTP peut ê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 traitée en raison d'un conflit avec le état de la ressource. Ce code n'est autorisé que dans les situations où il est prévu que l'utilisateur peut être en mesure de résoudre le conflit et soumettre de nouveau la demande. L'organisme de réponse devrait inclure suffisamment de

informations pour l'utilisateur de reconnaître la source du conflit. Idéalement, l'entité de réponse serait suffisamment d'informations pour la utilisateur ou agent utilisateur pour corriger le problème; toutefois, cela pourrait ne pas être possible et n'est pas nécessaire.

les conflits sont plus susceptibles de se produire en réponse à une demande de PUT. Pour exemple, si versioning étaient utilisés et l'entité étant mis inclus les modifications apportées à une ressource qui entrent en conflit avec celles apportées par un antérieur (tiers), le serveur peut utiliser la réponse 409 pour indiquer qu'il ne peut pas remplir la demande. Dans ce cas, l' l'entité de réponse contiendrait probablement une liste des différences entre les deux versions dans un format défini par le type de contenu de la réponse.

répondre avec un code de statut de 409 conflit est le recours correct parce que :

  • effectuer un POST de données qui a un L'ID qui correspond à une ressource déjà dans le système est "un conflit avec l'état actuel de la ressource."
  • puisque la partie importante est pour le client de comprendre le serveur a la ressource et de prendre des mesures appropriées. Il s'agit d'une "situation où l'on s'attend à ce que l'utilisateur soit en mesure de résoudre le conflit et de présenter de nouveau la demande."
  • une réponse qui contient L'URL de la ressource avec L'ID de conflit et le les conditions préalables à la ressource fourniraient "suffisamment d'information pour que l'utilisateur ou l'agent utilisateur puisse corriger le problème", ce qui est le cas idéal selon la RFC 2616.

mise à Jour basé sur la libération de la RFC 7231 pour Remplacer 2616

RFC 7231 est conçu pour remplacer 2616 et dans à la Section 4.3.3, décrit le suivre de réponse possible pour un POST

si le résultat du traitement d'un représentation d'une ressource existante, un serveur origin peut rediriger l'agent utilisateur à cette ressource en envoyant une réponse 303 (voir autre) avec l'Identificateur de la ressource existante dans le champ Emplacement. Ce a les avantages de fournir à l'agent utilisateur un identificateur de ressource et le transfert de la représentation par une méthode plus la mise en cache partagée, mais au prix d'une demande supplémentaire si l'utilisateur agent n'a pas déjà la représentation en cache.

aujourd'hui, Il peut être tentant de simplement retourner un 303 dans le cas où un POSTE est répété. Toutefois, le contraire est vrai. Retourner un 303 n'aurait de sens que si plusieurs requêtes create (créant des ressources différentes) retournaient le même contenu. Un exemple serait un "merci de soumettre votre message de demande" que le client n'a pas besoin de télécharger à chaque fois. La RFC 7231 maintient toujours à la section 4.2.2 que POST ne doit pas être idempotent et continue à maintenir que POST doit être utilisé pour create.

pour plus d'informations à ce sujet, lire article .

53
répondu Joshcodes 2017-10-21 15:39:27
la source

tous les deux sont utilisés pour la transmission de données entre client et serveur, mais il y a des différences subtiles entre eux, qui sont:

Enter image description here

analogie:

  • MIS par exemple, et mettre où il était.
  • POST comme d'envoyer des messages dans post office.

enter image description here

51
répondu Premraj 2018-08-07 11:46:59
la source

j'aime cet avis, à partir de RFC 2616 la définition de :

la différence fondamentale entre les demandes de poste et de poste se reflète dans le sens différent de la demande-URI. L'URI dans une requête POST identifie la ressource qui traitera l'entité incluse. Cette ressource pourrait être un processus d'acceptation des données, une passerelle vers un autre protocole ou une entité distincte qui accepte les annotations. En revanche, L'URI dans une requête PUT identifie l'entité contenue dans la requête -- l'agent utilisateur sait quelle URI est prévue et le serveur ne doit pas tenter d'appliquer la requête à une autre ressource.

ce jibes avec les autres conseils ici, qui mettent est mieux appliqué aux ressources qui ont déjà un nom, et POST est bon pour créer un nouvel objet sous une ressource existante (et laisser le serveur l'appeler).

j'interprète ceci, et l'idempotence

  • POST est bon pour créer de nouveaux objets en vertu d'une collection (et de créer n'a pas besoin d'être idempotent)
  • est bon pour la mise à jour des objets existants (et mise à jour doit être idempotent)
  • POST peut également être utilisé pour les mises à jour non-idempotent à des objets existants (en particulier, changer une partie d'un objet sans spécifier la chose entière -- si vous y pensez, créer un nouveau membre d'une collection est en fait un cas particulier de ce type de mise à jour, du point de vue de la collection)
  • PUT peut aussi être utilisé pour créer si et seulement si vous autorisez le client à nommer la ressource. Mais puisque les clients REST ne sont pas censés faire des suppositions sur la structure D'URL, c'est moins dans l'esprit des choses.
48
répondu metamatt 2012-01-11 21:18:54
la source

en bref:

METTRE est la quantité, où les ressources de l'état sera de même si la même opération est exécutée une seule fois ou plusieurs fois.

POST est non la quantité, où les ressources de l'état peut être différent si l'opération est exécutée plusieurs fois par rapport à l'exécution d'une seule fois.

analogie avec requête de base de données

METTRE Vous pouvez penser similaires à "mise à JOUR de l'ÉTUDIANT SET adresse = "abc" where id="123";

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

L'identification de L'élève est générée automatiquement.

avec PUT, si la même requête est exécutée plusieurs fois ou une seule fois, L'état de la table STUDENT reste le même.

en cas de poste, si la même requête est exécutée plusieurs fois, alors plusieurs enregistrements D'étudiants sont créés dans la base de données et l'état de la base de données change à chaque exécution d'une requête "INSERT".

NOTE: PUT a besoin d'un emplacement de Ressource (déjà-ressource) sur lequel la mise à jour doit se produire, alors que POST ne nécessite pas cela. Par conséquent, intuitivement POST est destiné à la création d'une nouvelle ressource, alors que PUT est nécessaire pour mettre à jour la ressource déjà existante.

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

39
répondu bharatj 2017-10-21 15:46:45
la source

POST est comme poster une lettre à une boîte aux lettres ou poster un email à une file d'attente de courrier électronique. Mettre est comme quand vous mettez un objet dans un trou cubby ou un endroit sur une étagère (il a une adresse connue).

Avec la POSTE, vous êtes à poster à l'adresse de la FILE d'attente ou de la COLLECTION. Avec PUT, vous mettez à l'adresse de l'objet.

est idempotent. Vous pouvez envoyer la demande 100 fois et cela n'aura pas d'importance. La POSTE n'est pas idempotent. Si vous envoyez la demande 100 fois, vous recevrez 100 e-mails ou 100 lettres dans votre boîte postale.

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

POST versus PUT

38
répondu Homer6 2013-07-10 23:52:13
la source

Nouvelle Réponse (Maintenant que je comprends mieux le repos):

PUT est simplement un énoncé de ce que le service devrait, à partir de maintenant, utiliser pour rendre des représentations de la ressource identifiée par le client; POST est un énoncé de ce que le service devrait, à partir de maintenant, contenir (peut-être dupliqué), mais c'est au serveur Comment identifier ce contenu.

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

PUT x (si x n'identifie pas une ressource):" créer une nouvelle ressource contenant mon contenu et utiliser 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é avec d'autres contenus). Ladite ressource doit être identique ou subordonnée à celle que x identifie."" y ressource est subordonné à x ressource" est généralement, mais pas nécessairement mis en œuvre en faisant y un subpath de x (par exemple x = /foo et y = /foo/bar ) et la modification de la représentation(s) de x ressource reflétant l'existence d'une nouvelle ressource, par exemple avec un lien hypertexte vers la ressource y et certaines métadonnées. Seul ce dernier est vraiment essentiel à une bonne conception, car les URLs sont opaques dans REST -- vous êtes censés utiliser hypermedia au lieu de construction D'URL côté client pour traverser le service de toute façon.

dans REST, il n'y a pas de ressource contenant "content". Je me réfère comme "contenu" aux données que le service utilise pour présenter des représentations de façon uniforme. Il se compose généralement de quelques lignes connexes 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 utile JSON en relevés SQL.

réponse originale (plus facile à lire) :

PUT /something (si /something existe déjà):" prenez tout ce que vous avez à /something et le remplacer par ce que je te donne."

PUT /something (si /something n'existe pas déjà): "prenez ce que je vous donne et mettez-le à /something ."

POST /something :" prenez ce que je vous donne et mettez-le où vous voulez sous /something aussi longtemps que vous me donnez son URL quand vous avez fini."

34
répondu Jordan 2017-05-23 14:55:13
la source

Ruby on Rails 4.0 utilisera la méthode' PATCH ' au lieu de PUT pour faire 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 de prévenir erreur. 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 faire des changements partiels. Autrement, les mandataires et les caches, et même les clients et les serveurs, peuvent obtenir confus quant au résultat de l'opération. POST est déjà utilisé mais sans une interopérabilité étendue (pour l'un, il n'y a pas de moyen standard de découvrez le support du format patch). PATCH a été mentionné dans le HTTP précédent spécifications, mais pas complètement définies.

" le Bord des Rails: PATCH est la principale méthode HTTP pour les mises à jour " explique.

31
répondu germanlinux 2017-09-16 23:17:52
la source

Brève Réponse:

simple règle empirique: Utiliser POST pour créer, utiliser PUT pour mettre à jour.

Longue Réponse:

POST:

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

:

  • PUT est utilisé pour état de transfert vers le serveur
  • utile lorsque l'URL d'une ressource est connue

Plus Longue Réponse:

pour le comprendre nous avons besoin de se demander pourquoi mis était nécessaire, quels étaient les problèmes mis essayait de résoudre ce poste ne pouvait pas.

du point de vue d'une architecture de repos il n'y a rien qui importe. On aurait pu vivre sans PUT. Mais de la part d'un développeur client point de vue cela a rendu sa vie beaucoup plus simple.

avant la mise, Les clients ne pouvaient pas savoir directement L'URL générée par le serveur ou si tout ce qu'il avait généré ou si les données à envoyer au serveur sont déjà mises à jour ou non. Soulage le développeur de tous ces maux de tête. PUT est idempotent, PUT gère les conditions de course, et PUT permet au client de choisir l'URL.

28
répondu ishandutta2007 2017-10-21 16:03:18
la source

au risque de répéter ce qui a déjà été dit, il semble important de se rappeler que PUT implique que le client contrôle ce que URL va finir par être, lors de la création d'une ressource. Ainsi, une partie du choix entre PUT et POST va être sur combien vous pouvez faire confiance au client pour fournir correct, normalisé URL qui sont cohérents avec quel que soit votre schéma d'URL est.

Quand vous ne pouvez pas faire entièrement confiance au client de faire la bonne chose, il serait plus approprié d'utiliser POST pour créer un nouvel élément et ensuite envoyer L'URL au client dans la réponse.

24
répondu skillet-thief 2014-08-28 13:17:34
la source

la considération la plus importante est fiabilité . Si un message 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 indéfini que jusqu'à la première tentative réussie.

par exemple, il peut ne pas être une bonne idée de créer des transactions par carte de crédit avec la poste.

si vous avez généré automatiquement des URI sur votre ressource, vous pouvez toujours utiliser PUT by transmettre une URI générée (pointant vers une ressource vide) au client.

quelques autres considérations:

  • POST invalide les copies mises en cache de l'ensemble contenant des ressources (de cohérence)
  • METTRE les réponses ne sont pas mis en cache alors que les POST sont ceux qui Exigent le Contenu-l'Emplacement et la date d'expiration)
  • est de moins en moins pris en charge, par exemple en Java ME, les navigateurs plus anciens, pare-feu
18
répondu Hans Malherbe 2012-02-10 09:53:13
la source

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

Case 1: Quand vous postez quelque chose sur votre ligne de temps, c'est une nouvelle entrée. Donc, dans ce cas, ils utilisent la méthode POST parce que la méthode POST est non-idempotent.

Case 2: Si votre ami commente votre message la première fois, cela créera également une nouvelle entrée dans la base de données de sorte que la méthode POST utilisé.

cas 3: Si votre ami modifie son commentaire, dans ce cas, ils avaient un ID de commentaire, donc ils vont mettre à jour un commentaire existant au lieu de créer une nouvelle entrée dans la base de données. C'est pourquoi pour ce type d'opération utilisez la méthode PUT parce qu'elle est idempotent.*

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

18
répondu UniCoder 2017-10-21 15:49:12
la source

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 de repos. La plupart des développeurs vont essayer d'associer directement les opérations CRUD aux méthodes HTTP. Je vais argumenter que ce n'est pas correct et 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 le R (etrieve) et le D (elete) des opérations CRUD peuvent être directement mis en correspondance avec les méthodes HTTP GET et DELETE respectivement. Toutefois, 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 nécessaire. L'ambiguïté réside dans la définition d'une méthode de PUT HTTP par rapport à une méthode de POST HTTP.

selon les spécifications HTTP 1.1, les méthodes GET, HEAD, DELETE et PUT doivent être idempotent, et la méthode POST n'est pas idempotent. C'est-à-dire qu'une opération est idempotent si elle peut être réalisée sur une ressource en une ou plusieurs fois et toujours le même état de cette ressource. Alors qu'une opération non idempotent peut retourner un état modifié de la ressource d'une requête à une autre. Par conséquent, dans une opération non idempotent, il n'y a aucune garantie qu'une personne recevra le même état d'une ressource.

basé sur la définition d'idempotent ci-dessus, mon point de vue sur l'utilisation de la méthode HTTP PUT par rapport à L'utilisation de la méthode HTTP POST pour les services REST est: Utiliser la mise HTTP méthode dans laquelle:

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 exécutées plusieurs fois avec les mêmes résultats. C'est la ressource ne sera pas changé en demandant l'opération plus d'une fois. Par conséquent, une véritable opération équipotente. 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élent pas directement et ne mappent pas les opérations CRUD aux méthodes HTTP pour les services de repos. L'utilisation D'une méthode de PUT HTTP par rapport à une La méthode HTTP POST doit être basée sur l'aspect idempotent de cette opération. C'est-à-dire, si l'opération est idempotent, alors utilisez la méthode HTTP PUT. Si l'opération n'est pas idempotent, utilisez la méthode HTTP POST.

13
répondu Burhan 2013-10-10 08:18:51
la source

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

donc vous utilisez POST et probablement, mais pas nécessaire mis pour la création de ressources. Vous n'avez pas à soutenir à la fois. Pour moi, le POST est parfaitement suffisant. C'est donc une décision de conception.

comme votre citation l'a mentionné, vous utilisez PUT pour la création d'il n'y a aucune ressource assignée à un IRI, et vous voulez créer une ressource de toute façon. Par exemple, PUT /users/123/password habituellement remplace l'ancien mot de passe par un nouveau, mais vous pouvez l'utiliser pour créer un mot de passe si elle n'existe pas déjà (par exemple, par fraîchement utilisateurs enregistrés ou en restaurant interdit aux utilisateurs).

12
répondu inf3rno 2017-10-21 15:41:52
la source

les lecteurs nouveaux à ce sujet sera frappé par la discussion sans fin sur ce que vous devrait faire, et l'absence relative de leçons de l'expérience. Le fait que le repos soit" préféré " au savon est, je suppose, un apprentissage de haut niveau à partir de l'expérience, mais la bonté, nous devons avoir progressé à partir de là? On est en 2016. La thèse de Roy était en 2000. Qu'avons-nous développé? C'était amusant? Était-il facile à intégrer? Soutenir? Est-il gérer la montée des smartphones et des feuilletée connexions mobiles?

selon moi, les réseaux réels ne sont pas fiables. Les demandes de délai d'attente. Les connexions sont réinitialisées. Les réseaux tombent pendant des heures ou des jours à la fois. Les Trains entrent dans les tunnels avec des utilisateurs mobiles à bord. Pour toute demande (parfois reconnu dans toute cette discussion) la demande peut tomber dans l'eau sur son chemin, ou que la réponse peut tomber dans l'eau sur son chemin de retour. dans ces conditions, l'émission PUT, POST et supprimer des demandes directement contre les ressources substantielles m'a toujours paru un peu brutal et naïf.

HTTP ne fait rien pour assurer l'achèvement fiable de la requête-réponse, et c'est très bien parce que c'est correctement le travail des applications réseau-conscientes. En développant une telle application, vous pouvez sauter à travers des cerceaux pour utiliser PUT au lieu de POST, puis plus de cerceaux pour donner un certain type d'erreur sur le serveur si vous détectez des requêtes en duplicata. De retour chez le client, vous devez ensuite sautez à travers les cerceaux pour interpréter ces erreurs, refetch, revalidate et repost.

ou vous pouvez faire ceci : considérez vos requêtes dangereuses comme des ressources mono-utilisateur éphémères (appelons-les actions). Les Clients demandent une nouvelle "action" sur une ressource substantielle avec un poste vide à la ressource. POST ne sera utilisé que pour cela. Une fois en sécurité en possession de L'URI de l'action fraîchement lancée, le client met la demande dangereuse à L'URI d'action, pas la ressource cible . Résoudre l'action et mettre à jour la ressource "réelle" est correctement le travail de votre API, et est ici découplé du réseau peu fiable.

le serveur fait l'affaire, 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à vu, il répète la stockées réponse et ne fait rien d'autre .

vous remarquerez rapidement la similitude avec les promesses: nous créons et retournons le paramètre pour le résultat avant de faire quoi que ce soit. Aussi comme une promesse, une action peut réussir ou échouer une fois, mais le résultat peut être récupérée à plusieurs reprises.

mieux que tout, nous donnons aux applications d'envoi et de réception une chance de lier l'action identifiée de façon unique à l'unicité dans leurs environnements respectifs. Et nous pouvons commencer à de la demande, et de faire respecter!, comportement responsable de la part des clients: répétez vos demandes autant que vous le souhaitez, mais ne générez pas une nouvelle action tant que vous n'êtes pas en possession d'un résultat définitif de l'action existante.

ainsi, de nombreux problèmes épineux disparaissent. Les requêtes répétées d'insertion ne créeront pas de doublons, et nous ne créerons pas la véritable ressource tant que nous ne serons pas en possession des données. (les colonnes de la base de données peuvent rester non-nulles). Les requêtes de mise à jour répétées ne seront pas incompatibles et ne supplantera pas les changements ultérieurs. Les Clients peuvent (re)récupérer et seamlessy traiter la confirmation originale pour quelque raison que ce soit (le client s'est écrasé, la réponse a disparu, etc.).

les demandes successives de suppression peuvent voir et traiter la confirmation originale, sans frapper une erreur 404. Si les choses prennent plus de temps que prévu, nous pouvons répondre provisoirement, et nous avons un endroit où le client peut vérifier en arrière pour le résultat définitif. La partie la plus belle de ce modèle est son Propriété de 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 transformer en une force : -)

avant de me dire que ce N'est pas reposant, s'il vous plaît considérer les nombreuses façons dont les principes du repos sont respectés. Les clients ne construisent pas D'URL. L'API reste détectable, mais avec un peu de changement de sémantique. Les verbes HTTP sont utilisés de façon appropriée. Si vous pensez que c'est un énorme mise en œuvre de changements, je peux vous dire par expérience qu'il ne l'est pas.

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

12
répondu bbsimonbb 2018-05-23 17:06:30
la source

je vais atterrir avec le suivant:

PUT fait référence à une ressource identifiée par L'URI. Dans ce cas, vous êtes de le mettre à jour. C'est la partie des trois verbes qui se réfère aux ressources -- supprimer et obtenir d'être les deux autres.

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


parce que PUT, GET et DELETE font référence à une ressource, ils sont aussi par définition idempotent.

POST peut effectuer les trois autres fonctions, mais alors la sémantique de la demande sera perdue sur les intermédiaires tels que les caches et les procurations. Cela s'applique également à fournir une sécurité sur la ressource, puisque L'URI d'un poste n'est pas nécessairement indiquez la ressource à laquelle elle s'applique (elle peut cependant).

un PUT n'a pas besoin d'être un create; le service peut faire une erreur si la ressource n'est pas déjà créée, mais sinon mettez-la à jour. Ou vice versa -- il peut créer la ressource, mais ne permet pas les mises à jour. La seule chose requise sur MIS, c'est qu'il pointe vers une ressource spécifique, et sa charge utile est la représentation de cette ressource. Un PUT réussi signifie (Sauf interférence) qu'un GET récupérerait la même ressource.


Edit: une chose de plus -- un PUT peut créer, mais s'il le fait, alors L'ID doit être un ID naturel -- alias une adresse e-mail. De cette façon, quand vous mettez deux fois, la deuxième mise est une mise à jour de la première. Cela fait idempotent .

si L'ID est généré (un nouvel ID d'employé, par exemple), alors le second mis avec la même URL créerait un nouvel enregistrement, ce qui viole la règle idempotent. Dans ce cas, le verbe serait POST, et le message (Pas ressource) serait de créer une ressource en utilisant les valeurs définies dans ce message.

10
répondu Gerard ONeill 2017-10-21 15:32:49
la source

les sémantiques sont supposées être différentes, dans ce" PUT", comme" GET " est supposé être idempotent -- ce qui signifie que vous pouvez exactement la même requête PUT plusieurs fois et le résultat sera comme si vous l'aviez exécutée une seule fois.

je vais décrire les conventions qui, je pense, sont les plus largement utilisés et sont plus utiles:

quand vous mettez une ressource à une URL particulière ce qui se passe est qu'elle devrait être sauvegardée à cette URL, ou quelque chose le long de ces ligne.

quand vous postez à une ressource à une URL particulière, souvent vous postez un élément d'information lié à cette URL. Cela implique que la ressource à l'URL existe déjà.

par exemple, quand vous voulez créer un nouveau flux, vous pouvez le mettre à une URL. Mais quand vous voulez poster un message à un flux existant, vous postez à son URL.

quant à la modification des propriétés du flux, vous pouvez le faire avec L'une ou L'autre des options suivantes: ou par la POSTE. Fondamentalement, n'utilisez "PUT" que lorsque l'opération est idempotent - sinon utilisez POST.

Notez, cependant, que tous les navigateurs modernes soutien verbes HTTP autres que GET ou POST.

8
répondu Gregory Magarshak 2011-10-24 00:07:55
la source

la plupart du temps, vous les utiliserez comme ceci:

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

par exemple:

  • POST / items
  • METTRE /articles/1234

Dans les deux cas, le corps de la demande contient les données pour la ressource à créer ou à mettre à jour. Il devrait être évident d'après les noms de routes que POST n'est pas idempotent (si vous l'appelez 3 fois il créera 3 objets), mais PUT est idempotent (si vous l'appelez 3 fois le résultat est le même). METTRE est souvent utilisé pour "upsert" de l'opération (création ou mise à jour), mais vous pouvez toujours retourner une erreur 404 si vous ne voulez modifier.

notez que POST "crée" un nouvel élément dans le collection, et mettre "remplace" un élément à une URL donnée, mais C'est une pratique très courante d'utiliser PUT pour des modifications partielles, c'est-à-dire l'utiliser seulement pour mettre à jour les ressources existantes et modifier seulement les champs inclus dans le corps (en ignorant les autres champs). Ceci est techniquement incorrect, si vous voulez être REST-purist, PUT devrait remplacer toute la ressource et vous devriez utiliser PATCH pour la mise à jour partielle. Personnellement, je ne me soucie pas tant que le comportement est clair et cohérent à travers tous vos API points de terminaison.

Rappelez-vous, le RESTE est un ensemble de conventions et de lignes directrices pour garder votre API simple. Si vous vous retrouvez avec un travail compliqué autour juste pour vérifier la boîte "RESTfull" alors vous êtes en train de vaincre le but;)

7
répondu tothemario 2017-06-21 20:38:44
la source

bien qu'il y ait probablement une façon agnostique de les décrire, il semble être en conflit avec divers énoncés des réponses aux sites web.

soyons très clairs et directs ici. Si vous êtes un développeur .NET travaillant avec L'API Web, les faits sont (à partir 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.

sûr vous "pouvez" utiliser "POST" mettre à jour, mais il suffit de suivre les conventions établies pour vous avec votre cadre. Dans mon cas, C'est L'API.NET / Web, donc est mis à jour il n'y a pas de débat.

j'espère que cela aide tous les développeurs de Microsoft qui ont lu tous les commentaires avec Amazon et Sun/Java liens de site web.

7
répondu Tom Stickel 2017-07-22 14:48:51
la source

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

  1. sélectionner
  2. insérer
  3. mise à Jour
  4. Supprimer
  5. Fusionner (mise à Jour si déjà existant, d'autre insert)

j'utilise PUT pour fusionner et mettre à jour des opérations similaires et utiliser POST pour les Insertions.

6
répondu Rajan 2016-06-30 00:13:07
la source

dans la pratique, la poste fonctionne bien pour créer des ressources. L'URL de la ressource nouvellement créée doit être retournée dans l'en-tête Location response. MIS de devrait être utilisé pour mettre à jour une ressource complètement. S'il vous plaît comprendre que ce sont les meilleures pratiques lors de la conception D'une API RESTful. La spécification HTTP en tant que telle ne limite pas L'utilisation de PUT/POST avec quelques restrictions pour créer/mettre à jour des ressources. Regardez http://techoctave.com/c7/posts/71-twitter-rest-api-dissected qui résume les meilleures pratiques.

5
répondu java_geek 2014-10-13 13:59:32
la source

Voici une règle simple:

METTRE à une URL doit être utilisé pour mettre à jour ou de créer de la ressource située à l'URL.

POST à une URL doit être utilisé pour mettre à jour ou de créer une ressource qui est situé à quelques autres (les"actions subalternes") de l'URL, ou n'est pas localisable via HTTP.

5
répondu Adam Griffiths 2017-09-16 23:24:31
la source

POST: utilisez-le pour créer de nouvelles ressources. C'est comme INSERT (SQL statement) avec un ID incrémenté automatiquement. Dans la partie réponse, il contient un nouvel Id généré.

POST est également utilisé pour mettre à jour un enregistrement.

: l'Utiliser pour la création d'une nouvelle ressource, mais ici, je sais que l'identité de la clé. C'est comme INSERT (SQL statement) où je connais à l'avance la clé d'identité. Dans la partie de réponse, il n'envoie rien.

PUT est également utilisé pour mettre à jour une ressource

3
répondu sushil pandey 2017-07-22 14:42:53
la source

Autres questions sur http rest post put