Crear una API REST con PHP

Publicado el 28 de enero 2012 greenhawk

Uno de los últimos (tipo de) las locuras que barren la red es API, más concretamente, los RESTO aprovechar eso. Es realmente no es de extrañar tampoco, como APIs REST consumo es tan increíblemente fácil ... en cualquier idioma. También es increíblemente fácil de crearlos a medida que utilizamos básicamente nada más que una especificación HTTP que ha existido durante siglos. Una de las pocas cosas que me dan crédito para Rails es su bien pensado RESTO apoyo, tanto para el suministro y consumo de estas API (como se ha explicado por todos los fanboys de Rails con la que trabajo).

En serio, si usted nunca ha usado REST, pero alguna vez has tenido que trabajar con (o, peor aún, crear) un API SOAP, o simplemente abrió un WSDL y tenía su cabeza explote, chico tengo buenas noticias para usted!

Así que, ¿qué diablos es REST? ¿Por qué te importa?

Antes de entrar en escribir algo de código, que quiere asegurarse de todo el mundo tiene una buena comprensión de lo que REST es y cómo es genial para las API. En primer lugar, técnicamente hablando, REST no es específico de las API solo, es más de un concepto genérico. Sin embargo, obviamente, por el bien de este artículo vamos a hablar de ello en el contexto de una API. Por lo tanto, echemos un vistazo a las necesidades básicas de una API REST y cómo se dirige a ellos.

Las solicitudes
Todas las API necesitan para aceptar solicitudes. Por lo general, con una API REST, que tendrá un esquema de dirección bien definida. Digamos que usted desea ofrecer una API para que los usuarios de su sitio (lo sé, yo siempre uso el "usuarios" concepto de mis ejemplos). Bueno, la estructura de su URL, probablemente sería algo así como, "api o usuarios" y "api / usuarios / [id]", dependiendo del tipo de operación que se solicita en contra de su API. También es necesario considerar cómo desea recibir los datos. En estos días una gran cantidad de personas están usando JSON o XML, y yo personalmente prefiero JSON, ya que funciona bien con JavaScript y PHP tiene una funcionalidad sencilla para la codificación y decodificación. Si usted quisiera que su API a ser muy robusto, que podría aceptar, tanto por olfatear el tipo de contenido de la solicitud (es decir, application / json o application / xml), pero es perfectamente aceptable para restringir las cosas a un tipo de contenido. Heck, incluso se podría utilizar simples pares clave / valor si se desea.

La otra pieza de una solicitud es lo que en realidad es la intención de hacer, como cargar, guardar, etc Normalmente, usted tendría que llegar a algún tipo de arquitectura que define la acción que el solicitante (los consumidores) los deseos, pero simplifica RESTO que. Mediante el uso de métodos de solicitud HTTP, o verbos, que no necesitamos para definir cualquier cosa. Sólo puede utilizar el GET, POST, PUT, y DELETE métodos, y que cubre todas las solicitudes que íbamos a necesitar. Usted puede igualar los verbos a su estándar de porquería al estilo de cosas: GET = carga / recuperación, POST = crear, PUT = update, delete = bien, eliminar. Es importante señalar que estos verbos no se traducen directamente a CRUD, pero es una buena manera de pensar acerca de ellos. Así que, volviendo a los ejemplos de URL anterior, echemos un vistazo a lo que algunos posibles solicitudes podría significar:

Solicitud GET / api / usuarios - Lista de todos los usuarios
Solicitud GET / api/users/1 - info para el usuario con ID de 1
Solicitud POST a / API / usuarios - Crear un nuevo usuario
PUT solicitud / api/users/1 - Instrucciones de actualización con la identificación de un
BORRAR solicitud / api/users/1 - Eliminar el usuario con el ID de 1

A medida que esperamos ver, REST ya ha tomado el cuidado de muchos de los grandes dolores de cabeza de la creación de su propia API a través de unos simples y bien conocidas las normas y protocolos, pero no hay otra pieza de una buena API ...

Respuestas
Por lo tanto, REST controla las solicitudes con mucha facilidad, pero también hace que las respuestas que generan fácil. Al igual que en las solicitudes, hay dos componentes principales de una respuesta REST: el cuerpo de la respuesta, y un código de estado. El cuerpo de la respuesta es bastante fácil de tratar. Al igual que las solicitudes, la mayoría de las respuestas en reposo son por lo general bien JSON o XML (tal vez sólo texto sin formato en el caso de los puestos, pero vamos a cubrir eso más adelante). Y, al igual que las solicitudes, el consumidor puede especificar el tipo de respuesta que les gustaría a través de otra parte de la especificación HTTP request, "Aceptar". Si un consumidor desea recibir una respuesta XML, que acababa de enviar un encabezado Accept, como parte de su petición diciendo lo mismo ("Accept: text / xml"). Es cierto que este método no es tan ampliamente adoptado (THO debe ser), por lo que tiene también pueden utilizar el concepto de una extensión en la URL. Por ejemplo, / api / users.xml significa que el consumidor quiere XML como respuesta, del mismo modo / api / users.json significa JSON (lo mismo para cosas como / api/users/1.json/xml). De cualquier manera que usted elija (lo digo hacer las dos cosas), usted debe seleccionar un tipo de respuesta por defecto como una gran parte del tiempo la gente 'wont siquiera te dicen lo que quieren. Una vez más, yo diría que ir con JSON. Por lo tanto, no hay encabezado Accept o extensión (es decir, / API / usuarios) no debe fallar, simplemente debe de conmutación por error a los valores de la respuesta tipo.

Pero, ¿qué acerca de los errores y otros mensajes de estado importantes asociadas a las solicitudes? Fácil, utilice los códigos de estado HTTP! Esto está muy lejos y por encima de una de mis cosas favoritas sobre la creación de las API de REST. Mediante el uso de códigos de estado HTTP, que no es necesario para llegar a un error / éxito de su plan de API, ya está hecho para ti. Por ejemplo, si un consumidor a PUESTOS / api / usuarios y desea informar una creación exitosa, sólo tiene que enviar un código de estado 201 (201 = Creado). Si no, envíe un 500 si no en su final (500 = Error interno del servidor), o tal vez un 400 si se equivocaron (400 request = malo). Quizás estén intentando escribir un mensaje en contra de un punto final de la API que no acepta mensajes ... enviar un 501 (no implementado). Tal vez su servidor MySQL se ha reducido, por lo que su API se encuentra temporalmente borked ... enviar un 503 (servicio no disponible). Con suerte, usted consigue la idea. Si quieres leer un poco sobre los códigos de estado, comprobar a cabo en la wikipedia: Lista de códigos de estado HTTP .

Espero que vea todas las ventajas que obtiene mediante el aprovechamiento de los conceptos de descanso para su API. Realmente es super-cool, y es una pena que no its más ampliamente hablado en la comunidad de PHP (por lo menos hasta donde yo sé). Creo que esto es probablemente debido a la falta de una buena documentación sobre cómo hacer frente a las peticiones que no son GET y POST, es decir, PUT y DELETE. Es cierto que es un poco ridículo tratar con ellos, pero ciertamente no es difícil. También estoy seguro de que algunos de los marcos populares hacia fuera allí, probablemente tienen algún tipo de aplicación REST, pero yo no soy un fan enorme marco (para un montón de razones que no voy a entrar en), y también es bueno saber estas cosas, incluso si alguien ya ha creado la solución para usted.

Si todavía no estás convencido de que este es un paradigma de la API útil echar un vistazo a lo que REST ha hecho por Ruby on Rails. Uno de sus principales reclamos a la fama es lo fácil que es crear API (a través de algún tipo de vudú, RoR, estoy seguro), y con razón. Por supuesto que sé muy poco acerca de RoR, pero los fanboys alrededor de la oficina han predicado este punto a mí muchas veces. Pero estoy divagando ... vamos a escribir algo de código!

Primeros pasos con REST y PHP

Uno renuncia últimos: el código que está a punto de pasar no es en ningún modo utilizado para ser utilizado como un ejemplo de una solución sólida. Mi principal objetivo aquí es mostrar cómo hacer frente a los componentes individuales de descanso en PHP, y dejar la creación de la solución final depende de usted.

Por lo tanto, vamos a profundizar en el! Creo que la mejor manera de hacer algo práctico es crear una clase que proporcione todas las funciones de utilidad que necesitamos para crear una API REST. También vamos a crear una pequeña clase para almacenar nuestros datos. También podría luego tomar esto, que se aplicará, y aplicarlo a sus propias necesidades. Por lo tanto, vamos a auxiliar a algunas cosas:

 RestUtils clase {proceseSolicitud public static function () {} sendResponse public static function ($ status = 200, $ cuerpo ='', 'text / html' $ content_type =) {} public static función getStatusCodeMessage ($ estado) {/ / estos pueden ser almacenados en un archivo. ini y carga / / a través de parse_ini_file () ...  Sin embargo, esto será suficiente / / $ para ver un ejemplo de códigos = Array (100 => 'Continuar', 101 => 'Switching Protocolos', 200 => 'OK', 201 => 'Creado', 202 => 'aceptado' , 203 => 'no autorizada de la información ", 204 =>' No hay contenido ', 205 =>' Restablecer contenido ', 206 =>' Contenido parcial ', 300 =>' Multiple Choices ', 301 =>' Moved Permanently ' , 302 => 'Found', 303 => 'Ver Otros', 304 => 'No modificado ", 305 =>' Usar proxy ', 306 =>' (sin usar) ', 307 =>' Redirección temporal", 400 => 'Bad Request', 401 => 'no autorizada', 402 => 'Pago Obligatorio', 403 => 'Prohibido', 404 => 'No se ha encontrado', 405 => 'Método no permitido', 406 => ' No Aceptable ', 407 =>' proxy requiere autenticación ', 408 =>' Solicitud de tiempo de espera ', 409 =>' Conflicto ', 410 =>' Gone ', 411 =>' Requiere longitud ', 412 =>' No se pudo condición previa ' , 413 => 'Entidad de solicitud demasiado grande ", 414 =>' Request-URI Too Long ', 415 =>' Unsupported Media Type ', 416 =>' No se puede satisfacer Pidió Rango ', 417 =>' Expectation Failed ', 500 => 'Error interno del servidor', 501 => 'no implementado ", 502 =>' Bad Gateway ', 503 =>' Servicio no disponible", 504 => 'Tiempo de espera de puerta de enlace', 505 => 'Versión de HTTP no compatible ") ; retorno (isset ($ códigos [$ estado]))?  $ Códigos [$ status]:'';}} {RestRequest clase privada $ request_vars; private $ datos, $ HTTP_ACCEPT privada, privada $ method, construir __ función pública () {$ this-> request_vars = array (); $ this- > data =''; $ this-> HTTP_ACCEPT = (strpos ($ _SERVER ['HTTP_ACCEPT'], 'json'))?  'Json': 'XML'; $ this-> method = "get ';} public function setData ($ datos) {$ this-> data = $ datos;} setMethod función pública ($ method) {$ this-> método de = $ método;} setRequestVars public function ($ request_vars) {$ this-> request_vars = $ request_vars; getData} public function () {return $ this-> data;} método getMethod función pública () {return $ this-> método; } public function getHttpAccept () {return $ this-> HTTP_ACCEPT;} getRequestVars la función pública () {return $ this-> request_vars;}}

OK, así que lo que tenemos es una clase simple para almacenar alguna información acerca de nuestra solicitud (RestRequest), y una clase con algunas funciones estáticas que podemos utilizar para hacer frente a las peticiones y respuestas. Como puede ver, en realidad sólo tienen dos funciones para escribir ... lo que es la belleza de todo esto! Bien, vamos a pasar ...

Tramitación de la solicitud

El procesamiento de la solicitud es muy sencilla, pero es aquí donde podemos toparnos con una pocas capturas (es decir, con PUT y DELETE ... PUT sobre todo). Vamos a repasar los de un momento, pero vamos a examinar la clase RestRequest un poco. Si usted se verá en el constructor, verás que ya estamos interpretando la cabecera HTTP_ACCEPT, y el incumplimiento a JSON si no se especifica. Con eso fuera del camino, sólo tenemos que hacer frente a los datos entrantes.

Hay algunas maneras que podríamos ir haciendo esto, pero vamos a suponer que siempre vamos a conseguir un par de clave / valor en nuestra petición: 'datos' => datos reales. Supongamos también que los datos reales será JSON. Como indiqué en mi anterior explicación de descanso, usted podría ver el tipo de contenido de la solicitud y acuerdo con cualquiera de JSON o XML, pero vamos a mantenerlo simple por ahora. Por lo tanto, nuestra función de petición de proceso terminan buscando algo como esto:

 proceseSolicitud public static function ()
	 {
		 / / Obtener nuestro verbo
		 $ REQUEST_METHOD = strtolower ($ _SERVER ['REQUEST_METHOD']);
		 $ Return_obj = new RestRequest ();
		 / / Vamos a almacenar nuestros datos aquí
		 $ Datos = array ();

		 switch ($ REQUEST_METHOD)
		 {
			 / / Obtiene son fáciles ...
			 caso de 'get':
				 $ Datos = $ _GET;
				 break;
			 / / Por lo que son mensajes
			 caso de 'post':
				 $ Datos = $ _POST;
				 break;
			 / / Aquí está el truco ...
			 caso de 'poner':
				 / / En el fondo, se lee una cadena de un lugar especial de entrada de PHP,
				 / / Y luego analizarlo a cabo en una matriz a través de parse_str ...  según la documentación de PHP:
				 / / Analiza str como si fuera la cadena de consulta que se pasa a través de una URL y se establece
				 / / Variables en el ámbito actual.
				 parse_str (file_get_contents ("php :/ / input '), $ put_vars);
				 $ Datos = $ put_vars;
				 break;
		 }

		 / / Almacenar el método
		 $ Return_obj-> setMethod ($ REQUEST_METHOD);

		 / / Establecer los datos en bruto, para que podamos acceder a él si es necesario (puede haber
		 Piezas / / otros a sus peticiones)
		 $ Return_obj-> setRequestVars ($ datos);

		 if (isset ($ datos ['datos']))
		 {
			 / / Traducir el JSON a un objeto para su uso como quieras
			 $ Return_obj-> setData (json_decode ($ datos ['datos']));
		 }
		 return $ return_obj;
	 }

Como he dicho, bastante sencilla. Sin embargo, algunas cosas que tener en cuenta ... En primer lugar, por lo general no aceptan los datos de las solicitudes de borrar, por lo que no tenemos un caso para ellos en el interruptor. En segundo lugar, te darás cuenta de que almacenar tanto las variables de demanda, y los datos JSON analizados. Esto es útil ya que puede tener otras cosas como parte de su solicitud (por ejemplo una clave de API o algo así) que no es realmente los datos en sí (como el nombre de un nuevo usuario, correo electrónico, etc.)

Así que, ¿cómo podemos usar esto? Volvamos al ejemplo de usuario. Si ya te has encaminado su petición al controlador adecuado para los usuarios, podríamos tener un código como este:

 $ Datos = RestUtils Título ProcessRequest ();

 switch ($ data-> método getMethod)
 {
	 caso de 'get':
		 / / Recuperar una lista de usuarios
		 break;
	 caso de 'post':
		 $ User = usuario nuevo ();
		 $ Usuario-> setFirstName ($ data-> getData () - first_name>) / / solo, por ejemplo, esto se debe hacer más limpia
		 / / Y así sucesivamente ...
		 $ User-> save ();
		 break;
	 / / Etc, etc, etc ..
 }

Por favor, no hagas esto en una aplicación real, esto es sólo un ejemplo rápido y sucio. Lo que quiere terminar con esto en una estructura de control agradable con todo lo que resumieron correctamente, pero esto le ayudará a tener una idea de cómo utilizar este material. Pero estoy divagando, vamos a pasar a enviar una respuesta.

El envío de la respuesta

Ahora que podemos interpretar la solicitud, vamos a pasar a enviar la respuesta. Ya sabemos que todo lo que necesitamos hacer es enviar el código de estado correcto, y tal vez algún cuerpo (si se tratara de una petición GET, por ejemplo), pero no es una captura importante para las respuestas que no tienen cuerpo. Decir que alguien hizo una petición en contra de nuestra API de usuario de ejemplo para un usuario que no existe (es decir, api/user/123). El código de estado apropiado para enviar es un 404 en este caso, sino simplemente de enviar el código de estado en las cabeceras no es suficiente. Si usted considera que la página en su navegador web, se llega a una pantalla en blanco. Esto se debe a Apache (o lo que sea su servidor web se ejecuta en) no está enviando el código de estado, así que no hay página de estado. Tendremos que tener esto en cuenta cuando construimos nuestra función. Teniendo todo esto en mente, esto es lo que el código debe ser similar a:

	 sendResponse public static function ($ status = 200, $ cuerpo ='', 'text / html' $ content_type =) {$ status_header = 'HTTP/1.1'.  $ Estado.  ''.  RestUtils Título getStatusCodeMessage ($ estado); / / establecer el encabezado de estado ($ status_header); / / establecer el encabezado de tipo de contenido ('Content-Type:'. $ Content_type); / / páginas con el cuerpo son fáciles if ($ cuerpo ! ='') {/ / enviar el cuerpo echo $ cuerpo; exit;} / / tenemos que crear el cuerpo si no se pasa else {/ / crear algunos de los mensajes del cuerpo $ message =''; / / esto es totalmente opcional , pero hace que las páginas de un poco más agradable de leer / / para los usuarios.  Puesto que no es probable que enviar una gran cantidad de códigos de estado diferentes, / / esto tampoco debe ser demasiado pesada para mantener switch ($ estado) {case 401: $ message = '. Debe estar autorizado para ver esta página'; descanso, y el caso 404: $ message = 'La URL solicitada.  $ _SERVER ['REQUEST_URI'].  "No se ha encontrado."; Break; caso 500: $ message = "El servidor encontró un error al procesar su solicitud. '; Descanso, y el caso 501: $ message ='. El método solicitado no está implementada"; break;} / / los servidores no siempre tienen una firma activa (esto es una directiva de apache "ServerSignature On") la firma $ = ($ _SERVER ['SERVER_SIGNATURE'] =='')?  $ _SERVER ['SERVER_SOFTWARE'].  "Servidor de menos '.  $ _SERVER ['SERVER_NAME'].  'Puerto'.  $ _SERVER ['SERVER_PORT']: $ _SERVER ['SERVER_SIGNATURE']; / / esto debe ser templatized en una solución en el mundo real $ cuerpo = '<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> '.  $ Estado.  ''.  RestUtils :: getStatusCodeMessage ($ estado).  '</ Title> </ head> <h1> <body>'.  RestUtils :: getStatusCodeMessage ($ estado).  '</ H1> <p'.  $ Mensaje.  </ P> <hr /> <dirección> '.  $ Firma.  '</ Address> </ body> </ html>'; echo $ cuerpo exit;}}

Eso es todo! Nosotros técnicamente tienen todo lo que necesitamos ahora para procesar las solicitudes y enviar las respuestas. Vamos a hablar un poco más acerca de por qué tenemos que tener una respuesta estándar del cuerpo o uno personalizado. Para peticiones GET, esto es bastante obvio, es necesario enviar XML / JSON contenido en lugar de una página de estado (siempre que la solicitud era válida). Sin embargo, también hay POST a tratar. Dentro de sus aplicaciones, al crear una nueva entidad, es probable que buscar ID de la nueva entidad a través de algo así como mysql_insert_id (). Bueno, si un usuario ingrese a su API, que probablemente querrán que el identificador de nuevo también. Lo que por lo general va a hacer en este caso, simplemente se envía el identificador de nuevo el cuerpo (con un código de estado 201), pero también se podría concluir que en XML o JSON, si lo desea.

Por lo tanto, vamos a ampliar nuestra implementación de ejemplo un poco:

 switch ($ data-> método getMethod)
 {
	 / / Esta es una solicitud para todos los usuarios, no uno en particular
	 caso de 'get':
		 $ Lista_usuarios getUserList = () / / asumir esta devuelve una matriz

		 if ($ data-> getHttpAccept == 'json')
		 {
			 RestUtils :: sendResponse (200, json_encode ($ lista_usuarios), "application / json ');
		 }
		 else if ($ data-> getHttpAccept == 'xml')
		 {
			 / / Utilizando el paquete XML_SERIALIZER Pera
			 $ Opciones = array
			 (
				 'Guión' => '",
				 'AddDecl' => false,
				 'RootName' => $ fc-> getAction (),
				 XML_SERIALIZER_OPTION_RETURN_RESULT => true
			 );
			 $ Serializador = XML_Serializer nueva ($ opciones);

			 RestUtils :: sendResponse (200, $ serializador-> serialize ($ lista_usuarios), 'application / xml');
		 }

		 break;
	 / / Crear nuevo usuario
	 caso de 'post':
		 $ User = usuario nuevo ();
		 $ Usuario-> setFirstName ($ data-> getData () - first_name>) / / solo, por ejemplo, esto se debe hacer más limpia
		 / / Y así sucesivamente ...
		 $ User-> save ();

		 / / Acaba de enviar la nueva identificación como el cuerpo
		 RestUtils :: sendResponse (201, $ usuario-> getId ());
		 break;
 }

Una vez más, esto es sólo un ejemplo, pero sí mostrar (creo que, al menos) el poco esfuerzo que se necesita para poner en práctica cosas REST.

Conclusión

Por lo tanto, eso es todo. Estoy bastante seguro de que me he golpeado el punto de que esta debe ser muy fácil en la tierra, así que me gustaría terminar con la forma en que usted puede tomar estas cosas y tal vez más adecuadamente su ejecución.

En una aplicación real MVC, lo que probablemente querría hacer es configurar un controlador para su API que los controladores de las cargas individuales de API. Por ejemplo, usando el material anterior, posiblemente crearía un UserRestController que tenía cuatro métodos: get (), put (), post () y delete (). El controlador de la API se vería en la solicitud y determinará el método para invocar en ese controlador. Este método sería entonces utilizar el utils para procesar la solicitud, hacer lo que tiene que ver los datos-sabio, a continuación, utilizar el utils para enviar una respuesta.

También puede tomar un paso más allá que eso, y abstraer el controlador de la API y modelos de datos un poco más. En lugar de crear explícitamente un controlador para cada modelo de datos en su aplicación, se puede añadir un poco de lógica en el controlador de la API a la primera mirada de un controlador se define explícitamente, y si no lo encuentra, trate de buscar un modelo existente. Por ejemplo, la url "api/user/1", en primer lugar daría lugar a una búsqueda de un controlador de descanso "usuario". Si no se encuentra ninguno, entonces se podría buscar un modelo llamado "usuario" en su aplicación. Si uno se encuentra, usted puede hacer un poco de vudú automatizado para procesar automáticamente todas las solicitudes en contra de esos modelos.

Yendo aún más lejos, usted podría hacer un genérico de "lista de todos" método que funciona de manera similar al ejemplo del párrafo anterior. Digamos que su url era "api o usuarios". El regulador de primera API podría comprobar si hay un controlador de "usuarios" descanso, y si no se encontró ninguno, reconocen que los usuarios se pluaralized, depluralize, y luego buscar un "usuario" del modelo. Si se ha encontrado, cargar una lista de la lista de usuarios y enviar que fuera.

Por último, habría que agregar la autenticación implícita a su API con bastante facilidad también. Digamos que sólo quería los usuarios debidamente identificados para acceder a su API, así, usted podría arrojar algo de código como este en su funcionalidad petición de proceso (tomado de una aplicación existente de la mina, así que hay algunas constantes y variables de referencia que no están definidos en este fragmento ):

			 / / Averiguar si tenemos que cuestionar el usuario
			 if (empty ($ _SERVER ['PHP_AUTH_DIGEST']))
			 {
				 header ('HTTP/1.1 401 Unauthorized');
				 header ('WWW-Authenticate: Digest realm = ".. AUTH_REALM'" ".. uniqid () '", qop = "auth", nonce =', opaca = ".. md5 (AUTH_REALM) '"') ;

				 / / Mostrar el error si golpean cancelar
				 morir (RestControllerLib :: error (401, true));
			 }

			 / / Ahora, el analayze PHP_AUTH_DIGEST var
			 if (($ datos = http_digest_parse ($ _SERVER ['PHP_AUTH_DIGEST'])) | | $ auth_username = $ datos ['username'])
			 {
				 / / Mostrar el error debido a la mala auth
				 morir (RestUtils :: sendResponse (401));
			 }

			 / / Hasta ahora, todo es bueno, ahora vamos a comprobar la respuesta un poco más ...
			 $ A1 = md5 ($ datos ['username'] ':' AUTH_REALM ':'.... $ Auth_pass);
			 $ A2 = md5 ($ _SERVER ['REQUEST_METHOD'] ':'.. $ Datos ['uri']);
			 $ Valid_response = md5 ($ A1. ':' $ Datos ['nonce']. '.:' $ Datos ['nc']. '.:' $ Datos ['cnonce']. '.:' $ Datos. ['qop'] ':' $ A2);..

			 / / En la última verificación ..
			 if ($ datos ['respuesta']! = $ valid_response)
			 {
				 morir (RestUtils :: sendResponse (401));
			 }

Cosas bastante bien, ¿no? Con un poco de código y algo de lógica inteligente, se puede añadir una API REST completamente funcional para sus aplicaciones con gran rapidez. No estoy diciendo que el concepto de cheerlead bien, he implementado este material en uno de mis marcos personales en aproximadamente la mitad de un día, y luego pasó otro medio día añadiendo todo tipo de magia muy cool en él. Si usted (el lector) está interesado en ver a mi final de ejecución, que me deje una nota en los comentarios y yo estaría feliz de compartirlo con ustedes! Además, si tienes alguna idea fresca que le gustaría compartir, asegúrese de eliminar estos en los comentarios, así ... si me gusta lo suficiente, yo incluso le permiten autor invitado a su propio artículo sobre el tema!

Hasta la próxima ...

ACTUALIZACIÓN: El tan pedido el seguimiento de este artículo ha sido publicado: Realizar solicitudes REST en PHP

Comparte este artículo: