Cree una API REST con Node.js y Express:Conexión de una base de datos
En el primer tutorial, Comprensión de las API RESTful, aprendimos qué es la arquitectura REST, qué son los métodos y respuestas de solicitud HTTP y cómo comprender un punto final de API RESTful. En el segundo tutorial, Cómo configurar un servidor Express API, aprendimos cómo construir servidores con ambos http integrados en Node. módulo y el marco Express, y cómo enrutar la aplicación que creamos a diferentes puntos finales de URL.
Actualmente, usamos datos estáticos para mostrar la información del usuario en forma de fuente JSON cuando el extremo de la API recibe un mensaje GET. petición. En este tutorial, configuraremos una base de datos MySQL para almacenar todos los datos, nos conectaremos a la base de datos desde nuestra aplicación Node.js y permitiremos que la API use GET , POST , PUT y DELETE métodos para crear una API completa.
Instalación
Hasta este momento, no hemos usado una base de datos para almacenar o manipular ningún dato, así que vamos a configurar una. Este tutorial usará MySQL, y si ya tiene MySQL instalado en su computadora, estará listo para continuar con el siguiente paso.
Si no tiene instalado MySQL, puede descargar MAMP para macOS y Windows, que proporciona un entorno de servidor local y una base de datos gratuitos. Una vez que haya descargado esto, abra el programa y haga clic en Iniciar servidores para iniciar MySQL.
Además de configurar MySQL, necesitaremos un software GUI para ver la base de datos y las tablas. Para Mac, descargue SequelPro y para Windows, descargue SQLyog. Una vez que haya descargado y ejecutado MySQL, puede usar SequelPro o SQLyog para conectarse a localhost con el nombre de usuario root y contraseña root en el puerto 3306 .
Una vez que todo esté configurado aquí, podemos pasar a configurar la base de datos para nuestra API.
Configuración de la base de datos
En su software de visualización de base de datos, agregue una nueva base de datos y llámela api . Asegúrese de que MySQL se esté ejecutando o no podrá conectarse a localhost .
Cuando tengas la api base de datos creada, vaya a ella y ejecute la siguiente consulta para crear una nueva tabla.
CREATE TABLE `users` ( `id` int(11) unsigned NOT NULL AUTO_INCREMENT, `name` varchar(30) DEFAULT '', `email` varchar(50) DEFAULT '', PRIMARY KEY (`id`) ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
Esta consulta SQL creará la estructura de nuestros users mesa. Cada usuario tendrá una identificación de incremento automático, un nombre y una dirección de correo electrónico.
También podemos llenar la base de datos con los mismos datos que estamos mostrando actualmente a través de una matriz JSON estática ejecutando INSERT consulta.
INSERT INTO users (name, email)
VALUES ('Richard Hendricks', '[email protected]'),
('Bertram Gilfoyle', '[email protected]');
No es necesario ingresar el id campo, ya que se incrementa automáticamente. En este punto, tenemos la estructura de nuestra tabla, así como algunos datos de muestra con los que trabajar.
Conexión a MySQL
De vuelta en nuestra aplicación, tenemos que conectarnos a MySQL desde Node.js para comenzar a trabajar con los datos. Anteriormente, instalamos mysql módulo npm, y ahora lo vamos a usar.
Cree un nuevo directorio llamado datos y crea un config.js archivo.
Comenzaremos requiriendo el mysql módulo en data/config.js .
const mysql = require('mysql');
Vamos a crear una config objeto que contiene el host, el usuario, la contraseña y la base de datos. Esto debería hacer referencia a la api base de datos que creamos y usamos la configuración predeterminada de localhost.
// Set database connection credentials
const config = {
host: 'localhost',
user: 'root',
password: 'root',
database: 'api',
};
Para mayor eficiencia, vamos a crear un grupo MySQL, que nos permite usar varias conexiones a la vez en lugar de tener que abrir y cerrar manualmente varias conexiones.
// Create a MySQL pool const pool = mysql.createPool(config);
Finalmente, exportaremos el grupo de MySQL para que la aplicación pueda usarlo.
// Export the pool module.exports = pool;
Puede ver el archivo de configuración de la base de datos completo en nuestro repositorio de GitHub.
Ahora que nos estamos conectando a MySQL y nuestra configuración está completa, podemos pasar a interactuar con la base de datos desde la API.
Obtención de datos API de MySQL
Actualmente, nuestro routes.js El archivo está creando manualmente una matriz JSON de usuarios, que se parece a esto.
const users = [{ ...
Dado que ya no usaremos datos estáticos, podemos eliminar toda la matriz y reemplazarla con un enlace a nuestro grupo de MySQL.
// Load the MySQL pool connection
const pool = require('../data/config');
Anteriormente, el GET para los /users la ruta estaba enviando los users estáticos datos. Nuestro código actualizado consultará la base de datos para obtener esos datos. Vamos a usar una consulta SQL para SELECT todo de los users tabla, que se ve así.
SELECT * FROM users
Esto es lo que nuestros nuevos /users obtener la ruta se verá así, usando pool.query() método.
// Display all users
app.get('/users', (request, response) => {
pool.query('SELECT * FROM users', (error, result) => {
if (error) throw error;
response.send(result);
});
});
Aquí, estamos ejecutando SELECT consulta y luego enviar el resultado como JSON al cliente a través de /users punto final Si reinicia el servidor y navega a /users página, verá los mismos datos que antes, pero ahora es dinámico.
Uso de parámetros de URL
Hasta ahora, nuestros puntos finales han sido rutas estáticas, ya sea el / raíz o /users —pero, ¿qué pasa cuando queremos ver datos solo sobre un usuario específico? Tendremos que usar un punto final variable.
Para nuestros usuarios, es posible que queramos recuperar información sobre cada usuario individual en función de su identificación única. Para hacer eso, usaríamos dos puntos (: ) para indicar que es un parámetro de ruta.
// Display a single user by ID
app.get('/users/:id', (request, response) => {
...
});
});
Podemos recuperar el parámetro para esta ruta con request.params propiedad. Dado que el nuestro se llama id , así será como nos referiremos a él.
const id = request.params.id;
Ahora agregaremos un WHERE cláusula a nuestro SELECT declaración para obtener solo los resultados que tienen el id especificado .
Usaremos ? como marcador de posición para evitar la inyección SQL y pasar la identificación como un parámetro, en lugar de crear una cadena concatenada, lo que sería menos seguro.
pool.query('SELECT * FROM users WHERE id = ?', id, (error, result) => {
if (error) throw error;
response.send(result);
});
El código completo para nuestro recurso de usuario individual ahora se ve así:
// Display a single user by ID
app.get('/users/:id', (request, response) => {
const id = request.params.id;
pool.query('SELECT * FROM users WHERE id = ?', id, (error, result) => {
if (error) throw error;
response.send(result);
});
});
Ahora puede reiniciar el servidor y navegar a https://localhost/users/2 para ver sólo la información de Gilfoyle. Si recibe un error como Cannot GET /users/2 , significa que necesita reiniciar el servidor.
Ir a esta URL debería arrojar un único resultado.
[{
id: 2,
name: "Bertram Gilfoyle",
email: "[email protected]"
}]
Si eso es lo que ve, felicidades:¡ha configurado con éxito un parámetro de ruta dinámica!
Enviar una solicitud POST
Hasta ahora, todo lo que hemos estado haciendo ha usado GET peticiones. Estas solicitudes son seguras, lo que significa que no alteran el estado del servidor. Simplemente hemos estado viendo datos JSON.
Ahora vamos a comenzar a hacer que la API sea verdaderamente dinámica usando un POST solicitud para agregar nuevos datos.
Mencioné anteriormente en el artículo Comprender REST que no usamos verbos como add o delete en la URL para realizar acciones. Para agregar un nuevo usuario a la base de datos, POST a la misma URL desde la que los vemos, pero configura una ruta separada para ello.
// Add a new user
app.post('/users', (request, response) => {
...
});
Tenga en cuenta que estamos usando app.post() en lugar de app.get() ahora.
Dado que estamos creando en lugar de leer, usaremos un INSERT consulta aquí, al igual que hicimos en la inicialización de la base de datos. Enviaremos el request.body completo hasta la consulta SQL.
pool.query('INSERT INTO users SET ?', request.body, (error, result) => {
if (error) throw error;
También vamos a especificar el estado de la respuesta como 201 , que significa Created . Para obtener la identificación del último elemento insertado, usaremos el insertId propiedad.
response.status(201).send(`User added with ID: ${result.insertId}`);
Todo nuestro POST el código de recepción se verá así.
// Add a new user
app.post('/users', (request, response) => {
pool.query('INSERT INTO users SET ?', request.body, (error, result) => {
if (error) throw error;
response.status(201).send(`User added with ID: ${result.insertId}`);
});
});
Ahora podemos enviar un POST solicitar a través de. La mayoría de las veces cuando envías un POST solicitud, lo estás haciendo a través de un formulario web. Aprenderemos cómo configurar eso al final de este artículo, pero la forma más rápida y fácil de enviar una prueba POST es con cURL, usando -d (--data) bandera.
Ejecutaremos curl -d , seguido de una cadena de consulta que contiene todos los pares clave/valor y el punto final de la solicitud.
curl -d "name=Dinesh Chugtai&[email protected]" http://localhost:3002/users
Una vez que envíe esta solicitud, debería recibir una respuesta del servidor.
User added with ID: 3
Si navega a http://localhost/users , verá la última entrada agregada a la lista.
Enviar una solicitud PUT
POST es útil para agregar un nuevo usuario, pero querremos usar PUT para modificar un usuario existente. PUT es idempotente, lo que significa que puede enviar la misma solicitud varias veces y solo se realizará una acción. Esto es diferente a POST , porque si enviáramos nuestra solicitud de nuevo usuario más de una vez, seguiría creando nuevos usuarios.
Para nuestra API, vamos a configurar PUT para poder manejar la edición de un solo usuario, entonces vamos a usar el :id parámetro de ruta esta vez.
Vamos a crear una UPDATE consulta y asegúrese de que solo se aplique a la identificación solicitada con WHERE cláusula. Estamos usando dos ? marcadores de posición, y los valores que pasemos irán en orden secuencial.
// Update an existing user
app.put('/users/:id', (request, response) => {
const id = request.params.id;
pool.query('UPDATE users SET ? WHERE id = ?', [request.body, id], (error, result) => {
if (error) throw error;
response.send('User updated successfully.');
});
});
Para nuestra prueba, editaremos el usuario 2 y actualice la dirección de correo electrónico de [email protected] a [email protected]. Podemos usar cURL nuevamente, con [-X (--request)] flag, para especificar explícitamente que estamos enviando una solicitud PUT.
curl -X PUT -d "name=Bertram Gilfoyle" -d "[email protected]" http://localhost:3002/users/2
Asegúrese de reiniciar el servidor antes de enviar la solicitud, de lo contrario obtendrá el Cannot PUT /users/2 error.
Deberías ver esto:
User updated successfully.
Los datos del usuario con id 2 ahora debería actualizarse.
Enviar una solicitud de ELIMINACIÓN
Nuestra última tarea para completar la funcionalidad CRUD de la API es crear una opción para eliminar un usuario de la base de datos. Esta solicitud utilizará el DELETE Consulta SQL con WHERE y eliminará un usuario individual especificado por un parámetro de ruta.
// Delete a user
app.delete('/users/:id', (request, response) => {
const id = request.params.id;
pool.query('DELETE FROM users WHERE id = ?', id, (error, result) => {
if (error) throw error;
response.send('User deleted.');
});
});
Podemos usar -X de nuevo con cURL para enviar la eliminación. Eliminemos el último usuario que creamos.
curl -X DELETE http://localhost:3002/users/3
Verá el mensaje de éxito.
User deleted.
Navegue a http://localhost:3002 , y verá que ahora solo hay dos usuarios.
¡Felicidades! En este punto, la API está completa. Visite el repositorio de GitHub para ver el código completo de routes.js .
Enviar solicitudes a través de request Módulo
Al comienzo de este artículo, instalamos cuatro dependencias, y una de ellas fue la request módulo. En lugar de utilizar solicitudes de cURL, puede crear un nuevo archivo con todos los datos y enviarlo. Crearé un archivo llamado post.js que creará un nuevo usuario a través de POST .
const request = require('request');
const json = {
"name": "Dinesh Chugtai",
"email": "[email protected]",
};
request.post({
url: 'http://localhost:3002/users',
body: json,
json: true,
}, function (error, response, body) {
console.log(body);
});
Podemos llamar a esto usando node post.js en una nueva ventana de terminal mientras el servidor se está ejecutando, y tendrá el mismo efecto que usar cURL. Si algo no funciona con cURL, la request El módulo es útil ya que podemos ver el error, la respuesta y el cuerpo.
Envío de solicitudes a través de un formulario web
Por lo general, POST y otros métodos HTTP que alteran el estado del servidor se envían mediante formularios HTML. En este ejemplo muy simple, podemos crear un index.html archivo en cualquier lugar y cree un campo para un nombre y una dirección de correo electrónico. La acción del formulario apuntará al recurso, en este caso http//localhost:3002/users , y especificaremos el método como post .
Crear index.html y añádele el siguiente código:
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Node.js Express REST API</title>
</head>
<body>
<form action="http://localhost:3002/users" method="post">
<label for="name">Name</label>
<input type="text" name="name">
<label for="email">Email</label>
<input type="email" name="email">
<input type="submit">
</form>
</body>
</html>
Abra este archivo HTML estático en su navegador, complételo y envíelo mientras el servidor se ejecuta en la terminal. Debería ver la respuesta de User added with ID: 4 y debería poder ver la nueva lista de usuarios.
