de Scott Domes

Construiti un API Nodejs in mai putin de 30 de

Construiți un API Node.js în mai puțin de 30 de minute

Node.js poate fi intimidant pentru începători. Dar structura sa flexibilă și lipsa unor linii directoare stricte îl fac să pară mai complicat decât este.

Acest tutorial este un ghid simplu și rapid pentru Node.js, cadrul Express și MongoDB, concentrându-se pe rutele REST fundamentale și interacțiunea de bază a bazei de date. Veți construi o boilerplate API simplă, care poate fi apoi utilizată ca bază pentru orice aplicație.

Cui este destinat acest tutorial: Ar trebui să aveți o înțelegere de bază a API-urilor REST și a operațiunilor CRUD, plus cunoștințe de bază JavaScript. Folosesc ES6 (în principal funcții săgeată grăsime), dar nimic prea complex.

Pentru acest tutorial, veți crea scheletul unui back-end pentru o aplicație de luare a notelor – gândiți-vă Google Keep. Doriți să puteți efectua toate cele patru acțiuni CRUD pe note: creați, citiți, actualizați și ștergeți.

Configurare

Dacă nu aveți Node instalat, Vezi aici.

Într-un nou director, rulați npm init și urmați instrucțiunile, oferind aplicației numele „notabil” (sau orice altceva ați putea dori).

npm init

Odată ce ați terminat, ar trebui să aveți un pachet.json gata de acces în directorul dvs. Aceasta înseamnă că puteți începe să instalați dependențele de care aveți nevoie pentru proiectul dvs.

Veți folosi Express ca framework, MongoDB ca bază de date și un pachet numit body-parser pentru a ajuta la rezolvarea cererilor JSON.

npm install --save express mongodb@2.2.16 body-parser

De asemenea, recomand cu tărie instalarea Nodemon ca dependență de dev. Este un mic pachet simplu care repornește automat serverul atunci când fișierele se schimbă.

Dacă alergi:

npm install --save-dev nodemon

Apoi puteți adăuga următorul script la pachet.json:

// package.json
  "scripts": {    "dev": "nodemon server.js"  },

Completa ta pachet.json ar trebui să arate așa:

// package.json
{  "name": "notable",  "version": "1.0.0",  "description": "",  "main": "server.js",  "scripts": {    "dev": "nodemon server.js"  },  "author": "",  "license": "ISC",  "dependencies": {    "body-parser": "^1.15.2",    "express": "^4.14.0",    "mongodb": "^2.2.16"  },  "devDependencies": {    "nodemon": "^1.11.0"  }}

Acum puteți să creați server.js fişier și începeți să vă construiți API-ul.

Serverul nostru

Să începem prin a solicita toate dependențele dvs. în server.js.

// server.js
const express        = require('express');const MongoClient    = require('mongodb').MongoClient;const bodyParser     = require('body-parser');
const app            = express();

Veți folosi MongoClient pentru a interacționa cu baza de date. Rețineți că, de asemenea, inițializați aplicația ca instanță a Express, cadrul dvs.

Ultimul lucru pe care trebuie să-l faceți pentru ca serverul dvs. să funcționeze este să spuneți aplicației dvs. să înceapă ascultare pentru solicitări HTTP.

Puteți specifica un port și puteți începe ascultarea astfel:

// server.js
const port = 8000;
app.listen(port, () => {  console.log('We are live on ' + port);});

Acum dacă alergi npm run dev (sau nod server.js dacă nu ați instalat Nodemon) ar trebui să vedeți „Suntem live pe portul 8000” în terminal.

Serverul dvs. este live. Dar nu face mult. Sau orice, într-adevăr.

Să remediem asta.

Rute CRUDdy

Pentru acest exemplu, doriți să construiți 4 rute; să CREAȚI o notă, să CITIȚI notele dvs., să ACTUALIZAȚI o notă și să ȘTERGEȚI o notă.

Acest lucru vă va oferi o idee bună despre cum să structurați aproape orice traseu de bază cu Node.

Pentru a vă testa API-ul, totuși, trebuie să imitați partea clientului care face cereri. Pentru a face acest lucru, veți utiliza o aplicație excelentă numită Poştaş. Vă permite să faceți cereri HTTP simple cu corpuri și parametri personalizați.

Instalați Postman și să începem să vă configurăm rutele.

Super organizat

Majoritatea tutorialelor Node.js (și multe aplicații reale) își pun toate rutele într-un mare routes.js fişier. Acest lucru mă face un pic incomod. În schimb, împărțirea fișierelor în dosare separate duce la o bună lizibilitate și face aplicațiile mari mai ușor de gestionat.

Nu aveți o aplicație mare, dar să facem acest lucru bine. Realizați următoarele directoare: an aplicație folder cu un folder de rute în interiorul acestuia, cu un index.js și a note_routes.js fișier în interiorul acestuia.

Cu alte cuvinte: root> app> routes> index.js și note_routes.js.

mkdir appcd appmkdir routescd routestouch index.jstouch note_routes.js

Aceste directoare pot părea exagerate pentru aplicația dvs. simplă mică, dar este întotdeauna bine să începeți cu cele mai bune practici.

Primul tău traseu

Să începem cu C în CRUD- create. Cum ați crea o notă?

Ei bine, înainte de a face asta, trebuie să construiești ceva mai multă infrastructură. În Express, rutele sunt împachetate într-o funcție, care ia instanța Express și o bază de date ca argumente.

Asa:

// routes/note_routes.js
module.exports = function(app, db) {
};

Puteți exporta această funcție prin intermediul index.js:

// routes/index.js
const noteRoutes = require('./note_routes');
module.exports = function(app, db) {  noteRoutes(app, db);  // Other route groups could go here, in the future};

Apoi importați-l pentru utilizare în server.js:

// server.js
const express        = require('express');const MongoClient    = require('mongodb').MongoClient;const bodyParser     = require('body-parser');
const app            = express();
const port = 8000;
require('./app/routes')(app, {});app.listen(port, () => {  console.log('We are live on ' + port);});

Rețineți că, deoarece nu aveți încă o bază de date configurată, treceți doar într-un obiect gol.

Bine, acum îți poți face traseul CREATE.

Sintaxa este simplă:

// note_routes.js
module.exports = function(app, db) {  app.post('/notes', (req, res) => {    // You'll create your note here.    res.send('Hello')  });};

Când aplicația primește un post cerere către calea „/ notes”, va executa codul în interiorul apelului invers – trecând într-un obiect de cerere (care conține parametrii sau JSON al cererii) și un obiect de răspuns (folosit pentru a răspunde).

Puteți testa acest lucru folosind Postman pentru a trimite o cerere POST către localhost: 8000 / note.

1612117149 928 Construiti un API Nodejs in mai putin de 30 de
Ar trebui să obțineți „Bună ziua” înapoi.

Grozav! Ti-ai creat primul traseu real.

Următorul pas este să adăugați câțiva parametri la solicitarea dvs. și să îi procesați în API-ul dvs. și, în cele din urmă, să adăugați în baza de date.

Solicitați parametrii

În Postman, accesați fila Corp și adăugați câteva perechi cheie-valoare, după ce ați selectat x-www-form-urlencoded buton de radio.

Aceasta va adăuga date de formular codate la cererea dvs., pe care le veți putea procesa cu API-ul dvs.

1612117149 94 Construiti un API Nodejs in mai putin de 30 de
Poți încerca să fii mai creativ decât mine.

Acum în note_routes.js, să ne deconectăm doar de pe corp.

// note_routes.js
module.exports = function(app, db) {  app.post('/notes', (req, res) => {    console.log(req.body)    res.send('Hello')  });};

Încercați să trimiteți cererea Postman și veți vedea … nedefinit.

Din păcate, Express nu poate procesa de la sine formularele codificate URL. Dar ați instalat acel pachet body-parser …

// server.
const express        = require('express');const MongoClient    = require('mongodb').MongoClient;const bodyParser     = require('body-parser');
const app            = express();
const port = 8000;
app.use(bodyParser.urlencoded({ extended: true }));
require('./app/routes')(app, {});app.listen(port, () => {  console.log('We are live on ' + port);});

Acum ar trebui să vedeți corpul ca un obiect în terminal.

{ title: 'My Note Title', body: 'What a great note.' }

Ultimul pas către ruta preliminară: configurați baza de date, apoi adăugați datele în.

Cel mai simplu mod de a configura o bază de date Mongo este prin mLab: este gratuit pentru cea mai mică dimensiune și este destul de rapid de configurat.

După ce creați un cont și o implementare MongoDB, adăugați un utilizator la baza de date cu un nume de utilizator și o parolă:

1612117150 598 Construiti un API Nodejs in mai putin de 30 de

apoi apucați adresa URL aici (a doua):

1612117150 713 Construiti un API Nodejs in mai putin de 30 de

Și într-un director de configurare din rădăcina proiectului dvs., creați un fișier db.js.

mkdir config cd configtouch db.js

În interior, adăugați adresa URL:

module.exports = {  url : YOUR URL HERE};

Nu uitați să adăugați numele de utilizator și parola (cele de la utilizatorul bazei de date, nu contul dvs. mLab) în adresa URL. (Dacă trimiteți acest proiect către Github, asigurați-vă că includeți un fișier .gitignore ca astfel, astfel încât să nu împărtășiți parola tuturor.)

Acum în server.js, puteți utiliza MongoClient pentru a vă conecta la DB și utilizați acest lucru pentru a încheia configurarea aplicației:

// server.js
const express        = require('express');const MongoClient    = require('mongodb').MongoClient;const bodyParser     = require('body-parser');const db             = require('./config/db');
const app            = express();
const port = 8000;
app.use(bodyParser.urlencoded({ extended: true }));
MongoClient.connect(db.url, (err, database) => {  if (err) return console.log(err)  require('./app/routes')(app, database);
  app.listen(port, () => {    console.log('We are live on ' + port);  });               })

Dacă utilizați cea mai recentă versiune a MongoDB (3.0+), modificați-o astfel:

// server.js
const express        = require('express');const MongoClient    = require('mongodb').MongoClient;const bodyParser     = require('body-parser');const db             = require('./config/db');
const app            = express();
const port = 8000;
app.use(bodyParser.urlencoded({ extended: true }));
MongoClient.connect(db.url, (err, database) => {  if (err) return console.log(err)                        // Make sure you add the database name and not the collection name  const database = database.db("note-api")  require('./app/routes')(app, database);
  app.listen(port, () => {    console.log('We are live on ' + port);  });               })

(Mulțumită Alex Stroulger pentru remedierea pentru 3.0)

Aceasta este ultima configurare a infrastructurii dvs.! Totul este construirea traseelor ​​de aici.

Adăugarea la baza de date

MongoDB stochează date în colecții– care sunt exact cum sună. În cazul dvs., doriți să vă stocați notele într-o colecție numită – ați ghicit – note.

Deoarece treceți în baza de date ca fișier db argument în rutele dvs., îl puteți accesa astfel:

db.collection('notes')

Crearea unei note este la fel de simplă ca apelarea introduce pe colecția ta:

const note = { text: req.body.body, title: req.body.title}  db.collection('notes').insert(note, (err, results) => {}

După ce inserarea este completă (sau a eșuat din orice motiv), doriți fie să trimiteți înapoi o eroare, fie să trimiteți înapoi obiectul de notă nou creat. Iată completul note_routes.js:

// note_routes.js
module.exports = function(app, db) {  const collection =   app.post('/notes', (req, res) => {    const note = { text: req.body.body, title: req.body.title };    db.collection('notes').insert(note, (err, result) => {      if (err) {         res.send({ 'error': 'An error has occurred' });       } else {        res.send(result.ops[0]);      }    });  });};

Încearcă! Trimiteți o cerere POST x-www-form-urlencoded cu Postman, cu un titlu și corp setat sub fila Corp.

Răspunsul ar trebui să arate astfel:

1612117150 694 Construiti un API Nodejs in mai putin de 30 de

Dacă vă conectați la mLab, ar trebui să vedeți și nota creată în baza de date.

Traseul dvs. CITIȚI

Acum puteți ridica puțin ritmul.

Spuneți că ați dorit să recuperați nota pe care tocmai ați creat-o, navigând la localhost: 8000 / notes / {the id}. În acest caz, ar fi localhost: 8000 / notes / 585182bd42ac5b07a9755ea3.

(Dacă nu aveți ID-ul pentru una dintre notele dvs., puteți verifica mLab sau pur și simplu creați unul nou).

Iată cum ar arăta acest lucru note_routes.js:

// note_routes.js
module.exports = function(app, db) {  app.get('/notes/:id', (req, res) => {      });
  app.post('/notes', (req, res) => {    const note = { text: req.body.body, title: req.body.title };    db.collection('notes').insert(note, (err, result) => {      if (err) {         res.send({ 'error': 'An error has occurred' });       } else {        res.send(result.ops[0]);      }    });  });};

La fel ca înainte, veți apela o metodă în baza de date colectată de note. Aici, este numitul potrivit findOne.

// note_routes.js
module.exports = function(app, db) {  app.get('/notes/:id', (req, res) => {    const details = { '_id': <ID GOES HERE> };    db.collection('notes').findOne(details, (err, item) => {      if (err) {        res.send({'error':'An error has occurred'});      } else {        res.send(item);      }    });  });
app.post('/notes', (req, res) => {    const note = { text: req.body.body, title: req.body.title };    db.collection('notes').insert(note, (err, result) => {      if (err) {         res.send({ 'error': 'An error has occurred' });       } else {        res.send(result.ops[0]);      }    });  });};

Puteți prelua ID-ul din parametrii URL prin req.params.id. Cu toate acestea, dacă încercați să introduceți șirul în <> de mai sus, nu va funcționa.

MongoDB necesită nu doar un ID ca fișier şir, dar ca un ID obiect sau, așa cum o numesc ei, un ObjectID.

Nu vă faceți griji, este o soluție ușoară. Iată codul complet:

// note_routes.js
var ObjectID = require('mongodb').ObjectID;
module.exports = function(app, db) {  app.get('/notes/:id', (req, res) => {    const id = req.params.id;    const details = { '_id': new ObjectID(id) };    db.collection('notes').findOne(details, (err, item) => {      if (err) {        res.send({'error':'An error has occurred'});      } else {        res.send(item);      }     });  });
app.post('/notes', (req, res) => {    const note = { text: req.body.body, title: req.body.title };    db.collection('notes').insert(note, (err, result) => {      if (err) {         res.send({ 'error': 'An error has occurred' });       } else {        res.send(result.ops[0]);      }    });  });};

Încercați-l cu unul dintre ID-urile dvs. de notă și ar trebui să arate astfel:

1612117150 983 Construiti un API Nodejs in mai putin de 30 de

Traseul tău ȘTERGERE

Ștergerea unui obiect este de fapt la fel ca și găsirea unui obiect. Pur și simplu folosiți elimina funcție în loc de găsește una. Iată codul complet. Am evidențiat diferitele de GET:

// note_routes.js
// ...
  app.delete('/notes/:id', (req, res) => {    const id = req.params.id;    const details = { '_id': new ObjectID(id) };    db.collection('notes').remove(details, (err, item) => {      if (err) {        res.send({'error':'An error has occurred'});      } else {        res.send('Note ' + id + ' deleted!');      }     });  });
// ...

Traseul dvs. de ACTUALIZARE

Ultimul! PUT este practic un hibrid între CITITI și CREATĂ. Găsiți obiectul, apoi îl actualizați în consecință. Dacă ați șters singura dvs. notă, este timpul să faceți alta!

Codul:

// note_routes.js
// ...
  app.put('/notes/:id', (req, res) => {    const id = req.params.id;    const details = { '_id': new ObjectID(id) };    const note = { text: req.body.body, title: req.body.title };    db.collection('notes').update(details, note, (err, result) =&gt; {      if (err) {          res.send({'error':'An error has occurred'});      } else {          res.send(note);      }     });  });
// ...

Acum puteți actualiza oricare dintre notele dvs., astfel:

1612117151 460 Construiti un API Nodejs in mai putin de 30 de

Rețineți imperfecțiunea cu acest cod – dacă nu furnizați un corp sau un titlu, cererea PUT va anula acele câmpuri din nota din baza de date.

Puteți adăuga cu ușurință o logică condițională pentru a actualiza câmpurile numai dacă acestea sunt prezente în cerere – am lăsat asta doar ca să fie simplă.

API completat

Asta este! Aveți un API Node funcțional cu fiecare dintre cele patru operațiuni majore CRUD.

Scopul acestui tutorial a fost de a vă oferi un anumit grad de familiaritate cu Express, Node și MongoDB – puteți utiliza aplicația simplă ca platformă de lansare pentru proiecte mai complexe.

În viitor, voi scrie tutoriale pentru a crea API-uri mai simple în diferite limbi și cadre. Dacă sunteți interesat, apăsați butonul de urmărire!

Dacă acest tutorial v-a fost de ajutor, vă rugăm să loviți inima verde de mai jos – înseamnă foarte mult. Nu ezitați să-mi lăsați un comentariu cu orice feedback sau întrebări.

Mulțumesc pentru lectură!