Welke caching biedt Laravel?

Question

Accepted Answer

Laravel biedt een uniforme, expressieve **caching-system** met meerdere backends (Redis, Memcached, bestand, database, array) achter een enkele API. Caching slaat dure resultaten op zodat ze niet opnieuw hoeven te worden berekend — een van de meest impactvolle prestatieoptimalisaties.

## 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() — het get-or-compute patroon (het meest nuttig)

```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()` is het elegante, veelgebruikte patroon: het retourneert de gecachte waarde indien aanwezig, of berekent deze (voert de closure uit), cached deze en retourneert deze — in één aanroep. Perfect voor het cachen van dure queryresultaten.

## Configureerbare backends (Redis voor productie)

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

De uniforme API betekent dat dezelfde code met elke backend werkt — en **Redis** is de standaard voor productie (een gedeelde cache over meerdere serverinstanties).

## Cache invalidatie (het moeilijke deel)

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

## Waarom het belangrijk is

Caching is een van de meest impactvolle prestatieoptimalisaties voor Laravel-applicaties, en het framework's uniforme, expressieve caching-system maakt het toegankelijk — dus het begrijpen ervan is waardevol voor het bouwen van snelle, schaalbare applicaties.

De kernwaarde is het vermijden van herhaalde dure arbeid: het cachen van resultaten van trage databasequery's, complexe berekeningen of externe API-aanroepen betekent dat volgende verzoeken snel worden bediend, wat latentie en belasting dramatisch vermindert.

De caching van Laravel is elegant, vooral het **`Cache::remember()` get-or-compute patroon** (gecachte gegevens retourneren indien aanwezig, of berekenen, cachen en retourneren in één schone aanroep — ideaal voor het cachen van queryresultaten), en de **uniforme API over backends** betekent dat dezelfde code met elke driver werkt.

Weten dat je **Redis** voor productie moet gebruiken (een gedeelde cache over meerdere serverinstanties — belangrijk omdat eenvoudigere per-server caches niet worden gedeeld bij horizontale schaling) is een belangrijk architectuurpunt.

Evenals belangrijk is het begrijpen van het centrale probleem van caching — **invalidatie** (gecachte gegevens wissen of vernieuwen wanneer de onderliggende gegevens veranderen, via TTL's, expliciete `forget` bij schrijfbewerkingen, of cache tags, om het serveren van verouderde gegevens te voorkomen) — omdat dit verkeerd doen de klassieke caching-fout is die gebruikers verouderde informatie toont.

Het begrijpen van het caching-system van Laravel — de API, het `remember` patroon, backend-selectie (Redis voor schaal), en vooral invalidatiestrategieën — is belangrijke kennis op seniorniveau voor het bouwen van performante, schaalbare Laravel-applicaties, omdat caching grote prestatiewinsten oplevert, maar voorzichtige invalidatie vereist om correct te blijven.