Comment utiliser le modèle de conception Java flyweight pour optimiser la création d'objets et améliorer les performances et l'efficacité

Introduction

Le modèle Flyweight en Java est un modèle de conception structurelle qui vise à réduire l'utilisation de la mémoire et à améliorer les performances en partageant autant d'objets que possible.

Le modèle Java Flyweight comprend généralement les 4 types de rôles suivants

• Flyweight Factory : Responsable de la création et de la gestion des objets flyweight.

• Concrete Flyweight : implémente l'interface flyweight et stocke l'état interne lié à l'état partagé.

• Abstract Flyweight (Flyweight) : définit l'interface ou la classe abstraite dont l'objet Flyweight a besoin implémenter.

• État non partagé (État non partagé) : stocke l'état non partagé de l'objet Flyweight

Remarque : les rôles abstraits Flyweight et d'état non partagé sont facultatifs, ils peuvent être omis pour fusionner leurs fonctionnalités dans d'autres rôles.

Lorsque le client demande de créer ou d'accéder à un objet flyweight, la fabrique de poids mouche vérifie si l'objet a déjà été créé. S'il a déjà été créé, une référence à l'objet existant est renvoyée s'il n'a pas encore été créé. un nouvel objet est créé et sa référence est renvoyée. De cette façon, les clients peuvent partager des objets existants sans avoir à créer de nouveaux objets, réduisant ainsi l'utilisation de la mémoire et améliorant les performances.

Implémentation

Prenons comme exemple les informations sur les produits dans le commerce électronique. Dans le commerce électronique, chaque produit a un nom, un prix, un inventaire et d'autres attributs. Habituellement, chaque produit doit créer un objet distinct, ce qui entraînera une augmentation de l'occupation de la mémoire et si le même produit est acheté plusieurs fois, le système. créera plusieurs objets identiques, gaspillant des ressources

Abstract Flyweight

public interface Product {
    String getName();
    double getPrice();
    int getStock();
}

Concrete Flyweight

public class ConcreteProduct implements Product{
    private String name;
    private double price;
    private int stock;
    public ConcreteProduct(String name, double price, int stock) {
        this.name = name;
        this.price = price;
        this.stock = stock;
    }
    @Override
    public String getName() {
        return name;
    }
    @Override
    public double getPrice() {
        return price;
    }
    @Override
    public int getStock() {
        return stock;
    }
}

Flyweight Factory

public class ProductFactory {
    private static Map<String, Product> productMap = new HashMap<>();
    public static Product getProduct(String name, double price, int stock) {
        String key = name + "_" + price;
        Product res = productMap.get(key);
        if (Objects.isNull(res)) {
            // 如果缓存池内不存在,就创建新对象放置到缓存池
            res = new ConcreteProduct(name, price, stock);
            productMap.put(key, res);
        }
        return res;
    }
}

Test

public class Demo {
    public static void main(String[] args) {
        Product p1 = ProductFactory.getProduct("iPhone 14 Plus", 8899, 1);
        Product p2 = ProductFactory.getProduct("iPhone 14 Plus", 8899, 1);
        System.out.println(p1 == p2);
    }
}

Dans l'exemple de code ci-dessus, créez d'abord une interface de produit Product, qui contient le nom. , le prix, l'inventaire et d'autres attributs du produit. Créez ensuite une classe de produit spécifique ConcreteProduct, implémentez l'interface Product et définissez le nom, le prix et le stock des états internes partagés. Nous créons ensuite l'usine de produits ProductFactory, qui est utilisée pour créer. et gérer les objets de produit partagés.Dans cette usine, nous utilisons HashMap pour stocker les objets de produit partagés. Chaque fois que le client a besoin d'acheter un produit, nous vérifions d'abord s'il a été créé, une référence à. l'objet existant est renvoyé. S'il n'a pas été créé, un nouvel objet est créé et stocké dans le HashMap et sa référence est renvoyée

Résumé

Avantages

• Réduire la création d'objets, Économiser de l'espace mémoire et améliorer. performances du système.

• En partageant des objets, une seule copie du même objet dans le système peut exister dans la mémoire, réduisant ainsi la surcharge de mémoire

• Améliorez l'évolutivité du système, si nécessaire Pour ajouter de nouveaux objets, il vous suffit de les créer en usine et vous n'avez pas besoin de modifier le code d'origine.

• Améliorez la sécurité du système. Les objets partagés sont en lecture seule et ne seront pas modifiés.

  Cela peut rendre le système trop complexe et augmenter la complexité du code.

Nécessite un travail supplémentaire pour maintenir la cohérence des objets partagés, tels que la sécurité des threads et d'autres problèmes.

• Cela peut être dû au partage. l'existence d'objets réduit la flexibilité du programme, comme l'impossibilité de personnaliser les objets partagés

• Scénarios d'application

• Lorsqu'il y a un grand nombre d'objets identiques ou similaires dans le système, vous pouvez envisager d'utiliser le poids mouche. modèle pour réduire la surcharge de mémoire.

Lorsque vous avez besoin de mettre en cache des objets et de les réutiliser, vous pouvez également envisager d'utiliser le mode poids mouche.

• Dans un environnement multithread, vous pouvez utiliser le mode poids mouche pour réaliser le partage d'objets. et améliorer la simultanéité du programme.

• Dans le développement de jeux, vous pouvez utiliser le mode poids mouche pour gérer des objets tels que des personnages dans le jeu.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!