Jaké caching možnosti poskytuje Laravel?

Question

Accepted Answer

Laravel nabízí jednotný, expresivní **caching systém** s více backendy (Redis, Memcached, soubor, databáze, pole) za jedním API. Caching ukládá nákladné výsledky, aby je nebylo třeba přepočítávat — jedná se o jednu z nejsilnějších optimalizací výkonu.

## 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() — get-or-compute pattern (nejužitečnější)

```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()` je elegantní, běžný pattern: vrací cachovanou hodnotu, pokud existuje, nebo ji vypočítá (spuštěním closure), cachuje ji a vrací — vše v jednom volání. Ideální pro cachování nákladných výsledků dotazů.

## Konfigurovatelné backendy (Redis pro produkci)

```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.
```

Jednotné API znamená, že stejný kód funguje s libovolným backendem — a **Redis** je standard pro produkci (sdílená cache napříč více server instancemi).

## Cache invalidace (složitá část)

```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)
```

## Proč je to důležité

Caching je jednou z nejsilnějších optimalizací výkonu pro Laravel aplikace a jednotný, expresivní caching systém frameworku jej činí přístupným — takže jeho pochopení je cenné pro budování rychlých, škálovatelných aplikací.

Jádrová hodnota spočívá v vyhýbání se opakované nákladné práci: cachování výsledků pomalých databázových dotazů, složitých výpočtů nebo volání externích API znamená, že následné požadavky jsou obsluhovány rychle, což dramaticky snižuje latenci a zátěž.

Caching Laravel je elegantní, zvláště **`Cache::remember()` get-or-compute pattern** (vrácení cachovaných dat, pokud existují, nebo jejich vypočítání, cachování a vrácení v jednom čistém volání — ideální pro cachování výsledků dotazů), a jeho **jednotné API napříč backendy** znamená, že stejný kód funguje s libovolným driverem.

Znalost použití **Redis** pro produkci (sdílená cache napříč více server instancemi — důležité, protože jednoduché per-server cache nejsou sdíleny při horizontálním škálování) je důležitý architektonický bod.

Rovněž důležité je pochopení centrální obtíže cachingu — **invalidace** (vymazání nebo obnovení cachovaných dat, když se podkladová data změní, prostřednictvím TTL, explicitního `forget` při zápisu nebo cache tagů, aby se zabránilo poskytování zastaralých dat) — protože chyba v tomto ohledu je klasickou chybou cachingu, která způsobuje, že uživatelé vidí zastaralé informace.

Pochopení caching systému Laravel — API, `remember` pattern, výběr backendu (Redis pro škálování) a zejména strategie invalidace — je důležitá znalost na seniorské úrovni pro budování výkonných, škálovatelných Laravel aplikací, protože caching přináší velké zisky na výkonu, ale vyžaduje opatrnou invalidaci, aby zůstal správný.