Caching apakah yang disediakan oleh Laravel?

Question

Accepted Answer

Laravel menawarkan **sistem caching** yang bersatu dan ekspresif dengan pelbagai backend (Redis, Memcached, fail, pangkalan data, array) di sebalik satu API tunggal. Caching menyimpan hasil yang mahal supaya ia tidak perlu dikira semula — salah satu pengoptimuman prestasi yang paling berimpak tinggi.

## API 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() — corak get-or-compute (paling berguna)

```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()` ialah corak yang elegan dan lazim: ia memulangkan nilai yang di-cache jika ada, atau mengiranya (menjalankan closure), men-cache-nya, dan memulangkannya — dalam satu panggilan. Sesuai untuk men-cache hasil query yang mahal.

## Backend boleh dikonfigurasi (Redis untuk produksi)

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

API yang bersatu bermakna kod yang sama berfungsi dengan mana-mana backend — dan **Redis** ialah standard untuk produksi (cache yang dikongsi merentas pelbagai instance pelayan).

## Pembatalan cache (bahagian yang sukar)

```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 ia penting

Caching ialah salah satu pengoptimuman prestasi yang paling berimpak tinggi untuk aplikasi Laravel, dan sistem caching yang bersatu dan ekspresif dalam framework ini menjadikannya mudah diakses — jadi memahaminya bernilai untuk membina aplikasi yang pantas dan boleh skala.

Nilai terasnya ialah mengelakkan kerja mahal yang berulang: men-cache hasil query pangkalan data yang perlahan, pengiraan rumit, atau panggilan API luaran bermakna permintaan seterusnya dilayan dengan pantas, mengurangkan latency dan beban secara mendadak.

Caching Laravel adalah elegan, terutamanya **corak get-or-compute `Cache::remember()`** (memulangkan data yang di-cache jika ada, atau mengira, men-cache, dan memulangkannya dalam satu panggilan yang bersih — ideal untuk men-cache hasil query), dan **API yang bersatu merentas backend** bermakna kod yang sama berfungsi dengan mana-mana driver.

Mengetahui untuk menggunakan **Redis** untuk produksi (cache yang dikongsi merentas pelbagai instance pelayan — penting kerana cache per-pelayan yang lebih ringkas tidak dikongsi apabila skala secara mendatar) ialah satu titik seni bina yang penting.

Sama penting ialah memahami kesukaran utama caching — **pembatalan** (membersihkan atau menyegarkan data yang di-cache apabila data asas berubah, melalui TTL, `forget` eksplisit semasa penulisan, atau cache tag, untuk mengelakkan menyajikan data lapuk) — kerana melakukannya dengan salah ialah kegagalan caching klasik yang menunjukkan maklumat ketinggalan zaman kepada pengguna.

Memahami sistem caching Laravel — API, corak `remember`, pemilihan backend (Redis untuk skala), dan terutamanya strategi pembatalan — ialah pengetahuan peringkat senior yang penting untuk membina aplikasi Laravel yang berprestasi dan boleh skala, kerana caching memberikan peningkatan prestasi yang besar tetapi memerlukan pembatalan yang teliti supaya kekal betul.