Laravel erbjuder ett enhetligt, expressivt cachesystem med flera backends (Redis, Memcached, fil, databas, array) bakom ett gemensamt API. Caching lagrar dyra resultat så de inte behöver räknas om — en av de högsta påverkande prestandaoptimeringarna.
Cache-API
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() — get-or-compute-mönstret (mest användbart)
// 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() är det eleganta, vanliga mönstret: det returnerar det cachade värdet om det finns, eller beräknar det (kör closuren), cachar det och returnerar det — i ett anrop. Perfekt för att cacha dyra frågeresultat.
Konfigurerbara backends (Redis för produktion)
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.
Det enhetliga API:et betyder att samma kod fungerar med valfri backend — och Redis är standarden för produktion (en delad cache över flera serverinstanser).
Cache-invalidering (den svåra delen)
// 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)
Varför det är viktigt
Caching är en av de högsta påverkande prestandaoptimeringarna för Laravel-applikationer, och ramverkets enhetliga, expressiva cachesystem gör det tillgängligt — så att förstå det är värdefullt för att bygga snabba, skalbara applikationer.
Kärnvärdet är att undvika upprepad dyrt arbete: caching av resultaten från långsamma databasfrågor, komplexa beräkningar eller externa API-anrop betyder att efterföljande förfrågningar serveras snabbt, vilket dramatiskt minskar latens och belastning.
Laravel:s caching är elegant, särskilt Cache::remember() get-or-compute-mönstret (returnera cachade data om de finns, eller beräkna, cacha och returnera det i ett rent anrop — idealt för att cacha frågeresultat), och dess enhetliga API över backends betyder att samma kod fungerar med vilken driver som helst.
Att veta att använda Redis för produktion (en delad cache över flera serverinstanser — viktigt eftersom enklare per-server-cachees inte delas vid horisontell skalning) är en viktig arkitekturpunkt.
Lika viktigt är att förstå cachings centrala svårighet — invalidering (rensa eller uppdatera cachade data när de underliggande data ändras, via TTL:er, explicit forget vid skrivningar eller cache-taggar, för att undvika att servera föråldrad data) — eftersom att göra detta fel är det klassiska caching-misslyckandet som visar användare föråldrad information.
Att förstå Laravel:s cachesystem — API:et, remember-mönstret, backend-val (Redis för skalning) och särskilt invalideringstrategier — är viktig senior-nivå-kunskap för att bygga högpresterande, skalbara Laravel-applikationer, eftersom caching ger stora prestandavinster men kräver försiktig invalidering för att förbli korrekt.