En este segundo artículo veremos mas a detalle cómo consumir servicios web a través de REST con slim php. Ya teniendo la instalación completa es necesario comenzar a crear la estructura de rutas y la conexión a la base de datos en caso de ser requerida, como vimos en el artículo anterior, que puedes consultar de nuevo dando click aqui, no es muy difícil iniciar un proyecto con slim, y como te darás cuenta tener una conexión a base de datos y las rutas para realizar consultas tampoco lo será, hoy tomaremos como ejemplo el de administrar usuarios a través de consultas HTTP, con los métodos GET, POST, PUT, DELETE descrito de la siguiente manera:
Lo primero que necesitamos hacer es crear la base de datos, en este caso la haremos en SQL, asumiendo que sea desde consola, ingresando el siguiente código:
|
1
2
3
4
5
6
7
8
9
|
CREATE DATABASE restslim;
USE restslim;
CREATE TABLE usuarios (
id int(11) NOT NULL AUTO_INCREMENT,
username varchar(100) NOT NULL,
password varchar(100) NOT NULL,
description text,
PRIMARY KEY (id)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
|
Una vez creada la base de datos y la tabla usuarios, el segundo paso es preparar la conexión a mysql, en php existen varios métodos para realizarlo como pueden ser funciones mysql (obsoleto desde la versión 5 de php), mysqli que recomienda el sitio oficial de php, y por último con un objeto de clases php PDO, aunque las 3 formas son válidas, utilizare la ultima opcion ya que a mi parecer es más fácil de utilizar y el uso de consulta preparas es muy simple.
Abrimos nuestro archivo index.php que configuramos anteriormente (ver de nuevo), de preferencia borramos el código innecesario y dejamos solo lo siguiente:
|
1
2
3
|
require 'Slim/Slim.php';
\Slim\Slim::registerAutoloader();
$app = new \Slim\Slim();
|
En la siguiente linea agregamos la función para poder realizar la conexión a la base de datos:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
/*
*conexiónon a base de datos
*/
function PDOconnection()
{
try{
$connection = new PDO("mysql:host=localhost;Mibase=prueba_slim", "usuario", "password");
$connection->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
}
catch(PDOException $error)
{
echo "Error PDOconnection: " . $error->getMessage();
}
return $connection;
}
|
Reemplaza el texto “mibase” por tu nombre de base de datos de igual manera el texto “usuario” y la “contraseña” por tu configuracion, y de esta manera ya tendremos la conexión a la base de datos, el siguiente paso es registrar las rutas en el objeto $app creado inicialmente.
En este punto comenzaremos a utilizar los métodos HTTP para obtener la lista de usuarios y los datos de un usuario en específico utilizando su id, en este caso haremos uso del método GET, para registrar una ruta en slim tipo GET, se utiliza el método con el mismo nombre quedando de la siguiente manera:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
$app->get("/usuarios/", function() use($app)
{
try{
$connection = PDOconnection();
$consulta = $connection->prepare("SELECT * FROM usuarios");
$consulta->execute();
$usuarios = $consulta->fetchAll();
$connection = null;
$app->response->headers->set("Content-type", "application/json");
$app->response->status(200);
$app->response->body(json_encode($usuarios));
}
catch(PDOException $error)
{
echo "Error PDOconnection: " . $error->getMessage();
}
});
|
En el método se agrega el primer parámetro “nombre de la ruta” y luego se agrega una función o clase a utilizar en este caso utilizamos una función anónima que puede ser declarada como parámetro, como puedes darte cuenta creamos la conexión a la base de datos, y con la sentencia SQL realizamos la consulta de manera rápida, siempre debes de realizar la consulta dentro de un try/catch para evitar errores en ejecución. Por último recogemos los datos y los mostramos en formato json con la función json_encode().
Para obtener los datos de un usuario en especifico solo necesitamos tener el identificador de la base de datos y podremos realizar la consulta, en este caso pasamos el parámetro id a través de la ruta “/usuario/:id”, el texto “:id” slim lo reconoce como variable y lo podremos utilizar dentro de la función como se ve a continuación:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
$app->get("/usuario/:id", function($id) use($app)
{
try{
$connection = PDOconnection();
$consulta = $connection->prepare("SELECT * FROM usuarios WHERE id = ?");
$consulta->bindParam(1, $id);
$consulta->execute();
$usuarios = $consulta->fetch();
$connection = null;
$app->response->headers->set("Content-type", "application/json");
$app->response->status(200);
$app->response->body(json_encode($usuarios));
}
catch(PDOException $error)
{
echo "Error PDOconnection: " . $error->getMessage();
}
});
|
Para utilizar el parámetro ”:id” declarado en la ruta, debemos incluir dentro de la función el parámetro con el mismo nombre. En la sentencia SQL utilizamos el signo ? para referirnos a un parámetro variable que desconocemos, esto se conoce como sentencias preparadas, puedes utilizar este signo para referirte a los parámetros que desees solo debes respetar el orden al ingresarlos, y con el método “bindParam(1, $id)” reemplazamos el signo por la variable.
Para insertar usuarios hacemos uso del método POST que es utilizado para enviar información de manera más discreta, el código a utilizar seria asi:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
$app->post("/usuarios/", function() use($app)
{
$usuario = $app->request->post("username");
$password = $app->request->post("password");
$description = $app->request->post("description");
try{
$connection = PDOconnection();
$db = $connection->prepare("INSERT INTO usuarios VALUES(null, ?, ?, ?)");
$db->bindParam(1, $usuario);
$db->bindParam(2, $password);
$db->bindParam(3, $description);
$db->execute();
$lastid = $connection->lastInsertId();
$connection = null;
$app->response->headers->set("Content-type", "application/json");
$app->response->status(200);
$app->response->body(json_encode($lastid));
}
catch(PDOException $error)
{
echo "Error PDOconnection: " . $error->getMessage();
}
});
|
Como puedes notar, con el método request->post(“nombre_de_lparametro”) obtenemos el valor de cada variable, y utilizando sentencias preparadas insertamos cada valor en nuestra base de datos, y como respuesta mostramos un 1 en caso de haberse agregado los datos con éxito.
Para actualizar los datos de un usuario existente en la base de datos, solo es necesarios el id, utilizamos el método PUT realizamos las modificaciones, el código necesarios es el siguiente:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
|
$app->put("/usuarios/", function() use($app)
{
$usuario = $app->request->put("username");
$password = $app->request->put("password");
$description = $app->request->put("description");
$id = $app->request->put("id");
try{
$connection = PDOconnection();
$db = $connection->prepare("UPDATE usuarios SET username = ?, password = ?, description = ? WHERE id = ?");
$db->bindParam(1, $usuario);
$db->bindParam(2, $password);
$db->bindParam(3, $description);
$db->bindParam(4, $id);
$db->execute();
$connection = null;
$app->response->headers->set("Content-type", "application/json");
$app->response->status(200);
$app->response->body(json_encode(array("update" => 1)));
}
catch(PDOException $error)
{
echo "Error PDOconnection: " . $error->getMessage();
}
});
|
El código es similar al método POST la diferencia es básicamente la consulta SQL que ahora es “update” en lugar de “insert”.
Si necesitamos eliminar un usuarios, utilizamos el método DELETE utilizando el id del usuarios para referirnos a él en la base de datos, de igual forma que en el método GET también pasamos el id a través de la url, el codigo quedaria de esta manera:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
$app->delete("/usuarios/:id", function($id) use($app)
{
try{
$connection = PDOconnection();
$db = $connection->prepare("DELETE FROM usuarios WHERE id = ?");
$db->bindParam(1, $id);
$db->execute();
$connection = null;
$app->response->headers->set("Content-type", "application/json");
$app->response->status(200);
$app->response->body(json_encode(array("delete" => 1)));
}
catch(PDOException $error)
{
echo "Error PDOconnection: " . $error->getMessage();
}
});
|
Si todo salio bien, mostramos un 1 como confirmación, y por último agregamos la linea “$app->run();” para poner a correr la aplicación.
Una vez finalizado la configuración en slim debemos probar si todo esta funcionado correctamente, lo cual explicaré en la próxima entrada para no hacer muy largo el artículo.
