Share
Nel precedente tutorial, abbiamo appreso quale sia l'architettura REST, i sei vincoli guida di REST, come comprendere i metodi di richiesta HTTP ei relativi codici di risposta e l'anatomia di un endpoint RESTful API.
In questo tutorial, configureremo un server in cui vivere la nostra API. Puoi costruire un'API con qualsiasi linguaggio di programmazione e software server, ma useremo Node.js, che è l'implementazione back-end di JavaScript, e Express, un framework popolare e minimo per Node.
Il nostro primo prerequisito è assicurarsi che Node.js e npm siano installati globalmente sul computer. Possiamo testare entrambi usando il -v flag, che mostrerà la versione. Aprire il prompt dei comandi e digitare quanto segue.
nodo -v && npm -v
v10.8.0 6.2.0
Le tue versioni potrebbero essere leggermente diverse dalle mie, ma finché ci sono entrambe, possiamo iniziare.
Creiamo una directory di progetto chiamata Express-api e passare ad esso.
mkdir express-api && cd express-api
Ora che siamo nella nostra nuova directory, possiamo inizializzare il nostro progetto con il comando init.
npm init
Questo comando ti chiederà di rispondere ad alcune domande sul progetto, che puoi scegliere di compilare o meno. Una volta completata la configurazione, avrai a package.json file che assomiglia a questo:
"name": "express-api", "version": "1.0.0", "description": "Node.js e Express REST API", "main": "index.js", "scripts": "test": "echo \" Errore: nessun test specificato \ "&& exit 1", "author": "Tania Rascia", "license": "MIT"
Ora che abbiamo il nostro package.json, possiamo installare le dipendenze richieste per il nostro progetto. Fortunatamente non abbiamo bisogno di troppe dipendenze, solo queste quattro elencate di seguito.
Useremo il installare comando seguito da ciascuna dipendenza per terminare la configurazione del nostro progetto.
npm install body-parser express richiesta mysql
Questo creerà a package-lock.json file e a node_modules directory, e il nostro package.json sarà aggiornato per assomigliare a qualcosa del genere:
"name": "express-api", "version": "1.0.0", "description": "Node.js e Express REST API", "main": "index.js", "scripts": "test": "echo \" Errore: nessun test specificato \ "&& exit 1", "autore": "Tania Rascia", "licenza": "MIT", "dipendenze": "dipendenze": "corpo -parser ":" ^ 1.18.3 "," express ":" ^ 4.16.3 "," mysql ":" ^ 2.16.0 "," request ":" ^ 2.88.0 "
Prima di iniziare a configurare un server Express, configureremo rapidamente un server HTTP con il built-in del Node http modulo, per avere un'idea di come funziona un semplice server.
Crea un file chiamato ciao-server.js. Caricare nel http modulo, impostare un numero di porta (ho scelto 3001) e creare il server con createServer () metodo.
Accentsconagua
// Crea un server con il modulo HTTP del nodo const http = require ('http'); const port = 3001; const server = http.createServer (); Nell'articolo introduttivo di REST, abbiamo discusso quali richieste e risposte riguardano un server HTTP. Imposteremo il nostro server per gestire una richiesta e mostreremo l'URL richiesto sul lato server e mostreremo a Ciao, server! messaggio al cliente dal lato della risposta.
server ** on ('request' ** (request, response) => console.log ('URL: $ request.url'); response.end ('Hello, server!')) Infine, diremo al server su quale porta ascoltare e visualizzerà un errore se ce n'è uno.
// Avvia il server server.listen (porta, (errore) => if (errore) return console.log ('Errore: $ error'); console.log ('Il server sta ascoltando sulla porta $ porta ')) Ora, possiamo avviare il nostro server con nodo seguito dal nome del file.
nodo hello-server.js
Vedrai questa risposta nel terminale:
Il server è in ascolto sulla porta 3001
Per verificare che il server sia effettivamente in esecuzione, andare a http: // localhost: 3001 / nella barra degli indirizzi del browser. Se tutto funziona correttamente, dovresti vedere Ciao, server! sulla pagina. Nel tuo terminale, vedrai anche gli URL che sono stati richiesti.
URL: / URL: /favicon.ico
Se dovessi navigare http: // localhost: 3001 / ciao, vedresti URL: / ciao.
Possiamo anche usare cURL sul nostro server locale, che ci mostrerà le intestazioni e il corpo esatti che vengono restituiti.
curl -i http: // localhost: 3001
HTTP / 1.1 200 OK Data: Mercoledì, 15 agosto 2018 22:14:23 Connessione GMT: keep-alive Content-Length: 14 Hello, server!
Se chiudi la finestra del terminale in qualsiasi momento, il server andrà via.
Ora che abbiamo un'idea di come il server, la richiesta e la risposta funzionano tutti insieme, possiamo riscriverlo in Express, che ha un'interfaccia ancora più semplice e funzionalità estese.
Creeremo un nuovo file, app.js, che sarà il punto di ingresso al nostro progetto attuale. Proprio come con il server http originale, avremo bisogno di un modulo e di una porta da avviare.
Creare un app.js file e inserire il seguente codice in esso.
// Richiede pacchetti e imposta la porta const express = require ('express'); const port = 3002; const app = express (); Ora, invece di cercare tutte le richieste, dichiareremo esplicitamente che stiamo cercando un OTTENERE richiesta sulla radice del server (/). quando / riceve una richiesta, mostreremo l'URL richiesto e "Hello, Server!" Messaggio.
app.get ('/', (request, response) => console.log ('URL: $ request.url'); response.send ('Hello, Server!');); Infine, avvieremo il server sulla porta 3002 con il ascolta() metodo.
// Avvia il server const server = app.listen (port, (error) => if (error) return console.log ('Errore: $ error'); console.log ('Server listening on port $ server.address (). port ');); Possiamo avviare il server con nodo app.js come abbiamo fatto prima, ma possiamo anche modificare il script proprietà nel nostro package.json file per eseguire automaticamente questo comando specifico.
"script": "start": "nodo app.js",
Ora possiamo usare inizio di npm per avviare il server, e vedremo il nostro messaggio del server nel terminale.
Ascolto del server sulla porta 3002
Se eseguiamo a arricciatura -i sull'URL, vedremo che è alimentato da Express ora e ci sono alcune intestazioni aggiuntive come Tipo di contenuto.
curl -i http: // localhost: 3002
HTTP / 1.1 200 OK X-Powered-By: Express Content-Type: text / html; charset = utf-8 Content-Length: 14 ETag: W / "e-gaHDsc0MZK + LfDiTM4ruVL4pUqI" Data: Mercoledì, 15 agosto 2018 22:38:45 Connessione GMT: keep-alive Hello, Server!
Al fine di affrontare facilmente INVIARE e METTERE richiede alla nostra API, aggiungeremo il middleware di analisi del corpo. Questo è dove il nostro corpo-parser il modulo entra. corpo-parser estrarrà l'intero corpo di una richiesta in arrivo e la analizzerà in un oggetto JSON con cui possiamo lavorare.
Richiediamo semplicemente il modulo nella parte superiore del nostro file. Aggiungi il seguente richiedere dichiarazione in cima alla tua app.js file.
const bodyParser = require ('body-parser'); ... Quindi diremo alla nostra app Express di usarla corpo-parser, e cerca JSON.
// Usa Node.js body parsing middleware app.use (bodyParser.json ()); app.use (bodyParser.urlencoded (extended: true,));
Inoltre, cambiamo il nostro messaggio per inviare un oggetto JSON come risposta anziché come testo normale.
response.send (messaggio: 'Node.js e Express REST API');
Di seguito è il nostro pieno app.json file così com'è ora.
// Richiede pacchetti e imposta la porta const express = require ('express'); const port = 3002; const bodyParser = require ('body-parser'); const app = express (); // Usa Node.js body parsing middleware app.use (bodyParser.json ()); app.use (bodyParser.urlencoded (extended: true,)); app.get ('/', (request, response) => response.send (message: 'Node.js e Express REST API');); // Avvia il server const server = app.listen (port, (error) => if (error) return console.log ('Errore: $ error'); console.log ('Server listening on port $ server.address (). port ');); Se si invia un arricciatura -i al server, vedrai che l'intestazione ora ritorna Content-Type: application / json; charset = utf-8.
Finora, abbiamo solo un OTTENERE percorso fino alla radice (/), ma la nostra API dovrebbe essere in grado di gestire tutti e quattro i principali metodi di richiesta HTTP su più URL. Stiamo andando a configurare un router e rendere visibili alcuni dati falsi.
Creiamo una nuova directory chiamata itinerari, e un file all'interno chiamato routes.js. Ci collegheremo ad esso nella parte superiore di app.js.
const routes = require ('./ routes / routes'); Si noti che il .js l'estensione non è necessaria nel fabbisogno. Ora sposteremo la nostra app OTTENERE ascoltatore a routes.js. Inserire il seguente codice in routes.js.
const router = app => app.get ('/', (request, response) => response.send (message: 'Node.js e Express REST API');); Infine, esportare il router quindi possiamo usarlo nel nostro app.js file.
// Esporta il router module.exports = router;
Nel app.js, sostituisci il app.get () codice che avevi prima con una chiamata a itinerari():
percorsi (app);
Ora dovresti essere in grado di andare a http: // localhost: 3002 e vedere la stessa cosa di prima. (Non dimenticare di riavviare il server!)
Una volta che tutto è stato configurato e funzionato correttamente, serviremo alcuni dati JSON con un'altra rotta. Per ora utilizzeremo solo dati falsi, dal momento che il nostro database non è ancora impostato.
Creiamo a utenti variabile in routes.js, con alcuni dati utente falsi in formato JSON.
const users = [id: 1, nome: "Richard Hendricks", email: "[email protected]",, id: 2, nome: "Bertram Gilfoyle", email: "[email protected]", ,];
Aggiungeremo un altro OTTENERE rotta verso il nostro router, / utenti, e inviare i dati dell'utente attraverso.
app.get ('/ users', (request, response) => response.send (users);); Dopo aver riavviato il server, ora puoi navigare verso http: // localhost: 3002 / utenti e vedere tutti i nostri dati visualizzati.
Nota: se non hai un'estensione per visualizzatori JSON sul tuo browser, ti consiglio vivamente di scaricarne uno, come JSONView per Chrome. Ciò renderà i dati molto più facili da leggere!
Visita il nostro GitHub Repo per vedere il codice completato per questo post e confrontarlo con il tuo.
In questo tutorial, abbiamo imparato come configurare un server HTTP integrato e un server Express nel nodo, instradare le richieste e gli URL e utilizzare i dati JSON con le richieste di ottenere.
Nell'ultima parte della serie API RESTful, collegheremo il nostro server Express a MySQL per creare, visualizzare, aggiornare ed eliminare utenti in un database, finalizzando la nostra funzionalità API.
