Source code aplikasi, template web, dan ebook. Unduh dari akun setelah bayar. Lihat produk

Blog / Performance, Caching & Scalability / Laravel Cache: Strategi Cache...
Performance, Caching & Scalability

Laravel Cache: Strategi Cache Data, Query, dan Halaman Tanpa Menyebabkan Data Kedaluwarsa

AD

Admin HijrahKreativa

Penulis

19 Oct 2026
14 min read
20 views

Memilih apa yang layak di-cache, merancang kunci cache yang aman, dan yang terpenting: kapan dan bagaimana cache dibuang saat data berubah. Membahas TTL, invalidasi berbasis event setelah commit, kunci berversi, cache tags, stale-while-revalidate dengan Cache::flexible, pencegahan stampede, cache fragmen dan halaman penuh, serta HTTP cache untuk browser dan CDN.

Overview

Ada pepatah lama di dunia pemrograman: hanya ada dua hal sulit, yaitu menamai sesuatu dan invalidasi cache. Menambahkan cache itu mudah:

$ringkasan = Cache::remember('dasbor:ringkasan', 3600, fn () => $this->hitungRingkasan());

Dasbor jadi cepat. Lalu bendahara mencatat pemasukan Rp500.000, membuka dasbor, dan saldo kas belum berubah. Ia mencatat ulang, dan sekarang ada transaksi ganda. Masalah performa selesai, berganti menjadi masalah kepercayaan terhadap data.

Kasus lain yang lebih berbahaya: halaman profil di-cache dengan kunci profil, lalu warga A melihat data milik warga B karena kunci cache tidak menyertakan ID pengguna.

Artikel ini membahas cache yang cepat dan tetap benar.

Hasil akhir:

  • panduan memilih apa yang di-cache dan berapa lama,
  • konvensi kunci cache yang aman dari kebocoran data antar-pengguna,
  • invalidasi berbasis event yang berjalan setelah transaksi commit,
  • kunci berversi dan cache tags untuk invalidasi berkelompok,
  • Cache::flexible (stale-while-revalidate) dan pencegahan stampede,
  • cache fragmen Blade, cache halaman publik, dan header HTTP cache,
  • test untuk memastikan cache dibuang saat data berubah.

Prerequisites

Komponen Versi
PHP 8.3+ (disarankan 8.4)
Laravel 13.x
Cache store Redis 7.x (dibutuhkan untuk cache tags)
Testing Pest 4

Step-by-step Tutorial

Langkah 1: Tentukan Apa yang Layak Di-cache

Kandidat Contoh Layak?
Perhitungan berat yang sering dibaca, jarang berubah Ringkasan kas bulanan, statistik dasbor Sangat layak
Data referensi Daftar RT, jenis iuran, pengaturan aplikasi Sangat layak
Respons API eksternal Data wilayah, kurs Layak; sesuaikan TTL dengan sumbernya
Halaman publik Daftar pengumuman, halaman profil RW Layak; HTTP cache/CDN
Daftar dengan filter dan pagination bebas Pencarian iuran dengan 8 filter Biasanya tidak: kombinasi kunci terlalu banyak, hit rate rendah; perbaiki query/index
Data yang harus akurat saat itu juga Saldo saat memproses pembayaran, stok, status pembayaran Jangan dibaca dari cache untuk keputusan
Query yang sudah cepat (< 5 ms) Mencari pengguna berdasarkan ID Tidak perlu; menambah kerumitan

Prinsip: cache dipakai untuk membaca dan menampilkan. Keputusan yang mengubah data (validasi saldo, pengecekan status) selalu membaca dari sumber aslinya.

Langkah 2: Konvensi Kunci Cache

Kunci cache yang tidak konsisten membuat invalidasi mustahil. Pusatkan pembuatan kunci:

// app/Support/Cache/KunciCache.php
namespace App\Support\Cache;

final class KunciCache
{
    public static function ringkasanKas(int $rwId, string $periode): string
    {
        return "rw:{$rwId}:kas:ringkasan:{$periode}";
    }

    public static function daftarRt(int $rwId): string
    {
        return "rw:{$rwId}:rt:daftar";
    }

    public static function tagihanKeluarga(int $keluargaId): string
    {
        return "keluarga:{$keluargaId}:tagihan:aktif";
    }

    public static function pengaturan(): string
    {
        return 'app:pengaturan';
    }
}

Aturan kunci:

  • Sertakan semua hal yang membuat hasil berbeda: ID tenant/RW, ID pengguna (bila data pribadi), periode, bahasa, peran (bila tampilan berbeda per peran).
  • Hierarkis (rw:{id}:kas:...) agar mudah dibaca dan dikelompokkan.
  • Jangan memakai input mentah pengguna sebagai kunci tanpa normalisasi; gunakan hash untuk kombinasi filter: 'cari:'.md5(json_encode($filterTervalidasi)).

Kebocoran data antar-pengguna lewat cache adalah bug keamanan, bukan sekadar bug tampilan. Bila ragu, sertakan ID pengguna di kunci.

Langkah 3: TTL sebagai Jaring Pengaman

Setiap entri cache sebaiknya punya TTL, bahkan bila sudah ada invalidasi berbasis event. Bila suatu saat invalidasi terlewat (bug, perubahan langsung di database, job gagal), TTL membatasi berapa lama data salah bertahan.

Data TTL Alasan
Pengaturan aplikasi 1 jam + invalidasi saat disimpan Jarang berubah
Daftar RT 1 hari + invalidasi Sangat jarang berubah
Ringkasan kas 10 menit + invalidasi Berubah setiap ada transaksi
Data wilayah dari API 7 hari Hampir tidak pernah berubah
Statistik publik 5 menit, tanpa invalidasi Selisih beberapa menit dapat diterima

Hindari Cache::forever() kecuali benar-benar ada invalidasi yang andal.

Langkah 4: Cache Query di Satu Tempat

Letakkan cache di service/query object, bukan tersebar di controller dan view:

// app/Modules/Kas/Queries/RingkasanKas.php
namespace App\Modules\Kas\Queries;

use App\Modules\Kas\Models\TransaksiKas;
use App\Support\Cache\KunciCache;
use Illuminate\Support\Facades\Cache;

final class RingkasanKas
{
    public function untuk(int $rwId, string $periode): array
    {
        return Cache::flexible(
            KunciCache::ringkasanKas($rwId, $periode),
            [600, 1800],                                  // segar 10 menit, boleh basi sampai 30 menit
            fn () => $this->hitung($rwId, $periode),
        );
    }

    public function hitungLangsung(int $rwId, string $periode): array
    {
        return $this->hitung($rwId, $periode);           // untuk keputusan yang butuh angka akurat
    }

    private function hitung(int $rwId, string $periode): array
    {
        $baris = TransaksiKas::where('rw_id', $rwId)
            ->where('periode', $periode)
            ->selectRaw("SUM(CASE WHEN jenis = 'masuk' THEN nominal ELSE 0 END) AS masuk")
            ->selectRaw("SUM(CASE WHEN jenis = 'keluar' THEN nominal ELSE 0 END) AS keluar")
            ->first();

        return [
            'masuk'  => (int) $baris->masuk,
            'keluar' => (int) $baris->keluar,
            'saldo'  => (int) $baris->masuk - (int) $baris->keluar,
            'dihitung_pada' => now()->toIso8601String(),
        ];
    }
}

Hal-hal penting:

  • Simpan array/data primitif, bukan model Eloquent atau koleksi besar. Model yang diserialisasi ikut membawa relasi dan atribut tersembunyi, ukurannya besar, dan bisa gagal dibaca setelah struktur kelas berubah.
  • dihitung_pada ditampilkan kecil di dasbor ("diperbarui 3 menit lalu"). Pengguna jadi paham bahwa angka itu ringkasan, bukan nilai real time.

Langkah 5: Cache::flexible (Stale-While-Revalidate)

Cache::flexible($kunci, [$segar, $basi], $callback) bekerja dalam tiga fase:

Umur data Perilaku
< $segar (10 menit) Kembalikan dari cache
antara $segar dan $basi (10–30 menit) Kembalikan data lama segera, lalu hitung ulang di belakang layar setelah respons dikirim
> $basi atau belum ada Hitung sekarang (pengguna menunggu)

Dengan ini, pengguna hampir tidak pernah menunggu perhitungan ulang, dan hanya satu proses yang menghitung ulang (Laravel memakai lock). Cocok untuk dasbor dan statistik.

Langkah 6: Invalidasi Berbasis Event, Setelah Commit

TTL saja berarti bendahara bisa melihat saldo lama selama 10 menit. Untuk data yang ia ubah sendiri, buang cache segera saat data berubah.

// app/Modules/Kas/Observers/TransaksiKasObserver.php
namespace App\Modules\Kas\Observers;

use App\Modules\Kas\Models\TransaksiKas;
use App\Support\Cache\KunciCache;
use Illuminate\Contracts\Events\ShouldHandleEventsAfterCommit;
use Illuminate\Support\Facades\Cache;

final class TransaksiKasObserver implements ShouldHandleEventsAfterCommit
{
    public function saved(TransaksiKas $trx): void
    {
        $this->buang($trx);

        // Bila periode berubah, cache periode lama juga harus dibuang
        // getPrevious(): nilai sebelum save terakhir. getOriginal() sudah berisi nilai baru
        // karena observer ini baru berjalan setelah commit (setelah syncOriginal).
        if ($trx->wasChanged('periode')) {
            Cache::forget(KunciCache::ringkasanKas($trx->rw_id, $trx->getPrevious()['periode']));
        }
    }

    public function deleted(TransaksiKas $trx): void
    {
        $this->buang($trx);
    }

    private function buang(TransaksiKas $trx): void
    {
        Cache::forget(KunciCache::ringkasanKas($trx->rw_id, $trx->periode));
    }
}
// app/Modules/Kas/Models/TransaksiKas.php
use Illuminate\Database\Eloquent\Attributes\ObservedBy;

#[ObservedBy(TransaksiKasObserver::class)]
class TransaksiKas extends Model { /* ... */ }

Mengapa setelah commit? Bila cache dibuang di dalam transaksi, ada jeda sebelum commit. Request lain yang masuk pada jeda itu membaca data lama dari database (karena belum commit), lalu menyimpannya kembali ke cache. Setelah commit, cache berisi data lama dan bertahan sampai TTL habis. ShouldHandleEventsAfterCommit membuat observer baru berjalan setelah transaksi selesai.

Keterbatasan observer: query massal seperti TransaksiKas::where(...)->update([...]) tidak memicu event model. Untuk operasi massal, buang cache secara eksplisit setelahnya, atau gunakan kunci berversi (Langkah 7).

Bila invalidasi dipicu dari modul lain, lebih baik lewat event domain (misalnya IuranDilunasi) yang didengar listener di modul pemilik cache.

Langkah 7: Kunci Berversi untuk Invalidasi Berkelompok

Bagaimana membuang semua cache milik satu RW (ringkasan semua periode, daftar, statistik) tanpa tahu satu per satu kuncinya? Gunakan nomor versi di dalam kunci:

// app/Support/Cache/VersiCache.php
namespace App\Support\Cache;

use Illuminate\Support\Facades\Cache;

final class VersiCache
{
    public static function ambil(string $ruang): int
    {
        return (int) Cache::rememberForever("versi:{$ruang}", fn () => 1);
    }

    public static function naikkan(string $ruang): void
    {
        Cache::add("versi:{$ruang}", 1);
        Cache::increment("versi:{$ruang}");
    }
}
$versi = VersiCache::ambil("rw:{$rwId}");
$kunci = "rw:{$rwId}:v{$versi}:kas:ringkasan:{$periode}";

VersiCache::naikkan("rw:{$rwId}") membuat semua kunci lama tidak pernah dibaca lagi (versinya sudah berbeda) dan dibiarkan kedaluwarsa oleh TTL atau dibuang LRU Redis. Cara ini bekerja di semua driver cache dan aman untuk operasi massal.

Kunci versi disimpan dengan rememberForever, jadi pastikan instance cache memakai kebijakan eviction yang tepat: bila kunci versi ter-evict, versi kembali ke 1 dan data dengan v1 yang mungkin masih tersisa bisa terbaca lagi. Untuk menghindarinya, simpan kunci versi di store redis dengan koneksi data (noeviction), atau di database.

Langkah 8: Cache Tags (Redis)

Driver Redis dan Memcached mendukung tags untuk mengelompokkan entri:

Cache::tags(["rw:{$rwId}", 'kas'])->remember(KunciCache::ringkasanKas($rwId, $periode), 600, fn () => ...);

// Buang semua cache kas milik RW ini
Cache::tags(["rw:{$rwId}", 'kas'])->flush();

Catatan:

  • Saat membaca, tags yang dipakai harus sama persis dengan saat menyimpan.
  • Tags tidak didukung driver file, database, dan dynamodb.
  • Untuk portabilitas antar-driver, kunci berversi (Langkah 7) adalah alternatif yang lebih sederhana.

Langkah 9: Mencegah Cache Stampede

Ketika entri populer kedaluwarsa dan banyak request datang bersamaan, semuanya menghitung ulang dan membebani database. Cara mencegahnya:

  1. Cache::flexible (Langkah 5): sudah memakai lock untuk perhitungan ulang.
  2. Lock eksplisit untuk remember biasa:
public function rememberDenganLock(string $kunci, int $ttl, \Closure $hitung): mixed
{
    if (($nilai = Cache::get($kunci)) !== null) {
        return $nilai;
    }

    return Cache::lock("lock:{$kunci}", 15)->block(10, function () use ($kunci, $ttl, $hitung) {
        return Cache::get($kunci) ?? tap($hitung(), fn ($v) => Cache::put($kunci, $v, $ttl));
    });
}
  1. TTL dengan jitter untuk banyak kunci yang dibuat bersamaan (misalnya cache semua RT dibuat saat deploy), agar tidak kedaluwarsa serentak: 600 + random_int(0, 120).
  2. Pemanasan cache lewat job terjadwal untuk data yang pasti dibuka (dasbor awal bulan).

Langkah 10: Cache per Request dengan memo dan once

Bila data yang sama dibaca berkali-kali dalam satu request (pengaturan dibaca di layout, sidebar, dan 10 komponen), bahkan Redis pun dipanggil berkali-kali.

// Memo di atas store mana pun: panggilan berikutnya dalam request yang sama tidak menyentuh Redis
$pengaturan = Cache::memo()->remember(KunciCache::pengaturan(), 3600, fn () => Pengaturan::pluck('nilai', 'kunci')->all());
// once(): hasil method disimpan per instance objek selama request
public function peranAktif(): array
{
    return once(fn () => $this->roles()->pluck('name')->all());
}

Langkah 11: Cache Fragmen HTML

Untuk bagian halaman yang mahal dibuat (misalnya widget statistik dengan banyak query dan perulangan), cache HTML hasil render sekaligus data di dalamnya. Kuncinya: data diambil di dalam closure cache, sehingga saat cache masih berlaku tidak ada query yang berjalan sama sekali.

// app/Modules/Laporan/Fragmen/StatistikRw.php
namespace App\Modules\Laporan\Fragmen;

use App\Support\Cache\VersiCache;
use Illuminate\Support\Facades\Cache;
use Illuminate\Support\HtmlString;

final class StatistikRw
{
    public function __construct(private StatistikQuery $statistik) {}

    public function html(int $rwId): HtmlString
    {
        $versi = VersiCache::ambil("rw:{$rwId}");

        $html = Cache::remember("fragmen:rw:{$rwId}:v{$versi}:statistik", 600, function () use ($rwId) {
            return view('dasbor.partials.statistik', [
                'statistik' => $this->statistik->untuk($rwId),     // query berat hanya saat cache kosong
            ])->render();
        });

        return new HtmlString($html);
    }
}
// Controller
return view('dasbor.index', [
    'statistikHtml' => app(StatistikRw::class)->html($rw->id),
]);
{{-- resources/views/dasbor/index.blade.php --}}
<section aria-label="Statistik RW">
    {{ $statistikHtml }}   {{-- HtmlString tidak di-escape ulang --}}
</section>

Partial yang di-cache harus bersifat sama untuk semua yang berbagi kunci tersebut. Jangan meng-cache fragmen yang berisi token CSRF, nama pengguna yang login, atau tombol yang tergantung izin, kecuali kunci menyertakan pengguna atau peran yang bersangkutan.

Langkah 12: Cache Halaman Publik dan HTTP Cache

Halaman publik (daftar pengumuman, profil RW) sama untuk semua pengunjung tamu. Cara paling efisien adalah membiarkan browser dan CDN meng-cache-nya, sehingga request bahkan tidak sampai ke PHP.

Laravel menyediakan middleware cache.headers:

// routes/web.php
Route::middleware('cache.headers:public;max_age=300;s_maxage=600;etag')->group(function () {
    Route::get('/pengumuman', [PengumumanPublikController::class, 'index'])->name('publik.pengumuman');
    Route::get('/pengumuman/{pengumuman:slug}', [PengumumanPublikController::class, 'show']);
});
Direktif Arti
public Boleh disimpan cache bersama (CDN, proxy)
max_age=300 Browser memakai salinan 5 menit
s_maxage=600 CDN memakai salinan 10 menit
etag Laravel menghitung ETag dari isi respons; browser mengirim If-None-Match dan menerima 304 Not Modified bila tidak berubah

Syarat aman untuk cache publik:

  • Halaman tidak bergantung pada pengguna yang login (tidak ada nama, menu admin, atau token CSRF di formulir).
  • Tidak ada cookie session yang di-set pada respons tersebut. Route di grup web memulai session dan mengirim cookie, sehingga banyak CDN menolak meng-cache-nya. Untuk halaman publik murni, pertimbangkan grup middleware tanpa session (withoutMiddleware([StartSession::class, ...])) atau atur CDN agar mengabaikan cookie hanya pada path publik.
  • Halaman yang menampilkan data pribadi selalu Cache-Control: private, no-store.

Saat pengumuman diterbitkan atau diubah, minta CDN membuang cache path tersebut (purge) lewat API CDN di observer/listener, atau terima jeda sesuai s_maxage.

Cache halaman penuh di aplikasi (tanpa CDN) bisa dibuat dengan middleware yang menyimpan respons untuk tamu:

// app/Http/Middleware/CacheHalamanTamu.php
public function handle(Request $request, Closure $next, int $ttl = 300)
{
    if ($request->user() || ! $request->isMethod('GET') || $request->query()) {
        return $next($request);
    }

    $kunci = 'halaman:'.sha1($request->getHost().$request->getPathInfo());

    if ($html = Cache::get($kunci)) {
        return response($html)->header('X-Cache', 'HIT');
    }

    $respons = $next($request);

    if ($respons->isSuccessful() && ! $respons->headers->has('Set-Cookie')) {
        Cache::put($kunci, $respons->getContent(), $ttl);
    }

    return $respons->header('X-Cache', 'MISS');
}

Set-Cookie dicek di objek respons, tetapi cookie session baru ditambahkan oleh middleware StartSession setelah middleware ini selesai bila urutannya di dalam grup web. Pasang middleware ini di grup tanpa session agar pengecekannya benar.

Langkah 13: Test Invalidasi

// tests/Feature/Cache/RingkasanKasCacheTest.php
use Illuminate\Support\Facades\Cache;

beforeEach(fn () => config(['cache.default' => 'array']));

it('ringkasan kas diperbarui setelah transaksi baru disimpan', function () {
    $rw = RukunWarga::factory()->create();
    TransaksiKas::factory()->for($rw, 'rukunWarga')->create(['jenis' => 'masuk', 'nominal' => 100_000, 'periode' => '2026-10']);

    $query = app(RingkasanKas::class);
    expect($query->untuk($rw->id, '2026-10')['saldo'])->toBe(100_000);

    TransaksiKas::factory()->for($rw, 'rukunWarga')->create(['jenis' => 'masuk', 'nominal' => 50_000, 'periode' => '2026-10']);

    expect($query->untuk($rw->id, '2026-10')['saldo'])->toBe(150_000);
});

it('kunci cache berbeda per RW (tidak bocor antar-tenant)', function () {
    expect(KunciCache::ringkasanKas(1, '2026-10'))->not->toBe(KunciCache::ringkasanKas(2, '2026-10'));
});

it('halaman publik mengirim header cache', function () {
    $this->get('/pengumuman')
        ->assertOk()
        ->assertHeader('Cache-Control')
        ->assertHeader('ETag');
});

it('halaman pribadi tidak boleh di-cache publik', function () {
    $warga = User::factory()->create()->assignRole('warga');

    $res = $this->actingAs($warga)->get('/tagihan-saya')->assertOk();

    expect($res->headers->get('Cache-Control'))->not->toContain('public');
});

Test pertama berjalan karena di dalam test, transaksi RefreshDatabase dianggap level dasar, sehingga observer ShouldHandleEventsAfterCommit tetap dijalankan setelah operasi simpan.

Troubleshooting

Error / Gejala Penyebab Solusi
Data di dasbor tidak berubah setelah disimpan Tidak ada invalidasi Observer/listener yang membuang kunci
Kadang masih data lama walau sudah di-invalidate Invalidasi di dalam transaksi ShouldHandleEventsAfterCommit
Update massal tidak membuang cache Query massal tidak memicu event model Invalidasi eksplisit atau kunci berversi
Pengguna melihat data pengguna lain Kunci cache tanpa ID pengguna/tenant Sertakan ID di kunci; tinjau semua remember
This cache store does not support tagging Driver file/database Redis/Memcached atau kunci berversi
Database melonjak saat cache kedaluwarsa Stampede Cache::flexible, lock, jitter
Error setelah deploy saat membaca cache Model/kelas yang diserialisasi berubah Simpan array primitif; naikkan versi kunci saat deploy
Halaman publik tidak di-cache CDN Respons membawa Set-Cookie Route publik tanpa session
Token CSRF salah (419) di halaman ter-cache Fragmen/halaman berisi token pengguna lain Jangan cache bagian berisi CSRF; ambil token lewat JS/meta terpisah
Hit rate rendah Kunci terlalu spesifik (filter bebas) Cache hanya kombinasi umum atau perbaiki query

Best Practices

Keamanan

  • Kunci cache selalu memuat ID tenant dan pengguna untuk data yang tidak publik.
  • Halaman berisi data pribadi: Cache-Control: private, no-store.
  • Jangan menyimpan token, password, atau data sensitif lain di cache bersama.
  • Keputusan yang mengubah data membaca dari sumber asli, bukan cache.

Performa

  • Cache::flexible untuk dasbor dan statistik.
  • Lock dan jitter untuk mencegah stampede.
  • memo/once untuk data yang dibaca berulang dalam satu request.
  • HTTP cache dan CDN untuk halaman publik, sehingga request tidak sampai ke PHP.

Maintainability

  • Kunci dibuat di satu kelas (KunciCache).
  • Cache diletakkan di query object/service, bukan tersebar di controller dan view.
  • Setiap cache punya TTL sebagai jaring pengaman, ditambah invalidasi eksplisit.
  • Test bahwa data berubah setelah disimpan, dan bahwa kunci tidak bocor antar-tenant.

Related Articles

Last Tested

Komponen Versi
Laravel 13.x
PHP 8.4
Redis 7.x
Pest 4.x
Tanggal 19 Oktober 2026

Bagikan artikel:

Artikel lainnya