Introduction au modèle Builder dans la conception Java

Cet article présente principalement l'analyse du modèle de constructeur qui se chevauche et les scénarios d'utilisation du modèle Builder à partir d'un exemple de personne, ainsi que l'utilisation du modèle JavaBeans pour combler les lacunes du modèle de constructeur qui se chevauche

Vue d'ensemble

Modèle de constructeur : Séparez la construction d'un objet complexe de sa représentation, afin que le même processus de construction puisse créer différentes représentations.

Scénarios d'utilisation

• La même méthode, un ordre d'exécution différent, produisent des résultats d'événement différents

• Plusieurs composants ou pièces peuvent être assemblés en un seul objet, mais les résultats d'exécution sont différents

• La classe de produits est très complexe, ou le produit Différentes commandes d'appel dans le la classe produit différents effets

• Lorsque l'initialisation d'un objet est particulièrement complexe, comme de nombreux paramètres, et de nombreux paramètres ont des valeurs par défaut

Les utilisations suivantes un exemple Person pour analyser l'utilisation du modèle de constructeur qui se chevauche, du modèle JavaBeans et du modèle Builder. La classe Person a deux paramètres obligatoires (id et nom) et 5 paramètres facultatifs (âge, sexe, téléphone, adresse et description)

Modèle de constructeur qui se chevauchent

Dans ce modèle, vous fournissez au premier constructeur uniquement les paramètres obligatoires, au second avec un paramètre facultatif, au troisième avec deux paramètres facultatifs, et ainsi de suite, le dernier constructeur contient tous les paramètres facultatifs. Jetons un coup d'œil à son implémentation de programmation :

/ * 使用重叠构造器模式
 */
public class Person {
 //必要参数
 private final int id;
 private final String name;
 //可选参数
 private final int age;
 private final String sex;
 private final String phone;
 private final String address;
 private final String desc;
 public Person(int id, String name) {
 this(id, name, 0);
 }
 public Person(int id, String name, int age) {
 this(id, name, age, "");
 }
 public Person(int id, String name, int age, String sex) {
 this(id, name, age, sex, "");
 }
 public Person(int id, String name, int age, String sex, String phone) {
 this(id, name, age, sex, phone, "");
 }
 public Person(int id, String name, int age, String sex, String phone, String address) {
 this(id, name, age, sex, phone, address, "");
 }
 public Person(int id, String name, int age, String sex, String phone, String address, String desc) {
 this.id = id;
 this.name = name;
 this.age = age;
 this.sex = sex;
 this.phone = phone;
 this.address = address;
 this.desc = desc;
 }
}

À partir du code ci-dessus, lorsque vous souhaitez créer une instance, utilisez la construction avec le paramètre le plus court constructeur de liste, mais la liste contient tous les paramètres à définir :

Person person = new Persion(1, "李四", 20, "男", "18800000000", "China", "测试使用重叠构造器模式");

Les constructeurs qui se chevauchent fonctionnent, mais lorsqu'il y a beaucoup de paramètres, créez en utilisant le code sera difficile à écrire et difficile à lire

Mode JavaBeans

Adoptez la méthode d'écriture Javabean, écrivez un tas de méthodes de définition pour les propriétés et pass Générez un objet, puis appelez la méthode setter pour attribuer une valeur à la propriété.

/ * 使用JavaBeans模式
 */
public class Person {
 //必要参数
 private int id;
 private String name;
 //可选参数
 private int age;
 private String sex;
 private String phone;
 private String address;
 private String desc;
 public void setId(int id) {
 this.id = id;
 }
 public void setName(String name) {
 this.name = name;
 }
 public void setAge(int age) {
 this.age = age;
 }
 public void setSex(String sex) {
 this.sex = sex;
 }
 public void setPhone(String phone) {
 this.phone = phone;
 }
 public void setAddress(String address) {
 this.address = address;
 }
 public void setDesc(String desc) {
 this.desc = desc;
 }

Ce modèle compense les lacunes du modèle de constructeur qui se chevauche. La création d'instances est simple et le code résultant est facile à lire :

Person person = new Person();
person.setId(1);
person.setName("李四");
person.setAge(20);
person.setSex("男");
person.setPhone("18800000000");
person.setAddress("China");
person.setDesc("测试使用JavaBeans模式");

Modèle JavaBeans en raison de la construction process Etant divisé en plusieurs appels, le JavaBean peut être dans un état incohérent lors du processus de construction. Les classes ne peuvent pas garantir la cohérence simplement en vérifiant la validité des paramètres du constructeur.

Modèle de constructeur

Le modèle de constructeur peut garantir la sécurité comme un constructeur qui se chevauche et la lisibilité comme le modèle JavaBean.

/**
 * 使用Builder模式
 */
public class Person {
 //必要参数
 private final int id;
 private final String name;
 //可选参数
 private final int age;
 private final String sex;
 private final String phone;
 private final String address;
 private final String desc;
 private Person(Builder builder) {
 this.id = builder.id;
 this.name = builder.name;
 this.age = builder.age;
 this.sex = builder.sex;
 this.phone = builder.phone;
 this.address = builder.address;
 this.desc = builder.desc;
 }
 public static class Builder {
 //必要参数
 private final int id;
 private final String name;
 //可选参数
 private int age;
 private String sex;
 private String phone;
 private String address;
 private String desc;
 public Builder(int id, String name) {
  this.id = id;
  this.name = name;
 }
 public Builder age(int val) {
  this.age = val;
  return this;
 }
 public Builder sex(String val) {
  this.sex = val;
  return this;
 }
 public Builder phone(String val) {
  this.phone = val;
  return this;
 }
 public Builder address(String val) {
  this.address = val;
  return this;
 }
 public Builder desc(String val) {
  this.desc = val;
  return this;
 }
 public Person build() {
  return new Person(this);
 }
 }
}

La personne est immuable et toutes les valeurs de paramètres par défaut sont placées à un endroit séparé. La méthode setter du constructeur renvoie le constructeur lui-même afin qu'il puisse être appelé dans une chaîne. Voici le code d'utilisation du client :

Person person = new Person.Builder(1, "Zhang San")
      .age(18).sex("Male").desc("Test using Mode constructeur").build();

Mode constructeur dans le code source Android

• Code source d'AlertDialog

• Bibliothèque d'images Universal-Image-Loader

• Code source de la demande d'OkHttp

Avantages :

• Une bonne encapsulation, l'utilisation du modèle de construction peut rendre le client indépendant et plus facile que de connaître les détails de la composition interne du produit

• Extension indépendante du constructeur (disponible via abstraction - interface, classe abstraite)

Inconvénients :

• générera des redondances Les objets Builders et Director consomment de la mémoire

Résumé : Le mode Builder est généralement utilisé comme une construction des classes de configuration Le constructeur sépare la construction et la présentation de la configuration. Il isole également la configuration de la classe cible et évite trop de méthodes de définition.

J'ai compilé ce qui précède pour vous, j'espère que cela vous sera utile à l'avenir.

Articles connexes :

Le problème selon lequel IE8 ne peut pas s'actualiser à chaque fois en utilisant l'accès ajax

Problème de cache Ajax sous IE8/IE9

Problème de cache Ajax et solution sous IE8

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!