Rozpakowywanie wywołań bazy danych węzłów

Poniżej znajduje się przykład, w jaki sposób można utworzyć opakowanie oparte na obietnicach, a następnie użyć go, aby pozbyć się zagnieżdżonych wywołań bazy danych.

To opakowanie oparte na obietnicy to tylko funkcja, która zwraca obietnicę. Tworzy instancję obietnicy, opakowuje bazowe wywołanie bazy danych i ostatecznie, gdy wywołanie bazy danych zwraca dane, powiadamia Twój kod.

function getCats() {
   return new Promise((resolve, reject) => {
       // make the database call
       db.cats((error, cats) => {
           // in case of an error, reject the promise by
           // calling "reject" function
           // Also pass the "error" object to the "reject" function
           // as an argument to get access to the error message 
           // in the code that calls this "getCats" function
           if (error) {
              reject(error);
              return;
           }
           
           // if there was no error, call "resolve" function
           // to resolve the promise. Promise will be resolved 
           // in case of successful database call
           // Also pass the data to "resolve" function
           // to access this data in the code that calls this
           // "getCats" function
           resolve(cats);
       });
   });
}

Teraz w funkcji obsługi trasy, zamiast wywoływania db.cats(...) , nazwij to getCats funkcja opakowania.

Istnieją dwa sposoby wywołania funkcji zwracającej obietnicę:

• Łańcuch obietnic (Aby uzyskać szczegółowe informacje, odwiedź linki wymienione powyżej)
• async-await składnia (zalecana)

Poniższy przykład kodu używa async-await składnia. W tym celu najpierw oznacz funkcję obsługi trasy jako async za pomocą async słowo kluczowe przed funkcją słowo kluczowe. Robiąc to, możemy użyć await słowo kluczowe wewnątrz tej funkcji obsługi trasy.

app.get('/pets', async function(req, res, next) {
    try {
       const cats = await getCats();
       // similar wrappers for other database calls
       const dogs = await getDogs();
       const budgies = await getBudgies();
       
       // render the pub template, passing in the data
       // fetched from the database 
       ...

     catch (error) {
       // catch block will be invoked if the promise returned by
       // the promise-based wrapper function is rejected
       // handle the error appropriately
     }
});

Powyższy przykład kodu pokazuje tylko, jak zawinąć db.cats(...) Wywołaj bazę danych w opakowaniu opartym na obietnicy i użyj tego opakowania, aby pobrać dane z bazy danych. Podobnie możesz utworzyć opakowania dla db.dogs(...) i db.budgies(...) połączeń.

Zamiast tworzyć oddzielne opakowanie oparte na obietnicach dla każdego wywołania bazy danych, najlepiej powinieneś utworzyć funkcję opakowania opartą na obietnicach wielokrotnego użytku który pobiera funkcję do wywołania i zawija to wywołanie funkcji w obietnicę, tak jak pokazano w powyższym przykładzie kodu, tj. getCats funkcja.

Równoległe wywołania bazy danych

Jedna ważna rzecz do zapamiętania w powyższym kodzie w funkcji obsługi trasy

const cats = await getCats();
const dogs = await getDogs();
const budgies = await getBudgies();

jest to, że doprowadzi to do sekwencyjnych wywołań bazy danych co może, ale nie musi, czego chcesz.

Jeśli te wywołania bazy danych nie są od siebie zależne, możesz równolegle wywołać opakowania oparte na obietnicach, używając Promise.all() metoda.

Poniższy przykład kodu pokazuje, jak można równolegle wywołać funkcje opakowujące oparte na obietnicy za pomocą Promise.all() .

app.get('/pets', async function(req, res, next) {
    try {
       // "petsData" will be an array that will contain all the data from 
       // three database calls.
       const petsData = await Promise.all([getCats(), getDogs(), getBudgies()]);
       
       // render the pub template, passing in the data
       // fetched from the database 
       ...
 
     catch (error) {
       ...
     }
 });

Mam nadzieję, że to wystarczy, aby pozbyć się zagnieżdżonych wywołań bazy danych w bieżącym kodzie i zacząć używać obietnic w kodzie.