Caching apa yang disediakan Laravel?

Question

Accepted Answer

Laravel menawarkan sistem **caching** yang unified dan ekspresif dengan multiple backends (Redis, Memcached, file, database, array) di balik satu API. Caching menyimpan hasil yang expensive sehingga tidak perlu dihitung ulang — salah satu optimasi performa dengan dampak tertinggi.

## 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() — the get-or-compute pattern (most useful)

```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()` adalah pola yang elegant dan umum: mengembalikan nilai cached jika ada, atau menghitungnya (menjalankan closure), caching-nya, dan mengembalikannya — dalam satu panggilan. Perfect untuk caching hasil query yang expensive.

## Configurable backends (Redis for 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.
```

Unified API berarti kode yang sama bekerja dengan backend apapun — dan **Redis** adalah standar untuk production (shared cache di multiple server instances).

## Cache invalidation (the hard part)

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

## Mengapa ini penting

Caching adalah salah satu optimasi performa dengan dampak tertinggi untuk aplikasi Laravel, dan sistem caching yang unified dan ekspresif dari framework membuat semuanya accessible — jadi memahami ini valuable untuk membangun aplikasi yang cepat dan scalable.

Core value-nya adalah menghindari repeated expensive work: caching hasil dari slow database queries, computations yang kompleks, atau external API calls berarti request berikutnya dilayani dengan cepat, dramatically mengurangi latency dan load.

Caching Laravel adalah elegant, terutama **`Cache::remember()` get-or-compute pattern** (mengembalikan cached data jika ada, atau menghitung, caching, dan mengembalikannya dalam satu clean call — ideal untuk caching query results), dan **unified API across backends**-nya berarti kode yang sama bekerja dengan driver apapun.

Mengetahui untuk menggunakan **Redis** untuk production (shared cache di multiple server instances — penting karena simpler per-server caches tidak shared ketika scaling horizontally) adalah poin architectural yang penting.

Equally penting adalah memahami kesulitan central dari caching — **invalidation** (clearing atau refreshing cached data ketika underlying data berubah, via TTLs, explicit `forget` pada writes, atau cache tags, untuk menghindari serving stale data) — karena getting ini wrong adalah classic caching failure yang menunjukkan users informasi outdated.

Memahami sistem caching Laravel — API, `remember` pattern, backend selection (Redis untuk scale), dan terutama invalidation strategies — adalah penting senior-level knowledge untuk membangun aplikasi Laravel yang performant dan scalable, karena caching memberikan major performance gains tetapi memerlukan careful invalidation untuk tetap correct.