💾 El Patrón Flyweight: El gran ahorrador de memoria

¿Te ha pasado alguna vez que tu aplicación necesita crear miles o millones de objetos que son casi iguales y la RAM se va a la puta? Pues para eso existe el patrón de diseño Flyweight, un patrón estructural que va perfecto para ahorrar memoria compartiendo todo lo que se pueda entre objetos.

La idea es bastante de simple: si tienes 10.000 objetos y todos comparten los mismos datos pesados, ¿para qué copiar esos datos 10.000 veces? Creas una única instancia compartida y que todos la referencien. EA.

No dupliques lo que es igual. Guárdalo una vez y que todo el mundo tire de la misma copia.

---

💾 1. Estado intrínseco vs extrínseco

Esto es lo más importante del patrón, así que pay attention please:

Todo el patrón se basa en esta separación. Lo que se repite va dentro del Flyweight (una sola copia para todos). Lo que varía se queda fuera y se pasa como parámetro cuando hace falta.

---

🚗 2. La fábrica de coches

Imagina una fábrica que saca miles de coches:

• Sin Flyweight: Cada coche lleva incrustada la imagen del logo de la marca (5MB). Si fabricas 1000 coches, son 5000 MB (5GB) solo en logos. Tu servidor llora.

• Con Flyweight: La imagen del logo se guarda una sola vez. Los 1000 coches apuntan a esa única imagen. Cada coche solo guarda lo suyo: matrícula, GPS, color. Resultado: 5MB del logo + los datos de cada coche (que pesan nada). Tu servidor ni se entera.

---

🛠️ 3. Los roles del patrón

El cliente nunca crea Flyweights directamente. Siempre pasa por la Factory. Si te saltas la Factory y haces new, te cargas todo el beneficio del patrón.

---

🧑‍💻 4. Ejemplo práctico en PHP: Árboles en un juego

Imagina un RPG con miles de árboles. Todos los Robles tienen la misma textura (20MB) y el mismo modelo 3D. Lo que cambia es dónde está plantado cada uno.

<?php

// 1. Interfaz del Flyweight
interface TipoDeArbol {
    public function dibujar(int $x, int $y): void;
}

// 2. Flyweight Concreto (guarda el estado intrínseco)
class ArbolFlyweight implements TipoDeArbol {
    // Estado intrínseco: compartido e inmutable
    private string $nombre;
    private string $textura; // Simula un archivo pesado (20MB)

    public function __construct(string $nombre, string $textura) {
        $this->nombre = $nombre;
        $this->textura = $textura;
        echo "   [FLYWEIGHT] Creado: $this->nombre (Textura: $this->textura)\n";
    }

    // Recibe el estado extrínseco (posición) como parámetro
    public function dibujar(int $x, int $y): void {
        echo "   [DIBUJO] $this->nombre en ($x, $y) con textura $this->textura\n";
    }
}

// 3. Factoría del Flyweight (caché de objetos)
class FactoriaArbol {
    /** @var TipoDeArbol[] */
    private array $flyweights = [];

    public function getFlyweight(string $nombre, string $textura): TipoDeArbol {
        if (!isset($this->flyweights[$nombre])) {
            // No existe, lo creamos
            $this->flyweights[$nombre] = new ArbolFlyweight($nombre, $textura);
        }
        // Ya existe, lo devolvemos (¡ahorro!)
        return $this->flyweights[$nombre];
    }

    public function getNumFlyweights(): int {
        return count($this->flyweights);
    }
}

// 4. Uso del patrón (El Motor del Juego)
$factoria = new FactoriaArbol();

echo "--- 3 Robles (mismo tipo, distinta posición) ---\n";
$factoria->getFlyweight('Roble', 'roble_hd.jpg')->dibujar(10, 50);
$factoria->getFlyweight('Roble', 'roble_hd.jpg')->dibujar(20, 60);
$factoria->getFlyweight('Roble', 'roble_hd.jpg')->dibujar(30, 70);

echo "\n--- 2 Abetos (nuevo tipo) ---\n";
$factoria->getFlyweight('Abeto', 'abeto_hd.png')->dibujar(5, 10);
$factoria->getFlyweight('Abeto', 'abeto_hd.png')->dibujar(8, 12);

echo "\n--- Resumen ---\n";
echo "Árboles solicitados: 5\n";
echo "Flyweights en memoria: " . $factoria->getNumFlyweights() . "\n";
// Solo 2 objetos en memoria, no 5. ¡Ahorro del 60%!

// 🖥️ Salida:
// --- 3 Robles (mismo tipo, distinta posición) ---
//    [FLYWEIGHT] Creado: Roble (Textura: roble_hd.jpg)
//    [DIBUJO] Roble en (10, 50) con textura roble_hd.jpg
//    [DIBUJO] Roble en (20, 60) con textura roble_hd.jpg
//    [DIBUJO] Roble en (30, 70) con textura roble_hd.jpg
//
// --- 2 Abetos (nuevo tipo) ---
//    [FLYWEIGHT] Creado: Abeto (Textura: abeto_hd.png)
//    [DIBUJO] Abeto en (5, 10) con textura abeto_hd.png
//    [DIBUJO] Abeto en (8, 12) con textura abeto_hd.png
//
// --- Resumen ---
// Árboles solicitados: 5
// Flyweights en memoria: 2

“[FLYWEIGHT] Creado” solo sale dos veces: una para Roble y otra para Abeto. Las demás llamadas reutilizan el que ya existe. Si tuvieras 10.000 robles, seguirías teniendo un solo Flyweight en memoria. Eso es lo bonito del asunto.

---

🌍 5. Ejemplo real en PHP: Caché de iconos

Los jueguecitos están bien para explicar, pero en backend PHP esto también se usa. Imagina un sistema que genera PDFs con iconos:

class IconoFlyweight {
    private string $nombre;
    private string $svgData; // El SVG puede pesar lo suyo

    public function __construct(string $nombre, string $svgData) {
        $this->nombre = $nombre;
        $this->svgData = $svgData;
    }

    public function renderizar(int $tamaño, string $color): string {
        // Estado intrínseco: svgData (compartido)
        // Estado extrínseco: tamaño y color (único por uso)
        return "<svg width='$tamaño' fill='$color'>{$this->svgData}</svg>";
    }
}

class FactoriaIconos {
    private array $iconos = [];

    public function getIcono(string $nombre): IconoFlyweight {
        if (!isset($this->iconos[$nombre])) {
            // Simula cargar el SVG del disco
            $svg = file_get_contents("/icons/$nombre.svg");
            $this->iconos[$nombre] = new IconoFlyweight($nombre, $svg);
        }
        return $this->iconos[$nombre];
    }
}

// Uso: un PDF con 500 líneas, cada una con el icono "check"
$factoria = new FactoriaIconos();

foreach ($lineasDelPdf as $linea) {
    $icono = $factoria->getIcono('check'); // Siempre el mismo objeto
    echo $icono->renderizar(16, $linea['color']); // Distinto color
}
// El SVG se cargó del disco UNA vez, no 500

Otro caso muy típico son los sistemas que renderizan fuentes tipográficas. Cada carácter tiene un glyph (la forma visual del carácter), que es el estado intrínseco. La posición, tamaño y color son el estado extrínseco. Un documento con 100.000 caracteres no necesita 100.000 glyphs en memoria, solo los del alfabeto (~52). Lo demás son posiciones.

---

📊 6. Números reales: ¿Cuánto ahorra?

Para que veas que no exagero, aquí tienes los números del ejemplo de los árboles:

Cuantos más objetos tengas y más pese el estado intrínseco, más bestial es el ahorro. Pero ojo que si tus objetos pesan poco y son pocos, Flyweight es matar moscas a cañonazos.

---

🔄 7. Comparativa con otros patrones

La confusión que más veo es Flyweight vs Singleton. La diferencia es que un Singleton es siempre una sola instancia global. Flyweight puede tener varias (una por tipo: un Flyweight para “Roble”, otro para “Abeto”, etc.). La Factory decide cuál te toca.

---

⚖️ 8. Relación con SOLID

---

✅ 9. Ventajas y desventajas

---

⚠️ 10. Errores comunes

1. Colar estado extrínseco dentro del Flyweight

Si el Flyweight guarda datos que son diferentes para cada uso, ya no se puede compartir y te cargas el patrón entero:

// ❌ MAL: la posición es única, no pinta nada en el Flyweight
class ArbolFlyweight {
    private string $textura;
    private int $x; // ← Esto es estado extrínseco
    private int $y; // ← Esto también

    public function dibujar(): void {
        // Usa $this->x y $this->y directamente
    }
}

// ✅ BIEN: la posición se pasa como parámetro
class ArbolFlyweight {
    private string $textura; // Solo estado intrínseco

    public function dibujar(int $x, int $y): void {
        // Recibe x,y como parámetros (estado extrínseco)
    }
}

2. Saltarse la Factoría

Si el cliente crea Flyweights a pelo con new, no hay compartición ninguna. Como si no existiera el patrón:

// ❌ MAL: crea objetos nuevos cada vez
$roble1 = new ArbolFlyweight('Roble', 'roble.jpg');
$roble2 = new ArbolFlyweight('Roble', 'roble.jpg'); // ¡Duplicado!

// ✅ BIEN: siempre a través de la Factoría
$roble1 = $factoria->getFlyweight('Roble', 'roble.jpg');
$roble2 = $factoria->getFlyweight('Roble', 'roble.jpg'); // Misma instancia

3. Flyweight con setters (mutable)

Si dejas que alguien cambie el estado interno del Flyweight, se lía parda. Recuerda que ese objeto lo comparten TODOS:

// ❌ MAL: el Flyweight tiene setters
class ArbolFlyweight {
    public function setTextura(string $textura): void {
        $this->textura = $textura; // ¡Cambia para TODOS los que lo comparten!
    }
}

// Si cambias la textura del "Roble", TODOS los robles del juego cambian.
// Probablemente no es lo que quieres, nene.

El Flyweight tiene que ser inmutable. Si necesitas cambiar algo, crea un nuevo tipo.

4. Usarlo cuando no hace falta

Si solo tienes 20 objetos ligeros, montar la Factory y separar el estado es trabajar de más para nada. Flyweight es un patrón de optimización, no lo metas por si acaso:

// ❌ Sobreingeniería: 5 botones con un icono de 2KB
$factoria->getFlyweight('boton-guardar', 'save.svg');

// ✅ Para 5 botones, crea los objetos normales y déjate de historias
$boton = new Boton('Guardar', 'save.svg');

---

🤔 11. ¿Cuándo usarlo y cuándo no?

Si has perfilado tu aplicación y ves que cientos de objetos comparten los mismos datos pesados, tira de Flyweight. Si no has medido que la memoria es un problema, probablemente no lo necesitas. No seas ése que optimiza prematuramente.

---

💡 12. Conclusión

El Flyweight es un patrón de optimización pura y dura. No te cambia la arquitectura ni te añade funcionalidad nueva. Lo que hace es que tu aplicación funcione donde antes se quedaba tiesa por falta de memoria.

La idea consiste en guardar solamente una vez lo que se repite. Lo que varía, pásalo como parámetro. Es lo que hacen los motores de videojuegos con las texturas, los procesadores de texto con las fuentes y los navegadores con los estilos CSS.

No es de los patrones que usas todos los días. Pero el día que lo necesitas, te marca la diferencia entre una aplicación que tira y una que se cae a la puta.

EA, ¡saluditos y nos vemos en los bares! 🍻