Jakie cachowanie oferuje Laravel?

Question

Accepted Answer

Laravel oferuje ujednolicony, ekspresyjny **system cachowania** z wieloma backendami (Redis, Memcached, plik, baza danych, tablica) za pojedynczym API. Cachowanie przechowuje drogi wyniki obliczeń, tak aby nie trzeba było ich przeliczać — jedna z najwyższych optymalizacji wydajności.

## The cache API

```php
use Illuminate\Support\Facades\Cache;

Cache::put('key', $value, 3600);          // store for 1 hour (seconds)
Cache::get('key');                         // retrieve (null if missing)
Cache::get('key', 'default');              // with a default
Cache::has('key');
Cache::forget('key');                      // delete (invalidate)
Cache::forever('key', $value);             // store with no expiry
```

## remember() — wzorzec get-or-compute (najbardziej przydatny)

```php
// if cached, return it; otherwise run the closure, cache the result, and return it
$users = Cache::remember('active_users', 3600, function () {
    return User::where('active', true)->get();   // expensive query — cached for 1 hour
});
```

`Cache::remember()` to elegancki, powszechny wzorzec: zwraca wartość z cache'u jeśli jest dostępna, lub oblicza ją (uruchamiając closure), cachuje ją i zwraca — w jednym wywołaniu. Idealny do cachowania drogi wyników zapytań.

## Konfigurowalne backendy (Redis do produkcji)

```text
config/cache.php → choose the driver:
  redis     → fast, SHARED across servers (production standard for multi-server apps)
  memcached → fast, shared
  file/database → simpler, for smaller/single-server setups
  array     → in-memory, for testing
The SAME Cache API works regardless of backend → easy to switch.
```

Ujednolicone API oznacza, że ten sam kod działa z każdym backendem — a **Redis** to standard do produkcji (wspólny cache na wielu instancjach serwerów).

## Invalidacja cache'u (trudna część)

```php
// when data changes, clear the affected cache or it serves stale data
public function updateUser($user, $data) {
    $user->update($data);
    Cache::forget('active_users');     // INVALIDATE so the next read recomputes
}
// strategies: TTL (accept brief staleness), explicit forget on writes, cache tags
Cache::tags(['users'])->flush();        // tagged invalidation (Redis/Memcached)
```

## Dlaczego to ważne

Cachowanie to jedna z najwyższych optymalizacji wydajności dla aplikacji Laravel, a ujednolicony, ekspresyjny system cachowania frameworku sprawia, że jest dostępny — dlatego jego zrozumienie jest cenne dla budowania szybkich, skalowalnych aplikacji.

Wartością fundamentalną jest uniknięcie powtarzanego, drogiego pracy: cachowanie wyników wolnych zapytań do bazy danych, złożonych obliczeń lub wywołań zewnętrznych API oznacza, że kolejne żądania są obsługiwane szybko, dramatycznie zmniejszając opóźnienie i obciążenie.

Cachowanie Laravel'a jest eleganckie, zwłaszcza **`Cache::remember()` wzorzec get-or-compute** (zwracanie danych z cache'u jeśli są dostępne, lub obliczanie, cachowanie i zwracanie ich w jednym czystym wywołaniu — idealne do cachowania wyników zapytań), a jego **ujednolicone API między backendami** oznacza, że ten sam kod działa z każdym driverem.

Ważnym punktem architektonicznym jest wiedza, by używać **Redis** do produkcji (wspólny cache na wielu instancjach serwerów — ważne, ponieważ prostsze cache'e per-serwer nie są dzielone podczas skalowania poziomego).

Również ważne jest zrozumienie centralnej trudności cachowania — **invalidacji** (czyszczenie lub odświeżanie cached danych gdy dane źródłowe się zmieniają, poprzez TTL, jawne `forget` przy pisaniu, lub cache tagi, aby uniknąć serwowania nieaktualnych danych) — ponieważ źle to zrobić to klasyczna awaria cachowania, która pokazuje użytkownikom starą informację.

Zrozumienie systemu cachowania Laravel'a — API, wzorca `remember`, wyboru backendu (Redis do skali), a zwłaszcza strategii invalidacji — to ważna wiedza na poziomie seniora do budowania wydajnych, skalowalnych aplikacji Laravel, ponieważ cachowanie daje duże zyski wydajności ale wymaga ostrożnej invalidacji, aby pozostać poprawnym.