Kurs JavaScript i TypeScript · Moduł 4: Programowanie asynchroniczne
Obsługa żądań HTTP - Praktyczne wzorce i zaawansowane techniki
W tej lekcji9
W poprzednim ćwiczeniu zapoznaliśmy się z podstawami Fetch API, które pozwala na wykonywanie żądań HTTP w JavaScript. Teraz rozszerzymy naszą wiedzę o bardziej zaawansowane techniki i praktyczne wzorce, które pomogą nam stworzyć solidny system komunikacji w naszym Parku Jurajskim. Przyjrzymy się, jak obsługiwać różne scenariusze, które mogą wystąpić podczas komunikacji sieciowej.
Kompleksowa obsługa błędów
W środowisku tak krytycznym jak Park Jurajski, gdzie awaria systemu może doprowadzić do niebezpiecznych sytuacji, prawidłowa obsługa błędów w komunikacji HTTP jest niezwykle ważna. Stwórzmy bardziej zaawansowany mechanizm obsługi błędów:
async function bezpieczneZapytanie(url, options = {}) {
const controller = new AbortController();
const { signal } = controller;
// Ustawienie timeoutu (10 sekund)
const timeoutId = setTimeout(() => controller.abort(), 10000);
try {
const response = await fetch(url, { ...options, signal });
clearTimeout(timeoutId);
// Kategorie błędów HTTP
if (response.status >= 500) {
throw new Error('Błąd serwera, prawdopodobnie tymczasowy problem.');
} else if (response.status === 404) {
throw new Error('Zasób nie został znaleziony.');
} else if (response.status === 403) {
throw new Error('Brak uprawnień do tego zasobu.');
} else if (response.status === 401) {
throw new Error('Wymagane uwierzytelnienie. Zaloguj się ponownie.');
} else if (!response.ok) {
throw new Error(`Nieoczekiwany błąd HTTP: ${response.status}`);
}
// Obsługa różnych typów odpowiedzi
const contentType = response.headers.get('content-type');
if (contentType && contentType.includes('application/json')) {
return await response.json();
} else if (contentType && contentType.includes('text/')) {
return await response.text();
} else {
return await response.blob();
}
} catch (error) {
clearTimeout(timeoutId);
// Obsługa różnych typów błędów
if (error.name === 'AbortError') {
throw new Error('Żądanie przerwane - upłynął limit czasu (10s).');
} else if (!navigator.onLine) {
throw new Error('Brak połączenia internetowego. Sprawdź swoje połączenie z siecią.');
} else {
console.error('Szczegóły błędu:', error);
throw new Error(`Błąd podczas komunikacji z serwerem: ${error.message}`);
}
}
}Wzorzec retry - automatyczne ponawianie żądań
W sieci Parku Jurajskiego mogą występować chwilowe problemy z łącznością, szczególnie w odległych częściach wyspy. Zaimplementujmy mechanizm automatycznego ponawiania nieudanych żądań:
/**
* Wykonuje żądanie HTTP z automatycznymi ponownymi próbami
* @param {Function} requestFn - Funkcja wykonująca żądanie, zwracająca Promise
* @param {Object} options - Opcje konfiguracyjne
* @returns {Promise} - Wynik żądania lub ostatni błąd po wyczerpaniu prób
*/
async function zPonawianiem(requestFn, options = {}) {
const {
maxProb = 3,
poczatkoweOpoznienie = 1000,
czynnikOpoznienia = 2,
maxOpoznienie = 10000,
timeoutMs = 10000,
czyPonowic = (error) => {
// Domyślnie ponawiamy tylko dla błędów serwera (5xx) i problemów z siecią
return (
error.message.includes('Błąd serwera') ||
error.message.includes('Brak połączenia') ||
error.name === 'AbortError'
);
}
} = options;
let ostatniBlad;
let proba = 0;
while (proba <= maxProb) {
try {
// Dla każdej próby tworzymy nowy kontroler przerwania
const controller = new AbortController();
const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
// Jeśli to nie pierwsza próba, czekamy przed ponowieniem
if (proba > 0) {
const opoznienie = Math.min(
poczatkoweOpoznienie * Math.pow(czynnikOpoznienia, proba - 1),
maxOpoznienie
);
console.log(`Próba ${proba}/${maxProb} nie powiodła się. Ponowienie za ${opoznienie}ms...`);
await new Promise(resolve => setTimeout(resolve, opoznienie));
}
// Wykonanie żądania
const wynik = await requestFn(controller.signal);
clearTimeout(timeoutId);
return wynik;
} catch (error) {
clearTimeout(timeoutId);
ostatniBlad = error;
// Sprawdzenie, czy ponawiać próbę
if (proba === maxProb || !czyPonowic(error)) {
break;
}
proba++;
}
}
// Wyrzucenie ostatniego błędu po wyczerpaniu prób
throw new Error(`Nie udało się po ${maxProb} próbach: ${ostatniBlad.message}`);
}
// Przykład użycia
async function pobierzDaneDinozaura(id) {
return zPonawianiem(
async (signal) => {
const response = await fetch(`https://api.jurassic-park.com/dinosaurs/${id}`, { signal });
if (!response.ok) {
throw new Error(`Błąd HTTP: ${response.status}`);
}
return response.json();
},
{
maxProb: 5,
poczatkoweOpoznienie: 500,
czyPonowic: (error) => error.message.includes('Błąd HTTP: 5')
}
);
}Kolejkowanie żądań i limit równoległych połączeń
W sytuacjach, gdy musimy wykonać wiele żądań HTTP, ale chcemy ograniczyć liczbę równoczesnych połączeń, aby nie przeciążyć sieci lub serwera, możemy zaimplementować kolejkowanie żądań:
class KolejkaZadan {
constructor(maxRownoleglosc = 3) {
this.maxRownoleglosc = maxRownoleglosc;
this.aktywneZadania = 0;
this.kolejka = [];
}
async dodaj(zadanie) {
// Jeśli mamy miejsce na więcej równoległych zadań, wykonaj od razu
if (this.aktywneZadania < this.maxRownoleglosc) {
return this.wykonaj(zadanie);
}
// W przeciwnym razie dodaj do kolejki
return new Promise((resolve, reject) => {
this.kolejka.push({ zadanie, resolve, reject });
});
}
async wykonaj(zadanie) {
this.aktywneZadania++;
try {
// Wykonanie zadania
const wynik = await zadanie();
return wynik;
} catch (error) {
throw error;
} finally {
this.aktywneZadania--;
this.przetworzNastepne();
}
}
przetworzNastepne() {
if (this.kolejka.length === 0 || this.aktywneZadania >= this.maxRownoleglosc) {
return;
}
// Pobierz następne zadanie z kolejki
const { zadanie, resolve, reject } = this.kolejka.shift();
// Wykonaj zadanie i przekieruj wynik do oczekującego Promise
this.wykonaj(zadanie)
.then(resolve)
.catch(reject);
}
}
// Przykład użycia kolejki do monitorowania wielu dinozaurów
async function monitorujWszystkieDinozaury(listaId) {
const kolejka = new KolejkaZadan(5); // Maksymalnie 5 równoczesnych żądań
const wyniki = [];
const bledy = [];
// Funkcje pomocnicze do śledzenia postępu
const totalZadan = listaId.length;
let ukonczoneZadania = 0;
function aktualizujPostep() {
ukonczoneZadania++;
const procent = Math.floor((ukonczoneZadania / totalZadan) * 100);
console.log(`Postęp monitorowania: ${procent}% (${ukonczoneZadania}/${totalZadan})`);
}
// Tworzenie tablicy Promise dla wszystkich zadań
const promisy = listaId.map(id => {
return kolejka.dodaj(async () => {
try {
console.log(`Monitorowanie dinozaura #${id}...`);
const wynik = await pobierzDaneDinozaura(id);
wyniki.push(wynik);
aktualizujPostep();
return wynik;
} catch (error) {
bledy.push({ id, error: error.message });
aktualizujPostep();
throw error;
}
}).catch(error => {
// Przechwytujemy błędy, aby nie przerywać całego procesu
console.error(`Błąd monitorowania dinozaura #${id}:`, error.message);
});
});
// Czekamy na zakończenie wszystkich zadań
await Promise.all(promisy);
return {
wyniki,
bledy,
podsumowanie: {
total: totalZadan,
sukces: wyniki.length,
blad: bledy.length
}
};
}Zarządzanie danymi w pamięci podręcznej (caching)
W Parku Jurajskim mamy dane, które zmieniają się rzadko (np. gatunki dinozaurów) oraz dane, które zmieniają się często (np. lokalizacje dinozaurów). Implementacja pamięci podręcznej pomoże zoptymalizować komunikację:
class ZarzadcaPamieciPodrecznej {
constructor() {
this.cache = new Map();
this.statystyki = {
trafienia: 0,
pudla: 0,
unieważnienia: 0
};
}
/**
* Pobiera dane z cache lub wykonuje funkcję pobierającą, jeśli danych nie ma w cache
* @param {string} klucz - Unikalny identyfikator danych w cache
* @param {Function} pobierzFn - Funkcja pobierająca dane, jeśli nie ma ich w cache
* @param {Object} opcje - Opcje cache
* @returns {Promise} - Promise z danymi
*/
async pobierz(klucz, pobierzFn, opcje = {}) {
const {
ttl = 60000, // Domyślny czas życia: 1 minuta
forceRefresh = false, // Czy wymusić odświeżenie pomimo obecności w cache
onlyIfCached = false // Czy zwracać tylko z cache (bez zapytania sieciowego)
} = opcje;
// Sprawdź czy dane są w cache i czy są aktualne
const wpis = this.cache.get(klucz);
const teraz = Date.now();
if (wpis && !forceRefresh && teraz < wpis.expiresAt) {
// Dane znalezione w cache i ważne
this.statystyki.trafienia++;
return wpis.dane;
}
// Jeśli żądamy tylko z cache i nie ma danych, zwróć null
if (onlyIfCached) {
return null;
}
// Danych nie ma w cache lub wymuszamy odświeżenie
this.statystyki.pudla++;
try {
// Pobierz dane
const dane = await pobierzFn();
// Zapisz w cache
this.cache.set(klucz, {
dane,
expiresAt: teraz + ttl,
dodanoAt: teraz
});
return dane;
} catch (error) {
// Jeśli mamy stare dane w cache, możemy je zwrócić jako awaryjne
if (wpis) {
console.warn(`Błąd pobierania danych dla ${klucz}, używam przestarzałych danych z cache:`, error);
return wpis.dane;
}
// W przeciwnym razie propagujemy błąd
throw error;
}
}
/**
* Unieważnia wpisy w cache pasujące do wzorca
* @param {string|RegExp} wzorzec - Wzorzec do dopasowania kluczy cache
*/
uniewaznij(wzorzec) {
const isString = typeof wzorzec === 'string';
let licznik = 0;
for (const klucz of this.cache.keys()) {
if (isString ? klucz.includes(wzorzec) : wzorzec.test(klucz)) {
this.cache.delete(klucz);
licznik++;
}
}
this.statystyki.unieważnienia += licznik;
return licznik;
}
/**
* Czyści wszystkie wpisy cache
*/
wyczysc() {
const licznik = this.cache.size;
this.cache.clear();
this.statystyki.unieważnienia += licznik;
return licznik;
}
/**
* Zwraca statystyki użycia cache
*/
pobierzStatystyki() {
const totalZapytan = this.statystyki.trafienia + this.statystyki.pudla;
const wspolczynnikTrafien = totalZapytan === 0 ? 0 : this.statystyki.trafienia / totalZapytan;
return {
...this.statystyki,
totalZapytan,
wspolczynnikTrafien: wspolczynnikTrafien.toFixed(2),
aktywneWpisy: this.cache.size
};
}
}
// Utworzenie instancji zarządcy pamięci podręcznej
const cacheDinozaurow = new ZarzadcaPamieciPodrecznej();
// Przykład użycia
async function pobierzDaneDinozauraZCache(id, opcje = {}) {
return cacheDinozaurow.pobierz(
`dino-${id}`,
async () => {
const response = await fetch(`https://api.jurassic-park.com/dinosaurs/${id}`);
if (!response.ok) {
throw new Error(`Błąd HTTP: ${response.status}`);
}
return response.json();
},
{
ttl: 300000, // 5 minut dla danych dinozaura
...opcje
}
);
}
// Funkcja do unieważniania cache po aktualizacji
async function aktualizujDinozaura(id, dane) {
const response = await fetch(`https://api.jurassic-park.com/dinosaurs/${id}`, {
method: 'PUT',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify(dane)
});
if (!response.ok) {
throw new Error(`Błąd aktualizacji: ${response.status}`);
}
// Unieważnij cache tego dinozaura
cacheDinozaurow.uniewaznij(`dino-${id}`);
// Unieważnij również listę dinozaurów, które mogą zawierać tego dinozaura
cacheDinozaurow.uniewaznij('dino-list');
return response.json();
}
// Pobieranie listy dinozaurów z cache na krócej (dane zmieniają się częściej)
async function pobierzListeDinozaurow(filter = {}) {
const queryParams = new URLSearchParams(filter).toString();
const cacheKey = `dino-list-${queryParams || 'all'}`;
return cacheDinozaurow.pobierz(
cacheKey,
async () => {
const url = `https://api.jurassic-park.com/dinosaurs?${queryParams}`;
const response = await fetch(url);
if (!response.ok) {
throw new Error(`Błąd HTTP: ${response.status}`);
}
return response.json();
},
{ ttl: 60000 } // 1 minuta dla list dinozaurów
);
}Obsługa żądań synchronizowanych z serwerem
W Parku Jurajskim musimy czasami wykonywać operacje, które wymagają synchronizacji z serwerem, np. aktualizacje statusu zdrowia dinozaurów. Zaimplementujmy mechanizm, który zapewni, że dane zostaną zapisane nawet w przypadku problemów z łącznością:
class KolejkaSynchronizacji {
constructor(opcje = {}) {
// Klucz w localStorage do przechowywania kolejki
this.klucz = opcje.klucz || 'dinozaury-sync-queue';
// Ładowanie zapisanej kolejki
this.kolejka = this.zaladujKolejke();
// Flaga wskazująca, czy synchronizacja jest aktywna
this.jestSynchronizacja = false;
// Automatyczne rozpoczęcie synchronizacji
if (opcje.autoSync !== false) {
this.rozpocznijSynchronizacje();
}
// Nasłuchiwanie na zmiany stanu online/offline
window.addEventListener('online', () => {
console.log('Połączenie przywrócone. Rozpoczynam synchronizację...');
this.rozpocznijSynchronizacje();
});
window.addEventListener('offline', () => {
console.log('Utracono połączenie. Synchronizacja wstrzymana.');
});
}
/**
* Ładuje kolejkę z localStorage
*/
zaladujKolejke() {
try {
const zapisanaKolejka = localStorage.getItem(this.klucz);
return zapisanaKolejka ? JSON.parse(zapisanaKolejka) : [];
} catch (error) {
console.error('Błąd podczas ładowania kolejki synchronizacji:', error);
return [];
}
}
/**
* Zapisuje kolejkę do localStorage
*/
zapiszKolejke() {
try {
localStorage.setItem(this.klucz, JSON.stringify(this.kolejka));
} catch (error) {
console.error('Błąd podczas zapisywania kolejki synchronizacji:', error);
}
}
/**
* Dodaje operację do kolejki synchronizacji
* @param {string} url - URL do żądania
* @param {Object} opcje - Opcje fetch
* @param {string} typ - Typ operacji (np. 'aktualizacja-zdrowia')
* @returns {string} - ID operacji w kolejce
*/
dodajDoKolejki(url, opcje = {}, typ = 'nieznany') {
const id = `op-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
this.kolejka.push({
id,
url,
opcje,
typ,
dodano: new Date().toISOString(),
proby: 0
});
this.zapiszKolejke();
this.rozpocznijSynchronizacje();
return id;
}
/**
* Rozpoczyna proces synchronizacji
*/
async rozpocznijSynchronizacje() {
// Jeśli już synchronizujemy lub nie ma połączenia, nie rób nic
if (this.jestSynchronizacja || !navigator.onLine || this.kolejka.length === 0) {
return;
}
this.jestSynchronizacja = true;
try {
let index = 0;
while (index < this.kolejka.length) {
const operacja = this.kolejka[index];
try {
console.log(`Synchronizacja operacji: ${operacja.typ} (${operacja.id})`);
// Inkrementacja liczby prób
operacja.proby++;
this.zapiszKolejke();
// Wykonanie żądania
const response = await fetch(operacja.url, operacja.opcje);
if (!response.ok) {
throw new Error(`Błąd HTTP: ${response.status}`);
}
// Operacja zakończona sukcesem, usuń z kolejki
this.kolejka.splice(index, 1);
this.zapiszKolejke();
console.log(`Operacja ${operacja.id} zsynchronizowana pomyślnie`);
// Nie zwiększaj indeksu, ponieważ usunęliśmy element
} catch (error) {
console.error(`Błąd synchronizacji operacji ${operacja.id}:`, error);
// Jeśli osiągnęliśmy maksymalną liczbę prób, oznacz jako nieudaną
if (operacja.proby >= 5) {
console.warn(`Operacja ${operacja.id} przekroczyła limit prób. Oznaczanie jako nieudana.`);
operacja.status = 'nieudana';
operacja.bladKomunikat = error.message;
this.zapiszKolejke();
}
// Przejdź do następnej operacji
index++;
}
}
} finally {
this.jestSynchronizacja = false;
// Jeśli wciąż są elementy w kolejce, ponowna próba za 1 minutę
if (this.kolejka.some(op => !op.status || op.status !== 'nieudana')) {
setTimeout(() => this.rozpocznijSynchronizacje(), 60000);
}
}
}
/**
* Usuwa nieudane operacje z kolejki
*/
wyczyscNieudaneOperacje() {
const poprzedniaLiczba = this.kolejka.length;
this.kolejka = this.kolejka.filter(op => !op.status || op.status !== 'nieudana');
this.zapiszKolejke();
return poprzedniaLiczba - this.kolejka.length;
}
/**
* Zwraca aktualny stan kolejki
*/
pobierzStatus() {
const wszystkie = this.kolejka.length;
const nieudane = this.kolejka.filter(op => op.status === 'nieudana').length;
const oczekujace = wszystkie - nieudane;
return {
wszystkie,
oczekujace,
nieudane,
jestSynchronizacja: this.jestSynchronizacja
};
}
}
// Utworzenie instancji kolejki synchronizacji
const syncDinozaurow = new KolejkaSynchronizacji({
klucz: 'jurassic-park-dino-sync'
});
// Przykład użycia: aktualizacja zdrowia dinozaura, która będzie synchronizowana
function aktualizujZdrowieDinozaura(id, parametryZdrowia) {
// Przygotuj dane do wysyłki
const dane = {
id,
health: parametryZdrowia.health,
lastCheckTime: new Date().toISOString(),
symptoms: parametryZdrowia.symptoms || [],
updatedBy: 'dr-wu'
};
// Jeśli jesteśmy online, próbuj od razu
if (navigator.onLine) {
return fetch(`https://api.jurassic-park.com/dinosaurs/${id}/health`, {
method: 'PUT',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify(dane)
})
.then(response => {
if (!response.ok) {
throw new Error(`Błąd HTTP: ${response.status}`);
}
return response.json();
})
.catch(error => {
console.warn('Nie udało się zaktualizować zdrowia online, dodaję do kolejki synchronizacji');
// Dodaj do kolejki synchronizacji
syncDinozaurow.dodajDoKolejki(
`https://api.jurassic-park.com/dinosaurs/${id}/health`,
{
method: 'PUT',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify(dane)
},
`aktualizacja-zdrowia-${id}`
);
// Zwróć dane, jakby operacja się powiodła, choć będzie zsynchronizowana później
return {
...dane,
pendingSync: true
};
});
} else {
// Jeśli jesteśmy offline, od razu dodaj do kolejki
syncDinozaurow.dodajDoKolejki(
`https://api.jurassic-park.com/dinosaurs/${id}/health`,
{
method: 'PUT',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify(dane)
},
`aktualizacja-zdrowia-${id}`
);
return Promise.resolve({
...dane,
pendingSync: true
});
}
}Uwierzytelnianie i odświeżanie tokenów
W systemie Parku Jurajskiego potrzebujemy zabezpieczyć dostęp do API, używając tokenów uwierzytelniających. Zaimplementujmy mechanizm, który automatycznie odświeża token, gdy wygaśnie:
class ZarzadcaUwierzytelniania {
constructor() {
this.tokenAccessKey = 'jp-access-token';
this.tokenRefreshKey = 'jp-refresh-token';
this.expiryKey = 'jp-token-expiry';
this.refreshInProgress = false;
this.refreshListeners = [];
}
/**
* Pobiera aktualny token dostępu
* @param {boolean} autoRefresh - Czy automatycznie odświeżyć token, jeśli wygasł
* @returns {Promise<string>} - Promise z tokenem dostępu
*/
async pobierzTokenDostepowy(autoRefresh = true) {
const token = localStorage.getItem(this.tokenAccessKey);
const expiry = localStorage.getItem(this.expiryKey);
// Sprawdź, czy token istnieje i czy nie wygasł
if (token && expiry) {
const expiryDate = new Date(expiry);
const now = new Date();
// Dodajemy 1 minutę buforu, aby uniknąć używania wygasającego za chwilę tokenu
const bufferTime = 60 * 1000; // 1 minuta w milisekundach
if (expiryDate.getTime() - now.getTime() > bufferTime) {
return token;
}
// Token wygasł lub wygaśnie wkrótce
if (autoRefresh) {
return this.odswiezToken();
}
}
throw new Error('Brak ważnego tokenu dostępowego');
}
/**
* Odświeża token dostępu używając tokenu odświeżającego
* @returns {Promise<string>} - Promise z nowym tokenem dostępu
*/
async odswiezToken() {
// Jeśli odświeżanie jest już w toku, zaczekaj na jego wynik
if (this.refreshInProgress) {
return new Promise((resolve, reject) => {
this.refreshListeners.push({ resolve, reject });
});
}
this.refreshInProgress = true;
try {
const refreshToken = localStorage.getItem(this.tokenRefreshKey);
if (!refreshToken) {
throw new Error('Brak tokenu odświeżającego');
}
const response = await fetch('https://api.jurassic-park.com/auth/refresh', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ refresh_token: refreshToken })
});
if (!response.ok) {
if (response.status === 401) {
// Token odświeżający jest nieprawidłowy, wyloguj użytkownika
this.wyloguj();
throw new Error('Sesja wygasła. Zaloguj się ponownie.');
}
throw new Error(`Błąd odświeżania tokenu: ${response.status}`);
}
const data = await response.json();
// Zapisz nowe tokeny
localStorage.setItem(this.tokenAccessKey, data.access_token);
localStorage.setItem(this.tokenRefreshKey, data.refresh_token);
// Oblicz czas wygaśnięcia
const expiry = new Date();
expiry.setSeconds(expiry.getSeconds() + data.expires_in);
localStorage.setItem(this.expiryKey, expiry.toISOString());
// Powiadom wszystkich oczekujących
this.refreshListeners.forEach(listener => {
listener.resolve(data.access_token);
});
this.refreshListeners = [];
return data.access_token;
} catch (error) {
// W przypadku błędu, powiadom wszystkich oczekujących
this.refreshListeners.forEach(listener => {
listener.reject(error);
});
this.refreshListeners = [];
throw error;
} finally {
this.refreshInProgress = false;
}
}
/**
* Zapisuje tokeny po zalogowaniu
* @param {Object} authData - Dane uwierzytelniające
*/
zapiszTokeny(authData) {
localStorage.setItem(this.tokenAccessKey, authData.access_token);
localStorage.setItem(this.tokenRefreshKey, authData.refresh_token);
// Oblicz czas wygaśnięcia
const expiry = new Date();
expiry.setSeconds(expiry.getSeconds() + authData.expires_in);
localStorage.setItem(this.expiryKey, expiry.toISOString());
}
/**
* Wylogowuje użytkownika
*/
wyloguj() {
localStorage.removeItem(this.tokenAccessKey);
localStorage.removeItem(this.tokenRefreshKey);
localStorage.removeItem(this.expiryKey);
}
/**
* Sprawdza, czy użytkownik jest zalogowany
* @returns {boolean}
*/
czyZalogowany() {
return !!localStorage.getItem(this.tokenAccessKey);
}
}
// Tworzenie instancji zarządcy uwierzytelniania
const auth = new ZarzadcaUwierzytelniania();
// Przykład użycia - funkcja do wykonywania uwierzytelnionych żądań
async function zapytanieUwierzytelnione(url, options = {}) {
try {
// Pobierz token dostępu (z automatycznym odświeżaniem)
const token = await auth.pobierzTokenDostepowy();
// Dodaj token do nagłówków
const authOptions = {
...options,
headers: {
...options.headers,
'Authorization': `Bearer ${token}`
}
};
// Wykonaj żądanie
const response = await fetch(url, authOptions);
// Obsługa błędów autoryzacji
if (response.status === 401) {
// Spróbuj odświeżyć token i ponowić żądanie
try {
const newToken = await auth.odswiezToken();
// Ponów żądanie z nowym tokenem
const refreshedOptions = {
...options,
headers: {
...options.headers,
'Authorization': `Bearer ${newToken}`
}
};
return fetch(url, refreshedOptions);
} catch (refreshError) {
// Nie udało się odświeżyć tokenu, wyloguj użytkownika
auth.wyloguj();
window.location.href = '/login'; // Przekieruj do logowania
throw new Error('Sesja wygasła. Zaloguj się ponownie.');
}
}
return response;
} catch (error) {
console.error('Błąd uwierzytelnionego żądania:', error);
throw error;
}
}
// Przykład użycia
async function pobierzDaneWybiegu(wybiegId) {
const response = await zapytanieUwierzytelnione(
`https://api.jurassic-park.com/paddocks/${wybiegId}`
);
if (!response.ok) {
throw new Error(`Błąd pobierania danych wybiegu: ${response.status}`);
}
return response.json();
}
// Funkcja logowania
async function zaloguj(email, haslo) {
try {
const response = await fetch('https://api.jurassic-park.com/auth/login', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ email, password: haslo })
});
if (!response.ok) {
throw new Error(`Błąd logowania: ${response.status}`);
}
const authData = await response.json();
// Zapisz tokeny
auth.zapiszTokeny(authData);
return {
success: true,
user: authData.user
};
} catch (error) {
console.error('Błąd logowania:', error);
return {
success: false,
error: error.message
};
}
}Przesyłanie plików z postępem
W Parku Jurajskim często musimy przesyłać duże pliki, takie jak obrazy czy filmy z kamer monitoringu dinozaurów. Zaimplementujmy funkcję, która obsługuje przesyłanie plików z informacją o postępie:
/**
* Wysyła plik na serwer z monitorowaniem postępu
* @param {File} plik - Plik do wysłania
* @param {string} url - URL docelowy
* @param {Object} opcje - Dodatkowe opcje
* @returns {Promise} - Promise z wynikiem operacji
*/
async function wyslijPlik(plik, url, opcje = {}) {
return new Promise((resolve, reject) => {
// Domyślne opcje
const {
metoda = 'POST',
nazwaPolaPliku = 'file',
dodatkoweDane = {},
naPostep = null,
naBlad = null,
maxRetries = 3
} = opcje;
// Licznik ponownych prób
let proby = 0;
// Funkcja do wykonania żądania
function wykonajWysylanie() {
// Utworzenie obiektu XHR
const xhr = new XMLHttpRequest();
// Konfiguracja obsługi zdarzeń
xhr.upload.addEventListener('progress', (event) => {
if (event.lengthComputable && typeof naPostep === 'function') {
const procent = Math.round((event.loaded / event.total) * 100);
naPostep({
loaded: event.loaded,
total: event.total,
procent
});
}
});
xhr.addEventListener('load', () => {
if (xhr.status >= 200 && xhr.status < 300) {
try {
// Parsowanie odpowiedzi JSON
const odpowiedz = JSON.parse(xhr.responseText);
resolve(odpowiedz);
} catch (e) {
resolve({
success: true,
status: xhr.status,
message: xhr.statusText
});
}
} else {
const blad = new Error(`Błąd HTTP: ${xhr.status}`);
blad.status = xhr.status;
blad.statusText = xhr.statusText;
if (xhr.status >= 500 && proby < maxRetries) {
// Dla błędów serwera, spróbuj ponownie
proby++;
console.warn(`Błąd wysyłania pliku (${xhr.status}). Ponowna próba ${proby}/${maxRetries}...`);
setTimeout(wykonajWysylanie, 2000 * proby); // Zwiększanie czasu między próbami
} else {
if (typeof naBlad === 'function') {
naBlad(blad);
}
reject(blad);
}
}
});
xhr.addEventListener('error', () => {
const blad = new Error('Błąd sieci podczas wysyłania pliku');
if (typeof naBlad === 'function') {
naBlad(blad);
}
if (proby < maxRetries) {
proby++;
console.warn(`Błąd sieci podczas wysyłania. Ponowna próba ${proby}/${maxRetries}...`);
setTimeout(wykonajWysylanie, 2000 * proby);
} else {
reject(blad);
}
});
xhr.addEventListener('abort', () => {
const blad = new Error('Wysyłanie pliku zostało przerwane');
if (typeof naBlad === 'function') {
naBlad(blad);
}
reject(blad);
});
// Otwarcie połączenia
xhr.open(metoda, url, true);
// Przygotowanie danych FormData
const formData = new FormData();
formData.append(nazwaPolaPliku, plik);
// Dodanie dodatkowych danych
Object.entries(dodatkoweDane).forEach(([klucz, wartosc]) => {
formData.append(klucz, wartosc);
});
// Wysłanie żądania
xhr.send(formData);
// Zwrócenie obiektu z metodą przerwania
return {
przerwij: () => xhr.abort()
};
}
// Rozpoczęcie wysyłania
wykonajWysylanie();
});
}
// Przykład użycia
async function wyslijNagranieZKamery(plik, lokalizacja) {
const controller = document.getElementById('upload-controller');
const progressBar = document.getElementById('upload-progress');
const statusText = document.getElementById('upload-status');
controller.classList.remove('hidden');
statusText.textContent = 'Przygotowywanie...';
try {
const wynik = await wyslijPlik(
plik,
'https://api.jurassic-park.com/security/camera-footage',
{
dodatkoweDane: {
location: lokalizacja,
timestamp: new Date().toISOString(),
operator: 'dr-wu'
},
naPostep: (info) => {
progressBar.value = info.procent;
statusText.textContent = `Wysyłanie: ${info.procent}%`;
},
naBlad: (blad) => {
statusText.textContent = `Błąd: ${blad.message}`;
progressBar.classList.add('error');
}
}
);
statusText.textContent = 'Wysyłanie ukończone!';
progressBar.value = 100;
setTimeout(() => {
controller.classList.add('hidden');
}, 3000);
return wynik;
} catch (error) {
statusText.textContent = `Błąd: ${error.message}`;
progressBar.classList.add('error');
throw error;
}
}Monitorowanie stanu sieci
W Parku Jurajskim musimy być przygotowani na problemy z łącznością, zwłaszcza w oddalonych częściach wyspy. Zaimplementujmy system monitorowania stanu sieci:
class MonitorSieci {
constructor(opcje = {}) {
this.sluchacze = {
zmiana: [],
online: [],
offline: []
};
this.ostatniPing = null;
this.opoznienie = null;
this.status = navigator.onLine ? 'online' : 'offline';
this.adresEndpointu = opcje.endpointPing || 'https://api.jurassic-park.com/ping';
this.interwalPingu = opcje.interwalPingu || 30000; // 30 sekund
this.timeoutPingu = opcje.timeoutPingu || 5000; // 5 sekund
// Dodanie nasłuchiwaczy na zdarzenia online/offline
window.addEventListener('online', this.obslugaOnline.bind(this));
window.addEventListener('offline', this.obslugaOffline.bind(this));
// Start regularnego pingowania
if (opcje.autostartPing !== false) {
this.startPingowanie();
}
}
/**
* Obsługa zdarzenia przejścia do trybu online
*/
obslugaOnline() {
const poprzedniStatus = this.status;
this.status = 'online';
// Powiadomienie słuchaczy
this.powiadomSluchaczy('online');
if (poprzedniStatus !== this.status) {
this.powiadomSluchaczy('zmiana', { status: this.status, poprzedni: poprzedniStatus });
}
// Wykonaj natychmiastowy ping dla sprawdzenia rzeczywistej łączności
this.ping();
}
/**
* Obsługa zdarzenia przejścia do trybu offline
*/
obslugaOffline() {
const poprzedniStatus = this.status;
this.status = 'offline';
this.opoznienie = null;
// Powiadomienie słuchaczy
this.powiadomSluchaczy('offline');
if (poprzedniStatus !== this.status) {
this.powiadomSluchaczy('zmiana', { status: this.status, poprzedni: poprzedniStatus });
}
}
/**
* Ping serwera dla sprawdzenia rzeczywistej łączności
* @returns {Promise<number>} - Promise z czasem opóźnienia w ms
*/
async ping() {
if (!navigator.onLine) {
this.opoznienie = null;
return Promise.reject(new Error('Przeglądarka jest w trybie offline'));
}
try {
const startTime = Date.now();
// Ustawienie timeout dla fetch
const controller = new AbortController();
const timeoutId = setTimeout(() => controller.abort(), this.timeoutPingu);
const response = await fetch(`${this.adresEndpointu}?t=${startTime}`, {
method: 'GET',
cache: 'no-store',
signal: controller.signal
});
clearTimeout(timeoutId);
if (!response.ok) {
throw new Error(`Błąd HTTP: ${response.status}`);
}
// Oblicz opóźnienie
const endTime = Date.now();
this.opoznienie = endTime - startTime;
this.ostatniPing = new Date();
// Aktualizacja statusu
const poprzedniStatus = this.status;
this.status = 'online';
if (poprzedniStatus !== this.status) {
this.powiadomSluchaczy('zmiana', { status: this.status, poprzedni: poprzedniStatus });
this.powiadomSluchaczy('online');
}
return this.opoznienie;
} catch (error) {
// Jeśli timeout lub błąd sieci, oznacz jako offline
if (error.name === 'AbortError' || error instanceof TypeError) {
const poprzedniStatus = this.status;
this.status = 'offline';
this.opoznienie = null;
if (poprzedniStatus !== this.status) {
this.powiadomSluchaczy('zmiana', { status: this.status, poprzedni: poprzedniStatus });
this.powiadomSluchaczy('offline');
}
}
throw error;
}
}
/**
* Rozpoczyna regularne pingowanie serwera
*/
startPingowanie() {
// Zatrzymaj istniejący interwał, jeśli istnieje
this.stopPingowanie();
// Wykonaj pierwszy ping natychmiast
this.ping().catch(e => console.warn('Błąd początkowego pingu:', e));
// Ustaw interwał pingowania
this.pingInterval = setInterval(() => {
this.ping().catch(e => console.warn('Błąd pingowania:', e));
}, this.interwalPingu);
}
/**
* Zatrzymuje regularne pingowanie serwera
*/
stopPingowanie() {
if (this.pingInterval) {
clearInterval(this.pingInterval);
this.pingInterval = null;
}
}
/**
* Dodaje słuchacza na zdarzenie
* @param {string} typZdarzenia - Typ zdarzenia ('zmiana', 'online', 'offline')
* @param {Function} callback - Funkcja callback
*/
nasluchuj(typZdarzenia, callback) {
if (this.sluchacze[typZdarzenia]) {
this.sluchacze[typZdarzenia].push(callback);
}
return this; // Dla chain API
}
/**
* Usuwa słuchacza
* @param {string} typZdarzenia - Typ zdarzenia
* @param {Function} callback - Funkcja callback do usunięcia
*/
przestanNasluchiwac(typZdarzenia, callback) {
if (this.sluchacze[typZdarzenia]) {
this.sluchacze[typZdarzenia] = this.sluchacze[typZdarzenia].filter(cb => cb !== callback);
}
return this;
}
/**
* Powiadamia słuchaczy o zdarzeniu
* @param {string} typZdarzenia - Typ zdarzenia
* @param {Object} dane - Dane zdarzenia
*/
powiadomSluchaczy(typZdarzenia, dane = {}) {
if (this.sluchacze[typZdarzenia]) {
this.sluchacze[typZdarzenia].forEach(callback => {
try {
callback({
typ: typZdarzenia,
timestamp: new Date(),
status: this.status,
opoznienie: this.opoznienie,
...dane
});
} catch (e) {
console.error(`Błąd w słuchaczu ${typZdarzenia}:`, e);
}
});
}
}
/**
* Zwraca aktualny stan sieci
*/
pobierzStan() {
return {
status: this.status,
opoznienie: this.opoznienie,
ostatniPing: this.ostatniPing,
przegldarkaOnline: navigator.onLine
};
}
}
// Utworzenie instancji monitora sieci
const monitorSieci = new MonitorSieci();
// Przykład użycia
monitorSieci.nasluchuj('zmiana', (info) => {
console.log(`Zmiana stanu sieci: ${info.poprzedni} -> ${info.status}`);
// Aktualizacja interfejsu użytkownika
const statusIndicator = document.getElementById('network-status');
if (statusIndicator) {
statusIndicator.className = `status-${info.status}`;
statusIndicator.textContent = info.status === 'online'
? `Online (ping: ${info.opoznienie}ms)`
: 'Offline';
}
});
monitorSieci.nasluchuj('offline', () => {
// Pokaż powiadomienie użytkownikowi
pokazPowiadomienie('Utracono połączenie z siecią', 'error');
// Włącz tryb offline w aplikacji
app.wlaczTrybOffline();
});
monitorSieci.nasluchuj('online', (info) => {
pokazPowiadomienie(`Połączenie przywrócone (ping: ${info.opoznienie}ms)`, 'success');
// Synchronizuj dane z serwerem
syncDinozaurow.rozpocznijSynchronizacje();
// Wyłącz tryb offline
app.wylaczTrybOffline();
});
function pokazPowiadomienie(tekst, typ) {
const notification = document.createElement('div');
notification.className = `notification ${typ}`;
notification.textContent = tekst;
document.body.appendChild(notification);
// Usuń powiadomienie po 5 sekundach
setTimeout(() => {
notification.classList.add('fade-out');
setTimeout(() => {
document.body.removeChild(notification);
}, 500);
}, 5000);
}Podsumowanie - Tworzenie kompleksowego klienta API
Łącząc wszystkie omówione techniki, możemy stworzyć wysoko wydajny, odporny na błędy i przyjazny dla użytkownika system komunikacji z API. Oto przykład kompletnego rozwiązania:
/**
* Kompleksowy klient API dla systemu Parku Jurajskiego
*/
class JurassicAPIClient {
constructor(opcje = {}) {
// Konfiguracja bazowego URL
this.baseUrl = opcje.baseUrl || 'https://api.jurassic-park.com';
// Inicjalizacja zarządcy uwierzytelniania
this.auth = new ZarzadcaUwierzytelniania();
// Inicjalizacja cache
this.cache = new ZarzadcaPamieciPodrecznej();
// Inicjalizacja kolejki synchronizacji
this.syncQueue = new KolejkaSynchronizacji({
klucz: 'jp-sync-queue',
autoSync: true
});
// Inicjalizacja monitora sieci
this.networkMonitor = new MonitorSieci({
endpointPing: `${this.baseUrl}/ping`,
interwalPingu: 30000
});
// Monitorowanie stanu sieci
this.networkMonitor.nasluchuj('online', () => {
this.syncQueue.rozpocznijSynchronizacje();
});
// Domyślne opcje żądań
this.defaultOptions = {
timeout: 30000,
retries: 3,
cacheTime: 300000, // 5 minut
useCache: true
};
}
/**
* Wykonuje żądanie HTTP
* @param {string} endpoint - Endpoint API
* @param {Object} opcje - Opcje żądania
* @returns {Promise} - Promise z wynikiem żądania
*/
async request(endpoint, opcje = {}) {
// Połączenie domyślnych opcji z przekazanymi
const {
method = 'GET',
body,
headers = {},
useAuth = true,
useCache = this.defaultOptions.useCache,
cacheTime = this.defaultOptions.cacheTime,
forceRefresh = false,
timeout = this.defaultOptions.timeout,
retries = this.defaultOptions.retries,
offlineFallback = true
} = opcje;
// Przygotowanie klucza cache
const cacheKey = `${method}:${endpoint}:${JSON.stringify(body || {})}`;
// Sprawdzenie, czy zapytanie jest w cache (tylko dla GET)
if (method === 'GET' && useCache && !forceRefresh) {
try {
const cachedData = await this.cache.pobierz(
cacheKey,
() => {}, // Pusta funkcja, bo nie chcemy jeszcze wykonywać żądania
{ ttl: cacheTime, onlyIfCached: true }
);
if (cachedData) {
return cachedData;
}
} catch (error) {
// Ignoruj błędy cache
}
}
// Sprawdzenie stanu sieci
if (!this.networkMonitor.pobierzStan().status === 'online') {
// Jesteśmy offline, sprawdź czy mamy dane w cache
if (method === 'GET' && useCache && offlineFallback) {
try {
const cachedData = await this.cache.pobierz(
cacheKey,
() => {}, // Pusta funkcja, bo nie chcemy jeszcze wykonywać żądania
{ ttl: Infinity, onlyIfCached: true, ignoreExpiry: true }
);
if (cachedData) {
// Informacje o trybie offline
return {
...cachedData,
_meta: {
fromCache: true,
offlineMode: true,
timestamp: new Date()
}
};
}
} catch (error) {
// Ignoruj błędy cache
}
}
// Jeśli to żądanie modyfikujące dane, dodaj do kolejki synchronizacji
if (method !== 'GET' && offlineFallback) {
return this.addToSyncQueue(endpoint, { method, body, headers, useAuth });
}
throw new Error('Brak połączenia z siecią. Nie można wykonać żądania.');
}
// Funkcja wykonująca właściwe żądanie
const executeRequest = async (signal) => {
// Przygotowanie URL
const url = `${this.baseUrl}${endpoint}`;
// Przygotowanie opcji żądania
const requestOptions = {
method,
headers: {
'Content-Type': 'application/json',
...headers
},
signal
};
// Dodanie ciała żądania, jeśli istnieje
if (body) {
requestOptions.body = JSON.stringify(body);
}
// Dodanie tokenu uwierzytelniającego, jeśli wymagane
if (useAuth) {
try {
const token = await this.auth.pobierzTokenDostepowy();
requestOptions.headers['Authorization'] = `Bearer ${token}`;
} catch (error) {
// Jeśli nie udało się pobrać tokenu, a żądanie wymaga uwierzytelnienia
throw new Error('Brak uwierzytelnienia. Zaloguj się ponownie.');
}
}
// Wykonanie żądania z timeoutem
const controller = new AbortController();
const { signal: abortSignal } = controller;
if (signal) {
// Jeśli przekazano signal z zewnątrz, łączymy go z naszym
signal.addEventListener('abort', () => controller.abort());
}
const timeoutId = setTimeout(() => controller.abort(), timeout);
requestOptions.signal = abortSignal;
try {
const response = await fetch(url, requestOptions);
clearTimeout(timeoutId);
// Obsługa błędów HTTP
if (response.status === 401 && useAuth) {
// Próba odświeżenia tokenu
try {
await this.auth.odswiezToken();
// Ponowna próba z nowym tokenem
return this.request(endpoint, opcje);
} catch (refreshError) {
throw new Error('Sesja wygasła. Zaloguj się ponownie.');
}
}
if (!response.ok) {
const error = new Error(`Błąd HTTP: ${response.status}`);
error.status = response.status;
error.statusText = response.statusText;
// Próba pobrania szczegółów błędu z odpowiedzi
try {
const errorData = await response.json();
error.data = errorData;
error.message = errorData.message || error.message;
} catch (e) {
// Ignoruj błędy parsowania
}
throw error;
}
// Parsowanie odpowiedzi w zależności od typu
const contentType = response.headers.get('content-type');
let data;
if (contentType && contentType.includes('application/json')) {
data = await response.json();
} else if (contentType && contentType.includes('text/')) {
data = await response.text();
} else {
data = await response.blob();
}
// Zapisanie odpowiedzi w cache dla żądań GET
if (method === 'GET' && useCache) {
this.cache.pobierz(cacheKey, () => data, { ttl: cacheTime, forceRefresh: true });
}
return data;
} catch (error) {
clearTimeout(timeoutId);
if (error.name === 'AbortError') {
throw new Error(`Żądanie przerwane po upływie czasu (${timeout}ms)`);
}
throw error;
}
};
// Wykonanie żądania z ponawianiem prób
return zPonawianiem(
(signal) => executeRequest(signal),
{
maxProb: retries,
poczatkoweOpoznienie: 1000,
czynnikOpoznienia: 2,
timeoutMs: timeout
}
);
}
/**
* Dodaje żądanie do kolejki synchronizacji (tryb offline)
* @param {string} endpoint - Endpoint API
* @param {Object} opcje - Opcje żądania
* @returns {Promise} - Promise z tymczasowym wynikiem
*/
addToSyncQueue(endpoint, opcje) {
const { method, body } = opcje;
// Generowanie unikalnego ID dla operacji
const operationId = `op-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
// Dodanie do kolejki synchronizacji
this.syncQueue.dodajDoKolejki(
`${this.baseUrl}${endpoint}`,
{
method,
headers: {
'Content-Type': 'application/json',
// Token będzie dodany podczas rzeczywistej synchronizacji
},
body: body ? JSON.stringify(body) : undefined
},
`${method}-${endpoint}`
);
// Zwrócenie tymczasowej odpowiedzi
return Promise.resolve({
_meta: {
pendingSync: true,
operationId,
timestamp: new Date(),
offlineMode: true
},
...body // Zwróć przekazane dane jako tymczasowy wynik
});
}
// Metody pomocnicze dla różnych typów żądań
/**
* Wykonuje żądanie GET
* @param {string} endpoint - Endpoint API
* @param {Object} opcje - Opcje żądania
* @returns {Promise} - Promise z wynikiem żądania
*/
async get(endpoint, opcje = {}) {
return this.request(endpoint, { ...opcje, method: 'GET' });
}
/**
* Wykonuje żądanie POST
* @param {string} endpoint - Endpoint API
* @param {Object} body - Ciało żądania
* @param {Object} opcje - Opcje żądania
* @returns {Promise} - Promise z wynikiem żądania
*/
async post(endpoint, body, opcje = {}) {
return this.request(endpoint, { ...opcje, method: 'POST', body });
}
/**
* Wykonuje żądanie PUT
* @param {string} endpoint - Endpoint API
* @param {Object} body - Ciało żądania
* @param {Object} opcje - Opcje żądania
* @returns {Promise} - Promise z wynikiem żądania
*/
async put(endpoint, body, opcje = {}) {
return this.request(endpoint, { ...opcje, method: 'PUT', body });
}
/**
* Wykonuje żądanie DELETE
* @param {string} endpoint - Endpoint API
* @param {Object} opcje - Opcje żądania
* @returns {Promise} - Promise z wynikiem żądania
*/
async delete(endpoint, opcje = {}) {
return this.request(endpoint, { ...opcje, method: 'DELETE' });
}
/**
* Wysyła plik na serwer
* @param {string} endpoint - Endpoint API
* @param {File} plik - Plik do wysłania
* @param {Object} opcje - Opcje żądania
* @returns {Promise} - Promise z wynikiem żądania
*/
async uploadFile(endpoint, plik, opcje = {}) {
const {
nazwaPolaPliku = 'file',
dodatkoweDane = {},
naPostep = null,
useAuth = true
} = opcje;
// Jeśli offline, dodaj do kolejki synchronizacji
if (!this.networkMonitor.pobierzStan().status === 'online') {
throw new Error('Nie można wysłać pliku w trybie offline.');
}
// Przygotowanie danych FormData
const formData = new FormData();
formData.append(nazwaPolaPliku, plik);
// Dodanie dodatkowych danych
Object.entries(dodatkoweDane).forEach(([klucz, wartosc]) => {
formData.append(klucz, JSON.stringify(wartosc));
});
// Opcje żądania
const requestOptions = {
method: 'POST',
body: formData
};
// Dodanie tokenu uwierzytelniającego, jeśli wymagane
if (useAuth) {
try {
const token = await this.auth.pobierzTokenDostepowy();
requestOptions.headers = {
'Authorization': `Bearer ${token}`
};
} catch (error) {
throw new Error('Brak uwierzytelnienia. Zaloguj się ponownie.');
}
}
return new Promise((resolve, reject) => {
const xhr = new XMLHttpRequest();
xhr.upload.addEventListener('progress', (event) => {
if (event.lengthComputable && typeof naPostep === 'function') {
const procent = Math.round((event.loaded / event.total) * 100);
naPostep({
loaded: event.loaded,
total: event.total,
procent
});
}
});
xhr.addEventListener('load', () => {
if (xhr.status >= 200 && xhr.status < 300) {
try {
const odpowiedz = JSON.parse(xhr.responseText);
resolve(odpowiedz);
} catch (e) {
resolve({
success: true,
status: xhr.status,
message: xhr.statusText
});
}
} else {
const blad = new Error(`Błąd HTTP: ${xhr.status}`);
blad.status = xhr.status;
blad.statusText = xhr.statusText;
reject(blad);
}
});
xhr.addEventListener('error', () => {
reject(new Error('Błąd sieci podczas wysyłania pliku'));
});
xhr.addEventListener('abort', () => {
reject(new Error('Wysyłanie pliku zostało przerwane'));
});
xhr.open('POST', `${this.baseUrl}${endpoint}`, true);
if (requestOptions.headers) {
Object.entries(requestOptions.headers).forEach(([key, value]) => {
xhr.setRequestHeader(key, value);
});
}
xhr.send(formData);
});
}
/**
* Uwierzytelnia użytkownika
* @param {string} email - Adres email
* @param {string} haslo - Hasło
* @returns {Promise} - Promise z wynikiem uwierzytelnienia
*/
async login(email, haslo) {
try {
const response = await this.request('/auth/login', {
method: 'POST',
body: { email, password: haslo },
useAuth: false
});
// Zapisz tokeny
this.auth.zapiszTokeny(response);
return {
success: true,
user: response.user
};
} catch (error) {
return {
success: false,
error: error.message
};
}
}
/**
* Wylogowuje użytkownika
*/
logout() {
this.auth.wyloguj();
// Opcjonalne wyczyszczenie cache przy wylogowaniu
this.cache.wyczysc();
}
}
// Utworzenie instancji klienta API
const api = new JurassicAPIClient({
baseUrl: 'https://api.jurassic-park.com'
});
// Przykład użycia klienta API
// Logowanie
async function logowanie(email, haslo) {
const wynik = await api.login(email, haslo);
if (wynik.success) {
console.log(`Zalogowano jako ${wynik.user.name}`);
return true;
} else {
console.error(`Błąd logowania: ${wynik.error}`);
return false;
}
}
// Pobieranie danych dinozaura
async function pobierzDinozaura(id) {
try {
return await api.get(`/dinosaurs/${id}`);
} catch (error) {
console.error(`Nie udało się pobrać dinozaura #${id}:`, error.message);
throw error;
}
}
// Aktualizacja danych dinozaura
async function aktualizujDinozaura(id, dane) {
try {
return await api.put(`/dinosaurs/${id}`, dane);
} catch (error) {
console.error(`Nie udało się zaktualizować dinozaura #${id}:`, error.message);
throw error;
}
}
// Pobieranie listy dinozaurów z filtrowaniem
async function pobierzListeDinozaurow(filter = {}) {
try {
return await api.get('/dinosaurs', {
body: filter,
cacheTime: 60000 // Krótszy czas cache dla list (1 minuta)
});
} catch (error) {
console.error('Nie udało się pobrać listy dinozaurów:', error.message);
throw error;
}
}
// Wysyłanie dokumentacji medycznej dinozaura
async function wyslijDokumentacjeMedyczna(dinoId, plik, dane) {
const progressBar = document.getElementById('upload-progress');
const statusText = document.getElementById('upload-status');
try {
return await api.uploadFile(`/dinosaurs/${dinoId}/medical-records`, plik, {
dodatkoweDane: dane,
naPostep: (info) => {
if (progressBar) progressBar.value = info.procent;
if (statusText) statusText.textContent = `Wysyłanie: ${info.procent}%`;
}
});
} catch (error) {
console.error(`Nie udało się wysłać dokumentacji dla dinozaura #${dinoId}:`, error.message);
if (statusText) statusText.textContent = `Błąd: ${error.message}`;
throw error;
}
}W tym obszernym przykładzie zaimplementowaliśmy zaawansowany klient API, który obsługuje:
- Kompleksową obsługę błędów - różne rodzaje błędów HTTP i sieciowych
- Automatyczne ponawianie żądań - w przypadku tymczasowych problemów
- Cachowanie odpowiedzi - dla szybszego dostępu i wsparcia trybu offline
- Kolejkowanie operacji w trybie offline - dla zapewnienia spójności danych
- Monitorowanie stanu sieci - dla podejmowania odpowiednich decyzji
- Uwierzytelnianie i odświeżanie tokenów - dla bezpiecznego dostępu do API
- Wysyłanie plików z monitorowaniem postępu - dla lepszego doświadczenia użytkownika
Taki kompleksowy klient API zapewnia odporność na problemy sieciowe, efektywność dzięki cachowaniu, wsparcie dla trybu offline oraz przyjazne dla użytkownika mechanizmy, takie jak monitorowanie postępu. Jest to idealne rozwiązanie dla krytycznych systemów, takich jak system zarządzania Parkiem Jurajskim, gdzie niezawodność i bezpieczeństwo są kluczowe.
W następnej lekcji przyjrzymy się, jak efektywnie przetwarzać dane JSON otrzymane z API, aby prezentować je użytkownikom w przystępny sposób.
Kod do tej lekcji: index.js
// Function Factory - Fabryka funkcji
console.log("FUNCTION FACTORY - FABRYKA FUNKCJI\n");
// Factory function - funkcja tworząca inne funkcje
function createDinosaurHandler(species, defaultDangerLevel) {
console.log(`Tworzenie handlera dla: ${species}`);
// Zwracamy nową funkcję z "zapamiętanymi" parametrami
return function(action) {
console.log(`\n[${species}] Akcja: ${action}`);
console.log(` Domyślne zagrożenie: ${defaultDangerLevel}/10`);
switch(action) {
case 'FEED':
console.log(` Karmienie ${species}`);
break;
case 'MONITOR':
console.log(` Monitoring ${species}`);
break;
case 'ALERT':
console.log(` ALARM! ${species} wymaga uwagi!`);
break;
default:
console.log(` Nieznana akcja`);
}
};
}
// Tworzenie specjalizowanych handlerów
console.log("=== TWORZENIE HANDLERÓW ===\n");
const trexHandler = createDinosaurHandler('T-Rex', 10);
const triceratopsHandler = createDinosaurHandler('Triceratops', 3);
const velociraptorHandler = createDinosaurHandler('Velociraptor', 8);
// Używanie handlerów
console.log("\n=== UŻYWANIE HANDLERÓW ===");
trexHandler('FEED');
trexHandler('MONITOR');
triceratopsHandler('FEED');
velociraptorHandler('ALERT');
// Factory z dodatkowymi opcjami
console.log("\n=== ZAAWANSOWANA FACTORY ===\n");
function createAdvancedHandler(config) {
const {
species,
dangerLevel,
feedingTime,
maxCapacity
} = config;
let currentCount = 0;
return {
add: function() {
if (currentCount < maxCapacity) {
currentCount++;
console.log(`Dodano ${species}. Obecnie: ${currentCount}/${maxCapacity}`);
return true;
} else {
console.log(`Brak miejsca dla ${species}! (${currentCount}/${maxCapacity})`);
return false;
}
},
remove: function() {
if (currentCount > 0) {
currentCount--;
console.log(`Usunięto ${species}. Obecnie: ${currentCount}/${maxCapacity}`);
return true;
} else {
console.log(`Brak ${species} do usunięcia`);
return false;
}
},
getInfo: function() {
return {
species,
dangerLevel,
feedingTime,
count: currentCount,
capacity: maxCapacity,
occupancy: `${((currentCount / maxCapacity) * 100).toFixed(1)}%`
};
},
feed: function() {
console.log(`Karmienie ${currentCount} x ${species} o ${feedingTime}`);
}
};
}
// Tworzenie zaawansowanych handlerów
const trexManager = createAdvancedHandler({
species: 'T-Rex',
dangerLevel: 10,
feedingTime: '18:00',
maxCapacity: 5
});
const velociraptorManager = createAdvancedHandler({
species: 'Velociraptor',
dangerLevel: 8,
feedingTime: '16:00',
maxCapacity: 10
});
console.log("=== ZARZĄDZANIE POPULACJĄ ===\n");
trexManager.add();
trexManager.add();
trexManager.add();
console.log("\nT-Rex Info:", trexManager.getInfo());
trexManager.feed();
console.log("");
velociraptorManager.add();
velociraptorManager.add();
velociraptorManager.add();
velociraptorManager.add();
velociraptorManager.add();
console.log("\nVelociraptor Info:", velociraptorManager.getInfo());
console.log("\n=== KORZYŚCI Z FACTORY PATTERN ===");
console.log("Enkapsulacja - ukryte dane wewnętrzne");
console.log("Reużywalność - łatwe tworzenie podobnych obiektów");
console.log("Customizacja - każdy handler może mieć własną konfigurację");
console.log("Closures - każdy handler pamięta swoje ustawienia");Hasła z dokumentacji w tej lekcji
Widzisz błąd w tej lekcji?
Sprawdź się
Odpowiedz na pytania z tej lekcji. Wybierz odpowiedź, a od razu zobaczysz, czy jest poprawna.
1. Co to jest retry pattern w kontekście żądań HTTP?
2. Która technika jest najbardziej efektywna do debugowania nieobsłużonych błędów w Promise?
Zadania praktyczne w grze
- Edytor kodu
Napisz async function fetchWithRetry(url, maxRetries), która ponawia fetch po błędzie z rosnącym opóźnieniem.
- Układanie w pionie
Uporządkuj etapy wzorca retry z exponential backoff:
- Klikanie w kolejności
Ułóż elementy wyścigu Promise:
- Układanie w pionie
Uporządkuj kolejność wykonania tego kodu: console.log('A'); setTimeout(() => console.log('B'), 0); Promise.resolve().then(() => console.log('C')); console.log('D');
- Układanie w pionie
Uporządkuj kolejność przetwarzania kodu przez Event Loop:
- Układanie w pionie
Uporządkuj etapy pobierania danych z API:
Zadania po tej lekcji
- PytanieWzorzec retry
- Zadanie z kodemPraktyka: Wzorzec retry z async/await
- Ułóż w kolejnościEtapy retry z exponential backoff
- Kliknij w kolejnościSkładnia Promise.race
- Ułóż w kolejnościKolejność wykonania: synchroniczny vs asynchroniczny
- PytanieDebugowanie kodu asynchronicznego
- Ułóż w kolejnościPrzetwarzanie kodu przez Event Loop
- Ułóż w kolejnościEtapy obsługi żądania HTTP z async/await