Que caching o Laravel oferece?

Question

Accepted Answer

Laravel oferece um sistema de **caching** unificado e expressivo com múltiplos backends (Redis, Memcached, arquivo, banco de dados, array) por trás de uma única API. O caching armazena resultados caros para que não precisem ser recomputados — uma das otimizações de performance com maior impacto.

## A 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() — o padrão get-or-compute (mais útil)

```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()` é o padrão elegante e comum: ele retorna o valor em cache se presente, ou o computa (executando o closure), faz cache e retorna — em uma única chamada. Perfeito para fazer cache de resultados caros de queries.

## Backends configuráveis (Redis para produção)

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

A API unificada significa que o mesmo código funciona com qualquer backend — e **Redis** é o padrão para produção (um cache compartilhado entre múltiplas instâncias de servidor).

## Invalidação de cache (a parte difícil)

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

## Por que isso importa

Caching é uma das otimizações de performance com maior impacto para aplicações Laravel, e o sistema de caching unificado e expressivo do framework o torna acessível — então entender isso é valioso para construir aplicações rápidas e escaláveis.

O valor central é evitar trabalho caro repetido: fazer cache de resultados de queries de banco de dados lentas, computações complexas ou chamadas de API externas significa que requisições subsequentes são servidas rapidamente, reduzindo dramaticamente a latência e a carga.

O caching do Laravel é elegante, especialmente o **padrão get-or-compute `Cache::remember()`** (retornando dados em cache se presente, ou computando, fazendo cache e retornando em uma única chamada limpa — ideal para fazer cache de resultados de queries), e sua **API unificada entre backends** significa que o mesmo código funciona com qualquer driver.

Saber usar **Redis** para produção (um cache compartilhado entre múltiplas instâncias de servidor — importante já que caches mais simples por servidor não são compartilhados ao escalar horizontalmente) é um ponto arquitetônico importante.

Igualmente importante é entender a dificuldade central do caching — **invalidação** (limpar ou atualizar dados em cache quando os dados subjacentes mudam, via TTLs, `forget` explícito em escritas, ou cache tags, para evitar servir dados desatualizados) — já que acertar isso errado é a falha clássica de caching que mostra aos usuários informações desatualizadas.

Entender o sistema de caching do Laravel — a API, o padrão `remember`, seleção de backend (Redis para escala) e especialmente estratégias de invalidação — é conhecimento importante de nível sênior para construir aplicações Laravel performáticas e escaláveis, já que caching entrega ganhos de performance significativos mas requer invalidação cuidadosa para permanecer correto.