Creando un API REST con acceso a base de datos con PHP7 + SLIM + ILLUMINATE

En una publicación  anterior revisamos la creación de un proyecto básico de PHP usando la plataforma SLIM.

En esta ocasión vamos a profundizar en algunos conceptos importantes para desarrollar una interfaz de programación (API) basada en protocolo REST que a su vez interactúe con una base de datos MySQL usando el paquete Illuminate/Database.

Temas a desarrollar:

  1. Rutas
  2. Interacción con base de datos y métodos de Bootstrapping
    1. Creación de base de datos didáctica
    2. Instalación del paquete Illuminate/Database
    3. Bootstrapping
    4. Modelos
    5. Carga de Clases Automática
    6. Obtención de registros de la base de datos
    7. Ejecución del proyecto.

Recordemos que para preparar nuestro ambiente de desarrollo vamos a instalar los siguientes instrumentos:

  1. Servidores Web y de Base de DatosXAMPP con PHP7, MySQL, Apache, phpMyAdmin
  2. Gestor de Paquetes de PHP: Composer
  3. Crearemos un proyecto SLIM (instrucciones)

(!) Este artículo se basa en el proyecto inicial que construimos en la publicación anterior “PHP SLIM Framework”. Si aun no lo ha hecho, haga clic aquí para seguir las instrucciones en dicho artículo inicial y crear nuestro proyecto base..

1 Rutas

En otra publicación discutimos con cierto nivel de detalle el tema de rutas.

En general podemos definir una ruta HTTP como el mapa entre un URL (enlace), un verbo HTTP  (tipo de solicitud HTTP) y los recursos lógicos que ofrece un sistema.

En SLIM, se definen rutas mediante el objeto $app y los métodos del framework SLIM propios de los verbos HTTP:

  • GET: $app->get($ruta, $función)
  • POST: $app->post($ruta, $función)
  • DELETE: $app->delete($ruta, $función)
  • PUT: $app->put($ruta, $función)

En esta lista anterior la variable $ruta contiene una representación en cadena (String) de la ruta a configurar, incluyendo parámetros de forma opcional. Un ejemplo de nuestro proyecto base sería:

$app->get('/hello/{name}', function (Request $request, Response $response, array $args) {
   $name=$args['name'];
   $response->getBody()->write("Hello, $name");
   return$response;
});

En nuestro ejemplo anterior, la ruta /hello recibe un parámetro {name} el cual es usado para responder un saludo personalizado, así  cuando invocamos la ruta /hello/Jose la respuesta será "Hello, Jose".

2 Interacción con base de datos y métodos de bootstrapping

Para poder interactuar con la base de datos necesitaremos obviamente tener una base de datos, instalar algunas librerías o paquetes que nos faciliten esa interacción y configurar en general nuestro proyecto (bootstrapping) para usar dichas librerías y nuestras propias clases.

2.1 Creación de la Base de Datos

Vamos a crear una base de datos básica. Usando phpMyAdmin vamos a ejecutar el siguiente script para crear nuestra base de datos de ejemplo.

-- phpMyAdmin SQL Dump
-- version 4.7.7
-- https://www.phpmyadmin.net/
--
-- Host: 127.0.0.1
-- Generation Time: Sep 29, 2018 at 04:52 AM
-- Server version: 10.1.30-MariaDB
-- PHP Version: 7.2.2

SET SQL_MODE = "NO_AUTO_VALUE_ON_ZERO";
SET AUTOCOMMIT = 0;
START TRANSACTION;
SET time_zone = "+00:00";

--
-- Database: `mi_base_de_datos`
--
DROP DATABASE IF EXISTS `mi_base_de_datos`;
CREATE DATABASE IF NOT EXISTS `mi_base_de_datos` DEFAULT CHARACTER SET utf8 COLLATE utf8_general_ci;
USE `mi_base_de_datos`;

-- --------------------------------------------------------

--
-- Table structure for table `datos`
--

DROP TABLE IF EXISTS `datos`;
CREATE TABLE `datos` (
  `id` int(11) NOT NULL,
  `nombre` varchar(20) NOT NULL,
  `valor` varchar(500) NOT NULL,
  `fecha_de_creacion` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP,
  `fecha_de_modificacion` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

--
-- Dumping data for table `datos`
--

INSERT INTO `datos` (`id`, `nombre`, `valor`, `fecha_de_creacion`, `fecha_de_modificacion`) VALUES
(1, 'Prueba de dato 01', 'Valor del dato 01', '2018-09-28 20:51:17', '2018-09-28 20:51:17'),
(2, 'dato 02', 'valor del dato 02', '2018-09-28 20:51:17', '2018-09-28 20:51:17');

--
-- Indexes for dumped tables
--

--
-- Indexes for table `datos`
--
ALTER TABLE `datos`
  ADD PRIMARY KEY (`id`);

--
-- AUTO_INCREMENT for dumped tables
--

--
-- AUTO_INCREMENT for table `datos`
--
ALTER TABLE `datos`
  MODIFY `id` int(11) NOT NULL AUTO_INCREMENT, AUTO_INCREMENT=3;
COMMIT;

2.2 Instalación del Paquete Illuminate/Database

Para este ejemplo utilizaremos el paquete illuminate/database proveniente del sistema Laravel. Nótese que en este tutorial no usaremos Laravel como sistema base para nuestro desarrollo, solo el componente referente a bases de datos. El siguiente comando instalará los paquetes requeridos en nuestro proyecto así como sus dependencias.

composer require illuminate/database "~5.2"

Usualmente se recomienda crear un archivo de configuración que contiene la información necesaria para conectarse a nuestra base de datos. Por ello vamos a crear una carpeta /config en nuestro proyecto y vamos a crear  allí un archivo /config/credenciales.php con el siguiente contenido:

/config/credenciales.php

<?php
$db_host = "localhost";
$db_name = "mi_base_de_datos";
$db_user = "root";
$db_pass = ""; /* Nunca utilice una contraseña vacía */

2.3 Concepto de Bootstrapping

Esta sección nada tiene que ver el sistema de estilizado HTML Bootstrap, sino con el concepto de carga o inicialización de un sistema informático. El término bootstrap en este contexto viene de la expresión “ponerse las botas”, es decir, prepararse para la acción.

Para esta parte vamos a crear un archivo /bootstrap.php en nuestro sistema con el siguiente contenido. (podría llamarse patito.php, pero sería dificil luego recordar de qué se trataba)

/bootstrap.php

<?php 
include 'config/credenciales.php'; //Nuestras credenciales de base de datos
include 'vendor/autoload.php'; //Cargamos los paquetes necesarios de Composer

use Illuminate\Database\Capsule\Manager as Capsule; 

$capsule = new Capsule();
$capsule->addConnection([
    "driver"    => "mysql",
    "host"      => $db_host,
    "database"  => $db_name,
    "username"  => $db_user,
    "password"  => $db_pass,
    "charset"   => "utf8",
    "collation" => "utf8_general_ci",
    "prefix"    => ""
]);

$capsule->bootEloquent();

$capsule->bootEloquent();   

En este punto será necesario editar nuestro archivo /index.php  para incluir nuestro nuevo archivo bootstrap.php en la ejecución de nuestra aplicación.

/index.php

<?php
/*REFERENCIA AL SCRIPT DE INICIALIZACIÓN*/
require 'bootstrap.php';

$app = new \Slim\App();
/*RUTA RAIZ*/
$app->get('/', function ($request, $response, $args) {
    return $response->write("Hola. Esta es la raiz");
});

/*RUTA HELLO*/
$app->get('/hello/{name}', function ($request, $response, $args) {
    return $response->write("Hola " . $args['name']);
});

$app->run();

2.4 Creación de nuestros modelos

Generalmente se llama “modelos” a las clases que describen y/o proveen funcionalidad respecto al modelo de datos subyacente.

Vamos a crear una carpeta /src/MiApp/ donde pondremos las clases relacionadas con nuestra aplicación.

Dentro de esta crearemos una carpeta adicional a la que llamaremos /src/MiApp/Modelos/. En esta carpeta ubicaremos todos las clases PHP que describen nuestros datos.

Nuestra base de datos tiene solamente una tabla de nombre “datos” con un par de registros dentro; así que crearemos una clase de modelo correspondiente

/src/MiApp/Modelos/Dato.php

<?php
namespace MiApp\Modelos;

class Dato extends \Illuminate\Database\Eloquent\Model {  
}

Nótese que creamos un nuevo espacio de nombres (namespace) para nuestra aplicación. Así nuestras clases estarán adecuadamente ordenadas.

Al heredar de la clase Model del nombre de espacio \Illuminate\Database\Eloquent tendremos una serie de funciones de manipulación de base datos completa.

2.5 Carga Automática de Clases

Con el fin de automatizar la carga de las clases referentes a nuestra aplicación, modificaremos el archivo composer.json para que luzca de la siguiente manera:

/composer.json

{
    "require": {
        "slim/slim": "^3.11",
        "illuminate/database": "~5.2"
    },
    "autoload": {
        "psr-4":{"MiApp\\":"src/MiApp"}
    }
}

En este archivo acabamos de agregarla sección autoload que contiene una regla de tipo “psr-4” (que es la forma en que el estándar define la carga automatizada de clases para PHP).

Seguidamente ejecutaremos el comando composer update en la terminal. Esto hará que se actualicen los scripts de autocarga de clases.

composer update

Este comando genera en la carpeta /vendor una serie de archivos que auto-cargan las clases correspondientes en tiempo de ejecución.

2.6 Obtención de registros de la base de datos

Finalmente editamos nuestro archivo /index.php para que luzca así:

/index.php

<?php

/*INICIALIZACION*/
require 'bootstrap.php';

/*REFERENCIA A NUESTRA CLASE Dato*/
use MiApp\Modelos\Dato;

$app = new \Slim\App();

$app->get('/', function ($request, $response, $args) {
    return $response->write("Hola. Esta es la raiz");
});

$app->get('/hello/{name}', function ($request, $response, $args) {
    return $response->write("Hola " . $args['name']);
});

/*NUESTRA NUEVA RUTA PARA OBTENER DATOS*/
$app->get('/datos', function ($request, $response, $args) {
    $da_datos = new Dato();
    $datos = $da_datos->all(); /*FUNCION DE ELOQUENT PARA OBTENER TODOS LOS DATOS*/
    return $response->withStatus(200)->withJson($datos);
});

$app->run();

2.7 Ejecución del Proyecto

Para ejecutar el proyecto usaremos el siguiente comando desde la carpeta del proyecto.

php -S localhost:9090

Este comando ejecutará un servidor que escucha en la dirección http://localhost:9090.

Basta con abrir un navegador y dirigirnos a esa dirección (o hacer clic acá)

Tenemos a nuestra disposición tres rutas que podemos ejemplificar como sigue:

  • http://localhost:9090/           (ruta raiz)
  • http://localhost:9090/hello/Jose          (ruta Hello con parametro Jose) devuelve una cadena “Hello, Jose”
  • http://localhost:9090/hello/Amigo     (ruta Hello con parametro Amigo) devuelve una cadena “Hello, Amigo”
  • http://localhost:9090/datos          (ruta Datos) devuelve una cadena JSON con el contenido de los datos como sigue:
    [
     {
       id: 1,
       nombre: "Prueba de dato 01",
       valor: "Valor del dato 01",
       fecha_de_creacion: "2018-09-28 20:51:17",
       fecha_de_modificacion: "2018-09-28 20:51:17"
     },
     {
       id: 2,
       nombre: "dato 02",
       valor: "valor del dato 02",
       fecha_de_creacion: "2018-09-28 20:51:17",
       fecha_de_modificacion: "2018-09-28 20:51:17"
     }
    ]

Hasta acá nuestro tutorial. Espero que les haya sido de utilidad.

En nuestra siguiente entrega modificaremos este proyecto para poder editar y borrar datos de nuestra tabla.

¡Hasta entonces!

168 total views, 4 views today

5Shares

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *

This site uses Akismet to reduce spam. Learn how your comment data is processed.