Quel système de cache Laravel propose-t-il ?

Question

Accepted Answer

Laravel propose un système de cache **unifié et expressif** avec plusieurs backends (Redis, Memcached, fichier, base de données, tableau) derrière une API unique. Le cache stocke les résultats coûteux pour éviter qu'ils ne soient recalculés — l'une des optimisations de performance ayant le plus grand impact.

## L'API de cache

```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() — le motif get-or-compute (le plus utile)

```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()` est le motif élégant et courant : il retourne la valeur en cache si elle existe, ou la calcule (en exécutant la closure), la met en cache et la retourne — en un seul appel. Parfait pour mettre en cache les résultats de requêtes coûteuses.

## Backends configurables (Redis en production)

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

L'API unifié signifie que le même code fonctionne avec n'importe quel backend — et **Redis** est le standard pour la production (un cache partagé sur plusieurs instances de serveur).

## Invalidation du cache (la partie difficile)

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

## Pourquoi c'est important

Le cache est l'une des optimisations de performance ayant le plus grand impact pour les applications Laravel, et le système de cache unifié et expressif du framework le rend accessible — donc le comprendre est précieux pour construire des applications rapides et scalables.

La valeur principale est d'éviter de répéter un travail coûteux : mettre en cache les résultats des requêtes de base de données lentes, des calculs complexes ou des appels externes à une API signifie que les requêtes suivantes sont servies rapidement, réduisant drastiquement la latence et la charge.

Le cache de Laravel est élégant, en particulier le **motif get-or-compute `Cache::remember()`** (retournant les données en cache si présentes, ou les calculant, les mettant en cache et les retournant en un seul appel propre — idéal pour mettre en cache les résultats de requêtes), et son **API unifiée entre les backends** signifie que le même code fonctionne avec n'importe quel driver.

Savoir utiliser **Redis** en production (un cache partagé sur plusieurs instances de serveur — important car les caches plus simples par serveur ne sont pas partagés lors de la mise à l'échelle horizontale) est un point architectural important.

Tout aussi important est de comprendre la difficulté centrale du cache — **l'invalidation** (effacer ou actualiser les données en cache quand les données sous-jacentes changent, via les TTL, l'oubli explicite `forget` lors des écritures, ou les tags de cache, pour éviter de servir des données obsolètes) — car mal faire cela est l'échec classique du cache qui montre aux utilisateurs des informations obsolètes.

Comprendre le système de cache de Laravel — l'API, le motif `remember`, la sélection du backend (Redis pour la scalabilité) et surtout les stratégies d'invalidation — est une connaissance importante au niveau senior pour construire des applications Laravel performantes et scalables, car le cache offre des gains de performance majeurs mais nécessite une invalidation soigneuse pour rester correct.