101 lines
3.3 KiB
Markdown
101 lines
3.3 KiB
Markdown
# Caching best practices
|
|
|
|
## Use `Cache::remember()` for cache-aside reads
|
|
|
|
`Cache::remember()` implements a cache-aside read without a separate truthiness check. It does not prevent concurrent requests from computing the same missing value. When you must prevent duplicate computation, use an atomic lock.
|
|
|
|
The manual version below treats valid falsy values, such as `false` or `0`, as cache misses.
|
|
|
|
Incorrect:
|
|
|
|
```php
|
|
$val = Cache::get('stats');
|
|
if (! $val) {
|
|
$val = $this->computeStats();
|
|
Cache::put('stats', $val, 60);
|
|
}
|
|
```
|
|
|
|
Correct:
|
|
|
|
```php
|
|
$val = Cache::remember('stats', 60, fn () => $this->computeStats());
|
|
```
|
|
|
|
## Consider `Cache::flexible()` for stale-while-revalidate
|
|
|
|
For frequently read keys, `Cache::flexible()` can serve stale data during a defined stale period and register a deferred refresh. During an HTTP request, that refresh normally runs after the response. The refresh is not a durable background job. After the stale period ends, the request recomputes the value synchronously.
|
|
|
|
Synchronous expiration:
|
|
|
|
```php
|
|
Cache::remember('users', 300, fn () => User::all());
|
|
```
|
|
|
|
Stale-while-revalidate tradeoff:
|
|
|
|
```php
|
|
Cache::flexible('users', [300, 600], fn () => User::all());
|
|
```
|
|
|
|
In this example, the value is fresh for five minutes. Laravel may serve the stale value until ten minutes after it was cached.
|
|
|
|
## Use `Cache::memo()` to avoid redundant hits within an execution
|
|
|
|
When code reads the same cache key repeatedly during one request or job, `memo()` decorates a cache store and keeps resolved values in memory for that execution.
|
|
|
|
```php
|
|
$settings = Cache::memo()->get('settings');
|
|
```
|
|
|
|
Repeated reads through the same memoized store avoid additional store lookups. Writes through the memoized store update or invalidate its in-memory values as appropriate.
|
|
|
|
## Use cache tags to invalidate related groups
|
|
|
|
Tags group related entries for invalidation without tracking each key. The `file`, `dynamodb`, and `database` drivers do not support cache tags. Confirm that a store supports tags before you choose it.
|
|
|
|
```php
|
|
Cache::tags(['user-1'])->flush();
|
|
```
|
|
|
|
## Use `Cache::add()` for atomic conditional writes
|
|
|
|
`add()` atomically writes a value only when the key does not already exist.
|
|
|
|
Incorrect:
|
|
|
|
```php
|
|
if (! Cache::has('lock')) {
|
|
Cache::put('lock', true, 10);
|
|
}
|
|
```
|
|
|
|
Correct:
|
|
|
|
```php
|
|
Cache::add('lock', true, 10);
|
|
```
|
|
|
|
When you need lock ownership and safe release, use `Cache::lock()` instead of an ordinary cache key.
|
|
|
|
## Use `once()` for in-process memoization
|
|
|
|
`once()` memoizes a callback's return value for the current request or job. Calls made from an object instance are scoped to that instance. Unlike `Cache::memo()`, `once()` does not read from an external cache store.
|
|
|
|
```php
|
|
public function roles(): Collection
|
|
{
|
|
return once(fn () => $this->loadRoles());
|
|
}
|
|
```
|
|
|
|
Repeated calls return the memoized result without rerunning the callback. Use `once()` for repeated computation within one execution. Use `Cache::memo()` to memoize access to an underlying store that can also persist values across executions.
|
|
|
|
## Configure failover cache stores in production
|
|
|
|
The failover driver tries each configured store in order when a store operation throws an exception. It does not consult later stores for an ordinary cache miss, and it does not replicate data between stores.
|
|
|
|
```php
|
|
'failover' => ['driver' => 'failover', 'stores' => ['redis', 'database']],
|
|
```
|