O compoñente Symfony Cache é a miúdo a ferramenta máis pouco utilizada no arsenal dun desenvolvedor.A maioría das implementacións paran en "instalar Redis" e envolven algunhas chamadas de base de datos nun Mentres funcional, isto apenas arranxa a superficie do que o compoñente pode facer en ambientes distribuídos de alto rendemento. $cache->get() En Symfony 7.3, o compoñente de caché non é só un almacén de valores clave; é un sistema sofisticado capaz de arquitectura nivelada, protección de estampas probabilísticas e cifrado transparente. Este artigo explora estratexias importantes de caché que resolven problemas arquitectónicos caros: , (Aínda que os gandeiros, (por exemplo ), e . latency concurrency security GDPR distributed invalidation A arquitectura da latencia: nivelado (cadea) Caching En arquitecturas de microservizos ou monólitos de alto tráfico, unha chamada de rede a Redis (típicamente 1–3ms) pode finalmente converterse nun obstáculo comparado coa memoria local (nanosegundos). A solución é a actuando efectivamente como unha Cache para a túa aplicación. , . Chain Cache L1/L2 CPU L1 is local (APCu) L2 is shared (Redis) A configuración Configuraremos un pool que lea desde APCu primeiro. Se falta, lea desde Redis, a continuación, poboará APCu. composer require symfony/cache symfony/orm-pack redis
 Configuración ( ) : 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]
 Uso Inxectar o pool específico usando o atributo 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]; 
    }
}
 Verificación 
 
 
 
 
 
 Cache limpo: bin/console cache:pool:clear cache.layered Solicita a páxina Comproba Redis (CLI): KEYS * (Verás a clave). Comproba APCu (Panel Web): Verás a clave. Desconectar Redis. A aplicación seguirá servindo desde APCu durante 60 segundos. Resolver o rebaño de tormentas: expiración precoz probábel O "Cache Stampede" (ou Thundering Herd) ocorre cando unha clave de caché quente expira. De súpeto, 1.000 solicitudes simultáneas perden a caché simultaneamente e golpean a súa base de datos para calcular o mesmo valor. A sinfonía resolve isto mecanismos de bloqueo complexos (como Semaphore) mediante o uso de . without Probabilistic Early Expiration como funciona En lugar de expirar exactamente ás 12:00, a caché afirma estar baleira un pouco antes da expiración, pero só para algunhas solicitudes. Canto máis preto da expiración, maior é a probabilidade de que se perda. A implementación Non necesita unha nova configuración; ten que usar o Parámetros do contrato. $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);
 Verificación matemática Non hai un comando CLI para "probar" a probabilidade, pero pode rexistrar as recomputacións. 
 
 
 
 Define $item-> expiresAfter(10). Crear un loop que bate esta clave de caché cada 100ms. Teña en conta que a chamada de retorno se activa antes de que pasen 10 segundos e xeralmente só unha vez, asegurando que o seu backend estea protexido. A "caixa negra": encriptación transparente con sodio Caché (PII) en Redis é unha Se un atacante descarta a súa memoria Redis, ten os datos. Personal Identifiable Information GDPR/security risk Symfony permítelle envolver o seu adaptador de caché nunha Imos usar o Para cifrar os datos de forma transparente antes de que saia de PHP e descifralo cando se recupere. Marshaller SodiumMarshaller asegurar é A extensión é En PHP 8.x libsodium installed enabled Configuración Necesitamos decorar o mariscal por defecto. usaremos unha " "Marshaller (para comprimir datos) envolto dentro dun " “ marshaller (para cifralo) 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.
 Refined Approach for Symfony (Best Practice): Instead of overriding the global adapter, define the pool service explicitly to inject the marshaller. # 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']
 Uso 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);
}
 Verificación 
 
 
 
 
 
 Gardar os datos na caché. Conectar a Redis a través de CLI: redis-cli. Toma a chave. Resultado: Verá o lixo binario (cadea cifrada), non o enderezo de texto simple. Buscalo a través de PHP: Obtén o enderezo de texto simple. Descargar cancións de Tags & Messenger O problema máis difícil na ciencia da computación é a invalidación da caché. É máis difícil cando ten 5 servidores web (pods). Se Server A actualiza un produto, a caché APCu de Server B aínda mantén o produto vello. Resolvemos isto transmitindo mensaxes de invalidación a través de Symfony Messenger. A estratexia 
 
 
 
 
 Escribe para Redis (compartido) Cache localmente en APCu (para velocidade). Cando os datos cambien, envíe unha mensaxe ao autobús. Todos os servidores consumen a mensaxe e limpan a súa APCu local para esa etiqueta específica. Configuración composer require symfony/messenger
 Necesitamos un transporte que soporte "Pub / Sub" (Fanout), para que cada servidor reciba a mensaxe. #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
 O código 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}"]));
    }
}
 O atributo #[Cacheable] No canto de escribir boilerplate en cada método de servizo, imos crear un que xestiona o cache automaticamente usando o ou . $cache->get() PHP 8 Attribute Decorator Pattern Event Subscription Abaixo está unha aplicación limpa usando un escoitador, que é eficiente e doado de razoar. 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
    ) {}
}
 Subscritor do evento Este escoitador intercepta as chamadas do controlador, verifica o atributo e intenta servir desde a caché. Esta implementación sinxela asume que o controlador devolve unha resposta serializable xenérica (como JSON ou un 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);
    }
}
 Tes que ter O teu cache polacos en a Para o Acceso a elas de xeito dinámico. register ServiceLocator Subscriber O código anterior demostra a modificación da Idealmente, para os servizos, usaría sobre a definición de servizo, pero para os controladores, interceptar o evento é o xeito da sinfonía. Kernel execution flow #[AsDecorator] Conclusión Implementación é fácil; arquitectar unha estratexia de caché que sobreviva ás particións de rede, Auditorías e O galego é unha disciplina. CacheInterface GDPR Black Friday traffic As estratexias descritas aquí - pola súa latitude, pola competición, para a seguridade, e para a coherencia - mover a súa aplicación lonxe de optimizacións fráxiles e cara a enxeñaría robusta. Symfony proporciona estes primitivos fóra da caixa, o que nos permite resolver problemas complexos de sistema distribuído sen introducir infraestruturas pesadas de terceiros. Chain Caching Probabilistic Expiration Sodium Encryption Messenger-based Invalidation Deixar de tratar a súa caché como un campo de dumping temporal. Tratalo como unha capa crítica e segura da súa estratexia de persistencia de datos. Seguimos coa discusión A arquitectura de PHP de alto rendemento é un paisaxe en constante evolución. Se está a refactorizar un monolito legado ou a deseñar un sistema distribuído en Symfony, gustaríame escoitar sobre os retos que se enfrontan. Implementou un Marshaller personalizado para necesidades específicas de cumprimento? Como xestiona a invalidación da caché en implementacións multi-rexión? Achégate a min directamente en LinkedIn. imos gozar da arquitectura, compartir historias de guerra e construír un software mellor.

Read My Stories

Este audio está producido na lingua orixinal da historia!

Estratexias importantes de caché: como crear caché resiliente en sinfonía

About Author

COMENTARIOS

Etiquetas colgantes

ESTE ARTIGO FOI PRESENTADO EN

Related Stories

HackerNoon Decoded 2024: Celebrating Our Tech Stories Community!

HackerNoon Decoded 2024: Celebrating Our HackerNoon Community!

HackerNoon Decoded 2024: Celebrating Our Product Management Community!

Coñece R Systems: HackerNoon empresa da semana

HackerNoon Decoded 2024: Celebrating Our Tech Stories Community!

HackerNoon Decoded 2024: Celebrating Our HackerNoon Community!

HackerNoon Decoded 2024: Celebrating Our Product Management Community!

Coñece R Systems: HackerNoon empresa da semana

Light-Mode

Classic

Newspaper

Minty

Dark-Mode

Neon Noir

Minty

HN StartUps