Symfony Cache 组件通常是开发人员库中最少使用的工具,大多数实现停止在“安装 Redis”时,并将几个数据库调用包裹到一个 虽然功能性,但这几乎不会擦伤部件在高输出、分布式环境中所能做的表面。 $cache->get() 在 Symfony 7.3 中,缓存组件不仅仅是一个关键值存储,它是一个具有层级架构、概率标签保护和透明加密能力的复杂系统。 本文探讨了解决昂贵建筑问题的重要缓存策略: , (一群牛群) (一) )和 . latency concurrency security GDPR distributed invalidation 延迟的架构:层级(链)缓存 在微服务架构或高流量单元格中,对Redis的网络呼叫(通常为1～3ms)最终可能与本地内存(纳米秒)相比成为瓶颈。 解决方案是A 实际上,作为一个 为您的应用程序提供缓存。 , . Chain Cache L1/L2 CPU L1 is local (APCu) L2 is shared (Redis) 配置 我们将配置一个从 APCu 读取的池,如果错过了,它会从 Redis 读取,然后将 APCu 读取。 composer require symfony/cache symfony/orm-pack redis
 配置( ) ) : config/packages/cache.yaml framework:
    cache:
        # Prefix all keys to avoid collisions in shared Redis instances
        prefix_seed: '%env(APP_SECRET)%'

        pools:
            # L2 Cache: Redis (Shared)
            cache.redis:
                adapter: cache.adapter.redis
                provider: 'redis://%env(REDIS_HOST)%:6379'
                default_lifetime: 3600 # 1 hour

            # L1 Cache: APCu (Local Memory)
            cache.apcu:
                adapter: cache.adapter.apcu
                default_lifetime: 60 # Short TTL to prevent stale local data

            # The Chain: L1 + L2
            cache.layered:
                adapter: cache.adapter.chain
                provider: [cache.apcu, cache.redis]
 使用 使用目标属性注入特定池。 namespace App\Service;

use Symfony\Component\DependencyInjection\Attribute\Target;
use Symfony\Contracts\Cache\CacheInterface;
use Symfony\Contracts\Cache\ItemInterface;

class DashboardService
{
    public function __construct(
        #[Target('cache.layered')]
        private readonly CacheInterface $cache
    ) {}

    public function getStats(): array
    {
        // 1. Checks APCu. Hit? Return.
        // 2. Miss? Checks Redis. Hit? Populate APCu & Return.
        // 3. Miss? Run Callback. Populate Redis & APCu.
        return $this->cache->get('stats_v1', function (ItemInterface $item): array {
            $item->expiresAfter(3600);
            return $this->computeHeavyStats();
        });
    }
    
    private function computeHeavyStats(): array 
    { 
        // Simulation of heavy work
        return ['users' => 10500, 'revenue' => 50000]; 
    }
}
 验证 
 
 
 
 
 
 清晰的缓存:bin/console cache:pool:clear cache.layered 请求页面 点击 Redis (CLI): KEYS * (您将看到密钥)。 点击 APCu(Web Panel):您将看到密钥。 关闭 Redis 应用程序将继续从 APCu 服务 60 秒。 解决雷动群:概率早期到期 “Cache Stampede” (或 Thundering Herd) 发生在热缓存密钥过期时。突然,1000个同时请求同时错过缓存,并击中您的数据库以计算相同的值。 交响乐解决了这个问题 复杂的锁定机制(如 Semaphore)通过使用 . without Probabilistic Early Expiration 如何运作 缓存声称在到期前稍微空,但仅限于某些请求。临近到期,错误的概率就越高.一个幸运的请求重新计算值,而其他请求则提供“失效”(但有效)的数据。 实施 您不需要新的配置;您需要使用 合同中的参数。 $beta // $beta of 1.0 is standard. 
// Higher = recompute earlier. 
// 0 = disable. 
// INF = force recompute.
$beta = 1.0; 

$value = $this->cache->get('stock_ticker_aapl', function (ItemInterface $item) {
    // The item ACTUALLY expires in 1 hour
    $item->expiresAfter(3600);
    
    return $this->stockApi->fetchPrice('AAPL');
}, $beta);
 数学验证 没有 CLI 命令来“证明”概率,但你可以记录重算。 
 
 
 
 设置 $item-> expiresAfter(10)。 创建一个循环,每 100 毫米击中此缓存密钥。 请注意,在10秒过去前启动回调,通常只有一次,确保您的后端受到保护。 “黑匣子”:透明加密使用钠 缓存 (PII) 在 Redis 是 a 如果攻击者丢弃了您的 Redis 内存,他们将拥有数据。 Personal Identifiable Information GDPR/security risk Symfony 允许您将您的缓存适配器包装在一个 我们将使用的 在它离开PHP之前透明地加密数据,并在检索时解密。 Marshaller SodiumMarshaller 保证 是 而且,扩展是 在 PHP 8.x 中。 libsodium installed enabled 配置 我们需要装饰默认马歇尔. 我们将使用一个“ ”马歇尔(压缩数据)包装在一个“ ”马歇尔(加密它)。 Deflate Sodium #config/services.yaml

services:
    # 1. Generate a key: php -r "echo bin2hex(random_bytes(SODIUM_CRYPTO_SECRETBOX_KEYBYTES));"
    # Store this in .env.local: CACHE_DECRYPTION_KEY=your_hex_key
    
    # 2. Define the Marshaller Service
    app.cache.marshaller.secure:
        class: Symfony\Component\Cache\Marshaller\SodiumMarshaller
        arguments: 
            - ['%env(hex2bin:CACHE_DECRYPTION_KEY)%']
            - '@app.cache.marshaller.deflate' # Chain encryption OVER compression

    app.cache.marshaller.deflate:
        class: Symfony\Component\Cache\Marshaller\DeflateMarshaller
        arguments: ['@default_marshaller']
        
    default_marshaller:
        class: Symfony\Component\Cache\Marshaller\DefaultMarshaller

    # 3. Use the custom marshaller in your cache adapter
    Symfony\Component\Cache\Adapter\RedisAdapter:
        arguments:
            $marshaller: '@app.cache.marshaller.secure'
 #config/packages/cache.yaml

framework:
    cache:
        pools:
            cache.secure:
                adapter: cache.adapter.redis
                # We need to point the 'default_marshaller' of this pool to our secure one?
                # Actually, defining the adapter service globally as we did above 
                # is the cleanest way if you want ALL redis caches encrypted.
                # Alternatively, use the provider syntax:
                
                # For specific pool encryption, we often have to define the service manually 
                # or use a factory because framework.yaml config is limited for complex DI.
 对交响曲的精简方法(最佳实践):而不是超越全球适配器,明确定义池服务以注射马歇勒。 # config/services.yaml
services:
    app.cache.secure_pool:
        class: Symfony\Component\Cache\Adapter\RedisAdapter
        arguments:
            $redis: 'redis://%env(REDIS_HOST)%:6379'
            $marshaller: '@app.cache.marshaller.secure'
        tags: ['cache.pool']
 使用 public function storeUserAddress(int $userId, string $address): void
{
    // This data is compressed and encrypted in Redis
    $cacheItem = $this->securePool->getItem('user_addr_' . $userId);
    $cacheItem->set($address);
    $this->securePool->save($cacheItem);
}
 验证 
 
 
 
 
 
 将数据保存到缓存中。 通过 CLI 连接到 Redis: redis-cli。 拿起钥匙。 结果:您将看到二进制垃圾(加密字符串),而不是单文地址。 通过PHP获取它:你得到一个简单的地址。 分布式失效:标签和使者 计算机科学中最困难的问题是缓存无效,当你有5个网页服务器(pods)时,它变得更加困难。如果服务器A更新一个产品,服务器B的APCu缓存仍然保留旧产品。 我们通过Symfony Messenger播放无效信息来解决此问题。 战略 
 
 
 
 
 写给Redis(分享) 在 APCu 中本地缓存(速度)。 当数据发生变化时,向公交车发送消息。 所有服务器都消耗了消息并为该特定标签清除其本地APCu。 配置 composer require symfony/messenger
 我们需要一个支持“Pub/Sub”(Fanout)的传输器,这样每个服务器都会收到消息。 #config/packages/messenger.yaml

framework:
    messenger:
        transports:
            # Use a fanout exchange so ALL pods receive the message
            cache_invalidation: 
                dsn: '%env(MESSENGER_TRANSPORT_DSN)%'
                options:
                    exchange:
                        type: fanout
                        name: cache_invalidation_fanout
 代码 1. The Invalidation Message namespace App\Message;

final readonly class InvalidateTagsMessage
{
    public function __construct(
        public array $tags
    ) {}
}
 2. The Handler This handler runs on every server. namespace App\MessageHandler;

use App\Message\InvalidateTagsMessage;
use Symfony\Component\Messenger\Attribute\AsMessageHandler;
use Symfony\Contracts\Cache\TagAwareCacheInterface;
use Symfony\Component\DependencyInjection\Attribute\Target;

#[AsMessageHandler]
final readonly class InvalidateTagsHandler
{
    public function __construct(
        #[Target('cache.layered')] // Target our Chain Cache
        private TagAwareCacheInterface $cache
    ) {}

    public function __invoke(InvalidateTagsMessage $message): void
    {
        // This invalidates the local APCu layer AND the shared Redis layer
        $this->cache->invalidateTags($message->tags);
    }
}
 3. The Service Triggering the Change namespace App\Service;

use App\Message\InvalidateTagsMessage;
use Symfony\Component\Messenger\MessageBusInterface;
use Symfony\Contracts\Cache\TagAwareCacheInterface;

class ProductService
{
    public function __construct(
        private TagAwareCacheInterface $cache,
        private MessageBusInterface $bus
    ) {}

    public function updateProduct(int $id, array $data): void
    {
        // 1. Update Database...
        
        // 2. Invalidate
        // We do NOT call $cache->invalidateTags() directly here.
        // Because that would only clear THIS server's APCu and the shared Redis.
        // Other servers would remain stale.
        
        $this->bus->dispatch(new InvalidateTagsMessage(["product_{$id}"]));
    }
}
 一个 #[Cacheable] 属性 写作而不是 锅炉板在每个服务方法中,让我们创建一个 它会自动处理缓存,使用 或 . $cache->get() PHP 8 Attribute Decorator Pattern Event Subscription 下面是使用一个清洁的实现。 听力,这是有效和易于推理的。 Kernel::CONTROLLER_ARGUMENTS The Attribute namespace App\Attribute;

use Attribute;

#[Attribute(Attribute::TARGET_METHOD)]
final readonly class Cacheable
{
    public function __construct(
        public string $pool = 'cache.app',
        public int $ttl = 3600,
        public ?string $key = null
    ) {}
}
 活动订阅者 此聆听器拦截控制器呼叫,检查属性,并尝试从缓存中服务。 这种简单的实现假定控制器会返回一般的可序列化响应(如 JSON 或 Array)。 namespace App\EventSubscriber;

use App\Attribute\Cacheable;
use Symfony\Component\EventDispatcher\EventSubscriberInterface;
use Symfony\Component\HttpKernel\Event\ControllerEvent;
use Symfony\Component\HttpKernel\KernelEvents;
use Symfony\Component\DependencyInjection\ServiceLocator;
use Symfony\Contracts\Cache\ItemInterface;

class CacheableSubscriber implements EventSubscriberInterface
{
    public function __construct(
        private ServiceLocator $cachePools // Inject locator to find pools dynamically
    ) {}

    public static function getSubscribedEvents(): array
    {
        return [
            // High priority to catch request before execution
            KernelEvents::CONTROLLER => ['onKernelController', 10], 
        ];
    }

    public function onKernelController(ControllerEvent $event): void
    {
        $controller = $event->getController();

        // Handle array callables [$object, 'method']
        if (is_array($controller)) {
            $method = new \ReflectionMethod($controller[0], $controller[1]);
        } elseif (is_object($controller) && is_callable($controller)) {
            $method = new \ReflectionMethod($controller, '__invoke');
        } else {
            return;
        }

        $attributes = $method->getAttributes(Cacheable::class);
        if (empty($attributes)) {
            return;
        }

        /** @var Cacheable $cacheable */
        $cacheable = $attributes[0]->newInstance();

        if (!$this->cachePools->has($cacheable->pool)) {
            return;
        }

        $pool = $this->cachePools->get($cacheable->pool);
        
        // Generate a key based on Controller Class + Method + Request Params
        // This is a simplified key generation strategy
        $request = $event->getRequest();
        $cacheKey = $cacheable->key ?? 'ctrl_' . md5($request->getUri());

        // We cannot easily "skip" the controller execution inside a Listener 
        // using the Cache Contract pattern nicely without replacing the controller.
        // 
        // For a TRULY robust attribute implementation, one should use 
        // a "Service Decorator" logic, but for Controllers, we can replace the 
        // controller callable with a closure that wraps the cache logic.
        
        $originalController = $event->getController();
        
        $newController = function() use ($pool, $cacheKey, $cacheable, $originalController, $request) {
            return $pool->get($cacheKey, function (ItemInterface $item) use ($cacheable, $originalController, $request) {
                $item->expiresAfter($cacheable->ttl);
                
                // Execute the original controller
                // Note: We need to manually resolve arguments or pass the request
                // This part is tricky in raw PHP. 
                // In Symfony we can simply execute the original callable 
                // IF we have the resolved arguments.
                
                // SIMPLIFICATION for article:
                // Assuming controller takes Request object or no args
                return $originalController($request);
            });
        };

        $event->setController($newController);
    }
}
 你必须要 你的秘密波兰在一个 对于The 以动态的方式访问它们。 register ServiceLocator Subscriber 上面的代码表明修改 理想情况下,对于服务,你会使用 在服务定义上,但对于控制器来说,拦截事件是交响乐的方式。 Kernel execution flow #[AsDecorator] 结论 实施 很容易;构建一个存储网络分区的缓存策略, 审计,以及 滑板是一个纪律。 CacheInterface GDPR Black Friday traffic 在这里描述的策略 - 为了延迟, 为了竞争, 为了安全,以及 为了保持一致性,将您的应用程序从脆弱的优化转移到坚实的工程领域,Symfony将这些原始概念带出盒子,使我们能够解决复杂的分布式系统问题,而无需引入重大的第三方基础设施。 Chain Caching Probabilistic Expiration Sodium Encryption Messenger-based Invalidation 停止将缓存视为临时倾销地,将其视为数据持久性策略的关键、安全层。 让我们继续讨论 高性能的PHP架构是一个不断变化的风景,如果你正在重塑一个传统的单元格或在Symfony中设计一个分布式系统,我很乐意听到你所面临的挑战。 您是否已为特定合规性需求实施了自定义 Marshaller? 您如何处理跨多区域部署的缓存无效? 直接在LinkedIn上联系我,让我们对架构感到兴奋,分享战争故事,并构建更好的软件。

Read My Stories

該音頻是用故事的原始語言製作的！

重要缓存策略:如何在交响乐中创建弹性缓存

About Author

註釋

標籤

这篇文章刊登在

Related Stories

Telegram：加密岛通往大陆的桥梁

Floki 的 Valhalla 成为印度环斯里兰卡赛事联合赞助商

从论坛到信息流：社交媒体算法如何塑造数字互动

创建以用户为中心的加密产品：客户反馈的重要性

Telegram：加密岛通往大陆的桥梁

Floki 的 Valhalla 成为印度环斯里兰卡赛事联合赞助商

从论坛到信息流：社交媒体算法如何塑造数字互动

创建以用户为中心的加密产品：客户反馈的重要性

Light-Mode

Classic

Newspaper

Minty

Dark-Mode

Neon Noir

Minty

HN StartUps