Digital solutions
Design Patterns avec Laravel

Flyweight Pattern

  • Type : Structurel
  • Difficulté : 8/10
  • Définition succincte : Le Flyweight Pattern est un design pattern structurel qui permet de réduire l'utilisation de mémoire en partageant le plus possible les objets similaires. Ce pattern est utile lorsque vous avez un grand nombre d'objets similaires et que leur création consomme beaucoup de ressources. Le Flyweight permet de réutiliser ces objets en partageant leur état commun, tout en conservant un état unique pour chaque objet si nécessaire.

Objectif du Flyweight Pattern

L'objectif du Flyweight Pattern est de réduire la consommation de mémoire en partageant des objets là où cela est possible, notamment lorsque plusieurs objets ont un état similaire. Ce pattern est particulièrement utile lorsque des objets similaires sont créés en masse, et que les duplications inutiles peuvent entraîner une surcharge en termes de mémoire et de performance.

Structure du Flyweight Pattern

  • Flyweight : Interface ou classe abstraite qui définit les opérations sur les objets partagés.
  • ConcreteFlyweight : Implémentation concrète du Flyweight, qui contient l'état partagé entre plusieurs objets.
  • UnsharedFlyweight : Classe pour les objets qui ne sont pas partagés et qui peuvent contenir un état unique.
  • FlyweightFactory : Une fabrique qui gère la création et le partage des objets Flyweight.
  • Client : L'objet qui utilise les Flyweights et les partage pour optimiser la consommation mémoire.

Implémentation avec Laravel

Imaginons que tu développes une application Laravel où chaque utilisateur possède un avatar. Cependant, ces avatars (par exemple, des images ou des fichiers) peuvent être partagés entre plusieurs utilisateurs. Chaque utilisateur aura ses propres informations spécifiques comme le nom, l'email, et le rôle, mais l'avatar (un objet partagé) est coûteux à créer et à gérer, puisqu'il représente un fichier image chargé depuis le stockage. Le Flyweight Pattern nous permettra de partager ces avatars tout en conservant les détails uniques pour chaque utilisateur.

a) Créer l'interface AvatarFlyweight

L'interface Flyweight définit les méthodes que chaque avatar doit implémenter.

// app/Contracts/AvatarFlyweight.php

namespace App\Contracts;

interface AvatarFlyweight
{
    public function render(string $userData): string;
}

b) Créer la classe ConcreteFlyweight Avatar

La classe ConcreteFlyweight représente un avatar partagé. Ici, l'image de l'avatar (gérée via l'objet Laravel File) est réutilisée pour plusieurs utilisateurs.

// app/Flyweights/Avatar.php

namespace App\Flyweights;

use App\Contracts\AvatarFlyweight;
use Illuminate\Support\Facades\Storage;
use Illuminate\Http\File;

class Avatar implements AvatarFlyweight
{
    private $imageFile;

    public function __construct(string $imagePath)
    {
        // Charger l'image de base en tant qu'objet Laravel File partagé
        $this->imageFile = new File(Storage::path($imagePath));
    }

    public function render(string $userData): string
    {
        // Générer l'affichage de l'avatar avec les informations utilisateur spécifiques
        return "Rendering avatar ({$this->imageFile->getFilename()}) for user: {$userData}";
    }
}

c) Créer la FlyweightFactory

La FlyweightFactory est responsable de la gestion des instances d'avatars partagés. Elle s'assure qu'une instance d'avatar est réutilisée si elle est déjà créée pour un chemin d'image spécifique.

// app/Factories/AvatarFactory.php

namespace App\Factories;

use App\Flyweights\Avatar;

class AvatarFactory
{
    private $avatars = [];

    public function getAvatar(string $imagePath): Avatar
    {
        // Si un avatar avec cette image existe déjà, réutiliser l'objet File
        if (!isset($this->avatars[$imagePath])) {
            $this->avatars[$imagePath] = new Avatar($imagePath);
        }

        return $this->avatars[$imagePath];
    }
}

d) Créer la classe User

La classe User représente les utilisateurs, avec des informations uniques (nom, email, rôle) qui diffèrent d'un utilisateur à l'autre. Chaque utilisateur utilise un avatar partagé, mais ses données sont uniques.

// app/Services/User.php

namespace App\Services;

use App\Flyweights\Avatar;
use App\Contracts\AvatarFlyweight;

class User
{
    private $name;
    private $email;
    private $role;
    private $avatar;

    public function __construct(string $name, string $email, string $role, AvatarFlyweight $avatar)
    {
        $this->name = $name;
        $this->email = $email;
        $this->role = $role;
        $this->avatar = $avatar;
    }

    public function renderAvatar(): string
    {
        // Passer les données utilisateur pour personnaliser l'avatar
        $userData = "Name: {$this->name}, Email: {$this->email}, Role: {$this->role}";
        return $this->avatar->render($userData);
    }
}

e) Utilisation du Flyweight Pattern dans une commande artisan

Nous allons créer une commande artisan pour illustrer comment plusieurs utilisateurs peuvent partager le même avatar (via un objet File), mais avec des informations uniques.

1. Commande GenerateUsersWithAvatars

Cette commande génère plusieurs utilisateurs avec des avatars partagés, mais des informations utilisateurs uniques (nom, email, rôle).

// app/Console/Commands/GenerateUsersWithAvatars.php

namespace App\Console\Commands;

use Illuminate\Console\Command;
use App\Factories\AvatarFactory;
use App\Services\User;

class GenerateUsersWithAvatars extends Command
{
    protected $signature = 'users:generate';
    protected $description = 'Génère des utilisateurs avec des avatars partagés (Flyweight Pattern)';

    public function handle()
    {
        $avatarFactory = new AvatarFactory();

        // Liste des utilisateurs avec des avatars partagés
        $usersData = [
            ['name' => 'Alice', 'email' => 'alice@example.com', 'role' => 'Admin', 'avatar' => 'avatars/base1.png'],
            ['name' => 'Bob', 'email' => 'bob@example.com', 'role' => 'User', 'avatar' => 'avatars/base1.png'],
            ['name' => 'Charlie', 'email' => 'charlie@example.com', 'role' => 'Moderator', 'avatar' => 'avatars/base2.png'],
        ];

        // Créer et afficher les utilisateurs avec leurs avatars
        foreach ($usersData as $userData) {
            $avatar = $avatarFactory->getAvatar($userData['avatar']);
            $user = new User($userData['name'], $userData['email'], $userData['role'], $avatar);
            $this->info($user->renderAvatar());
        }
    }
}

f) Exécution de la commande

Tu peux maintenant exécuter la commande suivante pour générer des utilisateurs avec des avatars partagés, mais des données spécifiques à chaque utilisateur :

php artisan users:generate

Résultat attendu

Rendering avatar (base1.png) for user: Name: Alice, Email: alice@example.com, Role: Admin
Rendering avatar (base1.png) for user: Name: Bob, Email: bob@example.com, Role: User
Rendering avatar (base2.png) for user: Name: Charlie, Email: charlie@example.com, Role: Moderator

Explication

Dans cet exemple, les utilisateurs Alice et Bob partagent le même avatar (image base1.png), tandis que Charlie utilise un autre avatar (base2.png). Les avatars (objets File) sont coûteux à créer, donc le Flyweight Pattern permet de réutiliser les instances d'avatars pour optimiser la mémoire. Cependant, chaque utilisateur a ses propres données uniques comme son nom, email et rôle, qui sont spécifiques à chaque instance de User.

Avantages du Flyweight Pattern

  1. Réduction de l'utilisation de mémoire : Le Flyweight Pattern permet de réutiliser des objets similaires au lieu de les dupliquer, ce qui réduit considérablement la consommation de mémoire, notamment dans des systèmes avec des objets massivement similaires.
  2. Optimisation des performances : En évitant la duplication d'objets, le pattern améliore les performances en réduisant le coût de création et de gestion des objets.
  3. Centralisation de l'état partagé : Le pattern centralise l'état partagé dans un seul objet, ce qui facilite la gestion et la modification de cet état.

Inconvénients du Flyweight Pattern

  1. Complexité accrue : L'implémentation du Flyweight Pattern peut ajouter de la complexité, notamment dans la gestion de l'état partagé et non partagé.
  2. Difficulté à gérer l'état non partagé : Lorsque les objets ont à la fois des états partagés et non partagés, la gestion de ces états peut devenir difficile à maintenir et à comprendre.
  3. Adapté à des cas spécifiques : Ce pattern est utile dans des contextes très spécifiques où la gestion efficace de la mémoire est cruciale. Dans d'autres contextes, il pourrait ne pas être nécessaire.

Conclusion

Le Flyweight Pattern est une solution efficace pour réduire la consommation de mémoire dans des systèmes où de nombreux objets similaires sont créés. En Laravel, ce pattern pourrait être utilisé pour des systèmes où des objets partagent des attributs communs, comme les avatars ou les éléments d'interface utilisateur. Il permet de réutiliser les objets autant que possible, optimisant ainsi la performance et la gestion des ressources dans les applications à grande échelle.