07 enero 2017

Crear un Web Service API Rest con PHP y MySQL

 

Los API Rest son en la actualidad la nueva manera de trabajar los sistemas web, los mismos se encargan de servir la información que luego sera consumida por algún cliente, usualmente usando alguna librería JavaScript como jQuery o AngularJS.

Los Web Services no son mas que archivos en formato JSON que sirven los datos de una base de datos de una manera mas dinámica y apreciable, estos proporcionan las acciones que desde tiempo remotos trabajan las paginas web dinámicas, el tipo CRUD (Create-Read-Update-Delete) son ahora manejados de una forma mas sencilla usando un Web Services API Rest y los métodos HTTP.

De seguro si, alguna vez al escuchado el típico método POST o Método GET, de los cuales haremos uso en este post, además de los no tan mencionados pero ya bastante conocidos método PUT y DELETE.


Ahora, que necesitamos saber antes de empezar? Presentamos esta información sumamente importante antes de continuar creando el Web Services.

Métodos HTTP

Método Aplicaron Descripción
GET GET /api/usuario Obtiene todos los elementos de la entidad Usuario
GET /api/usuario/1 Obtiene el elemento con Id 1 de la entidad Usuario
POST POST api/usuario Publica un nuevo elemento de la entidad Usuario
PUT PUT api/usuario/1 Modifica el elemento con Id 1 de la entidad Usuario
DELETE DELETE api/usuario/1 Elimina el elemento con Id 1 de la entidad Usuario

Códigos de Cabecera HTTP

Los códigos de cabecera HTTP definen el status actual de una pagina o documento con respecto a la solicitud realizada, de seguro que hemos visto el tipico error 404, en este tutorial haremos uso de los mostrados con posterioridad, sin embargo, te dejo este articulo de Wikipedia que te ayudara a comprender mejor de que trata.

Código Definición Uso o Aplicaron
200 OK Lo usaremos para cuando la solicitud se realiza correctamente, sin importar si su estatus es verdadero o falso
201 Created Se aplicara cuando para cada entidad se cree un nuevo elemento
204 No Content Se usara para cuando la entidad no tiene elementos
404 Not Found Se usara para cuando se solicita un elemento que no existe en la base de datos
405 Method Not Allowed Se usara por defecto para cuando el método solicitado no coincida con la URL o sea un método distinto a GET, POST, PUT y DELETE

Postman o Insomnia

Interfaz principal de Insomnia
Para efectos de prueba haremos uso de una extensión para Chrome como aplicacion, entre ellas podemos mencionar dos herramientas realmente muy amigables como Postman o Insomnia, yo en lo particular, sugiero el uso de Insomia. Recuerden que necesitamos hacer uso de los mismos ya que el navegador por defecto ejecuta solamente el metodo GET, para firefox, puedes hacer uso de la extensión Firebug.

JSON y XML

Los estándares JSON y XML son con peculiaridad los lenguajes usados para servir datos desde un Web Services. Los lenguajes son equivalente, con la única diferencia de que su sintaxis tienen su particularidad. He aqui algunos ejemplos.
Ejemplo de JSON (JavaScript Object Notation)

{
    "statusCode": 200,
    "statusMessage": "OK",
    "data": [
        {
            "Id": "1",
            "Usuario": "admin",
            "Clave": "21232f297a57a5a74389",
            "Status": "1"
        }
    ]
}

Ejemplo de XML (eXtended Markup Language)

<?xml version="1.0" encoding="UTF-8" ?>
<statusCode>200</statusCode>
<statusMessage>OK</statusMessage>
<data>
    <Id>1</Id>
    <Usuario>admin</Usuario>
    <Clave>21232f297a57a5a74389</Clave>
    <Status>1</Status>
</data>

Como podemos ver, de ambas formas se sirve la información correctamente, aunque para efectos del tutorial, haremos uso de JSON específicamente, ya que en resumen, es mucho mas legible que XML, aunque el uso del uno u otro es irrelevante.

No haré mucho énfasis en explicar el código para crear el Web Services ya que el código mismo esta documentado, esta sera el directorio de la aplicaron.

Crea el directorio tal cual ves en la imagen en tu servidor y agrega los siguientes códigos proporcionados a continuación

Antes de empezar, vamos a nuestro PhpMyAdmin para crear nuestra base de datos, en mi caso, la llame Api, y ejecuta el siguiente código






api.sql

CREATE TABLE IF NOT EXISTS `usuario` (
  `Id` int(11) NOT NULL AUTO_INCREMENT,
  `Usuario` varchar(20) NOT NULL,
  `Clave` varchar(20) NOT NULL,
  `Status` tinyint(20) NOT NULL,
  PRIMARY KEY (`Id`)
) ENGINE=InnoDB  DEFAULT CHARSET=latin1 AUTO_INCREMENT=4 ;

core/config.php

<?php 

 /* 
  * En este archivo se definiran la información de configuracion del API,
  * variables, constantes y funciones requeridas para el resto de los archivos
 */

 // Dirección del servidor de Base de datos
 define("DB_HOST", "localhost");

 // Nombre de usuario de Base de datos
 define("DB_USER", "root");

 // Clave de usuario de Base de datos
 define("DB_PASS", "root");

 // Nombre de la tabla sobre la cual se trabajara
 define("DB_NAME", "api");
?>

core/iModel.php

<?php 
 // Declarar la interfaz 'iModel'
 // Define cada una de las funciones que el model.php debe especificar
 interface iModel
 {
     // GET : Solicitar un elemento
     public function get();
     // POST : Publicar un nuevo elemento
     public function post();
     // PUT: Modificar un elemento
     public function put();
     // DELETE: Eliminar un elemento
     public function delete();
 }
?>

core/db_model.php

<?php 
  // Incluimos el archivo de configuración el cual posee las credenciales de conexión
  include 'config.php';

  // Se crea la clase de conexión y ejecución de consultas
  class db_model {

    // Variable de conexion
    public $conn;

    // La función constructora crea y abre la conexión al momento de instanciar esta clase
    function __construct() {
      $this->conn = new mysqli(DB_HOST, DB_USER, DB_PASS, DB_NAME); // Los parametros de la funcion mysqli() son las constantes previamente declaradas en el archivo config.php
    }

    // Funcion para obtener un array de resultados
    // Solo se usara para las consultas de tipo SELECT
    function get_query($sql) {
      // Lee la cadena SQL recibida y ejecuta la consulta
      $result = $this->conn->query($sql);

      // Hace el rrecorrido por el array de datos y lo guarda en la variable $rows
      while ($rows[] = $result->fetch_assoc());

      // Cierra la consulta
      $result->close();

      // Retorna el resultado obtenido
      return $rows;
    }

    // Funcion para hacer cambios dentro de la base de datos
    // Solo se usara para las consultas de tipo INSERT, UPDATE Y DELETE
    function set_query($sql) {
      // Lee la cadena SQL recibida y ejecuta la consulta
      $result = $this->conn->query($sql);

      // Retorna el resultado
      return $result;

    }

    // La función destructora cierra la conexión previamente abierta en el constructor
    function __destruct() {
      $this->conn->close();
    }
  }
?>

model.php

<?php 
 // Se incluye el archivo de conexion de base de datos
 include 'core/db_model.php';
 // Se incluye la interfaz de Modelo
 include 'core/iModel.php';

 // Se crea la clase que ejecuta llama a las funciones de ejecución para interactuar con la Base de datos
 // Esta clase extiende a la clase db_model en el archivo db_model.php (hereda sus propiedades y metodos)
 // Esta clase implementa la interfaz iModel (Enmascara cada una de las funciones declaradas)
 class generic_class extends db_model implements iModel {
  // Ya que la clase es generica, es importante poseer una variable que permitira identificar con que tabla se trabaja
  public $entity;
  // Almacena la informacion que sera enviada a la Base de datos
  public $data;
  
  // Esta funcion se activara al utilizar el metodo GET
  // Envia por defecto el parametro Id cuyo valor sera 0 hasta que se modifique
  function get($id = 0) {
   /* 
    * Si el valor del parametro Id es igual a 0, se solicitaran todos los elementos
    * ya que no se ha solicitado un elemento especifico 
    */
   if($id == 0) {
    return $this->get_query(sprintf("
     SELECT 
      * 
     FROM 
      %s", 
      $this->entity
      )
     );
   // Si el valor del parametro Id es diferente a 0, se solicitara solo y unicamente el elemento cuyo Id sea igual al parametro recibido
   } else {
    return $this->get_query(sprintf("
     SELECT 
      * 
     FROM 
      %s 
     WHERE 
      Id = %d", 
      $this->entity, 
      $id
      )
     );
   }
  }

  // Esta funcion sera llamada al momento de usar el metodo POST
  function post() {

   return $this->set_query(sprintf("
    INSERT INTO 
     %s
     %s",
     $this->entity,
     $this->data
     
    )
   );

   
  }

  // Esta funcion sera llamada al momento de usar el metodo PUT
  function put() {
   return $this->set_query(sprintf("
    UPDATE 
     %s 
    SET 
     %s 
    WHERE 
     Id = %d", 
     $this->entity,
     $this->data, 
     $this->Id
    )
   );

  }

  // Esta funcion sera llamada al momento de usar el metodo DELETE
  function delete() {
   return $this->set_query(sprintf("
    DELETE FROM 
     %s 
    WHERE 
     Id = %d", 

     $this->entity,
     $this->Id
    )
   );

  }
 }
?>

controller.php

<?php 
 // Permite la conexion desde cualquier origen
 header("Access-Control-Allow-Origin: *");
 // Permite la ejecucion de los metodos
 header("Access-Control-Allow-Methods: GET, POST, PUT, DELETE");  
 // Se incluye el archivo que contiene la clase generica
 include 'model.php';

 // Se toma la URL solicitada y se guarda en un array de datos
 // Por ejemplo si la URL solicitada es http://localhost/api/usuario
 // $_SERVER['REQUEST_URI'] imprime "/api/usuario"
 // La funcion explode() crea un array de la URL de la siguiente forma
 /*
  Array
  (
      [0] => 
      [1] => api
      [2] => usuario
  )
 */
 // Por ejemplo si la URL solicitada es http://localhost/api/usuario/1
 // $_SERVER['REQUEST_URI'] imprime "/api/usuario/1"
 // La funcion explode() crea un array de la URL de la siguiente forma
 /*
  Array
  (
      [0] => 
      [1] => api
      [2] => usuario
      [3] => 1
  )
 */
 // Esto nos ayuda a identificar cuando se esta solicitando la URL general o un elemento especifico
 $array = explode("/", $_SERVER['REQUEST_URI']);

 // Obtener el cuerpo de la solicitud HTTP
 // En nuestro caso, el cuerpo solo sera enviado en peticiones de tipo POST y PUT, en el cual enviaremos el objeto JSON a registrar o modificar
 $bodyRequest = file_get_contents("php://input");

 /* Este ciclo rrecorre el array previamente creado y si hay algun valor en blanco lo elimina del array
    Esto con el fin de controlar cuando la URL se enviar en estilo http://localhost/api/usuario/
    Si bien, se esta haciendo uso del "/" al final, no se esta enviando ningun parametro de Id
    Sin embargo, el array se crea de la siguiente forma
 
  Array
  (
      [0] => 
      [1] => api
      [2] => usuario
      [3] => 
  )

  Ya que la ultima pocision esta vacia, si lo permitieramos asi, nos arrojaria un error ya que no haria la
  Solicitud de manera correcta con un dato que esta vacio, por lo que si la URL es enviada del forma, se asume
  que se esta realizando una solicitud general al estilo http://localhost/api/usuario
 */
 foreach ($array as $key => $value) {
  if(empty($value)) {
   unset($array[$key]);
  }
 }

 /* Analiza la ultima pocision del array creado previamente, si el valor analizado es mayor que 0
    significa que el caracter enviado es un numero, por lo tanto, reconocemos que la solicitud se esta 
    haciendo a un Id especifico de tipo http://localhost/api/usuario/1, pero de no ser mayor que 0, reconocemos que el ultimo elemento del array
    es solo el nombre de la entidad, por lo tanto, reconocemos que se esta haciendo una solicitud general
    de tipo http://localhost/api/usuario
 */
 if(end($array)>0) {
  // De ser el valor numerico, crea dos variables que contienen el Id solicitado y la entidad solicitada
  $id = $array[count($array)];
  $entity = $array[count($array) - 1];
 } else {
  // De ser el valor de tipo string, solo crea la variable de la entidad solicitada
  $entity = $array[count($array)];
 }

 // Variable que guarda la instancia de la clase generica
 $obj = get_obj();

 // Se pasa a la entidad el valor de la entidad con la que actualmente se esta trabajando
 $obj->entity = $entity;

 // Analiza el metodo usado actualmente de los cuatro disponibles: GET, POST, PUT, DELETE
 switch ($_SERVER['REQUEST_METHOD']) {
  case 'GET':
   // Acciones del Metodo GET
   // Si la variable Id existe, solicita al modelo el elemento especifico
   if(isset($id)) {
    $data = $obj->get($id);
   // Si no existe, solicita todos los elementos
   } else {
    $data = $obj->get();
   }
   
   // Elimina el ultimo elemento del array $data, ya que usualmente, suele traer dos elementos, uno con la informacion, y otro NULL el cual no necesitamos
   array_pop($data);

   // Si la cantidad de elementos que trae el array de $data es igual a 0 entra en este condicional
   if(count($data)==0) {
    // Si la variable Id existe pero el array de $data no arroja resultado, significa que elemento no existe
    if(isset($id)) {
     print_json(404, "Not Found", null);
    // Pero si la variable Id existe y no trae $data, ya que no buscamos un elemento especifico, significa que la entidad no tiene elementos que msotrar
    } else {
     print_json(204, "Not Content", null);
    }
   // Si la cantidad de elementos del array de $data es mayor que 0 entra en este condicional
   } else {
    // Imprime la informacion solicitada
    print_json(200, "OK", $data);
   }
   
   break;
  case 'POST':
   // Acciones del Metodo POST
   
   /* Analiza si existe la variable Id, ya que la URL solicita por POST solo puede ser de estilo
      http://localhost/api/usuario no habria por que existir un Id ya que se esta registrando un 
      nuevo elemento y el Id es autogenerado, si el Id no existe, entra en esta condicional */
   if(!isset($id)) {
    // Decodifica el cuerpo de la solicitud y lo guarda en un array de PHP
    $array = json_decode($bodyRequest, true);

    // Renderiza la informacion obtenida que luego sera guardada en la Base de datos
    $obj->data = renderizeData(array_keys($array), array_values($array));

    // Ejecuta la funcion post() que se encuentra en la clase generica
    $data = $obj->post();

    // Si la respuesta es correcta o es igual a true entra en este condicional
    if($data) {
     // Si la Id generada es diferente de 0 se creo el elemento y entra aqui
     if($obj->conn->insert_id != 0) {
      // Se consulta la Id autogenerada para hacer un callBack
      $data = $obj->get($obj->conn->insert_id);

      // Si la variable $data es igual a 0, significa que el elemento no ha sido creado como se suponia
      if(count($data)==0) {
       
       print_json(201, false, null);
      // Si la variable $data es diferente de 0, el elemento ha sido creado y manda la siguiente respuesta
      } else {
       array_pop($data);
       print_json(201, "Created", $data);
      }
      
     // Si el Id generada es igual a 0, el elemento no ha sido creado y manda la siguiente respuesta
     } else {
      print_json(201, false, null);

     }
    // Si la respuesta es false, se supone que el elemento no ha sido registrado, y entra en este condicional
    } else {
     print_json(201, false, null);
    }
   // En tal caso de que exista la variable Id, imprimira el mensaje del que el metodo solicitado no es correcto
   } else {
    print_json(405, "Method Not Allowed", null);
   }
   


   break;
  case 'PUT':
   // Acciones del Metodo PUT
   if(isset($id)) {
    // Consulta primeramente que en realidad exista un elemeto con el Id antes de modificar
    $info = $obj->get($id);
    array_pop($info);

    // Si la info recibida es diferente de 0, el elemento existe, por lo tanto procede a modificar 
    if(count($info)!=0) {
     $array = json_decode($bodyRequest, true);

     $obj->data = renderizeData(array_keys($array), array_values($array));

     $obj->Id = $id;
     $data = $obj->put();

     if($data) {
      $data = $obj->get($id);

      if(count($data)==0) {
       print_json(200, false, null);
      } else {
       array_pop($data);
       print_json(200, "OK", $data);
      }

     } else {
      print_json(200, false, null);
     }
    // Si la info recibida es igual a 0, el elemento no existe y no hay nada para modificar
    } else {
     print_json(404, "Not Found", null);
    }
    
   } else {
    print_json(405, "Method Not Allowed", null);
   }

   break;
  case 'DELETE':
   if(isset($id)) {

    $info = $obj->get($id);

    if(count($info)==0) {
     print_json(404, "Not Found", null);
    } else {
     $obj->Id = $id;
     $data = $obj->delete();

     if($data) {
      array_pop($info);
      if(count($info)==0) {
       print_json(404, "Not Found", null);
      } else {
       print_json(200, "OK", $info);
      }
      
     } else {
      print_json(200, false, null);
     }
    }

   } else {
    print_json(405, "Method Not Allowed", null);
   }
   break;
  
  default:
   // Acciones cuando el metodo no se permite
   // En caso de que el Metodo Solicitado no sea ninguno de los cuatro disponible, envia la siguiente respuesta
   print_json(405, "Method Not Allowed", null);
   break;
 }

 // ---------------------- Funciones controladoras ------------------------------- //

 // Esta funcion crea la instancia de la clase generica y la retorna
 function get_obj() {
  $object = new generic_class;
  return $object;
 }

 // Esta funcion renderiza la informacion que sera enviada a la base de datos
 function renderizeData($keys, $values) {

  switch ($_SERVER['REQUEST_METHOD']) {
   case 'POST':
    # code...
     foreach ($keys as $key => $value) {
      if($key == count($keys) - 1) {
       $str = $str . $value . ") VALUES (";

       foreach ($values as $key => $value) {
        if($key == count($values) - 1) {
         $str = $str . "'" . $value . "')";
        } else {
         $str = $str . "'" . $value . "',";
        }
        
       }
      } else {
       if($key == 0) {
        $str = $str . "(" . $value . ",";
       } else {
        $str = $str . $value . ",";
       }
       
      }
     }

     return $str;
    break;
   case 'PUT':
    foreach ($keys as $key => $value) {
     if($key == count($keys) - 1) {
      $str = $str . $value . "='" . $values[$key] . "'"; 
     } else {
      $str = $str . $value . "='" . $values[$key] . "',"; 
     }
    }
    return $str;
    break;
  }
  


 }

 // Esta funcion imprime las respuesta en estilo JSON y establece los estatus de la cebeceras HTTP
 function print_json($status, $mensaje, $data) {
  header("HTTP/1.1 $status $mensaje");
  header("Content-Type: application/json; charset=UTF-8");

  $response['statusCode'] = $status;
  $response['statusMessage'] = $mensaje;
  $response['data'] = $data;

  echo json_encode($response, JSON_PRETTY_PRINT);
 }
?>

.htaccess
Ahora, solo nos queda modificar el archivo .htaccess para poder acceder a las URL sin errores, recuerden que para que esto funcione, el mod_rewrite de Apache debe estar activado, de otra manera, todo el trabajo que has hecho, no serviría de nada.

# Se establece la ruta como el archivo principal o pagina principal
DirectoryIndex public_html/index.html

RewriteEngine On

# Para metodo GET, POST, PUT
RewriteRule ^api/([a-zA-Z]+)$ controller.php
RewriteRule ^api/([a-zA-Z]+)/$ controller.php

# Para metodo GET por Id y metodo DELETE
RewriteRule ^api/([a-zA-Z]+)/([0-9]+)$ controller.php
RewriteRule ^api/([a-zA-Z]+)/([0-9]+)/$ controller.php

# Expresiones regulares
## Alfanumericos | ([a-zA-Z0-9]+)
## Numericos     | ([0-9]+)
## Caracteres    | ([a-zA-Z]+)

Probando el Web Service

Como ya habiamos mencionado, probaremos el Web Services con la Extension Insomnia de Chrome, lo cual nos otorgara los siguiente resultados

GET api/usuario
POST api/usuario
GET api/usuario
GET api/usuario/7
PUT api/usuario/7
DELETE api/usuario/1
Luego de crear este Web Services, puedes crear cuantas tablas en la base de datos desees, y en la URL solo debes cambiar el nombre de la entidad por el nombre de la tabla en la base de datos. Olvidaba mencionarle que el archivo index.html dentro de la carpeta public_html sera la pagina principal del proyecto, en donde crearemos en front-end del mismo y donde se haran las solicitudes HTTP mediante el uso de la Librería jQuery o AngularJS. Estén atentos que hare una segunda parte de este tutorial explicando como consumir un API RestFul desde el cliente con JavaScript.

Demo

Segunda Parte: Consumir un Web Services API Rest con AngularJS

Enlaces para compartir en tu blog o pagina web.




Widget por Friki Bloggeo