Come creare percorsi sul lato server nel nodo.js

Routing è il processo utilizzato sul lato server per rispondere alle richieste del client. Definisce l'endpoint (URI) al back -end dell'applicazione creata. Possiamo anche definire il routing come "esprimere"Oggetti dell'applicazione utilizzati per corrispondere ai metodi HTTP. La tua applicazione "ascolta"Le richieste che corrispondono al metodo o alle rotte fornite, quindi chiama la funzione di callback specificata quando ne trova una.

Questo articolo dimostrerà come creare i percorsi sul lato server in nodo.js. Inoltre, verrà fornita anche la procedura per la creazione di endpoint API in base alle operazioni CRUD. Quindi iniziamo!

Come creare percorsi sul lato server nel nodo.js

Abbiamo già creato una semplice applicazione del sistema di gestione dei dipendenti con la reazione.JS front -end, nodo.server JS e creato una connessione tra il server e il database MongoDB. Dopo averlo fatto, abbiamo aggiunto due modelli: "dipendente.modello" E "designazione.modello"Con il loro schema correlato. Ora creeremo alcuni percorsi per presentare le informazioni dei modelli dal database MongoDB utilizzando "Mangusta" biblioteca.

Il prossimo passo è aggiungere i percorsi API per utilizzarli per eseguire le operazioni CRUD. Creeremo un "designazione" e un "dipendente"Percorso per dimostrazione. Per farlo, in primo luogo, creeremo un nuovo "itinerario"Cartella sul lato server:

Nomineremo la cartella appena creata come "itinerari":

Quindi, fai clic su "itinerari"Cartella e selezionare il"Nuovo file"Opzione per la creazione di un"dipendente.js"File di rotta:

Utilizzando lo stesso metodo, creeremo un altro file di rotta, "designazione.js"Nella cartella dei percorsi:

Come puoi vedere, abbiamo creato due file percorsi, "dipendente.js" E "designazione.file" nel "itinerari" cartella:

Nel terminale, eseguire il seguente comando per l'impostazione del React router Poiché è la libreria standard che può essere utilizzata per il routing:

> NPM Installa React-Router-Dom

Dopo averlo fatto, aggiungi la seguente riga nel tuo progetto "App.js" file:

import browserrouter come router, percorso da "react-router-dom";

Nel passaggio successivo, apri il "dipendente.js"File AD aggiungi il codice di seguito donati in esso:

In questo codice, abbiamo aggiunto due endpoint. Il primo endpoint gestirà l'HTTP in arrivo "OTTENERE"Richieste su"/dipendenti/"Percorso URL. Successivamente, il "Dipendente.Trovare()"Il metodo è richiesto per ottenere l'elenco dei dipendenti dal database MongoDB. Questo metodo find () restituirà una promessa e il risultato verrà restituito in formato JSON.

Il secondo endpoint che abbiamo aggiunto nel nostro "dipendente"File di rotta, gestirà l'HTTP in arrivo"INVIARE"Richieste sul percorso"/dipendenti/aggiungi/url. Il nome del nuovo dipendente verrà considerato come parte della richiesta. Dopo aver ricevuto il nuovo nome del dipendente, verrà creata una nuova istanza del dipendente e quindi la funzione "Save ()" salverà il nuovo record dei dipendenti nel database MongoDB. Se l'operazione specificata viene completata correttamente, allora il "Aggiunto dipendente!"Verrà restituita la stringa:

cost router = requisito ('express').Router ();
Let Employee = Requisite ('... /Models /Employee.modello');
router.itinerario('/').get ((req, res) =>
Dipendente.Trovare()
.Quindi (dipendenti => res.JSON (dipendenti))
.catch (err => res.Stato (400).json ('Errore:' + err));
);
router.route ('/aggiungi').post ((req, res) =>
const Employeename = req.corpo.Nome dipendente;
const newmployee = new Employee (Employeename);
nuovo impiegato.salva()
.Quindi (() => res.JSON ("dipendente aggiunto!'))
.catch (err => res.Stato (400).json ('Errore:' + err));
);
modulo.esportazioni = router;

Successivamente, apri il "designazione.js"File per la creazione delle rotte di designazione:

Ora, in primo luogo, aggiungeremo gli stessi endpoint che abbiamo aggiunto in "dipendenti.js"File percorsi. Tuttavia, questa volta spezzeremo tutti e tre i campi "Nome dipendente","designazione", E "data"Dai dati presentati:

cost router = requisito ('express').Router ();
let designation = requisite ('... /modelli /designazione.modello');
router.itinerario('/').get ((req, res) =>
Designazione.Trovare()
.Quindi (designazioni => res.JSON (designazioni))
.catch (err => res.Stato (400).json ('Errore:' + err));
);
router.route ('/aggiungi').post ((req, res) =>
const Employeename = req.corpo.Nome dipendente
const designation = req.corpo.designazione;
const data = Data.Parse (req.corpo.data);
const newDesignation = new Designation (
Nome dipendente,
designazione,
data,
);
nuova progettazione.salva()
.Quindi (() => res.JSON ('designazione aggiunta!'))
.catch (err => res.Stato (400).json ('Errore:' + err));
);
modulo.esportazioni = router;

Gli endpoint precedentemente aggiunti possono essere utilizzati per la lettura e la creazione degli elementi di designazione. Ora creeremo due percorsi per le restanti operazioni CRUD, che sono "aggiornamento" E "eliminare".

Nel codice di seguito donati "/:id"Ottieni Endpoint restituirà un elemento di designazione che avrà l'elemento specificato e verrà eliminato utilizzando"eliminare()" funzione. IL "/aggiornamento/: id"Post Endpoint aggiornerà gli elementi di designazione esistenti. Per l'endpoint di aggiornamento, in primo luogo, recupereremo l'elemento di designazione esistente dal database MongoDB in base all'ID specificato. Dopo averlo fatto, imposteremo i valori delle proprietà di designazione, come "Nome dipendente","designazione", E "data"Ai valori ricevuti nell'organismo di richiesta. Infine, chiameremo "designazione.salva()"Metodo per salvare l'oggetto di designazione aggiornato nel nostro database:

router.Route ('/: id').get ((req, res) =>
Designazione.FindByID (req.parametri.id)
.Quindi (designazione => res.JSON (designazione))
.catch (err => res.Stato (400).json ('Errore:' + err));
);
router.Route ('/: id').delete ((req, res) =>
Designazione.FindByidandDelete (req.parametri.id)
.Quindi (() => res.JSON ('Designazione Eliminata.'))
.catch (err => res.Stato (400).json ('Errore:' + err));
);
router.route ('/update/: id').post ((req, res) =>
Designazione.FindByID (req.parametri.id)
.Quindi (designation =>
designazione.EmployeEename = req.corpo.Nome dipendente;
designazione.designazione = req.corpo.designazione;
designazione.Data = Data.Parse (req.corpo.data);
designazione.salva()
.Quindi (() => res.JSON ('Designazione aggiornata!'))
.catch (err => res.Stato (400).json ('Errore:' + err));
)
.catch (err => res.Stato (400).json ('Errore:' + err));
);

Ora, diciamo al nodo.server js per utilizzare i percorsi creati nella cartella "percorsi". Per fare ciò, apriremo il "server.JS ”File JavaScript del nostro lato server:

Ecco come il nostro "server.js"Il file sembra a questo punto:

Il codice che stai per aggiungere dovrebbe essere posizionato prima del "app.Ascolta (port, function () " linea:

Ora, aggiungi il seguente codice nella sezione evidenziata:

const designationsRouter = requisite ('./percorsi/designazioni ');
const EmployeperSrouter = Requisito ('./percorsi/dipendenti ');
app.use ('/designations', designationsrouter);
app.utilizzare ('/dipendenti', dipendente);

Le prime due righe nel codice sopra dato caricheranno il router da "designazioni" E "dipendenti"File che abbiamo creato in"cartella percorsi,"E poi i router sono definiti come middleware:

Premere "Ctrl+s"Per salvare le modifiche aggiunte nel nodo.File lato server JS:

Dopo aver creato i percorsi sul lato server in nodo.JS, puoi testarli utilizzando qualsiasi applicazione di test API come Postman e Insomnia.

Conclusione

Il processo in cui le richieste client vengono elaborate dal lato server del nodo.JS è definito come routing. Nel routing, un percorso è una sezione di "esprimere"Codice che collega le richieste HTTP come POST, GET, Elimina e messo su un modello o percorso URL e quindi aggiunge una funzione per gestire il modello. Questo articolo ha dimostrato come creare i percorsi sul lato server nel nodo.js. Inoltre, viene fornita anche la procedura per la creazione di endpoint API in base alle operazioni CRUD.