Créer une API REST avec PHP

Posté le 28 Janvier, 2012 Greenhawk

Un des derniers (sorte de) engouements qui balaient le net est API, plus précisément ceux REST effet de levier qui. C'est vraiment pas une surprise non plus, car la consommation des API REST est si incroyablement facile ... dans n'importe quelle langue. Il est également incroyablement facile de les créer comme vous utilisent essentiellement rien de plus qu'une spécification HTTP qui a existé pendant des siècles. Une des rares choses que je donne crédit Rails, c'est son soutien ainsi REST thought-out, à la fois pour la fourniture et la consommation de ces API (comme son été expliqué par tous les fanboys Rails avec qui je travaille).

Sérieusement, si vous n'avez jamais utilisé de repos, mais vous avez déjà eu à travailler avec (ou pour le pire, de créer) une API SOAP, ou tout simplement ouvert un WSDL et avait la tête exploser, mon garçon ne j'ai de bonnes nouvelles pour vous!

Alors, qu'est-ce donc REST? Pourquoi devriez-vous en soucier?

Avant d'entrer dans l'écriture du code, je veux m'assurer que tout le monde a une bonne compréhension de ce que REST est et comment son grand pour API. Tout d'abord, techniquement parlant, REST n'est pas spécifique à juste API, il s'agit plus d'un concept générique. Mais, évidemment, pour le bien de cet article, nous allons en parler dans le contexte d'une API. Alors, regardons les besoins fondamentaux d'une API REST et comment les aborde.

Demandes
Toutes les API doivent accepter les demandes. En règle générale, avec une API RESTful, vous aurez un schéma d'URL bien défini. Disons que vous voulez fournir une API pour les utilisateurs sur votre site (je sais, j'ai toujours utiliser la fonction "utilisateurs" concept pour mes exemples). Eh bien, la structure de votre URL serait probablement quelque chose comme, "api / users" et "api / users / [id]" selon le type d'opération étant demandée à l'encontre de votre API. Vous devez également considérer comment vous voulez recevoir des données. Ces jours, beaucoup de gens utilisent JSON ou XML, et je préfère personnellement JSON car il fonctionne bien avec JavaScript, PHP et possède des fonctionnalités faciles pour l'encodage et le décodage. Si vous vouliez que votre API pour être vraiment solide, vous pourriez accepter à la fois en reniflant le contenu-type de la demande (c.-à-application / json ou application / xml), mais il est parfaitement acceptable de restreindre les choses à un type de contenu. Heck, vous pourriez même utiliser de simples paires clé / valeur si vous voulez.

L'autre élément d'une demande est ce qu'il est réellement l'intention de faire, comme charger, sauvegarder, etc Normalement, vous auriez à venir avec une sorte d'architecture qui définit ce que l'action de la demande (consommation) désirs, mais REST simplifie que. En utilisant des méthodes de requêtes HTTP, ou des verbes, nous n'avons pas besoin de définir quoi que ce soit. Nous pouvons simplement utiliser le GET, POST, PUT et DELETE méthodes, et qui couvre toutes les demandes que nous avions besoin. Vous pouvez assimiler les verbes au standard de votre crud style stuff: GET = charge / récupérer, POST = créer, PUT = UPDATE, DELETE = bien, supprimer. Il est important de noter que ces verbes ne se traduit pas directement à CRUD, mais c'est un bon moyen de penser à eux. Donc, pour en revenir aux exemples URL ci-dessus, nous allons jeter un coup d'oeil à ce que certains d'éventuelles demandes pourrait signifier:

Requête GET à / api / utilisateurs - Liste tous les utilisateurs
Requête GET à / api/users/1 - Informations sur la liste pour l'utilisateur avec l'ID de 1
POST demande / API / utilisateurs - Créer un nouvel utilisateur
PUT demande à / api/users/1 - Mise à jour avec l'utilisateur ID 1
SUPPRIMER demande / api/users/1 - Effacer l'utilisateur avec l'ID de 1

Comme vous nous l'espérons voir, REST a déjà pris soin de beaucoup des maux de tête importants de la création de votre propre API par le biais des simples, bien comprises des normes et des protocoles, mais il ya une autre pièce à une bonne API ...

Réponses
Ainsi, REST gère les demandes très facilement, mais il fait aussi des réponses génératrices facile. Semblable à la demande, il ya deux composantes principales d'une réponse RESTful: le corps de la réponse et un code d'état. Le corps de la réponse est assez facile à traiter. Comme les demandes, la plupart des réponses à REST sont généralement soit JSON ou XML (peut-être juste du texte dans le cas de postes, mais nous verrons cela plus tard). Et, comme les requêtes, le consommateur peut spécifier le type de réponse qu'ils aimeraient par une autre partie de la spécification de requête HTTP, "Accepter". Si un consommateur souhaite recevoir une réponse XML, qu'ils venaient d'envoyer un en-tête Accept dans le cadre de leur demande en disant que beaucoup ("Accept: application / xml"). Certes, cette méthode n'est pas aussi largement adopté (quoique cela devrait être), si vous avez pouvez également utiliser le concept d'une extension dans l'URL. Par exemple, / api / users.xml signifie que le consommateur veut XML comme une réponse, même / api / users.json signifie JSON (même pour des choses comme / api/users/1.json/xml). De toute façon que vous choisissez (je dis de faire les deux), vous devriez choisir un type de réponse par défaut en tant que la plupart du temps les gens ne 'même pas vous dire ce qu'ils veulent. Encore une fois, je dirais aller avec JSON. Donc, pas de tête Accept ou l'extension (c.-à-/ API / utilisateurs) ne devrait pas manquer, il devrait simplement fail-over à la valeur par défaut de réponse de type.

Mais qu'en est-il des erreurs et autres messages d'état importants associés aux demandes? Facile, utiliser des codes d'état HTTP! Ce qui est loin et au-dessus un de mes choses préférées sur la création RESTful API. En utilisant les codes d'état HTTP, vous n'avez pas besoin de venir avec une erreur / système de succès pour votre API, c'est déjà fait pour vous. Par exemple, si un POSTES consommateurs à / api / utilisateurs et que vous voulez lui faire rapport d'une création réussie, il suffit d'envoyer un code d'état 201 (201 = Création). Si elle a échoué, envoyer un 500 si elle n'a pas de votre côté (500 = Erreur interne du serveur), ou peut-être un 400 si elles vissé vers le haut (400 = demande Bad). Peut-être qu'ils essaient de poste contre un point de terminaison API qui n'accepte pas les messages ... envoyer un 501 (Non implémenté). Peut-être votre serveur MySQL est en baisse, de sorte que votre API est complètement foireuse ... temporairement envoyer un 503 (Service indisponible). Espérons que, vous voyez l'idée. Si vous souhaitez lire un peu sur les codes de statut, de les vérifier sur wikipedia: Liste des codes de statut HTTP .

J'espère que vous voyez tous les avantages que vous obtenez en s'appuyant sur les concepts de repos pour vos API. Il est vraiment super-cool, et c'est une honte its pas plus largement parlé dans la communauté PHP (au moins autant que je peux dire). Je pense que cela est probablement dû à l'absence d'une bonne documentation sur la façon de traiter les demandes qui ne sont pas GET ou POST, PUT et DELETE savoir. Certes, il est un peu maladroit face avec ces derniers, mais ce n'est certainement pas dur. Je suis également sûr que certains des cadres populaires là-bas sans doute avoir une sorte de mise en œuvre de repos, mais je ne suis pas un fan cadre immense (pour beaucoup de raisons que je ne parlerai pas), et il est également bon de savoir ces choses, même si quelqu'un a déjà créé la solution pour vous.

Si vous n'êtes toujours pas convaincu qu'il s'agit d'un paradigme API utile, jetez un oeil à ce que REST a fait pour Ruby on Rails. Un de ses revendications majeures de gloire est de savoir comment il est facile de créer des API (par une sorte de vaudou RoR, je suis sûr), et à juste titre. J'admets que je connais très peu de choses sur RoR, mais les fanboys autour du bureau ont prêché ce point à moi plusieurs fois. Mais, je m'égare ... nous allons écrire du code!

Premiers pas avec REST et PHP

Un avertissement dernières: le code que nous sommes sur le point de passer en revue n'est en aucune façon destiné à être utilisé comme un exemple d'une solution robuste. Mon objectif principal ici est de montrer la façon de traiter avec les composants individuels de REST en PHP, et de laisser la création de la solution finale à vous.

Donc, nous allons creuser dans! Je pense que la meilleure façon de faire quelque chose de pratique est de créer une classe qui fournira toutes les fonctions d'utilité dont nous avons besoin de créer une API REST. Nous allons également créer une petite classe pour stocker nos données. Vous pouvez également profiter de cette puis, l'étendre, et de l'appliquer à vos propres besoins. Donc, nous allons stub quelques trucs sur:

 RestUtils classe {public static function processRequest () {} public static function sendResponse ($ status = 200, $ corps ='', 'text / html' $ content_type =) {} public static function getStatusCodeMessage ($ status) {/ / ces pourraient être stockées dans un fichier. ini et chargé / / via parse_ini_file () ...  Cependant, cela suffira / / pour un exemple $ codes = Array (100 => 'Continuer', 101 => 'protocoles de commutation', 200 => 'OK', 201 => 'Création', 202 => 'Accepté' , 203 => 'non-autoritaire de l'information', 204 => 'Pas de contenu ", 205 =>' Contenu Reset ', 206 =>' Contenu partiel ', 300 =>' Choix multiples», 301 => 'Moved Permanently " , 302 => 'trouvé', 303 => 'Voir d'autres', 304 => 'Pas de modification', 305 = "Use Proxy">, 306 => '(inutilisé)', 307 => 'Redirection temporaire ", 400 => 'Bad Request ", 401 =>' non autorisée ', 402 =>' Paiement requis ', 403 =>' interdite ', 404 =>' pas trouvé ', 405 =>' Method Not Allowed ', 406 =>' Non acceptable », 407 => 'Proxy Authentication Required", 408 =>' Demande Timeout ', 409 => «Conflit», 410 =>' Gone ', 411 =>' Longueur requise ', 412 =>' Echec de la précondition » , 413 => 'Request Entity Too Large ", 414 =>' Request-URI Too Long", 415 => 'Type non pris en charge des médias', 416 => 'demandé Range non satisfaisable', 417 => 'Expectation Failed', 500 => 'Erreur interne du serveur ", 501 =>' n'est pas implémentée", 502 => 'Bad Gateway', 503 => 'Service Unavailable', 504 => 'Gateway Timeout', 505 => 'HTTP Version Not Supported ") ; retour (isset ($ codes [$ status]))?  $ Codes [$ status]:'';}} class RestRequest {private $ request_vars; privée $ data; private $ HTTP_ACCEPT; private $ méthode; public function __ construct () {$ this-> request_vars = array (); $ this- > data =''; $ this-> HTTP_ACCEPT = (strpos ($ _SERVER ['HTTP_ACCEPT'], 'json'))?  'Json': 'xml'; $ this-> method = "get";} public function setData ($ data) {$ this-> data = $ data;} setMethod fonction publique ($ method) {$ this-> method = $ method;} setRequestVars fonction publique (request_vars $) {$ this-> request_vars = $ request_vars;} getData fonction publique () {return $ this-> data;} getMethod fonction publique () {return $ this-> method; } public function getHttpAccept () {return $ this-> HTTP_ACCEPT;} getRequestVars fonction publique () {return $ this-> request_vars;}}

OK, donc ce que nous avons est une classe simple pour stocker des informations sur notre demande (RestRequest), et une classe avec quelques fonctions statiques que nous pouvons utiliser pour traiter les demandes et les réponses. Comme vous pouvez le constater, nous n'avons que deux fonctions à écrire ... ce qui est la beauté de toute cette affaire! A droite, passons à autre chose ...

Traitement de la demande

Traitement de la demande est assez straight-forward, mais c'est là que nous pouvons exécuter en quelques captures (à savoir avec PUT et DELETE ... la plupart du temps PUT). Nous allons passer en revue dans un instant, mais nous allons examiner la classe RestRequest un peu. Si vous regardez le constructeur, vous verrez que nous sommes déjà l'interprétation de la tête HTTP_ACCEPT, et défaillant au format JSON si aucun n'est fourni. Avec cela à la manière, nous devons seulement traiter les données entrantes.

Il existe quelques façons que nous pourrions aller faire cela, mais nous allons simplement supposer que nous serons toujours obtenir une paire clé / valeur dans notre demande: 'data' => données réelles. Supposons aussi que les données réelles sera JSON. Comme indiqué dans mon explication précédente de REST, vous pouvez regarder le type de contenu de la demande et de traiter soit avec JSON ou XML, mais il faut garder les choses simples pour l'instant. Donc, notre fonction de demande de processus aboutira à la recherche quelque chose comme ceci:

 publique processRequest fonction statique () {/ / obtenir notre verbe $ REQUEST_METHOD = strtolower ($ _SERVER ['REQUEST_METHOD']); $ return_obj = new RestRequest (); / / Nous allons stocker nos données ici $ data = array (); switch ($ REQUEST_METHOD) {/ / obtient sont faciles ...  cas 'get': $ data = $ _GET; break; / / sont donc les messages cas 'post': $ data = $ _POST; break; / / voici le plus délicat ...  «put» cas: / / en gros, on peut lire une chaîne de l'emplacement de PHP entrée spéciale, / / et ensuite l'analyser dans un tableau à travers parse_str ...  par la documentation PHP: / / Analyse str comme s'il s'agissait de la chaîne de requête transmis via une URL et ensembles / / Les variables dans le champ d'application actuel.  parse_str (file_get_contents ('php :/ / input'), put_vars $); $ data = $ put_vars; break;} / / magasin de la méthode $ return_obj-> setMethod ($ REQUEST_METHOD); / / définir les données brutes, afin que nous pouvez y accéder en cas de besoin (il peut y avoir des morceaux / / autres à vos demandes) $ return_obj-> setRequestVars ($ data); if (isset ($ data ['data'])) {/ / traduire le JSON à un objet pour utiliser à sa guise $ return_obj-> setData (json_decode ($ data ['data']));} return $ return_obj;}

Comme je l'ai dit, assez straight-forward. Cependant, quelques petites choses à noter ... Tout d'abord, vous n'avez généralement pas accepter des données relatives aux demandes supprimer, de sorte que nous n'avons pas une affaire pour eux dans le commutateur. Deuxièmement, vous remarquerez que nous stockons à la fois les variables de requêtes, et les données JSON analysés. Ceci est utile car vous pouvez avoir d'autres choses comme une partie de votre demande (par exemple une clé API ou quelque chose) qui n'est pas vraiment les données elles-mêmes (comme le nom d'un nouvel utilisateur, email, etc.)

Alors, comment pourrions-nous l'utiliser? Revenons à l'exemple de l'utilisateur. En supposant que vous avez acheminé votre demande au contrôleur correct pour les utilisateurs, nous pourrions avoir un peu de code comme ceci:

 $ Data = RestUtils :: ProcessRequest ();

 Interrupteur ($ données> getMethod)
 {
	 cas 'get':
		 / / Récupérer la liste des utilisateurs
		 break;
	 cas «post»:
		 $ User = new User ();
		 $ User-> setFirstName ($ data-> getData () - prenom>); / / juste pour exemple, cela devrait être fait plus propre
		 / / Et ainsi de suite ...
		 $ User-> save ();
		 break;
	 / / Etc, etc, etc ..
 }

S'il vous plaît ne le faites pas dans une application réelle, c'est juste un exemple rapide et sale. Vous voudriez emballer cela dans une structure de contrôle gentil avec tout résumé correctement, mais cela devrait vous aider à avoir une idée de la façon d'utiliser ce genre de choses. Mais je m'éloigne du sujet, passons à l'envoi d'une réponse.

Envoi de la réponse

Maintenant que nous pouvons interpréter la demande, nous allons passer à l'envoi de la réponse. Nous savons déjà que tout ce que nous devons vraiment faire, c'est envoyer le bon code de statut, et peut-être un corps (s'il s'agissait d'une requête GET, par exemple), mais il ya une prise importante de réponses qui n'ont pas de corps. Dites quelqu'un a fait une demande contre notre API utilisateur échantillon pour un utilisateur qui n'existe pas (c.-à-api/user/123). Le code d'état approprié à envoyer est un 404 dans ce cas, mais simplement d'envoyer le code de statut dans les en-têtes ne suffit pas. Si vous avez vu cette page dans votre navigateur Web, vous obtenez un écran blanc. C'est parce que Apache (ou quel que soit votre serveur Web s'exécute sur) n'est pas d'envoyer le code d'état, il n'y a donc pas de page d'état. Nous aurons besoin de prendre cela en compte lorsque nous construisons notre fonction. En gardant tout cela à l'esprit, voici ce que le code devrait ressembler à:

	 publique sendResponse fonction statique ($ status = 200, $ corps ='', 'text / html' $ content_type =) {$ status_header = 'HTTP/1.1'.  $ Statut.  '.  RestUtils :: getStatusCodeMessage ($ status); / / définir le statut de tête ($ status_header); / / set l'en-tête type de contenu ("Content-type: '. $ Content_type); / / pages avec le corps sont faciles if ($ corps ! ='') {/ / envoyer le corps echo $ corps; exit;} / / nous avons besoin pour créer le corps si aucun n'est passé else {/ / créer des messages du corps $ message =''; / / ceci est purement facultative , mais rend les pages un peu plus agréable à lire / / pour vos utilisateurs.  Puisque vous ne sera probablement pas envoyer un grand nombre de codes d'état différents, / / cela aussi ne devrait pas être trop lourde à maintenir interrupteur ($ status) {case 401: $ message = '. Vous devez être autorisé à afficher cette page "; break; cas 404: $ message = "L'URL demandée '.  $ _SERVER ['REQUEST_URI'].  »N'a pas été trouvé. '; Break; cas 500: $ message =" Le serveur a rencontré une erreur lors du traitement de votre demande.'; Break; cas 501: $ message = '. La méthode demandée n'est pas implémentée "; break;} / / serveurs n'ont pas toujours une signature sous tension (il s'agit d'une directive apache "ServerSignature Sur") $ signature = ($ _SERVER ['SERVER_SIGNATURE'] =='')?  $ _SERVER ['SERVER_SOFTWARE'].  'Serveur au «.  $ _SERVER ['SERVER_NAME'].  «Port».  $ _SERVER ['SERVER_PORT']: $ _SERVER ['SERVER_SIGNATURE']; / / ce qui devrait être templatized dans une solution dans le monde réel $ corps = "<DOCTYPE HTML PUBLIC" - / / W3C / / DTD HTML 4.01 / / EN! "" http://www.w3.org/TR/html4/strict.dtd "> <html> <head> <meta http-equiv =" Content-Type "content =" text / html; charset = iso-8859 -1 "> <title> '.  $ Statut.  '.  RestUtils :: getStatusCodeMessage ($ status).  '</ Title> </ head> <h1> <body> ».  RestUtils :: getStatusCodeMessage ($ status).  »</ H1> <p».  $ Message.  »</ P> <hr /> <adresse>».  $ Signature.  »</ Adresse> </ body> </ html> '; echo $ body exit;}}

C'est Elle! Nous techniquement tout ce qu'il faut maintenant traiter les demandes et envoyer des réponses. Parlons un peu plus sur pourquoi nous avons besoin d'avoir une réponse organisme de normalisation ou par une autre. Pour les requêtes GET, c'est assez évident, nous avons besoin d'envoyer XML / JSON contenu au lieu d'une page d'état (condition que la demande était valide). Cependant, il ya aussi des postes à traiter. A l'intérieur de vos applications, lorsque vous créez une nouvelle entité, vous avez probablement chercher ID de la nouvelle entité via quelque chose comme mysql_insert_id (). Eh bien, si un utilisateur des messages à votre API, ils voudrez probablement que nouvel ID ainsi. Ce que je vais souvent faire dans ce cas est tout simplement envoyer un nouvel ID comme le corps (avec un code 201 du statut), mais vous pouvez également envelopper que XML ou JSON si vous le souhaitez.

Donc, nous allons étendre notre exemple d'implémentation un peu:

 Interrupteur ($ données> getMethod)
 {
	 / / S'agit d'une demande pour tous les utilisateurs, pas un en particulier
	 cas 'get':
		 $ User_list getUserList = (); / / on suppose que cette fonction retourne un tableau

		 if ($ data-> getHttpAccept == 'json')
		 {
			 RestUtils :: sendResponse (200, json_encode ($ user_list), 'application / json');
		 }
		 else if ($ data-> getHttpAccept == 'xml')
		 {
			 / / En utilisant la trousse de XML_Serializer Poire
			 $ Options = array
			 (
				 «Tiret '=>',
				 «AddDecl '=> false,
				 «RootName '=> $ fc-> getAction (),
				 XML_SERIALIZER_OPTION_RETURN_RESULT => true
			 );
			 $ Sérialiseur = XML_Serializer nouvelle ($ options);

			 RestUtils :: sendResponse (200, $ sérialiseur-> serialize ($ user_list), 'application / xml');
		 }

		 break;
	 / / Créer un nouvel utilisateur
	 cas «post»:
		 $ User = new User ();
		 $ User-> setFirstName ($ data-> getData () - prenom>); / / juste pour exemple, cela devrait être fait plus propre
		 / / Et ainsi de suite ...
		 $ User-> save ();

		 / / Suffit d'envoyer un nouvel ID comme le corps
		 RestUtils :: sendResponse (201, $ user-> getId ());
		 break;
 }

Encore une fois, c'est juste un exemple, mais il ne montrer (je pense, du moins) combien peu d'efforts qu'il faut pour mettre en œuvre des slideshows RESTful.

Conclusion

Donc, c'est tout. Je suis assez confiant que j'ai battu le point que ce devrait être assez facile dans le sol, donc je voudrais terminer avec la façon dont vous pouvez prendre ce genre de choses encore et peut-être mettre en œuvre correctement.

Dans une application réelle du monde MVC, ce que vous auriez probablement eu envie de faire, c'est mettre en place un contrôleur pour votre API que les contrôleurs de charges API individuelles. Par exemple, en utilisant les choses ci-dessus, nous aurions peut-être créer un UserRestController qui avait quatre méthodes: get (), put (), post (), et delete (). Le contrôleur API se pencherait sur la demande et de déterminer la méthode à invoquer sur ce contrôleur. Cette méthode serait alors utiliser les utilitaires pour traiter la demande, faire ce qu'il doit faire des données-sage, puis utilisez la utils pour envoyer une réponse.

Vous pouvez également prendre un peu plus loin que cela, et le résumé de votre contrôleur de l'API et des modèles de données un peu plus. Plutôt que de créer explicitement un contrôleur pour chaque modèle de données dans votre application, vous pouvez ajouter un peu de logique dans votre contrôleur API d'examiner d'abord d'un contrôleur explicitement défini, et si aucun n'est trouvé, essayez de chercher un modèle existant. Par exemple, l'url "api/user/1", d'abord déclencher une recherche pour un contrôleur "utilisateur" de repos. Si aucun n'est trouvé, il pourrait alors chercher un modèle appelé "utilisateur" dans votre application. Si l'on se trouve, vous pourriez écrire un peu de vaudou automatisé pour traiter automatiquement toutes les demandes à l'encontre des modèles.

Allant plus loin, vous pourriez alors faire un générique "liste-tout" méthode qui fonctionne de manière similaire à l'exemple du paragraphe précédent. Supposons que votre url est "API / users". Le contrôleur API pourrait d'abord vérifier pour un contrôleur "utilisateurs" de repos, et si aucune n'a été trouvée, reconnaissons que les utilisateurs est pluaralized, il depluralize, et ensuite chercher un «utilisateur» modèle. Si l'on a trouvé, de charger une liste de la liste des utilisateurs et d'envoyer ce hors tension.

Enfin, vous pouvez ajouter l'authentification Digest à votre API assez facilement ainsi. Dites que vous ne voulais utilisateurs correctement authentifiés d'accéder à votre API, ainsi, vous pourriez jeter un peu de code comme ceci dans votre processus de demande de fonctionnalité (emprunté à une application existante de la mine, il n'y a donc des constantes et des variables qui ne sont pas référencés définis dans cet extrait ):

			 / / Déterminer si nous avons besoin de contester l'utilisateur
			 if (empty ($ _SERVER ['PHP_AUTH_DIGEST']))
			 {
				 header ('HTTP/1.1 401 Unauthorized ");
				 header ('WWW-Authenticate: Digest realm = "'.. AUTH_REALM '" ".. uniqid ()'", qop = "auth", nonce = ", opaque =" '.. md5 (AUTH_REALM)' "') ;

				 / / Afficher le message d'erreur si ils ont frappé annuler
				 mourir (RestControllerLib :: erreur (401, true));
			 }

			 / / Maintenant, analayze l'PHP_AUTH_DIGEST var
			 if (($ data = http_digest_parse ($ _SERVER ['PHP_AUTH_DIGEST'])) | |! $ auth_username = $ data ['username'])
			 {
				 / / Afficher l'erreur due à une mauvaise auth
				 mourir (RestUtils :: sendResponse (401));
			 }

			 / / Jusqu'ici, tout est bon, nous allons maintenant vérifier la réponse un peu plus ...
			 $ A1 = md5 ($ data ['username'] ':' AUTH_REALM ':'.... $ Auth_pass);
			 $ A2 = md5 ($ _SERVER ['REQUEST_METHOD'] ':'.. $ Data ['uri']);
			 $ Valid_response = md5 ($ A1. ':' $ Data ['nonce']. '.:' $ Data ['nc']. '.:' $ Data ['cnonce']. '.:' $ Data. ['qop'] ':' $ A2);..

			 / / Dernier chèque ..
			 if ($ data ['réponse']! = $ valid_response)
			 {
				 mourir (RestUtils :: sendResponse (401));
			 }

Trucs assez cool, hein? Avec un peu de code et une certaine logique intelligente, vous pouvez ajouter une API REST totalement fonctionnelle pour vos applications très rapidement. Je ne dis pas ça pour cheerlead le concept soit, j'ai mis en place ce genre de choses dans un de mes cadres personnelles dans environ une demi-journée, et a ensuite passé une demi-journée en ajoutant toutes sortes de magie cool de le. Si vous (le lecteur) sont intéressés à voir ma mise en œuvre finale, envoyez-moi une note dans les commentaires et je serais heureux de partager avec vous! Aussi, si vous avez des idées cool que vous aimeriez partager, assurez-vous de laisser tomber ceux qui dans les commentaires aussi ... si je l'aime assez, je vous laisse même pas l'auteur invité de votre propre article sur le sujet!

Jusqu'à la prochaine fois ...

MISE À JOUR: Le très demandée suivi de cet article a été posté: Faire des demandes RESTful en PHP

Partager cet article: