Die Symfony Cache-komponent is dikwels die mees minder gebruikte hulpmiddel in 'n ontwikkelaar se arsenaal. Die meeste implementasies stop by "Installeer Redis" en wrap 'n paar databasisoproepe in 'n Terwyl funksioneel, dit skaars skraap die oppervlak van wat die komponent kan doen in hoë deurvoer, verspreide omgewings. $cache->get() In Symfony 7.3 is die Cache-komponent nie net 'n sleutel-waarde-opslag nie; dit is 'n gesofistikeerde stelsel wat in staat is om geslaagde argitektuur, waarskynlikheidstempelbeskerming en transparante enkripsie te hê. Hierdie artikel ondersoek belangrike cachingstrategieë wat duur argitektuurprobleme oplos: die (Hulle het die vee gekry) ( die ) en . latency concurrency security GDPR distributed invalidation Die Arkitektuur van Latency: Tiered (Chain) Caching In mikroservice-architekture of hoë-verkeersmonoliete kan 'n netwerkoproep na Redis (meestal 1–3ms) uiteindelik 'n bottleneck in vergelyking met plaaslike geheue (nanosekondes) word. Die oplossing is a Doeltreffend optree as 'n Cache vir jou aansoek. die . Chain Cache L1/L2 CPU L1 is local (APCu) L2 is shared (Redis) Die konfigurasie Ons sal 'n pool konfigurer wat eers van APCu lees. As dit mis, lees dit van Redis, dan bevolk APCu. composer require symfony/cache symfony/orm-pack redis
 Instruksies ( · : 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]
 Gebruik Injecteer die spesifieke pool met behulp van die Target-attribuut. 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]; 
    }
}
 Verifikasie 
 
 
 
 
 
 Clear cache: bin/console cache:pool:clear cache.layered – duidelik cache Vra die bladsy Kyk Redis (CLI): KEYS * (Jy sal die sleutel sien). Kyk na APCu (Web Panel): Jy sal die sleutel sien. Disconnect Redis. die app sal voortgaan om te dien van APCu vir 60 sekondes. Oplossing van die Thundering Herd: waarskynlike vroeë verval Die "Cache Stampede" (of Thundering Herd) gebeur wanneer 'n hot cache sleutel verval. skielik, 1000 gelyktydige versoekings mis die cache op dieselfde tyd en tref jou databasis om dieselfde waarde te bereken. Simfoniese oplossing vir hierdie komplekse sluitmechanisme (soos Semaphore) deur die gebruik van . without Probabilistic Early Expiration Hoe dit werk In plaas daarvan dat dit presies om 12:00 uur verval, beweer die cache dat dit 'n bietjie leeg is voor die vervaldatum, maar slegs vir sommige versoekings. Hoe nader die vervaldatum, hoe hoër die waarskynlikheid van 'n mis. Een gelukkige versoek herbereken die waarde terwyl ander die "stale" (maar geldig) data bedien word. Die implementering Jy het nie 'n nuwe konfigurasie nodig nie; jy moet die Parameters in die kontrak. $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);
 Wiskundige verifikasie Daar is geen CLI-bevel om waarskynlikheid te "bewys", maar jy kan die herberekenings log. 
 
 
 
 Stel die $item-> expiresAfter(10) op. Maak 'n loop wat hierdie cache sleutel elke 100ms tref. Let daarop dat die terugroep veroorsaak word voordat 10 sekondes verby is en gewoonlik slegs een keer, wat verseker dat u backend beskerm word. Die “swarte boks”: Transparante versleuteling met natrium Die Caching (PII) in Redis is 'n As 'n aanvaller jou Redis-geheue dump, het hulle die data. Personal Identifiable Information GDPR/security risk Symfony laat jou toe om jou cache-adapter in 'n Ons sal die om data transparant te encrypteer voordat dit PHP verlaat en dit te dekryp wanneer dit teruggevind word. Marshaller SodiumMarshaller Verseker is En die uitbreiding is In die PHP 8.x. libsodium installed enabled Konfigurasie Ons moet die standaard marshaller versier. Ons sal 'n " Marshaller (om data te komprimeer) in 'n " Marshall (om dit te kodeer) 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.
 Verfineerde benadering tot simfonie (beste praktyke): In plaas van die globale adapter te oorheers, definieer die pooldiens uitdruklik om die marshaller te injecteer. # 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']
 Gebruik 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);
}
 Verifikasie 
 
 
 
 
 
 Bespaar data in die cache. Verbind met Redis via CLI: redis-cli. Kry die sleutel. Resultaat: U sal die binêre vuil (versleutelde string) sien, nie die eenvoudige teksadres nie. Herhaal dit via PHP: Jy kry die plaintext adres. Verspreide Invalidasie: Tags & Messenger Die moeilikste probleem in rekenaarwetenskap is cache-invalidasie. Dit word moeiliker as jy 5 webbedieners (pods) het. As Server A 'n produk opdater, hou Server B se APCu-cache steeds die ou produk. Ons oplos dit deur die uitzending van ongeldigheidsboodskappe via Symfony Messenger. Die strategie 
 
 
 
 
 Skryf aan Redis (gedeel) Cache plaaslik in APCu (vir spoed). Wanneer die data verander, stuur 'n boodskap na die bus. Alle bedieners verbruik die boodskap en verwyder hul plaaslike APCu vir daardie spesifieke tag. Konfigurasie composer require symfony/messenger
 Ons benodig 'n vervoer wat "Pub / Sub" (Fanout) ondersteun, sodat elke bediener die boodskap ontvang. #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
 Die kode 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}"]));
    }
}
 Die #[Cacheable] attribuut In plaas van skryf boilerplate in elke diensmetode, laat ons 'n wat die caching outomaties behels met behulp van die of . $cache->get() PHP 8 Attribute Decorator Pattern Event Subscription Hieronder is 'n skoon implementering met behulp van a luisteraar, wat doeltreffend en maklik om te rede oor. 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
    ) {}
}
 Die Event Abonneer Hierdie luisteraar ontken beheerder oproepe, kyk vir die attribuut, en probeer om te dien van die cache. Hierdie eenvoudige implementasie veronderstel dat die beheerder 'n algemene serialiserbare reaksie (soos JSON of 'n Array) retourneer. 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);
    }
}
 Jy moet jou cache pools in 'n Vir die Om dit dinamiet te maak. register ServiceLocator Subscriber Die bovenstaande kode toon dat die verandering van die Ideaal gesproke, vir dienste, sal jy gebruik op die diensdefinisie, maar vir beheerders is die opname van die gebeurtenis die Symfoniese manier. Kernel execution flow #[AsDecorator] Konklusie Uitvoering is maklik; die ontwerp van 'n caching strategie wat netwerk partisies oorleef, Auditeer, en Spike is 'n dissipline CacheInterface GDPR Black Friday traffic Die strategieë wat hier uiteengesit word - vir die latentheid, vir die mededinging, vir veiligheid, en vir konsekwentheid – beweeg jou aansoek weg van fragile optimisasie en na robuuste ingenieurswese. Symfony bied hierdie primitiewe uit die boks, wat ons toelaat om komplekse gedistribueerde stelselprobleme op te los sonder om swaar derde-party-infrastruktuur in te voer. Chain Caching Probabilistic Expiration Sodium Encryption Messenger-based Invalidation Stop met die behandeling van jou cache as 'n tydelike dumping grond. Behandel dit as 'n kritieke, veilige laag van jou data persistentie strategie. Kom ons voortgaan die bespreking Hoë-prestasie PHP-argitektuur is 'n voortdurend ontwikkelende landskap. As jy 'n oorlewende monoliet herontwerp of 'n verspreide stelsel in Symfony ontwerp, wil ek graag hoor oor die uitdagings wat jy ondervind. Het jy 'n aangepaste Marshaller vir spesifieke voldoening behoeftes geïmplementeer? Hoe hanteer jy cache-invalidasie oor multi-regionale implementasies? Kom ons geek uit oor argitektuur, deel oorlog stories, en bou beter sagteware.

Read My Stories

Hierdie oudio word in die oorspronklike taal van die storie vervaardig!

Belangrike Cachingstrategieë: Hoe om veerkragtige Caching in Symfony te skep

About Author

KOMMENTAAR

HANG TAGS

HIERDIE ARTIKEL IS AANGEBIED IN

Related Stories

"What If ... I didn't Do It?"

Uber Still Can't Turn a Profit

The #decentralize-ai Writing Contest by ICP and HackerNoon: Results Announcement 🎉

$30M Raised in 30 Minutes and the Controversies to Follow: The Story Behind Dexter’s GM.ai Project

"What If ... I didn't Do It?"

Uber Still Can't Turn a Profit

The #decentralize-ai Writing Contest by ICP and HackerNoon: Results Announcement 🎉

$30M Raised in 30 Minutes and the Controversies to Follow: The Story Behind Dexter’s GM.ai Project

Light-Mode

Classic

Newspaper

Minty

Dark-Mode

Neon Noir

Minty

HN StartUps