Share
Nel primo tutorial, Comprendere le API RESTful, abbiamo appreso quale sia l'architettura REST, quali sono i metodi e le risposte delle richieste HTTP e come comprendere un endpoint RESTful dell'API. Nel secondo tutorial, Come configurare un server API Express, abbiamo appreso come creare server con il built-in di entrambi i nodi http modulo e il framework Express e come instradare l'app che abbiamo creato a diversi endpoint di URL.
Al momento, stiamo utilizzando dati statici per visualizzare le informazioni dell'utente sotto forma di un feed JSON quando l'endpoint dell'API viene colpito con a OTTENERE richiesta. In questo tutorial, creeremo un database MySQL per archiviare tutti i dati, connetterci al database dalla nostra app Node.js e consentire all'API di utilizzare il OTTENERE, INVIARE, METTERE, e ELIMINA metodi per creare un'API completa.
Fino a questo punto, non abbiamo utilizzato un database per archiviare o manipolare alcun dato, quindi ne imposteremo uno. Questo tutorial utilizzerà MySQL e, se hai già installato MySQL sul tuo computer, sarai pronto per passare al prossimo passaggio.
Se MySQL non è installato, è possibile scaricare MAMP per macOS e Windows, che fornisce un ambiente server e database gratuito. Una volta scaricato, apri il programma e fai clic Avvia server per avviare MySQL.
Oltre a configurare MySQL, vorremmo che il software della GUI visualizzasse il database e le tabelle. Per Mac, scaricare SequelPro, e per Windows scaricare SQLyog. Una volta scaricato e in esecuzione MySQL, è possibile utilizzare SequelPro o SQLyog per connettersi localhost con il nome utente radice e password radice in porto 3306.
Una volta che tutto è impostato qui, possiamo passare alla configurazione del database per la nostra API.
Nel tuo software di visualizzazione del database, aggiungi un nuovo database e chiamalo api. Assicurati che MySQL sia in esecuzione o non ti sarà possibile connettersi localhost.
Quando hai il api database creato, spostati in esso ed esegui la seguente query per creare una nuova tabella.
Accentsconagua
CREATE TABLE 'users' ('id' int (11) non firmato NOT NULL AUTO_INCREMENT, 'name' varchar (30) DEFAULT ", 'email' varchar (50) DEFAULT", PRIMARY KEY ('id')) ENGINE = InnoDB DEFAULT CHARSET = utf8; Questa query SQL creerà la struttura del nostro utenti tavolo. Ogni utente avrà un ID autoincrementante, un nome e un indirizzo email.
Possiamo anche riempire il database con gli stessi dati che stiamo attualmente visualizzando attraverso un array JSON statico eseguendo un INSERIRE domanda.
INSERISCI NEGLI UTENTI (nome, email) VALORI ('Richard Hendricks', '[email protected]'), ('Bertram Gilfoyle', '[email protected]'); Non è necessario inserire il id campo, in quanto è auto-incrementante. A questo punto, abbiamo la struttura della nostra tabella e alcuni dati di esempio con cui lavorare.
Di nuovo nella nostra app, dobbiamo connetterci a MySQL da Node.js per iniziare a lavorare con i dati. In precedenza, abbiamo installato il mysql modulo npm, e ora lo useremo.
Crea una nuova directory chiamata dati e fare un config.js file.
Inizieremo richiedendo il mysql modulo in dati / config.js.
const mysql = require ('mysql'); Creiamo a config oggetto che contiene l'host, l'utente, la password e il database. Questo dovrebbe riferirsi al api database che abbiamo creato e utilizzare le impostazioni di localhost predefinite.
// Imposta credenziali di connessione al database const config = host: 'localhost', utente: 'root', password: 'root', database: 'api',;
Per efficienza, creeremo un pool MySQL, che ci consentirà di utilizzare più connessioni contemporaneamente anziché dover aprire e chiudere manualmente più connessioni.
// Crea un pool di pool MySQL = mysql.createPool (config);
Infine, esporteremo il pool MySQL in modo che l'app possa utilizzarlo.
// Esporta il pool module.exports = pool;
Puoi vedere il file di configurazione del database completato nel nostro repository GitHub.
Ora che ci colleghiamo a MySQL e le nostre impostazioni sono complete, possiamo passare all'interazione con il database dall'API.
Attualmente, il nostro routes.js il file sta creando manualmente un array JSON di utenti, che assomiglia a questo.
const users = [...
Poiché non utilizzeremo più dati statici, possiamo eliminare l'intero array e sostituirlo con un collegamento al nostro pool MySQL.
// Carica la connessione al pool MySQL const pool = require ('... / data / config'); In precedenza, il OTTENERE per il / utenti il percorso stava inviando la statica utenti dati. Il nostro codice aggiornato cercherà invece il database per quei dati. Utilizzeremo una query SQL per SELEZIONARE tutto dal utenti tavolo, che assomiglia a questo.
SELEZIONA * DA utenti
Ecco cosa è il nostro nuovo / utenti ottenere il percorso sarà simile, utilizzando il pool.query () metodo.
// Visualizza tutti gli utenti app.get ('/ users', (request, response) => pool.query ('SELECT * FROM users', (error, result) => if (errore) errore di lancio; risposta. invia (risultato););); Qui, stiamo eseguendo il SELEZIONARE interrogare e quindi inviare il risultato come JSON al client tramite il / utenti endpoint. Se si riavvia il server e si passa a / utenti pagina, vedrai gli stessi dati di prima, ma ora è dinamico.
Finora, i nostri endpoint sono stati percorsi statici, o il / radice o / utenti-ma che dire quando vogliamo vedere i dati solo su un utente specifico? Dovremo utilizzare un endpoint variabile.
Per i nostri utenti, potremmo voler recuperare informazioni su ogni singolo utente in base al suo ID univoco. Per farlo, useremmo due punti (:) per indicare che si tratta di un parametro del percorso.
// Visualizza un singolo utente per ID app.get ('/ users /: id', (request, response) => ...); ); Possiamo recuperare il parametro per questo percorso con request.params proprietà. Dal momento che il nostro è chiamato id, sarà così che ci riferiamo ad esso.
const id = request.params.id;
Ora aggiungeremo un DOVE clausola al nostro SELEZIONARE dichiarazione per ottenere solo i risultati che hanno specificato id.
Useremo ? come segnaposto per evitare l'iniezione SQL e passare l'id attraverso come parametro, invece di costruire una stringa concatenata, che sarebbe meno sicura.
pool.query ('SELECT * FROM users WHERE id =?', id, (error, result) => if (errore) errore di lancio; response.send (risultato);); Il codice completo per la nostra singola risorsa utente ora appare così:
// Visualizza un singolo utente per ID app.get ('/ users /: id', (request, response) => const id = request.params.id; pool.query ('SELECT * FROM users WHERE id =? ', id, (error, result) => if (errore) errore di lancio; response.send (risultato););); Ora puoi riavviare il server e navigare http: // localhost / utenti / 2 per vedere solo le informazioni per Gilfoyle. Se ricevi un errore come Impossibile ottenere / utenti / 2, significa che devi riavviare il server.
Andando a questo URL dovrebbe restituire un singolo risultato.
[id: 2, nome: "Bertram Gilfoyle", email: "[email protected]"]
Se è quello che vedi, congratulazioni: hai impostato con successo un parametro di percorso dinamico!
Finora, tutto ciò che abbiamo fatto ha usato OTTENERE richieste. Queste richieste sono sicure, nel senso che non alterano lo stato del server. Abbiamo semplicemente visto i dati JSON.
Ora inizieremo a rendere l'API veramente dinamica utilizzando a INVIARE richiesta di aggiungere nuovi dati.
Ho accennato in precedenza all'articolo Understanding REST che non usiamo verbi come Inserisci o Elimina nell'URL per eseguire azioni. Per aggiungere un nuovo utente al database, lo faremo INVIARE allo stesso URL da cui li vediamo, ma semplicemente impostiamo un percorso separato per esso.
// Aggiungi un nuovo utente app.post ('/ users', (request, response) => ...); Nota che stiamo usando app.post () invece di app.get () adesso.
Dal momento che stiamo creando anziché leggere, useremo un INSERIRE interrogare qui, proprio come abbiamo fatto all'inizializzazione del database. Invieremo l'intero request.body attraverso la query SQL.
pool.query ('INSERT INTO users SET?', request.body, (error, result) => if (errore) errore di lancio; Specificheremo anche lo stato della risposta come 201, che sta per Creato. Per ottenere l'ID dell'ultimo elemento inserito, useremo il insertId proprietà.
response.status (201) .send ('Utente aggiunto con ID: $ result.insertId'); Il nostro intero INVIARE ricevere il codice sarà simile a questo.
// Aggiungi un nuovo utente app.post ('/ users', (request, response) => pool.query ('INSERT INTO users SET?', Request.body, (error, result) => if (errore ) throw error; response.status (201) .send ('Utente aggiunto con ID: $ result.insertId'););); Ora possiamo inviare un INVIARE richiesta attraverso. La maggior parte delle volte quando invii un INVIARE richiesta, lo stai facendo attraverso un modulo web. Impareremo come impostarlo alla fine di questo articolo, ma il modo più semplice e veloce per inviare un test INVIARE è con cURL, usando il -d (- data) bandiera.
Correremo arricciatura -d, seguito da una stringa di query contenente tutte le coppie chiave / valore e l'endpoint della richiesta.
curl -d "name = Dinesh [email protected]" http: // localhost: 3002 / users
Una volta inviata questa richiesta, dovresti ricevere una risposta dal server.
Utente aggiunto con ID: 3
Se navighi http: // localhost / utenti, vedrai l'ultima voce aggiunta alla lista.
INVIARE è utile per aggiungere un nuovo utente, ma vorremmo usarlo METTERE per modificare un utente esistente. METTERE è idempotente, nel senso che è possibile inviare la stessa richiesta più volte e verrà eseguita solo un'azione. Questo è diverso da INVIARE, perché se avessimo inviato la nostra nuova richiesta utente per più di una volta, continuerebbe a creare nuovi utenti.
Per la nostra API, stiamo per iniziare METTERE essere in grado di gestire la modifica di un singolo utente, quindi useremo il : id parametro di rotta questa volta.
Creiamo un AGGIORNARE interrogare e accertarsi che si applichi solo all'ID richiesto con DOVE clausola. Ne stiamo usando due ? segnaposto e i valori che passeremo andranno in ordine sequenziale.
// Aggiorna un utente esistente 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 ('Utente aggiornato correttamente.'););); Per il nostro test, modificheremo l'utente 2 e aggiorna l'indirizzo email da [email protected] a [email protected]. Possiamo usare di nuovo cURL, con il [-X (--request)] flag, per specificare esplicitamente che stiamo inviando una richiesta PUT attraverso.
curl -X PUT -d "nome = Bertram Gilfoyle" -d "[email protected]" http: // localhost: 3002 / users / 2
Assicurati di riavviare il server prima di inviare la richiesta, altrimenti otterrai il Can not PUT / users / 2 errore.
Dovresti vedere questo:
Utente aggiornato correttamente.
I dati utente con id 2 dovrebbe ora essere aggiornato.
La nostra ultima operazione per completare la funzionalità CRUD dell'API consiste nel creare un'opzione per l'eliminazione di un utente dal database. Questa richiesta utilizzerà il ELIMINA Query SQL con DOVE, e cancellerà un singolo utente specificato da un parametro di percorso.
// Elimina un utente app.delete ('/ users /: id', (request, response) => const id = request.params.id; pool.query ('ELIMINA DAGLI utenti WHERE id =?', Id, (error, result) => if (error) throw error; response.send ('Utente eliminato.'););); Possiamo usare -X di nuovo con cURL per inviare l'eliminazione tramite. Eliminiamo l'ultimo utente che abbiamo creato.
curl -X DELETE http: // localhost: 3002 / users / 3
Vedrai il messaggio di successo.
Utente eliminato.
Navigare verso http: // localhost: 3002, e vedrai che ora ci sono solo due utenti.
Congratulazioni! A questo punto, l'API è completa. Visita il repository GitHub per vedere il codice completo per routes.js.
richiesta ModuloAll'inizio di questo articolo, abbiamo installato quattro dipendenze e una di queste era la richiesta modulo. Invece di utilizzare le richieste CURL, puoi creare un nuovo file con tutti i dati e inviarlo. Creerò un file chiamato post.js che creerà un nuovo utente tramite INVIARE.
const request = require ('richiesta'); const json = "name": "Dinesh Chugtai", "email": "[email protected]",; request.post (url: 'http: // localhost: 3002 / users', corpo: json, json: true,, function (error, response, body) console.log (body);); Possiamo chiamare questo usando nodo post.js in una nuova finestra di terminale mentre il server è in esecuzione e avrà lo stesso effetto dell'uso di cURL. Se qualcosa non funziona con cURL, il richiesta il modulo è utile in quanto possiamo visualizzare l'errore, la risposta e il corpo.
Generalmente, INVIARE e altri metodi HTTP che alterano lo stato del server vengono inviati utilizzando i moduli HTML. In questo esempio molto semplice, possiamo creare un index.html file ovunque, e creare un campo per un nome e un indirizzo e-mail. L'azione del modulo punta alla risorsa, in questo caso http // localhost: 3002 / utenti, e specificheremo il metodo come inviare.
Creare index.html e aggiungere il seguente codice ad esso:
API REST Node.js Express
Aprire questo file HTML statico nel browser, compilarlo e inviarlo mentre il server è in esecuzione nel terminale. Dovresti vedere la risposta di Utente aggiunto con ID: 4, e dovresti essere in grado di visualizzare il nuovo elenco di utenti.
In questo tutorial, abbiamo imparato come collegare un server Express a un database MySQL e impostare percorsi corrispondenti a OTTENERE, INVIARE, METTERE, e ELIMINA metodi per percorsi e parametri di percorso dinamici. Abbiamo anche imparato come inviare richieste HTTP a un server API utilizzando cURL, il Node.js richiesta modulo e moduli HTML.
A questo punto, dovresti avere una buona conoscenza di come funzionano le API RESTful e ora puoi creare la tua API completa in Node.js con Express e MySQL!
