Le Design Pattern Flyweight (Poids mouche)

Aujourd'hui je vous propose de parler Design Pattern, et plus particulièrement d'un pattern intéressant à mettre en place quand on cherche à alléger (en mémoire) une application : le pattern Flyweight (poid mouche).

Problème à résoudre

l'application doit manipuler de très nombreuses Entités (des produits pour une boutique par exemple), et chaque Entité est représentée par un Objet. L'instanciation de tous ces objets est très gourmande en mémoire :

$oDataMapper = new DataMapper_Product();
$tRowset = $oDataMapper->fetchAll($where);

foreach($tRowset as $oProduct) {
    // one instance of Product $oProduct is created in each loop
    echo $oProduct->getName();
}

On voit le problème : pour chaque ligne récupérée, un objet est instancié, donc est créé, chargé en mémoire... c'est lent et coûteux.

La solution : Flyweight

Il suffit de n'instancier qu'une seule fois l'objet en question, et de l'hydrater au fur et à mesure du besoin :

$oDataMapper = new DataMapper_Product();
$tRowset = $oDataMapper->fetchAll($where);

// Only one instance of Product is used
$oProduct = new Product;

foreach($tRowset as $tInfosAboutProduct) {
    $oProduct->hydrate($tInfosAboutProduct);
    echo $oProduct->getName();
}

Ce qui dans notre cas pourrait donner par exemple cette classe :

class Product extends Dao {

    protected $_name;
    protected $_price;

    (... getter and setters ...)
    
    public function hydrate(array $tData) {
        $this
                ->setName($tData['name'])
                ->setPrice($tData['price']);
        return $this;
    }

}

Les performances sont dans ce cas meilleures, et l'utilisation mémoire est plus réduite.

Quand utiliser le pattern Flyweight ?

Ce type de pattern n'est pas forcément adapté dans toutes les situations, on l'utilise :

• quand on doit manipuler de très nombreux petits objets
• quand le coût (mémoire/vitesse) de cette manipulation est élevé

Et vous, avez-vous déjà utilisé ce pattern ? Quel est votre retour d'expérience ?