Bouw een REST API met Node.js en Express:een database verbinden
In de eerste zelfstudie, RESTful API's begrijpen, hebben we geleerd wat de REST-architectuur is, wat HTTP-verzoekmethoden en -antwoorden zijn en hoe een RESTful API-eindpunt te begrijpen. In de tweede zelfstudie, Een Express API-server instellen, hebben we geleerd hoe we servers kunnen bouwen met de ingebouwde http van beide Nodes. module en het Express-framework, en hoe de app die we hebben gemaakt naar verschillende URL-eindpunten te routeren.
Momenteel gebruiken we statische gegevens om gebruikersinformatie weer te geven in de vorm van een JSON-feed wanneer het API-eindpunt wordt geraakt met een GET verzoek. In deze zelfstudie gaan we een MySQL-database opzetten om alle gegevens op te slaan, verbinding maken met de database vanuit onze Node.js-app en de API toestaan de GET te gebruiken , POST , PUT , en DELETE methoden om een volledige API te maken.
Installatie
Tot nu toe hebben we geen database gebruikt om gegevens op te slaan of te manipuleren, dus we gaan er een opzetten. Deze tutorial maakt gebruik van MySQL en als MySQL al op je computer is geïnstalleerd, ben je klaar om door te gaan naar de volgende stap.
Als MySQL niet is geïnstalleerd, kunt u MAMP voor macOS en Windows downloaden, dat een gratis, lokale serveromgeving en database biedt. Zodra u dit hebt gedownload, opent u het programma en klikt u op Servers starten om MySQL te starten.
Naast het opzetten van MySQL zelf, willen we dat GUI-software de database en tabellen kan bekijken. Download voor Mac SequelPro en voor Windows download SQLyog. Zodra MySQL is gedownload en actief is, kunt u SequelPro of SQLyog gebruiken om verbinding te maken met localhost met de gebruikersnaam root en wachtwoord root op poort 3306 .
Zodra alles hier is ingesteld, kunnen we doorgaan met het opzetten van de database voor onze API.
De database instellen
Voeg in uw databaseweergavesoftware een nieuwe database toe en noem deze api . Zorg ervoor dat MySQL actief is, anders kunt u geen verbinding maken met localhost .
Als je de api . hebt database gemaakt, ga ernaartoe en voer de volgende query uit om een nieuwe tabel te maken.
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;
Deze SQL-query creëert de structuur van onze users tafel. Elke gebruiker heeft een automatisch oplopende ID, een naam en een e-mailadres.
We kunnen de database ook vullen met dezelfde gegevens die we momenteel weergeven via een statische JSON-array door een INSERT uit te voeren vraag.
INSERT INTO users (name, email)
VALUES ('Richard Hendricks', '[email protected]'),
('Bertram Gilfoyle', '[email protected]');
Het is niet nodig om de id . in te voeren veld, omdat het automatisch wordt verhoogd. Op dit punt hebben we de structuur van onze tabel en enkele voorbeeldgegevens om mee te werken.
Verbinding maken met MySQL
Terug in onze app moeten we vanuit Node.js verbinding maken met MySQL om met de gegevens te gaan werken. Eerder installeerden we de mysql npm-module, en nu gaan we hem gebruiken.
Maak een nieuwe map met de naam data en maak een config.js bestand.
We beginnen met het vereisen van de mysql module in data/config.js .
const mysql = require('mysql');
Laten we een config maken object dat de host, gebruiker, wachtwoord en database bevat. Dit moet verwijzen naar de api database die we hebben gemaakt en gebruiken de standaard localhost-instellingen.
// Set database connection credentials
const config = {
host: 'localhost',
user: 'root',
password: 'root',
database: 'api',
};
Voor de efficiëntie gaan we een MySQL-pool maken, waarmee we meerdere verbindingen tegelijk kunnen gebruiken in plaats van handmatig meerdere verbindingen te moeten openen en sluiten.
// Create a MySQL pool const pool = mysql.createPool(config);
Ten slotte exporteren we de MySQL-pool zodat de app deze kan gebruiken.
// Export the pool module.exports = pool;
U kunt het voltooide databaseconfiguratiebestand zien in onze GitHub-opslagplaats.
Nu we verbinding maken met MySQL en onze instellingen zijn voltooid, kunnen we overgaan tot interactie met de database vanuit de API.
API-gegevens ophalen uit MySQL
Momenteel zijn onze routes.js bestand maakt handmatig een JSON-array van gebruikers aan, die er als volgt uitziet.
const users = [{ ...
Aangezien we geen statische gegevens meer gaan gebruiken, kunnen we die hele array verwijderen en vervangen door een link naar onze MySQL-pool.
// Load the MySQL pool connection
const pool = require('../data/config');
Voorheen was de GET voor de /users pad stuurde de statische users gegevens. Onze bijgewerkte code gaat in plaats daarvan de database opvragen voor die gegevens. We gaan een SQL-query gebruiken om SELECT allemaal van de users tabel, die er zo uitziet.
SELECT * FROM users
Dit is wat onze nieuwe /users get route eruit zal zien, met behulp van de pool.query() methode.
// Display all users
app.get('/users', (request, response) => {
pool.query('SELECT * FROM users', (error, result) => {
if (error) throw error;
response.send(result);
});
});
Hier voeren we de SELECT query en vervolgens het resultaat als JSON naar de client sturen via de /users eindpunt. Als u de server opnieuw opstart en naar de /users . gaat pagina, ziet u dezelfde gegevens als voorheen, maar nu is het dynamisch.
URL-parameters gebruiken
Tot nu toe zijn onze eindpunten statische paden geweest—ofwel de / root of /users -maar hoe zit het als we alleen gegevens over een specifieke gebruiker willen zien? We moeten een variabel eindpunt gebruiken.
Voor onze gebruikers willen we misschien informatie over elke individuele gebruiker ophalen op basis van hun unieke id. Om dat te doen, zouden we een dubbele punt gebruiken (: ) om aan te geven dat het een routeparameter is.
// Display a single user by ID
app.get('/users/:id', (request, response) => {
...
});
});
We kunnen de parameter voor dit pad ophalen met de request.params eigendom. Aangezien de onze id heet , zo zullen we ernaar verwijzen.
const id = request.params.id;
Nu voegen we een WHERE . toe clausule aan onze SELECT statement om alleen resultaten te krijgen met de gespecificeerde id .
We gebruiken ? als tijdelijke aanduiding om SQL-injectie te vermijden en de id als parameter door te geven, in plaats van een aaneengeschakelde string te bouwen, wat minder veilig zou zijn.
pool.query('SELECT * FROM users WHERE id = ?', id, (error, result) => {
if (error) throw error;
response.send(result);
});
De volledige code voor onze individuele gebruikersbron ziet er nu als volgt uit:
// 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);
});
});
Nu kunt u de server opnieuw opstarten en navigeren naar https://localhost/users/2 om alleen de informatie voor Gilfoyle te zien. Als u een foutmelding krijgt zoals Cannot GET /users/2 , betekent dit dat u de server opnieuw moet opstarten.
Als u naar deze URL gaat, wordt er één resultaat geretourneerd.
[{
id: 2,
name: "Bertram Gilfoyle",
email: "[email protected]"
}]
Als dat is wat je ziet, gefeliciteerd:je hebt met succes een dynamische routeparameter ingesteld!
Een POST-verzoek verzenden
Tot nu toe heeft alles wat we hebben gedaan gebruik gemaakt van GET verzoeken. Deze verzoeken zijn veilig, wat betekent dat ze de status van de server niet veranderen. We hebben gewoon JSON-gegevens bekeken.
Nu gaan we beginnen om de API echt dynamisch te maken met behulp van een POST verzoek om nieuwe gegevens toe te voegen.
Ik heb eerder in het artikel Inzicht in REST vermeld dat we geen werkwoorden gebruiken zoals add of delete in de URL voor het uitvoeren van acties. Om een nieuwe gebruiker aan de database toe te voegen, zullen we POST naar dezelfde URL waarvan we ze bekijken, maar stel er gewoon een aparte route voor in.
// Add a new user
app.post('/users', (request, response) => {
...
});
toe
Let op:we gebruiken app.post() in plaats van app.get() nu.
Omdat we creëren in plaats van lezen, gebruiken we een INSERT query hier, net zoals we deden bij de initialisatie van de database. We sturen de volledige request.body door naar de SQL-query.
pool.query('INSERT INTO users SET ?', request.body, (error, result) => {
if (error) throw error;
We gaan ook de status van het antwoord specificeren als 201 , wat staat voor Created . Om de id van het laatst ingevoegde item te krijgen, gebruiken we de insertId eigendom.
response.status(201).send(`User added with ID: ${result.insertId}`);
Onze hele POST ontvangstcode ziet er als volgt uit.
// 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}`);
});
});
Nu kunnen we een POST . sturen aanvragen via. Meestal wanneer u een POST . verzendt aanvraag doet u dit via een webformulier. We zullen aan het einde van dit artikel leren hoe u dat kunt instellen, maar de snelste en gemakkelijkste manier om een test POST te verzenden is met cURL, met behulp van de -d (--data) vlag.
We gebruiken curl -d , gevolgd door een queryreeks die alle sleutel/waarde-paren en het eindpunt van de aanvraag bevat.
curl -d "name=Dinesh Chugtai&[email protected]" http://localhost:3002/users
Zodra je dit verzoek hebt verzonden, zou je een reactie van de server moeten krijgen.
User added with ID: 3
Als u navigeert naar http://localhost/users , ziet u het laatste item dat aan de lijst is toegevoegd.
Een PUT-verzoek verzenden
POST is handig voor het toevoegen van een nieuwe gebruiker, maar we willen PUT . gebruiken om een bestaande gebruiker te wijzigen. PUT is idempotent, wat betekent dat u hetzelfde verzoek meerdere keren kunt verzenden en dat er slechts één actie wordt uitgevoerd. Dit is anders dan POST , want als we ons nieuwe gebruikersverzoek meer dan eens zouden verzenden, zou het nieuwe gebruikers blijven maken.
Voor onze API gaan we PUT instellen om een enkele gebruiker te kunnen bewerken, dus we gaan de :id . gebruiken routeparameter deze keer.
Laten we een UPDATE maken query en zorg ervoor dat deze alleen van toepassing is op de gevraagde id met de WHERE clausule. We gebruiken twee ? tijdelijke aanduidingen, en de waarden die we doorgeven, gaan in de juiste volgorde.
// 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.');
});
});
Voor onze test bewerken we gebruiker 2 en werk het e-mailadres bij van [email protected] naar [email protected]. We kunnen cURL opnieuw gebruiken, met de [-X (--request)] vlag, om expliciet aan te geven dat we een PUT-verzoek doorsturen.
curl -X PUT -d "name=Bertram Gilfoyle" -d "[email protected]" http://localhost:3002/users/2
Zorg ervoor dat u de server opnieuw opstart voordat u het verzoek verzendt, anders krijgt u de melding Cannot PUT /users/2 fout.
Je zou dit moeten zien:
User updated successfully.
De gebruikersgegevens met id 2 moet nu worden bijgewerkt.
Een VERWIJDERING-verzoek verzenden
Onze laatste taak om de CRUD-functionaliteit van de API te voltooien, is om een optie te maken voor het verwijderen van een gebruiker uit de database. Dit verzoek gebruikt de DELETE SQL-query met WHERE , en het zal een individuele gebruiker verwijderen die is gespecificeerd door een routeparameter.
// 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.');
});
});
We kunnen -X . gebruiken opnieuw met cURL om de verwijdering door te sturen. Laten we de laatste gebruiker die we hebben gemaakt verwijderen.
curl -X DELETE http://localhost:3002/users/3
U ziet het succesbericht.
User deleted.
Navigeer naar http://localhost:3002 , en je zult zien dat er nu nog maar twee gebruikers zijn.
Gefeliciteerd! Op dit punt is de API voltooid. Bezoek de GitHub-repo om de volledige code voor routes.js te zien .
Verzoeken verzenden via het request Module
Aan het begin van dit artikel hebben we vier afhankelijkheden geïnstalleerd, en een daarvan was het request module. In plaats van cURL-verzoeken te gebruiken, kunt u een nieuw bestand maken met alle gegevens en dit doorsturen. Ik maak een bestand met de naam post.js die een nieuwe gebruiker zal maken via 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);
});
We kunnen dit aanroepen met behulp van node post.js in een nieuw terminalvenster terwijl de server draait, en het heeft hetzelfde effect als het gebruik van cURL. Als iets niet werkt met cURL, het request module is handig omdat we de fout, het antwoord en de hoofdtekst kunnen bekijken.
Verzoeken verzenden via een webformulier
Gewoonlijk POST en andere HTTP-methoden die de status van de server wijzigen, worden verzonden met behulp van HTML-formulieren. In dit zeer eenvoudige voorbeeld kunnen we een index.html . maken bestand overal en maak een veld voor een naam en e-mailadres. De actie van het formulier verwijst naar de bron, in dit geval http//localhost:3002/users , en we specificeren de methode als post .
Maak index.html en voeg er de volgende code aan toe:
<!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>
Open dit statische HTML-bestand in uw browser, vul het in en verzend het terwijl de server in de terminal draait. U zou de reactie moeten zien van User added with ID: 4 , en u zou de nieuwe lijst met gebruikers moeten kunnen bekijken.