Node.js to środowisko uruchomieniowe JavaScript o otwartym kodzie źródłowym, zbudowane na silniku v8 chrome, który umożliwia uruchamianie kodu JavaScript poza przeglądarką.
Jego model zdarzeń, ekosystem i szybkość sprawiły, że Node.js jest jednym z najbardziej pożądanych i używanych środowisk wykonawczych dla aplikacji po stronie serwera.
Większość serwerów Node.js API używa Express lub innego frameworka. Możesz jednak również stworzyć proste API Node.js bez frameworka w zaledwie kilku krokach.
Krok 1: Konfiguracja środowiska programistycznego
Utwórz katalog projektu i płyta CD do niego, uruchamiając:
mkdir nodejs-api
płyta CD nodejs-api
Następnie zainicjuj npm w swoim projekcie, uruchamiając:
npm początek -y
Ten interfejs API CRUD będzie wykorzystywał MongoDB, bazę danych NoSQL i jej popularny ODM, mangusta.
Uruchom następujące polecenie, aby zainstalować mangusta:
npm zainstalować mangusta
Następnie utwórz serwer.js plik w katalogu głównym projektu i dodaj poniższy blok kodu, aby utworzyć serwer:
stały http = wymagać("http");
stały server = http.createServer((req, res) => {});
server.listen (3000, () => {
konsola.dziennik(`Serwer działa`);
});
Ten blok kodu importuje moduł http, podstawowy moduł Node.js. Moduł http umożliwia Node.js przesyłanie danych przez HTTP. Ten moduł zawiera metody wymagane do utworzenia serwera.
Następnie wywołuje moduł http utwórzSerwer metoda, która tworzy i zwraca instancję serwera. The utwórzSerwer Metoda przyjmuje funkcję zwrotną z obiektem żądania i odpowiedzi jako parametry.
Następnie kod wywołuje słuchać metody na zwróconej instancji serwera. Pozwala to serwerowi na rozpoczęcie nasłuchiwania ruchu na danym porcie. The słuchać metoda uruchamia wywołanie zwrotne — drugi argument — gdy się powiedzie.
Na koniec utwórz dwa katalogi o nazwie trasy oraz modele w katalogu głównym projektu. The trasy folder będzie zawierał logikę routingu dla twojego API, podczas gdy Model będzie zawierać wszystko, co dotyczy bazy danych.
Krok 2: Łączenie aplikacji z bazą danych
W serwer.js, import mangusta:
stały mangusta = wymagać("mangusta");
Zadzwoń do łączyć metoda włączona mangusta i przekaż swój URI MongoDB jako argument:
mangusta.connect("MongoDB_URI")
Krok 3: Tworzenie modelu API
Utwórz CRUD API dla prostej aplikacji blogowej. W Twoim modele folder, utwórz blogModel.js plik i dodaj następujący kod do swojego pliku:
stały mangusta = wymagać("mangusta");
stały blogSchema = mangusta. Schemat({
tytuł: {
rodzaj: Strunowy,
wymagane: [prawda, "Blog musi mieć tytuł"],
},
ciało: {
rodzaj: Strunowy,
wymagane: [prawda, "Blog musi mieć ciało"],
},
});
moduł.eksport = mongoose.model("Blog", schemat bloga);
Powyższy blok kodu tworzy model mangusty z dwiema właściwościami i mapuje je do bazy danych MongoDB.
Obie właściwości w tym modelu mają Strunowy wpisz z wymagany Ustawić PRAWDA. Towarzyszące komunikaty o błędach zostaną wyświetlone, jeśli treść żądania nie zawiera żadnej z właściwości.
Ostatnia linia tworzy i eksportuje model mangusty, wywołując Model metoda włączona mangusta. Podaj nazwę modelu (Blog) jako pierwszy argument i schemat (blogSchemat) jako drugi argument.
Krok 4: Implementacja routingu w Twojej aplikacji
Bez pomocy frameworki takie jak Express, musisz ręcznie utworzyć logikę do obsługi każdego żądania wysłanego do Twojego interfejsu API.
Najpierw utwórz blogRoutes.js plik w twoim trasy folderu, a następnie zaimportuj model bloga:
stały Blog = wymagać(../modele/blogModel");
Następnie utwórz asynchroniczny router funkcja, pass wymagane oraz res jako parametry i wyeksportuj funkcję:
stały router = asynchronicznyfunkcjonować (wym., odp) {};
moduł.eksport = router;
Ta funkcja zawiera całą logikę routingu.
Następnie zaimplementujesz trasę logiki routingu według trasy.
POBIERZ Trasy
Dodaj poniższy blok kodu do swojego router funkcja do realizacji DOSTAWAĆ obsługa tras dla próśb skierowanych do /api/blogs:
// GET: /api/blogs
jeśli (wymagany adres URL "/api/blogs"&& wymagana metoda "DOSTAWAĆ") {
// pobierz wszystkie blogi
stały blogi = czekać na Blog.znajdź();// ustawić ten status kod orazzawartość-rodzaj
res.writeHead (200, { "Typ zawartości": "aplikacja/json" });
// przesłać dane
res.koniec(JSON.stringify(blogi));
}
Powyższy blok kodu sprawdza adres URL oraz metoda właściwości obiektu żądania. Następnie pobiera wszystkie blogi z bazy danych za pomocą odnaleźć metoda na modelu mangusty (Blog).
Następnie nazywa Napisz Głowę metoda włączona res, obiekt odpowiedzi. Ta metoda wysyła nagłówek odpowiedzi z trzema argumentami: kodem stanu, opcjonalnym komunikatem o stanie i nagłówkami. The 200 kod stanu reprezentuje pomyślną odpowiedź, a typ zawartości dla tego wywołania interfejsu API jest ustawiony na aplikacja/json.
Na koniec zamknij żądanie, aby upewnić się, że serwer nie zawiesi się, wywołując koniec metoda włączona res. Wezwanie do JSON.stringify konwertuje blogi obiekt do ciągu JSON i przekazanie go do koniec Metoda zwraca ją jako treść odpowiedzi.
Dodaj poniższy blok kodu do swojego router funkcja do realizacji DOSTAWAĆ procedura obsługi tras dla pojedynczego zasobu:
// GET: /api/blogs/:id
if (req.url.match(/\\/api\\/blogs\\/([0-9]+)/) && wymagana metoda "DOSTAWAĆ") {
próbować {
// wyodrębnij id z url
const id = wymaga.url.split("/")[3];// pobierz bloga z DB
stały blog = czekać na Blog.findById (identyfikator);
jeśli (blog) {
res.writeHead (200, { "Typ zawartości": "aplikacja/json" });
res.koniec(JSON.stringify(blog));
} w przeciwnym razie {
rzucićNowyBłąd(„Blog nie istnieje”);
}
} złapać (błąd) {
res.writeHead (404, { "Typ zawartości": "aplikacja/json" });
res.koniec(JSON.stringify({ wiadomość: błąd }));
}
}
Ten kod wykorzystuje mecz metoda, która jako argument przyjmuje wyrażenie regularne, aby sprawdzić, czy adres URL jest zgodny z formatem: /api/blogs/.
Następnie wyodrębnij ID nieruchomość z adres URL ciąg, wywołując jego rozdzielać metoda. Ta metoda przyjmuje wzorzec jako argument (/), dzieli ciąg na podstawie wzorca i zwraca tablicę. Trzecim elementem tej tablicy jest ID.
Na koniec pobierz dokument z pasującym ID z Twojej bazy danych. Jeśli istnieje, wyślij kod odpowiedzi 200, zamknij żądanie i wyślij pobrany blog. Jeśli nie istnieje, zgłoś błąd i wyślij go jako odpowiedź w bloku catch.
POST Trasa
Dodaj poniższy blok kodu do funkcji routera, aby zaimplementować POCZTA obsługa trasy:
// POST: /api/blogi/
jeśli (wymagany adres URL "/api/blogs"&& wymagana metoda "POCZTA") {
próbować {
niech ciało = "";// Nasłuchuj zdarzenia danych
wym.("dane", (fragment) => {
treść += fragment.toString();
});// Słuchaj koniecwydarzenie
wym.("koniec", asynchroniczny () => {
// Utwórz bloga
wynajmować blog = Nowy Blog(JSON.parse (ciało));
// Zapisz do bazy danych
czekać na blog.zapisz();
res.writeHead (200, { "Typ zawartości": "aplikacja/json" });
res.koniec(JSON.stringify(blog));
});
} złapać (błąd) {
konsola.log (błąd);
}
}
Obiekt żądania implementuje Node.js ReadableStream interfejs. Ten strumień emituje a dane i koniec zdarzenie, które daje dostęp do danych z treści żądania.
Ten kod nasłuchuje zdarzenia danych i obsługuje je, konwertując je na ciąg i łącząc je z ciało zmienny. w koniec obsługa zdarzeń, tworzy Blog wystąpienie z przeanalizowanym ciągiem treści. Następnie zapisuje nowego bloga, wysyła kod stanu i nagłówek treści oraz zamyka żądanie.
Trasa PUT
Dodaj poniższy blok kodu do funkcji routera, aby zaimplementować POŁOŻYĆ obsługa trasy:
// PUT: /api/blogs/:id
if (req.url.match(/\\/api\\/blogs\\/([0-9]+)/) && wymagana metoda "POŁOŻYĆ") {
próbować {
// wyodrębnij id z url
const id = wymaga.url.split("/")[3];
niech ciało = "";wym.("dane", (fragment) => {
treść += fragment.toString();
});
wym.("koniec", asynchroniczny () => {
// Znajdź i aktualizacjadokument
wynajmować zaktualizowanyBlog = czekać na Blog.findByIdAndUpdate (identyfikator, JSON.parse (ciało), {
Nowy: PRAWDA,
});
res.writeHead (200, { "Typ zawartości": "aplikacja/json" });
res.koniec(JSON.stringify(zaktualizowanyBlog));
});
} złapać (błąd) {
konsola.log (błąd);
}
}
Program obsługi żądań PUT jest prawie identyczny z POCZTA obsługi żądań, z wyjątkiem tego, że wyodrębnia ID nieruchomość z adres URL aby zaktualizować odpowiedni blog.
USUŃ trasę
Dodaj poniższy blok kodu do funkcji routera, aby zaimplementować swój KASOWAĆ obsługa trasy:
// KASOWAĆ: /api/blogi/:ID
if (req.url.match(/\\/api\\/blogs\\/([0-9]+)/) && wymagana metoda "KASOWAĆ") {
próbować {
const id = wymaga.url.split("/")[3];
// Usuwać blog z DB
czekać na Blog.findByIdAndDelete (identyfikator);
res.writeHead (200, { "Typ zawartości": "aplikacja/json" });
res.end (JSON.stringify({ wiadomość: "Blog został pomyślnie usunięty" }));
} złapać (błąd) {
res.writeHead (404, { "Typ zawartości": "aplikacja/json" });
res.koniec(JSON.stringify({ wiadomość: błąd }));
}
}
Ten blok kodu wyodrębnia ID od adres URL, usuwa dokument z pasującym ID, wysyła kod stanu i nagłówki oraz zamyka żądanie.
Wreszcie, importuj router w Twoim serwer.js złóż plik i zadzwoń router funkcja, przekazywanie wymagane oraz res jako argumenty:
stały router = wymagać("./trasy/blogTrasy");
stały server = http.createServer((req, res) => {
router (wymagany, res);
});
Dzięki temu serwer może odpowiednio przechwytywać i obsługiwać żądania.
W tym miejscu możesz znaleźć ukończony projekt Repozytorium GitHub.
Korzystanie z frameworka Node.js
Chociaż możliwe jest ręczne utworzenie internetowego interfejsu API, może to być trudne zadanie. Musisz upewnić się, że omówiłeś wiele przypadków brzegowych, a Twój kod powinien być wolny od błędów.
Przez lata programiści budowali frameworki, takie jak ExpressJS, NestJS, Fastify itp., aby to znacznie ułatwić.
