Quand vous utilisez le modèle de générateur ?

Question

Quels sont les , d’utiliser le motif Builder ? Qu’il vous acheter ? Pourquoi ne pas simplement utiliser un modèle de fabrique ?

Answer 1

Ci-dessous sont quelques raisons plaidant pour l'utilisation du modèle et un exemple de code en Java, mais c'est une implémentation du Générateur de Modèle couverts par la " bande des Quatre Modèles de Conception. Les raisons que vous pouvez l'utiliser en Java sont également applicables à d'autres langages de programmation.

Comme Joshua Bloch états Efficace Java, 2nd Edition:

Le générateur de modèle est un bon choix lors de la conception des classes dont les constructeurs statiques ou des usines aurait plus qu'une poignée de paramètres.

Nous avons tous à un certain point rencontré une classe avec une liste de constructeurs où chaque addition ajoute une nouvelle option de paramètre:

Pizza(int size) { ... }        
Pizza(int size, boolean cheese) { ... }    
Pizza(int size, boolean cheese, boolean pepperoni) { ... }    
Pizza(int size, boolean cheese, boolean pepperoni, boolean bacon) { ... }

Ceci est appelé le Télescopage Constructeur Modèle. Le problème avec ce modèle est que, une fois que les constructeurs sont des 4 ou 5 paramètres de temps il devient difficile de se rappeler la nécessaire afin de paramètres ainsi que ce particulier, constructeur, vous voudrez peut-être dans une situation donnée.

Une alternative que vous avez à le Télescopage Constructeur Modèle est le JavaBean Modèle où vous appeler un constructeur avec les paramètres obligatoires et ensuite appeler toute option setters après:

Pizza pizza = new Pizza(12);
pizza.setCheese(true);
pizza.setPepperoni(true);
pizza.setBacon(true);

Le problème ici est que parce que l'objet est créé sur plusieurs appels, il peut être dans un état incohérent, partiellement, par le biais de sa construction. Cela nécessite aussi beaucoup d'effort supplémentaire pour assurer la sécurité des threads.

La meilleure alternative est d'utiliser le Générateur de Modèle.

public class Pizza {
  private int size;
  private boolean cheese;
  private boolean pepperoni;
  private boolean bacon;

  public static class Builder {
    //required
    private final int size;

    //optional
    private boolean cheese = false;
    private boolean pepperoni = false;
    private boolean bacon = false;

    public Builder(int size) {
      this.size = size;
    }

    public Builder cheese(boolean value) {
      cheese = value;
      return this;
    }

    public Builder pepperoni(boolean value) {
      pepperoni = value;
      return this;
    }

    public Builder bacon(boolean value) {
      bacon = value;
      return this;
    }

    public Pizza build() {
      return new Pizza(this);
    }
  }

  private Pizza(Builder builder) {
    size = builder.size;
    cheese = builder.cheese;
    pepperoni = builder.pepperoni;
    bacon = builder.bacon;
  }
}

Notez que la Pizza est immuable et que les valeurs des paramètres sont tous dans un seul endroit. Parce que le Constructeur du setter retour le Constructeur de l'objet qu'ils sont en mesure d'être enchaînés.

Pizza pizza = new Pizza.Builder(12)
                       .cheese(true)
                       .pepperoni(true)
                       .bacon(true)
                       .build();

Cela se traduit dans le code qui est facile à écrire et très facile à lire et à comprendre. Dans cet exemple, la méthode build pourrait être modifié pour vérifier les paramètres après qu'ils ont été copiés à partir du constructeur de l'objet Pizza et lever une exception IllegalStateException si une valeur de paramètre non valide a été fourni. Ce modèle est flexible et il est facile d'ajouter plus de paramètres dans le futur. Il est vraiment utile que si vous allez avoir plus de 4 ou 5 paramètres d'un constructeur. Cela dit, il pourrait être utile, en premier lieu, si vous pensez peut-être ajouter plus de paramètres dans l'avenir.

J'ai emprunté sur ce sujet dans le livre Efficace Java, 2nd Édition par Joshua Bloch. Pour en savoir plus sur ce modèle et d'autres moyens efficaces de Java pratiques je le recommande fortement.

Answer 2

Considérons un restaurant. La création de « repas d’aujourd'hui » est un modèle de fabrique, car vous dites la cuisine « get me repas aujourd'hui » et de la cuisine (usine) décide quel objet pour générer, fondée sur des critères cachés.

Le constructeur s’affiche si vous commandez une pizza personnalisée. Dans ce cas, le garçon a dit le chef (générateur) « j’ai besoin d’une pizza ; Ajouter fromage, oignons et bacon lui ! » Ainsi, le constructeur expose les attributs de l’objet généré devrait avoir, mais cache comment les configurer.

Answer 3

La principale différence entre le constructeur et l'usine à mon humble avis, c'est qu'un constructeur est utile lorsque vous avez besoin de faire beaucoup de choses pour construire un objet. Par exemple, imaginez un DOM. Vous devez créer beaucoup de nœuds et les attributs pour obtenir votre objet final. Une usine est utilisée lors de l'usine peut facilement créer l'ensemble de l'objet dans un délai d'un appel de méthode.

Un exemple d'utilisation d'un générateur est un bâtiment d'un document XML, j'ai utilisé ce modèle lors de la construction des fragments de HTML par exemple je pourrais avoir un Constructeur pour la construction d'un type spécifique de la table et il pourrait avoir des méthodes suivantes (les paramètres ne sont pas affichés):

BuildOrderHeaderRow()
BuildLineItemSubHeaderRow()
BuildOrderRow()
BuildLineItemSubRow()

Ce constructeur serait alors cracher le code HTML de moi. C'est beaucoup plus facile à lire puis à pied à travers une grande méthode procédurale.

Découvrez le Générateur de Modèle sur Wikipédia.

Answer 4

Pour un multi-fileté problème, nous avons besoin d'un objet complexe est à construire pour chaque thread. L'objet représenté les données en cours de traitement, et peuvent changer en fonction de la saisie de l'utilisateur.

Pourrait-on utiliser une usine à la place? Oui

Pourquoi n'avons-nous pas? Générateur de plus de sens, je suppose.

Les usines sont utilisés pour la création de différents types d'objets qui sont le même type de base (implémenter la même interface ou classe de base).

Les constructeurs de construire le même type d'objet, mais la construction est dynamique, donc il peut être modifiée lors de l'exécution.