Crear un Web Service API Rest con PHP

y MySQL
JSON MySQL PHP   Anthony Medina   22:46   

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 jQueryo 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 /api/usuario Obtiene todos los elementos de la entidad Usuario

GET
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ódig
Definición Uso o Aplicaron
o

Lo usaremos para cuando la solicitud se realiza correctamente, sin

200 OK
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

Códig
Definición Uso o Aplicaron
o

Se usara para cuando se solicita un elemento que no existe en la

404 Not Found
base de datos

Method Se usara por defecto para cuando el método solicitado no coincida

405 Not con la URL o sea un método distinto a GET, POST, PUT y
Allowed 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 siguientes 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.