Jak tworzyć trasy po stronie serwera w węźle.JS

Rozgromienie to proces używany po stronie serwera do odpowiedzi na żądania klientów. Definiuje punkt końcowy (URI) Na zapleczu utworzonej aplikacji. Możemy również zdefiniować routing jako „wyrazić”Obiekty aplikacyjne używane do odpowiadania metodom HTTP. Twoje zgłoszenie "słucha„Żądania pasujące do dostarczonej metody lub tras, a następnie wywołuje określoną funkcję wywołania zwrotnego, gdy ją znajdzie.

Ten zapis pokaże, jak utworzyć trasy po stronie serwera w węźle.JS. Ponadto zapewniona zostanie również procedura tworzenia punktów końcowych API na podstawie operacji CRUD. A więc zacznijmy!

Jak tworzyć trasy po stronie serwera w węźle.JS

Utworzyliśmy już prostą aplikację systemu zarządzania pracownikami z React.JS Front End, węzeł.serwer JS i zbudował połączenie między serwerem a bazą danych MongoDB. Po tym dodaliśmy dwa modele: „pracownik.Model" I "Przeznaczenie.Model„Z ich powiązanym schematem. Teraz utworzymy niektóre trasy do prezentacji informacji modeli z bazy danych MongoDB za pomocą „Mangusta" biblioteka.

Następnym krokiem jest dodanie tras API, aby wykorzystać je do wykonywania operacji CRUD. Stworzymy „Przeznaczenie”I„pracownik„Trasa demonstracji. Aby to zrobić, po pierwsze, stworzymy nowy „trasa„Folder po stronie serwera:

Nazwimy nowo utworzony folder jako „trasy”:

Następnie kliknij „trasy”Folder i wybierz„Nowy plik„Opcja tworzenia„pracownik.JS„Plik trasy:

Korzystając z tej samej metody, utworzymy inny plik trasy, „Przeznaczenie.JS„W folderze tras:

Jak widać, utworzyliśmy plik dwóch tras, „pracownik.JS" I "Przeznaczenie.plik" w "trasy" teczka:

W terminalu wykonaj następujące polecenie do konfigurowania React Router Ponieważ jest to standardowa biblioteka, której można użyć do routingu:

> NPM instaluj react-router-dom

Po zrobieniu tego dodaj następujący wiersz w swoim projekcie „App.JS" plik:

import Browserrouter jako router, trasa z „React-routeter-Dom”;

W następnym kroku otwórz „pracownik.JS„AD File AD Dodaj w nim kod poniżej:

W tym kodzie dodaliśmy dwa punkty końcowe. Pierwszy punkt końcowy poradzi sobie z przychodzącym HTTP „DOSTAWAĆ”Prośby o„/pracownicy/„Ścieżka URL. Następnie „Pracownik.znajdować()„Metoda jest wywoływana w celu uzyskania listy pracowników z bazy danych MongoDB. Ta metoda znalezienia () zwróci obietnicę, a wynik zostanie zwrócony w formacie JSON.

Drugi punkt końcowy, który dodaliśmy w naszym „pracownik„Plik trasy, obsługa przychodzącego HTTP”POST”Prośby na ścieżce„/Pracownicy/Add/URL. Nowa nazwa pracownika zostanie uznana za część wniosku. Po otrzymaniu nowej nazwy pracownika zostanie utworzona nowa instancja pracownika, a następnie funkcja „Save ()” zapisuje nowy rekord pracownika w bazie danych MongoDB. Jeśli określona operacja zostanie zakończona pomyślnie, to „Dodano pracownik!„Ciąg zostanie zwrócony:

const router = wymaga („express”).Router ();
Niech pracownik = wymaga („… /modele /pracownik.Model');
router.trasa('/').get ((req, res) =>
Pracownik.znajdować()
.Następnie (pracownicy => res.JSON (pracownicy))
.Catch (err => res.Status (400).JSON („błąd:” + err));
);
router.trasa ('/add').post ((req, res) =>
const zatrudniona = req.ciało.imię i nazwisko pracownika;
cont newEmployee = nowy pracownik (auctioneename);
nowy pracownik.ratować()
.następnie (() => res.JSON („Dodano pracownik!'))
.Catch (err => res.Status (400).JSON („błąd:” + err));
);
moduł.Eksport = router;

Następnie otwórz „Przeznaczenie.JS„Plik do tworzenia tras oznaczeń:

Po pierwsze, dodamy te same punkty końcowe, które dodaliśmy w „pracownicy.JS”Plik tras. Jednak tym razem złamiemy wszystkie trzy pola „imię i nazwisko pracownika”,„Przeznaczenie", I "data”Z przesłanych danych:

const router = wymaga („express”).Router ();
Niech oznaczenie = wymaga ('… /modele /oznaczenie.Model');
router.trasa('/').get ((req, res) =>
Przeznaczenie.znajdować()
.Następnie (oznaczenia => res.JSON (oznaczenia))
.Catch (err => res.Status (400).JSON („błąd:” + err));
);
router.trasa ('/add').post ((req, res) =>
const zatrudniona = req.ciało.imię i nazwisko pracownika
Oznaczenie conster = req.ciało.Przeznaczenie;
data const = data.Parse (req.ciało.data);
const newDesignation = nowe oznaczenie (
imię i nazwisko pracownika,
Przeznaczenie,
data,
);
NOWOŚĆ.ratować()
.następnie (() => res.JSON („Dodano oznaczenie!'))
.Catch (err => res.Status (400).JSON („błąd:” + err));
);
moduł.Eksport = router;

Wcześniej dodane punkty końcowe można wykorzystać do czytania i tworzenia elementów oznaczenia. Teraz utworzymy dwie trasy dla pozostałych operacji CRUD, które są „”aktualizacja" I "usuwać".

W poniższym kodzie „/:ID„Pobierz punkt końcowy zwróci element oznaczenia, który będzie miał określony element i zostanie usunięty za pomocą„usuwać()”Funkcja. „„/aktualizacja/: identyfikator”Post Endpoint zaktualizuje istniejące elementy oznaczenia. W przypadku punktu końcowego aktualizacji, po pierwsze, odzyskamy istniejący element oznaczenia z bazy danych MongoDB na podstawie określonego identyfikatora. Po tym ustawiamy wartości właściwości oznaczenia, takie jak „imię i nazwisko pracownika”,„Przeznaczenie", I "data„Do wartości otrzymanych w ciele żądania. Na koniec nazwiemy „Przeznaczenie.ratować()„Metoda zapisywania zaktualizowanego obiektu oznaczenia w naszej bazie danych:

router.trasa ('/: id').get ((req, res) =>
Przeznaczenie.FindById (req.Params.ID)
.Następnie (oznaczenie => res.JSON (oznaczenie))
.Catch (err => res.Status (400).JSON („błąd:” + err));
);
router.trasa ('/: id').delete ((req, res) =>
Przeznaczenie.FindByIdandDelete (req.Params.ID)
.następnie (() => res.JSON („Oznaczenie usunięte.'))
.Catch (err => res.Status (400).JSON („błąd:” + err));
);
router.trasa ('/aktualizacja/: id').post ((req, res) =>
Przeznaczenie.FindById (req.Params.ID)
.Następnie (oznaczenie =>
Przeznaczenie.AuctionEename = req.ciało.imię i nazwisko pracownika;
Przeznaczenie.Oznaczenie = req.ciało.Przeznaczenie;
Przeznaczenie.Data = data.Parse (req.ciało.data);
Przeznaczenie.ratować()
.następnie (() => res.JSON („Zaktualizowano oznaczenie!'))
.Catch (err => res.Status (400).JSON („błąd:” + err));
)
.Catch (err => res.Status (400).JSON („błąd:” + err));
);

Teraz powiedzmy węzeł.serwer JS do korzystania z tras, które utworzyliśmy w folderze „trasy”. Aby to zrobić, otworzymy „serwer.JS ”plik JavaScript naszego serwera:

W ten sposób nasz „serwer.JS„Plik wygląda w tym momencie:

Kod, który zamierzasz dodać, powinien zostać umieszczony przed „App.Słuchaj (port, funkcja () " linia:

Teraz dodaj następujący kod w podświetlonej sekcji:

const designationsRouter = wymaga ('./trasy/oznaczenia ');
const EmployersRouter = wymaga ('./trasy/pracownicy);
App.Użyj („/oznaczenia”, określenieroutter);
App.Użyj („/pracownicy”, pracownicy);

Pierwsze dwa wiersze w powyższym kodzie załadują router z „oznaczenia" I "pracownicy”Pliki, które utworzyliśmy w„Folder tras,”A następnie routery są zdefiniowane jako oprogramowanie pośrednie:

Naciskać "Ctrl+s”Aby zapisać dodane zmiany w węźle.plik po stronie serwera JS:

Po utworzeniu tras po stronie serwera w węźle.JS, możesz je przetestować przy użyciu dowolnej aplikacji testowania API, takiego jak Listonen i Bezsenność.

Wniosek

Proces, w którym żądania klienta są przetwarzane przez serwer Węzonu.JS jest definiowany jako routing. Podczas routingu trasa to sekcja „wyrazić”Kod, który łączy żądania HTTP, takie jak post, Get, Usuń i umieszcza wzór URL lub ścieżkę, a następnie dodaje funkcję obsługi wzoru. Ten zapis wykazał, jak utworzyć trasy po stronie serwera w węźle.JS. Ponadto zapewniona jest również procedura tworzenia punktów końcowych API na podstawie operacji CRUD.