Pattern Flyweight en Java

Modèle Flyweight en Java

1. Vue d'ensemble

Dans cet article, nous allons examiner le modèle de conception des poids mouches. Ce modèle est utilisé pour réduire l'encombrement de la mémoire. Cela peut également améliorer les performances dans les applications où l'instanciation d'objet est coûteuse.

Autrement dit, le modèle de poids mouche est basé sur une usine qui recycle les objets créés en les stockant après la création. Chaque fois qu’un objet est demandé, la fabrique le recherche pour vérifier s’il a déjà été créé. Si tel est le cas, l'objet existant est renvoyé - sinon, un nouvel objet est créé, stocké puis renvoyé.

L’état de l’objet flyweight est constitué d’un composant invariant partagé avec d’autres objets similaires (intrinsic) et d’un composant variant qui peut être manipulé par le code client (extrinsic).

Il est très important que les objets de poids mouche soient immuables: toute opération sur l'état doit être effectuée par l'usine.

2. la mise en oeuvre

Les principaux éléments du motif sont les suivants:

une interface qui définit les opérations que le code client peut effectuer sur l'objet flyweight
une ou plusieurs implémentations concrètes de notre interface
une fabrique pour gérer l'instanciation et la mise en cache des objets

Voyons comment mettre en œuvre chaque composant.

2.1. Interface du véhicule

Pour commencer, nous allons créer une interfaceVehicle. Puisque cette interface sera le type de retour de la méthode d'usine, nous devons nous assurer d'exposer toutes les méthodes pertinentes:

public void start();
public void stop();
public Color getColor();

2.2. Véhicule en béton

Ensuite, faisons une classeCar comme unVehicle. concret. Notre voiture implémentera toutes les méthodes de l'interface véhicule. Quant à son état, il aura un moteur et un champ de couleur:

private Engine engine;
private Color color;

2.3. Usine de véhicules

Enfin, nous allons créer lesVehicleFactory. La construction d'un nouveau véhicule est une opération très coûteuse, de sorte que l'usine ne créera qu'un véhicule par couleur.

Pour ce faire, nous gardons une trace des véhicules créés en utilisant une carte comme simple cache:

private static Map vehiclesCache
  = new HashMap<>();

public static Vehicle createVehicle(Color color) {
    Vehicle newVehicle = vehiclesCache.computeIfAbsent(color, newColor -> {
        Engine newEngine = new Engine();
        return new Car(newEngine, newColor);
    });
    return newVehicle;
}

Notez que le code client ne peut affecter que l'état extrinsèque de l'objet (la couleur de notre véhicule) en le passant comme argument à la méthodecreateVehicle.

3. Cas d'utilisation

3.1. Compression des données

L’objectif du modèle de poids mouche est de réduire l’utilisation de la mémoire en partageant autant de données que possible. C’est donc une bonne base pour les algorithmes de compression sans perte. Dans ce cas, chaque objet flyweight agit comme un pointeur, son état extrinsèque étant l’information dépendante du contexte.

Un exemple classique de cette utilisation est dans un traitement de texte. Ici, chaque caractère est un objet flyweight qui partage les données nécessaires au rendu. En conséquence, seule la position du caractère à l'intérieur du document occupe de la mémoire supplémentaire.

3.2. Mise en cache des données

De nombreuses applications modernes utilisent des caches pour améliorer le temps de réponse. Le modèle de poids mouche est similaire au concept de base d'une mémoire cache et peut parfaitement répondre à cet objectif.

Bien entendu, il existe quelques différences majeures de complexité et de mise en œuvre entre ce modèle et un cache typique à usage général.

4. Conclusion

Pour résumer, ce rapide tutoriel s'est concentré sur le modèle de conception flyweight en Java. Nous avons également vérifié certains des scénarios les plus courants impliquant ce modèle.

Tout le code des exemples est disponible surthe GitHub project.

TOC