缓存

简介
配置
- 驱动前提条件
缓存使用
缓存标签
原子锁
缓存故障转移 (Cache Failover)
添加自定义缓存驱动
- 编写驱动
- 注册驱动
活动

简介

应用程序执行的一些数据检索或处理任务可能是 CPU 密集型的，或者需要几秒钟才能完成。在这种情况下，通常会将检索到的数据缓存一段时间，以便在后续请求相同数据时能够快速获取。缓存的数据通常存储在非常快速的数据存储中，例如 Memcached 或 Redis。

值得庆幸的是，Laravel 为各种缓存后端提供了一个富有表现力、统一的 API，让您可以利用它们极快的数据检索速度来加速您的 Web 应用程序。

配置

应用程序的缓存配置文件位于 config/cache.php。在此文件中，您可以指定默认情况下在整个应用程序中使用的缓存存储。Laravel 开箱即用地支持流行的缓存后端，如 Memcached、Redis、DynamoDB 和关系数据库。此外，还提供基于文件的缓存驱动，而 array 和 null 缓存驱动则为您的自动化测试提供了便捷的缓存后端。

缓存配置文件还包含许多其他选项，您可以查看。默认情况下，Laravel 配置为使用 database 缓存驱动，该驱动将序列化后的缓存对象存储在您的应用程序数据库中。

驱动前提条件

数据库

当使用 database 缓存驱动时，您需要一个数据库表来容纳缓存数据。通常，这包含在 Laravel 默认的 0001_01_01_000001_create_cache_table.php 数据库迁移中；但是，如果您的应用程序不包含此迁移，您可以使用 make:cache-table Artisan 命令来创建它。

1php artisan make:cache-table
2 
3php artisan migrate

php artisan make:cache-table

php artisan migrate

Memcached

使用 Memcached 驱动需要安装 Memcached PECL 扩展包。您可以在 config/cache.php 配置文件中列出所有的 Memcached 服务器。该文件已经包含了一个 memcached.servers 条目，供您快速上手。

 1'memcached' => [
 2    // ...
 3 
 4    'servers' => [
 5        [
 6            'host' => env('MEMCACHED_HOST', '127.0.0.1'),
 7            'port' => env('MEMCACHED_PORT', 11211),
 8            'weight' => 100,
 9        ],
10    ],
11],

'memcached' => [
    // ...

    'servers' => [
        [
            'host' => env('MEMCACHED_HOST', '127.0.0.1'),
            'port' => env('MEMCACHED_PORT', 11211),
            'weight' => 100,
        ],
    ],
],

如果需要，您可以将 host 选项设置为 UNIX 套接字路径。如果这样做，port 选项应设置为 0。

 1'memcached' => [
 2    // ...
 3 
 4    'servers' => [
 5        [
 6            'host' => '/var/run/memcached/memcached.sock',
 7            'port' => 0,
 8            'weight' => 100
 9        ],
10    ],
11],

'memcached' => [
    // ...

    'servers' => [
        [
            'host' => '/var/run/memcached/memcached.sock',
            'port' => 0,
            'weight' => 100
        ],
    ],
],

Redis

在 Laravel 中使用 Redis 缓存之前，您需要通过 PECL 安装 PhpRedis PHP 扩展，或者通过 Composer 安装 predis/predis 包 (~2.0)。Laravel Sail 已经包含了此扩展。此外，诸如 Laravel Cloud 和 Laravel Forge 等官方 Laravel 应用程序平台默认已安装 PhpRedis 扩展。

有关配置 Redis 的更多信息，请查阅其 Laravel 文档页面。

DynamoDB

在使用 DynamoDB 缓存驱动之前，您必须创建一个 DynamoDB 表来存储所有缓存数据。通常，此表应命名为 cache。但是，您应该根据 cache 配置文件中 stores.dynamodb.table 配置值来命名该表。表名也可以通过 DYNAMODB_CACHE_TABLE 环境变量进行设置。

此表还应具有一个字符串分区键，其名称应与应用程序 cache 配置文件中 stores.dynamodb.attributes.key 配置项的值相对应。默认情况下，分区键应命名为 key。

通常，DynamoDB 不会主动从表中删除过期项目。因此，您应该在表上启用生存时间 (TTL)。在配置表的 TTL 设置时，应将 TTL 属性名称设置为 expires_at。

接下来，安装 AWS SDK，以便您的 Laravel 应用程序可以与 DynamoDB 通信。

1composer require aws/aws-sdk-php

composer require aws/aws-sdk-php

此外，您应该确保为 DynamoDB 缓存存储配置选项提供了值。通常，这些选项（如 AWS_ACCESS_KEY_ID 和 AWS_SECRET_ACCESS_KEY）应在应用程序的 .env 配置文件中定义。

1'dynamodb' => [
2    'driver' => 'dynamodb',
3    'key' => env('AWS_ACCESS_KEY_ID'),
4    'secret' => env('AWS_SECRET_ACCESS_KEY'),
5    'region' => env('AWS_DEFAULT_REGION', 'us-east-1'),
6    'table' => env('DYNAMODB_CACHE_TABLE', 'cache'),
7    'endpoint' => env('DYNAMODB_ENDPOINT'),
8],

'dynamodb' => [
    'driver' => 'dynamodb',
    'key' => env('AWS_ACCESS_KEY_ID'),
    'secret' => env('AWS_SECRET_ACCESS_KEY'),
    'region' => env('AWS_DEFAULT_REGION', 'us-east-1'),
    'table' => env('DYNAMODB_CACHE_TABLE', 'cache'),
    'endpoint' => env('DYNAMODB_ENDPOINT'),
],

MongoDB

如果您正在使用 MongoDB，官方的 mongodb/laravel-mongodb 包提供了一个 mongodb 缓存驱动，并且可以使用 mongodb 数据库连接进行配置。MongoDB 支持 TTL 索引，可用于自动清理过期的缓存项目。

有关配置 MongoDB 的更多信息，请参考 MongoDB 的缓存与锁文档。

缓存使用

获取缓存实例

要获取缓存存储实例，您可以使用 Cache 门面 (Facade)，这也是我们在本整个文档中将使用的内容。Cache 门面为 Laravel 缓存契约的底层实现提供了便捷、简洁的访问方式。

 1<?php
 2 
 3namespace App\Http\Controllers;
 4 
 5use Illuminate\Support\Facades\Cache;
 6 
 7class UserController extends Controller
 8{
 9    /**
10     * Show a list of all users of the application.
11     */
12    public function index(): array
13    {
14        $value = Cache::get('key');
15 
16        return [
17            // ...
18        ];
19    }
20}

<?php

namespace App\Http\Controllers;

use Illuminate\Support\Facades\Cache;

class UserController extends Controller
{
    /**
     * Show a list of all users of the application.
     */
    public function index(): array
    {
        $value = Cache::get('key');

        return [
            // ...
        ];
    }
}

访问多个缓存存储

使用 Cache 门面，您可以通过 store 方法访问各种缓存存储。传递给 store 方法的键应与 cache 配置文件中 stores 数组中列出的存储之一相对应。

1$value = Cache::store('file')->get('foo');
2 
3Cache::store('redis')->put('bar', 'baz', 600); // 10 Minutes

$value = Cache::store('file')->get('foo');

Cache::store('redis')->put('bar', 'baz', 600); // 10 Minutes

从缓存中获取项目

Cache 门面的 get 方法用于从缓存中检索项目。如果项目在缓存中不存在，将返回 null。如果您愿意，可以向 get 方法传递第二个参数，指定在项目不存在时希望返回的默认值。

1$value = Cache::get('key');
2 
3$value = Cache::get('key', 'default');

$value = Cache::get('key');

$value = Cache::get('key', 'default');

您甚至可以传递一个闭包作为默认值。如果指定的项目在缓存中不存在，则返回闭包的结果。传递闭包允许您推迟从数据库或其他外部服务检索默认值的操作。

1$value = Cache::get('key', function () {
2    return DB::table(/* ... */)->get();
3});

$value = Cache::get('key', function () {
    return DB::table(/* ... */)->get();
});

判断项目是否存在

has 方法可用于确定缓存中是否存在某个项目。如果项目存在但其值为 null，该方法也会返回 false。

1if (Cache::has('key')) {
2    // ...
3}

if (Cache::has('key')) {
    // ...
}

递增/递减值

increment 和 decrement 方法可用于调整缓存中整数项目的值。这两个方法都接受一个可选的第二个参数，指示增加或减少项目值的数量。

1// Initialize the value if it does not exist...
2Cache::add('key', 0, now()->plus(hours: 4));
3 
4// Increment or decrement the value...
5Cache::increment('key');
6Cache::increment('key', $amount);
7Cache::decrement('key');
8Cache::decrement('key', $amount);

// Initialize the value if it does not exist...
Cache::add('key', 0, now()->plus(hours: 4));

// Increment or decrement the value...
Cache::increment('key');
Cache::increment('key', $amount);
Cache::decrement('key');
Cache::decrement('key', $amount);

检索并存储

有时您可能希望从缓存中检索一个项目，但如果请求的项目不存在，也想存储一个默认值。例如，您可能希望从缓存中检索所有用户，或者如果它们不存在，则从数据库中检索它们并将它们添加到缓存中。您可以使用 Cache::remember 方法执行此操作。

1$value = Cache::remember('users', $seconds, function () {
2    return DB::table('users')->get();
3});

$value = Cache::remember('users', $seconds, function () {
    return DB::table('users')->get();
});

如果项目在缓存中不存在，将执行传递给 remember 方法的闭包，其结果将被放入缓存中。

您可以使用 rememberForever 方法从缓存中检索项目，如果它不存在，则将其永久存储。

1$value = Cache::rememberForever('users', function () {
2    return DB::table('users')->get();
3});

$value = Cache::rememberForever('users', function () {
    return DB::table('users')->get();
});

旧值重验证 (Stale While Revalidate)

当使用 Cache::remember 方法时，如果缓存值已过期，某些用户可能会遇到响应缓慢的情况。对于某些类型的数据，允许在后台重新计算缓存值的同时提供部分旧数据是有用的，这可以防止部分用户在计算缓存值时遇到缓慢的响应。这通常被称为“旧值重验证 (stale-while-revalidate)”模式，Cache::flexible 方法提供了此模式的实现。

flexible 方法接受一个数组，该数组指定缓存值被视为“新鲜 (fresh)”的时间以及它何时变为“陈旧 (stale)”。数组中的第一个值表示缓存被视为新鲜的秒数，而第二个值定义了在需要重新计算之前，它作为陈旧数据可以被提供多久。

如果在新鲜期内（第一个值之前）发出请求，缓存会立即返回，无需重新计算。如果在陈旧期内（两个值之间）发出请求，则向用户提供旧值，并注册一个延迟函数，以便在响应发送给用户后刷新缓存值。如果请求是在第二个值之后发出的，则缓存被视为已过期，值会立即重新计算，这可能会导致用户的响应变慢。

1$value = Cache::flexible('users', [5, 10], function () {
2    return DB::table('users')->get();
3});

$value = Cache::flexible('users', [5, 10], function () {
    return DB::table('users')->get();
});

检索并删除

如果您需要从缓存中检索一个项目然后删除它，可以使用 pull 方法。与 get 方法一样，如果项目在缓存中不存在，将返回 null。

1$value = Cache::pull('key');
2 
3$value = Cache::pull('key', 'default');

$value = Cache::pull('key');

$value = Cache::pull('key', 'default');

在缓存中存储项目

您可以使用 Cache 门面上的 put 方法在缓存中存储项目。

1Cache::put('key', 'value', $seconds = 10);

Cache::put('key', 'value', $seconds = 10);

如果没有将存储时间传递给 put 方法，该项目将无限期存储。

1Cache::put('key', 'value');

Cache::put('key', 'value');

除了将秒数作为整数传递外，您还可以传递一个 DateTime 实例，表示缓存项目所需的过期时间。

1Cache::put('key', 'value', now()->plus(minutes: 10));

Cache::put('key', 'value', now()->plus(minutes: 10));

不存在时存储

add 方法仅在缓存存储中尚不存在该项目时才会将其添加到缓存中。如果项目确实已添加到缓存中，该方法将返回 true。否则，该方法将返回 false。add 方法是一个原子操作。

1Cache::add('key', 'value', $seconds);

Cache::add('key', 'value', $seconds);

延长项目有效期

touch 方法允许您延长现有缓存项目的寿命 (TTL)。如果缓存项目存在且其过期时间成功延长，touch 方法将返回 true。如果项目在缓存中不存在，该方法将返回 false。

1Cache::touch('key', 3600);

Cache::touch('key', 3600);

您可以提供 DateTimeInterface、DateInterval 或 Carbon 实例来指定精确的过期时间。

1Cache::touch('key', now()->addHours(2));

Cache::touch('key', now()->addHours(2));

永久存储项目

forever 方法可用于将项目永久存储在缓存中。由于这些项目不会过期，因此必须使用 forget 方法手动从缓存中删除它们。

1Cache::forever('key', 'value');

Cache::forever('key', 'value');

如果您使用的是 Memcached 驱动，当缓存达到其大小限制时，可能会删除“永久”存储的项目。

从缓存中删除项目

您可以使用 forget 方法从缓存中删除项目。

1Cache::forget('key');

Cache::forget('key');

您也可以通过提供零或负数的过期秒数来删除项目。

1Cache::put('key', 'value', 0);
2 
3Cache::put('key', 'value', -5);

Cache::put('key', 'value', 0);

Cache::put('key', 'value', -5);

您可以使用 flush 方法清除整个缓存。

1Cache::flush();

Cache::flush();

您可以使用 flushLocks 方法清除缓存中的所有原子锁。

1Cache::flushLocks();

Cache::flushLocks();

刷新缓存不会考虑您配置的缓存“前缀”，并将删除缓存中的所有条目。在清除与其他应用程序共享的缓存时，请慎重考虑。

缓存记忆化 (Cache Memoization)

Laravel 的 memo 缓存驱动允许您在单个请求或作业执行期间临时将已解析的缓存值存储在内存中。这可以防止在同一执行过程中重复命中缓存，从而显著提高性能。

要使用记忆化缓存，请调用 memo 方法。

1use Illuminate\Support\Facades\Cache;
2 
3$value = Cache::memo()->get('key');

use Illuminate\Support\Facades\Cache;

$value = Cache::memo()->get('key');

memo 方法可选地接受缓存存储的名称，该名称指定记忆化驱动将装饰的底层缓存存储。

1// Using the default cache store...
2$value = Cache::memo()->get('key');
3 
4// Using the Redis cache store...
5$value = Cache::memo('redis')->get('key');

// Using the default cache store...
$value = Cache::memo()->get('key');

// Using the Redis cache store...
$value = Cache::memo('redis')->get('key');

对于给定的键，第一次 get 调用会从您的缓存存储中检索值，但同一请求或作业中的后续调用将从内存中检索该值。

1// Hits the cache...
2$value = Cache::memo()->get('key');
3 
4// Does not hit the cache, returns memoized value...
5$value = Cache::memo()->get('key');

// Hits the cache...
$value = Cache::memo()->get('key');

// Does not hit the cache, returns memoized value...
$value = Cache::memo()->get('key');

当调用修改缓存值的方法（如 put、increment、remember 等）时，记忆化缓存会自动忘记记忆化的值，并将修改方法调用委托给底层的缓存存储。

1Cache::memo()->put('name', 'Taylor'); // Writes to underlying cache...
2Cache::memo()->get('name');           // Hits underlying cache...
3Cache::memo()->get('name');           // Memoized, does not hit cache...
4 
5Cache::memo()->put('name', 'Tim');    // Forgets memoized value, writes new value...
6Cache::memo()->get('name');           // Hits underlying cache again...

Cache::memo()->put('name', 'Taylor'); // Writes to underlying cache...
Cache::memo()->get('name');           // Hits underlying cache...
Cache::memo()->get('name');           // Memoized, does not hit cache...

Cache::memo()->put('name', 'Tim');    // Forgets memoized value, writes new value...
Cache::memo()->get('name');           // Hits underlying cache again...

缓存辅助函数

除了使用 Cache 门面外，您还可以使用全局 cache 函数通过缓存检索和存储数据。当调用带有单个字符串参数的 cache 函数时，它将返回给定键的值。

1$value = cache('key');

$value = cache('key');

如果您向该函数提供键/值对数组和过期时间，它将把值存储在缓存中指定的持续时间。

1cache(['key' => 'value'], $seconds);
2 
3cache(['key' => 'value'], now()->plus(minutes: 10));

cache(['key' => 'value'], $seconds);

cache(['key' => 'value'], now()->plus(minutes: 10));

当在没有任何参数的情况下调用 cache 函数时，它会返回 Illuminate\Contracts\Cache\Factory 实现的一个实例，允许您调用其他缓存方法。

1cache()->remember('users', $seconds, function () {
2    return DB::table('users')->get();
3});

cache()->remember('users', $seconds, function () {
    return DB::table('users')->get();
});

在测试对全局 cache 函数的调用时，您可以像测试门面一样使用 Cache::shouldReceive 方法。

缓存标签

当使用 file、dynamodb 或 database 缓存驱动时，不支持缓存标签。

存储标记的缓存项目

缓存标签允许您标记缓存中的相关项目，然后刷新所有已分配给定标签的缓存值。您可以通过传入有序的标签名称数组来访问标记的缓存。例如，让我们访问标记的缓存并将一个值 put 到缓存中。

1use Illuminate\Support\Facades\Cache;
2 
3Cache::tags(['people', 'artists'])->put('John', $john, $seconds);
4Cache::tags(['people', 'authors'])->put('Anne', $anne, $seconds);

use Illuminate\Support\Facades\Cache;

Cache::tags(['people', 'artists'])->put('John', $john, $seconds);
Cache::tags(['people', 'authors'])->put('Anne', $anne, $seconds);

访问标记的缓存项目

通过标签存储的项目如果不提供用于存储该值的标签，则无法访问。要检索标记的缓存项目，请将相同的有序标签列表传递给 tags 方法，然后使用您希望检索的键调用 get 方法。

1$john = Cache::tags(['people', 'artists'])->get('John');
2 
3$anne = Cache::tags(['people', 'authors'])->get('Anne');

$john = Cache::tags(['people', 'artists'])->get('John');

$anne = Cache::tags(['people', 'authors'])->get('Anne');

移除标记的缓存项目

您可以刷新分配了标签或标签列表的所有项目。例如，以下代码将删除所有标记为 people、authors 或两者的缓存。因此，Anne 和 John 都将从缓存中删除。

1Cache::tags(['people', 'authors'])->flush();

Cache::tags(['people', 'authors'])->flush();

相反，下面的代码将只删除标记为 authors 的缓存值，因此 Anne 会被删除，但 John 不会。

1Cache::tags('authors')->flush();

Cache::tags('authors')->flush();

原子锁

要使用此功能，您的应用程序必须使用 memcached、redis、dynamodb、database、file 或 array 缓存驱动作为应用程序的默认缓存驱动。此外，所有服务器必须与同一个中央缓存服务器通信。

管理锁

原子锁允许在不担心竞争条件的情况下操作分布式锁。例如，Laravel Cloud 使用原子锁来确保服务器上一次只执行一个远程任务。您可以使用 Cache::lock 方法创建和管理锁。

1use Illuminate\Support\Facades\Cache;
2 
3$lock = Cache::lock('foo', 10);
4 
5if ($lock->get()) {
6    // Lock acquired for 10 seconds...
7 
8    $lock->release();
9}

use Illuminate\Support\Facades\Cache;

$lock = Cache::lock('foo', 10);

if ($lock->get()) {
    // Lock acquired for 10 seconds...

    $lock->release();
}

get 方法也接受一个闭包。执行闭包后，Laravel 将自动释放锁。

1Cache::lock('foo', 10)->get(function () {
2    // Lock acquired for 10 seconds and automatically released...
3});

Cache::lock('foo', 10)->get(function () {
    // Lock acquired for 10 seconds and automatically released...
});

如果锁在您请求时不可用，您可以指示 Laravel 等待指定的秒数。如果无法在指定的时间限制内获得锁，将抛出 Illuminate\Contracts\Cache\LockTimeoutException 异常。

 1use Illuminate\Contracts\Cache\LockTimeoutException;
 2 
 3$lock = Cache::lock('foo', 10);
 4 
 5try {
 6    $lock->block(5);
 7 
 8    // Lock acquired after waiting a maximum of 5 seconds...
 9} catch (LockTimeoutException $e) {
10    // Unable to acquire lock...
11} finally {
12    $lock->release();
13}

use Illuminate\Contracts\Cache\LockTimeoutException;

$lock = Cache::lock('foo', 10);

try {
    $lock->block(5);

    // Lock acquired after waiting a maximum of 5 seconds...
} catch (LockTimeoutException $e) {
    // Unable to acquire lock...
} finally {
    $lock->release();
}

上面的示例可以通过将闭包传递给 block 方法来简化。当将闭包传递给此方法时，Laravel 将尝试在指定的秒数内获取锁，并在闭包执行后自动释放锁。

1Cache::lock('foo', 10)->block(5, function () {
2    // Lock acquired for 10 seconds after waiting a maximum of 5 seconds...
3});

Cache::lock('foo', 10)->block(5, function () {
    // Lock acquired for 10 seconds after waiting a maximum of 5 seconds...
});

跨进程管理锁

有时，您可能希望在一个进程中获取锁并在另一个进程中释放它。例如，您可能在 Web 请求期间获取锁，并希望在由该请求触发的排队作业结束时释放该锁。在这种情况下，您应该将锁的作用域“所有者令牌 (owner token)”传递给排队作业，以便作业可以使用给定的令牌重新实例化锁。

在下面的示例中，如果成功获取了锁，我们将调度一个排队作业。此外，我们将通过锁的 owner 方法将锁的所有者令牌传递给排队作业。

1$podcast = Podcast::find($id);
2 
3$lock = Cache::lock('processing', 120);
4 
5if ($lock->get()) {
6    ProcessPodcast::dispatch($podcast, $lock->owner());
7}

$podcast = Podcast::find($id);

$lock = Cache::lock('processing', 120);

if ($lock->get()) {
    ProcessPodcast::dispatch($podcast, $lock->owner());
}

在应用程序的 ProcessPodcast 作业中，我们可以使用所有者令牌恢复并释放锁。

1Cache::restoreLock('processing', $this->owner)->release();

Cache::restoreLock('processing', $this->owner)->release();

如果您想在不考虑其当前所有者的情况下释放锁，可以使用 forceRelease 方法。

1Cache::lock('processing')->forceRelease();

Cache::lock('processing')->forceRelease();

并发限制

Laravel 的原子锁功能还提供了一些限制闭包并发执行的方法。当您希望在整个基础设施中只允许一个正在运行的实例时，请使用 withoutOverlapping。

1Cache::withoutOverlapping('foo', function () {
2    // Lock acquired after waiting a maximum of 10 seconds...
3});

Cache::withoutOverlapping('foo', function () {
    // Lock acquired after waiting a maximum of 10 seconds...
});

默认情况下，锁会一直保持到闭包执行完成，并且该方法最多等待 10 秒来获取锁。您可以使用附加参数自定义这些值。

1Cache::withoutOverlapping('foo', function () {
2    // Lock acquired for 120 seconds after waiting a maximum of 5 seconds...
3}, lockFor: 120, waitFor: 5);

Cache::withoutOverlapping('foo', function () {
    // Lock acquired for 120 seconds after waiting a maximum of 5 seconds...
}, lockFor: 120, waitFor: 5);

如果无法在指定的等待时间内获得锁，将抛出 Illuminate\Contracts\Cache\LockTimeoutException 异常。

如果您想要受控的并行性，请使用 funnel 方法设置最大并发执行数。funnel 方法适用于任何支持锁的缓存驱动。

1Cache::funnel('foo')
2    ->limit(3)
3    ->releaseAfter(60)
4    ->block(10)
5    ->then(function () {
6        // Concurrency lock acquired...
7    }, function () {
8        // Could not acquire concurrency lock...
9    });

Cache::funnel('foo')
    ->limit(3)
    ->releaseAfter(60)
    ->block(10)
    ->then(function () {
        // Concurrency lock acquired...
    }, function () {
        // Could not acquire concurrency lock...
    });

funnel 键标识正在被限制的资源。limit 方法定义最大并发执行数。releaseAfter 方法设置在自动释放已获取槽位之前的安全超时（秒）。block 方法设置等待可用槽位的秒数。

如果您更喜欢通过异常处理超时，而不是提供失败闭包，则可以省略第二个闭包。如果无法在指定的等待时间内获得锁，将抛出 Illuminate\Cache\Limiters\LimiterTimeoutException 异常。

 1use Illuminate\Cache\Limiters\LimiterTimeoutException;
 2 
 3try {
 4    Cache::funnel('foo')
 5        ->limit(3)
 6        ->releaseAfter(60)
 7        ->block(10)
 8        ->then(function () {
 9            // Concurrency lock acquired...
10        });
11} catch (LimiterTimeoutException $e) {
12    // Unable to acquire concurrency lock...
13}

use Illuminate\Cache\Limiters\LimiterTimeoutException;

try {
    Cache::funnel('foo')
        ->limit(3)
        ->releaseAfter(60)
        ->block(10)
        ->then(function () {
            // Concurrency lock acquired...
        });
} catch (LimiterTimeoutException $e) {
    // Unable to acquire concurrency lock...
}

如果您想为并发限制器使用特定的缓存存储，可以在所需的存储上调用 funnel 方法。

1Cache::store('redis')->funnel('foo')
2    ->limit(3)
3    ->block(10)
4    ->then(function () {
5        // Concurrency lock acquired using the "redis" store...
6    });

Cache::store('redis')->funnel('foo')
    ->limit(3)
    ->block(10)
    ->then(function () {
        // Concurrency lock acquired using the "redis" store...
    });

funnel 方法要求缓存存储实现 Illuminate\Contracts\Cache\LockProvider 接口。如果您尝试在不支持锁的缓存存储上使用 funnel，将抛出 BadMethodCallException 异常。

缓存故障转移 (Cache Failover)

failover 缓存驱动在与缓存交互时提供自动故障转移功能。如果 failover 存储的主缓存存储由于任何原因失败，Laravel 将自动尝试使用列表中配置的下一个存储。这对于确保在缓存可靠性至关重要的生产环境中实现高可用性特别有用。

要配置故障转移缓存存储，请指定 failover 驱动并提供按顺序尝试的存储名称数组。默认情况下，Laravel 在您应用程序的 config/cache.php 配置文件中包含了一个故障转移配置示例。

1'failover' => [
2    'driver' => 'failover',
3    'stores' => [
4        'database',
5        'array',
6    ],
7],

'failover' => [
    'driver' => 'failover',
    'stores' => [
        'database',
        'array',
    ],
],

配置好使用 failover 驱动的存储后，您需要将故障转移存储设置为应用程序 .env 文件中的默认缓存存储，以利用故障转移功能。

1CACHE_STORE=failover

CACHE_STORE=failover

当缓存存储操作失败且故障转移被激活时，Laravel 将触发 Illuminate\Cache\Events\CacheFailedOver 事件，让您能够报告或记录缓存存储已失败。

添加自定义缓存驱动

编写驱动

要创建自定义缓存驱动，我们首先需要实现 Illuminate\Contracts\Cache\Store 契约。因此，MongoDB 缓存实现可能看起来像这样：

 1<?php
 2 
 3namespace App\Extensions;
 4 
 5use Illuminate\Contracts\Cache\Store;
 6 
 7class MongoStore implements Store
 8{
 9    public function get($key) {}
10    public function many(array $keys) {}
11    public function put($key, $value, $seconds) {}
12    public function putMany(array $values, $seconds) {}
13    public function increment($key, $value = 1) {}
14    public function decrement($key, $value = 1) {}
15    public function forever($key, $value) {}
16    public function forget($key) {}
17    public function flush() {}
18    public function getPrefix() {}
19}

<?php

namespace App\Extensions;

use Illuminate\Contracts\Cache\Store;

class MongoStore implements Store
{
    public function get($key) {}
    public function many(array $keys) {}
    public function put($key, $value, $seconds) {}
    public function putMany(array $values, $seconds) {}
    public function increment($key, $value = 1) {}
    public function decrement($key, $value = 1) {}
    public function forever($key, $value) {}
    public function forget($key) {}
    public function flush() {}
    public function getPrefix() {}
}

我们只需要使用 MongoDB 连接实现这些方法中的每一个。有关如何实现这些方法中每一个的示例，请查看 Laravel 框架源代码中的 Illuminate\Cache\MemcachedStore。实现完成后，我们可以通过调用 Cache 门面的 extend 方法来完成自定义驱动的注册。

1Cache::extend('mongo', function (Application $app) {
2    return Cache::repository(new MongoStore);
3});

Cache::extend('mongo', function (Application $app) {
    return Cache::repository(new MongoStore);
});

如果您想知道将自定义缓存驱动代码放在哪里，可以在 app 目录下创建一个 Extensions 命名空间。但是，请记住 Laravel 没有严格的应用程序结构，您可以根据自己的偏好组织应用程序。

要向 Laravel 注册自定义缓存驱动，我们将使用 Cache 门面上的 extend 方法。由于其他服务提供者可能会在其 boot 方法中尝试读取缓存值，我们将在 booting 回调中注册我们的自定义驱动。通过使用 booting 回调，我们可以确保在调用应用程序服务提供者的 boot 方法之前、但在所有服务提供者的 register 方法被调用之后注册自定义驱动。我们将把 booting 回调注册在应用程序 App\Providers\AppServiceProvider 类的 register 方法中。

 1<?php
 2 
 3namespace App\Providers;
 4 
 5use App\Extensions\MongoStore;
 6use Illuminate\Contracts\Foundation\Application;
 7use Illuminate\Support\Facades\Cache;
 8use Illuminate\Support\ServiceProvider;
 9 
10class AppServiceProvider extends ServiceProvider
11{
12    /**
13     * Register any application services.
14     */
15    public function register(): void
16    {
17        $this->app->booting(function () {
18             Cache::extend('mongo', function (Application $app) {
19                 return Cache::repository(new MongoStore);
20             });
21         });
22    }
23 
24    /**
25     * Bootstrap any application services.
26     */
27    public function boot(): void
28    {
29        // ...
30    }
31}

<?php

namespace App\Providers;

use App\Extensions\MongoStore;
use Illuminate\Contracts\Foundation\Application;
use Illuminate\Support\Facades\Cache;
use Illuminate\Support\ServiceProvider;

class AppServiceProvider extends ServiceProvider
{
    /**
     * Register any application services.
     */
    public function register(): void
    {
        $this->app->booting(function () {
             Cache::extend('mongo', function (Application $app) {
                 return Cache::repository(new MongoStore);
             });
         });
    }

    /**
     * Bootstrap any application services.
     */
    public function boot(): void
    {
        // ...
    }
}

传递给 extend 方法的第一个参数是驱动程序的名称。这将与您 config/cache.php 配置文件中的 driver 选项相对应。第二个参数是一个闭包，它应该返回一个 Illuminate\Cache\Repository 实例。该闭包将接收一个 $app 实例，它是服务容器的一个实例。

扩展注册后，将 CACHE_STORE 环境变量或您应用程序 config/cache.php 配置文件中的 default 选项更新为您扩展的名称。

活动

要在每次缓存操作时执行代码，您可以监听缓存触发的各种事件。

事件名称
`Illuminate\Cache\Events\CacheFlushed`
`Illuminate\Cache\Events\CacheFlushing`
`Illuminate\Cache\Events\CacheFlushFailed`
`Illuminate\Cache\Events\CacheLocksFlushed`
`Illuminate\Cache\Events\CacheLocksFlushing`
`Illuminate\Cache\Events\CacheLocksFlushFailed`
`Illuminate\Cache\Events\CacheHit`
`Illuminate\Cache\Events\CacheMissed`
`Illuminate\Cache\Events\ForgettingKey`
`Illuminate\Cache\Events\KeyForgetFailed`
`Illuminate\Cache\Events\KeyForgotten`
`Illuminate\Cache\Events\KeyWriteFailed`
`Illuminate\Cache\Events\KeyWritten`
`Illuminate\Cache\Events\RetrievingKey`
`Illuminate\Cache\Events\RetrievingManyKeys`
`Illuminate\Cache\Events\WritingKey`
`Illuminate\Cache\Events\WritingManyKeys`

为了提高性能，您可以通过将应用程序 config/cache.php 配置文件中给定缓存存储的 events 配置选项设置为 false 来禁用缓存事件。

1'database' => [
2    'driver' => 'database',
3    // ...
4    'events' => false,
5],

'database' => [
    'driver' => 'database',
    // ...
    'events' => false,
],

缓存

在此页面上

产品

Packages

资源

合作伙伴