Komponent Symfony Cache jest często najbardziej niedostatecznie wykorzystywanym narzędziem w arsenale dewelopera. Większość wdrożeń zatrzymuje się przy "instalacji Redis" i owija kilka połączeń z bazą danych w jednym Chociaż funkcjonalne, to ledwo zarysuje powierzchnię tego, co komponent może zrobić w środowiskach o dużej przepustowości, rozproszonych. $cache->get() W Symfony 7.3 składnik pamięci podręcznej nie jest tylko magazynem wartości kluczowych; jest to zaawansowany system zdolny do architektury warstwowej, ochrony prawdopodobieństwa i przejrzystego szyfrowania. W tym artykule omówiono ważne strategie pamięci podręcznej, które rozwiązują kosztowne problemy architektoniczne: , (wędrowanie z trzody chlewnej) (w tym ) oraz . latency concurrency security GDPR distributed invalidation Architektura opóźnienia: łańcuchowa pamięć podręczna W architekturze mikrousługowej lub monolicie o dużym natężeniu ruchu połączenie sieciowe z Redis (zwykle 1–3 ms) może ostatecznie stać się przeszkodą w porównaniu z pamięcią lokalną (nanosekundy). Rozwiązaniem jest a Skutecznie działając jako Cache dla Twojej aplikacji. , . Chain Cache L1/L2 CPU L1 is local (APCu) L2 is shared (Redis) Konfiguracja Konfigurujemy basen, który najpierw czyta z APCu. Jeśli brakuje, czyta z Redis, a następnie populuje APCu. composer require symfony/cache symfony/orm-pack redis
 Konfiguracja ( ) do : 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]
 Używanie Wstrzyknięcie konkretnego puli przy użyciu atrybutu Target. 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]; 
    }
}
 weryfikacja 
 
 
 
 
 
 Wyczyść pamięć podręczną: bin/console cache:pool:clear cache.layered Poproś o stronę Sprawdź Redis (CLI): KEYS * (Zobaczysz klucz). Sprawdź APCu (Panel internetowy): zobaczysz klucz. Odłącz Redis. Aplikacja będzie nadal obsługiwać z APCu przez 60 sekund. Rozwiązywanie gromady grzmotów: prawdopodobne wczesne wygaśnięcie „Cache Stampede” (lub Thundering Herd) występuje, gdy kończy się ważność klucza pamięci podręcznej. Nagle 1000 równoczesnych żądań pomija pamięć podręczną jednocześnie i uderza w bazę danych, aby obliczyć tę samą wartość. Symfonia to rozwiązanie złożonych mechanizmów blokowania (takich jak Semaphore) przy użyciu . without Probabilistic Early Expiration Jak to działa Zamiast wygasnąć dokładnie o 12:00, pamięć podręczna twierdzi, że jest pusta nieco przed wygaśnięciem, ale tylko dla niektórych żądań. Im bliżej wygaśnięcia, tym większa prawdopodobieństwo pominięcia. wdrażania Nie potrzebujesz nowej konfiguracji; musisz użyć Parametry zawarte w umowie. $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);
 Weryfikacja matematyczna Nie ma polecenia CLI do "dowodzenia" prawdopodobieństwa, ale można rejestrować recomputations. 
 
 
 
 Ustaw pozycję $item->expiresAfter(10). Utwórz pętlę, która uderza w ten klucz pamięci podręcznej co 100 ms. Należy zauważyć, że połączenie zwrotne jest wyzwalane przed upływem 10 sekund i zwykle tylko raz, zapewniając, że twój backend jest chroniony. „Czarna skrzynka”: przejrzyste szyfrowanie za pomocą sodu Cachem (PII) w Redis jest a Jeśli atakujący wyrzuci Twoją pamięć Redis, posiada dane. Personal Identifiable Information GDPR/security risk Symfony pozwala owinąć adapter pamięci podręcznej w Będziemy korzystać z Aby przejrzyście szyfrować dane przed opuszczeniem PHP i odszyfrować je po odzyskaniu. Marshaller SodiumMarshaller Zapewnić Jest Rozszerzenie to jest w PHP 8.x libsodium installed enabled Konfiguracja Musimy ozdobić domyślnego marszałka. będziemy używać „ „Marshaller (do kompresji danych) owinięty wewnątrz „ „Marshaller (aby go zaszyfrować) 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.
 Wyrafinowane podejście do symfonii (najlepsze praktyki): Zamiast przeważać nad globalnym adapterem, wyraźnie zdefiniuj usługę basenu w celu wstrzyknięcia marszałka. # 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']
 Używanie 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);
}
 weryfikacja 
 
 
 
 
 
 Przechowywanie danych w cache. Połączenie z Redis za pomocą CLI: redis-cli. Zdobądź klucz Wynik: zobaczysz śmieci binarne (zaszyfrowany ciąg), a nie adres prostego tekstu. Pobierz go za pośrednictwem PHP: otrzymasz adres prostego tekstu. Invalidacja dystrybuowana: Tags & Messenger Najtrudniejszym problemem w informatyce jest unieważnienie pamięci podręcznej. Staje się to trudniejsze, gdy masz 5 serwerów internetowych (podów). Jeśli Server A aktualizuje produkt, pamięć podręczna APCu serwera B nadal przechowuje stary produkt. Rozwiązujemy to, wysyłając wiadomości o nieważności za pośrednictwem Symfony Messenger. Strategia 
 
 
 
 
 Napisz do Redis (podziel się) Cache lokalnie w APCu (dla prędkości). Gdy dane ulegną zmianie, wyślij wiadomość do autobusu. Wszystkie serwery zużywają wiadomość i wyczyszczają swoje lokalne APCu dla tego określonego tagu. Konfiguracja composer require symfony/messenger
 Potrzebujemy transportu, który obsługuje „Pub/Sub” (Fanout), więc każdy serwer otrzymuje wiadomość. #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
 Kodeks jest 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}"]));
    }
}
 Atrakcje w pobliżu #Cacheable Attribute Zamiast pisać w każdej metodzie obsługi, stworzmy Umożliwia to automatyczne korzystanie z lub . $cache->get() PHP 8 Attribute Decorator Pattern Event Subscription Poniżej znajduje się czysta implementacja za pomocą Słuchacz, który jest efektywny i łatwy w rozumowaniu. 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
    ) {}
}
 Subskrybent wydarzenia Ten słuchacz przechwytuje połączenia kontrolera, sprawdza atrybut i próbuje służyć z pamięci podręcznej. Ta prosta implementacja zakłada, że kontroler zwraca ogólną odpowiedź serializowalną (taką jak JSON lub 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);
    }
}
 Musisz mieć Twoja cache pols w a Dla tego Dostęp do nich dynamicznie. register ServiceLocator Subscriber Powyższy kod wskazuje na zmianę Idealnie, jeśli korzystasz z usług na definicji usługi, ale dla kontrolerów przechwytywanie zdarzenia jest sposobem symfonii. Kernel execution flow #[AsDecorator] konkluzji Wdrożenie jest łatwe; projektowanie strategii pamięci podręcznej, która przetrwa partycje sieciowe, audytów oraz Spikes to dyscyplina. CacheInterface GDPR Black Friday traffic Wymienione tutaj strategie - w zakresie latentności, w zakresie konkurencji, dla bezpieczeństwa, a także Aby osiągnąć spójność, przenieś aplikację z dala od kruchych optymalizacji i w kierunku solidnego inżynierii. Symfony dostarcza tych prymitywów z pudełka, co pozwala nam rozwiązywać złożone problemy z rozproszonymi systemami bez wprowadzania ciężkiej infrastruktury zewnętrznej. Chain Caching Probabilistic Expiration Sodium Encryption Messenger-based Invalidation Przestań traktować pamięć podręczną jako tymczasowe pole dumpingu, traktuj ją jako krytyczną, zabezpieczoną warstwę strategii utrzymania danych. Kontynuujmy dyskusję Wysokowydajna architektura PHP to stale rozwijający się krajobraz.Jeśli pracujesz nad odtworzeniem monolitu lub projektowaniem systemu rozproszonego w Symfonii, chciałbym usłyszeć o wyzwaniach, przed którymi stoisz. Czy wdrożyłeś niestandardowy Marshaller dla konkretnych potrzeb zgodności? Jak radzisz sobie z nieważnością pamięci podręcznej w wielu wdrożeniach regionalnych? Rozmawiajmy o architekturze, dzielmy się historiami wojennymi i budujmy lepsze oprogramowanie.

Read My Stories

Ten dźwięk jest produkowany w oryginalnym języku historii!

Ważne strategie pamięci podręcznej: jak utworzyć odporną pamięć podręczną w symfonii

About Author

UWAGI

ZAWIEŚĆ TAGI

ARTYKUŁ TEN ZOSTAŁ PREZENTOWANY W

Related Stories

Listen to Tech Brief Podcasts on Your Headphones: Stay Connected to HackerNoon Anywhere, Anytime

Reach More Readers! BOOST Your Story on HackerNoon

The Noonies 2022 Award Goes to Madalin Muraretiu - Contributor of The Year - Cryptocurrency Edition

The Blockchain Social Experiment: Enforced Logic

Listen to Tech Brief Podcasts on Your Headphones: Stay Connected to HackerNoon Anywhere, Anytime

Reach More Readers! BOOST Your Story on HackerNoon

The Noonies 2022 Award Goes to Madalin Muraretiu - Contributor of The Year - Cryptocurrency Edition

The Blockchain Social Experiment: Enforced Logic

Light-Mode

Classic

Newspaper

Minty

Dark-Mode

Neon Noir

Minty

HN StartUps