Optimiza tu Aplicación Symfony con Cache

• Son más rápidos de acceder y modificar: puedes tacharlos, garabatearlos, etc.
• Son temporales: en cuanto ya no los necesites o necesites tomar apuntes nuevos los desechas.
• Son una copia de trabajo: contienen la misma información final, pero en un formato menos estructurado.
• Tienen un espacio limitado: son, quizá, unas pocas hojas sueltas, no el cuaderno entero.

• Pasarlos a limpio: estructurarlos y guardarlos en la memoria principal.
• Desecharlos: si no los necesitamos más, ¿para qué guardarlos?

• Redis: Ofrece alto rendimiento y versatilidad. Ideal para entornos distribuidos y aplicaciones con alta concurrencia.
• Memcached: Proporciona rendimiento excepcional para operaciones simples y funciona bien en configuraciones distribuidas. Está limitado a almacenar strings y pierde los datos al reiniciar el servidor.
• APCu: Altamente eficiente ya que utiliza memoria del proceso de PHP y requiere mínima configuración. Solo funciona en entornos de un único servidor. Los datos se pierden entre reinicios.
• Filesystem: No requiere servicios adicionales. Ideal para desarrollo y aplicaciones pequeñas. Su rendimiento es inferior a las soluciones en memoria y puede presentar problemas de concurrencia.

• Pool para productos: almacena información básica como precio, stock, etc.
• Pool para categorías: almacena estructura de navegación, menús, etc.
• Pool para configuraciones: almacena parámetros del sistema.

composer require symfony/cache

# config/packages/cache.yaml
framework:
    cache:
        app: cache.adapter.apcu

use Symfony\Contracts\Cache\ItemInterface;
use Symfony\Contracts\Cache\TagAwareCacheInterface;

class ProductService
{
    public function __construct(
        private readonly ProductRepository $repository,
        private readonly TagAwareCacheInterface $cache,
    ) {}

    public function getProduct(int $id): array
    {
        return $this->cache->get(
            "product_$id",
            function (ItemInterface $item) use ($id): array {
                // Establecemos tiempo de vida
                $item->expiresAfter(3600);
                
                // Añadimos etiquetas
                $item->tag(['products', "product_$id"]);

                // Obtenemos los datos que queremos cachear
                return $this->repository->findOneBy(['id' => $id]);
            }
        );
    }
}

• Cada elemento tiene una clave única (primer parámetro)
• La función de callback (segundo parámetro) solo se ejecuta si no hay datos en caché
• El objeto ItemInterface permite configurar el elemento en caché
• Las etiquetas agrupan elementos para su gestión conjunta

class ProductService
{
    // [...]

    public function clearProductCache(int $id): void
    {
        // Elimina el elemento con la clave específica
        $this->cache->delete("product_$id");
    }
    
    public function clearAllProductsCache(): void
    {
        // Elimina todos los elementos con las etiquetas especificadas
        $this->cache->invalidateTags(['products']);
    }
}

# Listar pools configurados
php bin/console cache:pool:list

# Limpiar una pool específica
php bin/console cache:pool:clear products

# Limpiar todos los pools
php bin/console cache:pool:clear --all

# Excluir pools específicos
php bin/console cache:pool:clear --all --exclude=products --exclude=categories

# Limpiar caché global
php bin/console cache:pool:clear cache.global_clearer

# Invalidar por etiquetas
php bin/console cache:pool:invalidate-tags tag1 tag2
php bin/console cache:pool:invalidate-tags tag1 tag2 --pool=products

# config/packages/cache.yaml
framework:
    cache:
        app: cache.adapter.apcu

        # Se inyectará como $productsCache
        products:
            adapter: cache.adapter.redis_tag_aware
            provider: 'redis://localhost'

# config/packages/cache.yaml
framework:
    cache:
        app: cache.adapter.apcu

        products:
            adapter: cache.adapter.redis
            provider: 'redis://localhost'
            tags: products_tag_pool

        products_tag_pool:
            adapter: cache.app

#[AsTwigComponent]
class ProductCardComponent
{
    public int $productId;

    private function __construct(
        private readonly ProductRepository $repository,
        private readonly TagAwareCacheInterface $productsCache,
    )
    {}
    
    public function getProduct(): array
    {
        return $this->productsCache->get(
            "product_card_{$this->productId}",
            function (ItemInterface $item): array {
                $item->expiresAfter(3600);
                $item->tag(['product_cards', "product_{$this->productId}"]);
                
                $product = $this->repository->findOneBy(['id' => $this->productId]);
                
                return [
                    'id' => $this->productId,
                    'name' => $product->getName(),
                    'price' => /* Cálculos de precio */,
                ];
            }
        );
    }
}

1. Consultas Costosas:
   • Consultas con múltiples joins
   • Agregaciones y cálculos complejos
   • Datos con baja frecuencia de cambio
2. Componentes UI Complejos:
   • Listados extensos
   • Dashboards con múltiples widgets
   • Componentes con cálculos intensivos
3. Integraciones Externas:
   • Llamadas a APIs
   • Servicios de terceros
   • Sistemas integrados

1. Datos Dinámicos:
   • Información en tiempo real
   • Datos de sesión
2. Información Sensible:
   • Datos personales
   • Información financiera
   • Tokens de seguridad

1. Selección de Adaptador:
   • Filesystem: Desarrollo local
   • Redis/Memcached: Producción
   • APCu: Caché local rápida
2. Estrategia de Claves:

// Recomendado: claves descriptivas
$key = sprintf('product_%d_details_%s', $id, $locale);

// No recomendado: claves genéricas
$key = "prod_$id";

1. Gestión de Etiquetas:

// Estructura jerárquica de etiquetas
$item->tag([
    'products',
    "product_$id",
    "category_$categoryId"
]);

1. Identificar los elementos a cachear
2. Seleccionar el adaptador adecuado
3. Implementar una estrategia de invalidación efectiva
4. Monitorizar y optimizar continuamente

• Documentación oficial de Symfony Cache
• Caché en cadena
• Cifrado de caché
• Cálculo asíncrono de valores en caché