Welche Möglichkeiten gibt es, den Builder-Modus zu verwenden?

Dieses Mal zeige ich Ihnen, wie Sie den Builder-Modus verwenden und welche Vorsichtsmaßnahmen bei der Verwendung des Builder-Modus gelten. Das Folgende ist ein praktischer Fall, schauen wir uns das an.

Übersicht

Builder-Muster: Trennen Sie die Konstruktion eines komplexen Objekts von seiner Darstellung, sodass mit demselben Konstruktionsprozess unterschiedliche Darstellungen erstellt werden können.

Nutzungsszenarien

• Die gleiche Methode, unterschiedliche Ausführungsreihenfolge, führt zu unterschiedlichen Ereignisergebnissen

• Mehrere Komponenten oder Teile können zu einem Objekt zusammengefügt werden, aber die laufenden Ergebnisse sind unterschiedlich

• Die Produktklasse ist sehr komplex, oder das Produkt unterschiedliche Aufrufreihenfolgen in der Klasse erzeugt unterschiedliche Effekte

• Wenn die Initialisierung eines Objekts besonders komplex ist, z. B. viele Parameter, und viele Parameter Standardwerte haben

Die folgenden Verwendungen Ein Personenbeispiel zur Analyse der Verwendung des überlappenden Konstruktormusters, des JavaBeans-Musters und des Builder-Musters. Die Person-Klasse verfügt über zwei erforderliche Parameter (ID und Name) und 5 optionale Parameter (Alter, Geschlecht, Telefon, Adresse und Abstieg).

Überlappendes Konstruktormuster

In diesem Modus stellen Sie dem ersten Konstruktor nur erforderliche Parameter zur Verfügung, dem zweiten Konstruktor einen optionalen Parameter, dem dritten zwei optionale Parameter usw., der letzte Konstruktor enthält alle optionalen Parameter. Werfen wir einen Blick auf die Programmierimplementierung:

/ * 使用重叠构造器模式
 */
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;
 }
}

Wenn Sie im obigen Code eine Instanz erstellen möchten, verwenden Sie den Konstruktor mit der kürzesten Parameterliste, aber die Liste enthält alle festzulegenden Parameter:

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

Überlappende Konstruktoren funktionieren, aber wenn es viele Parameter gibt, kann das Erstellen und Verwenden von Code schwierig zu schreiben und schwer zu lesen sein

JavaBeans-Muster

Verwenden Sie die Javabean-Schreibmethode, um eine Reihe von Setter-Methoden für Eigenschaften zu schreiben, Objekte zu generieren und dann die Setter-Methoden aufzurufen, um den Eigenschaften Werte zuzuweisen.

/ * 使用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;
 }

Dieses Muster gleicht die Mängel des überlappenden Konstruktormusters aus. Das Erstellen einer Instanz ist einfach und der resultierende Code ist leicht zu lesen:

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

JavaBeans-Muster Da der Konstruktionsprozess in mehrere Aufrufe unterteilt ist, können sich JavaBeans während des Konstruktionsprozesses in einem inkonsistenten Zustand befinden. Klassen können die Konsistenz nicht einfach dadurch gewährleisten, dass sie die Gültigkeit von Konstruktorparametern überprüfen.

Builder-Muster

Builder-Muster können die Sicherheit wie überlappende Konstruktoren und die Lesbarkeit wie das JavaBean-Muster gewährleisten.

/**
 * 使用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);
 }
 }
}

Person ist unveränderlich und alle Standardparameterwerte werden an einem separaten Ort platziert. Die Setter-Methode des Builders gibt den Builder selbst zurück, sodass er in einer Kette aufgerufen werden kann. Das Folgende ist der Code, den der -Client verwenden kann:

Person person = new Person.Builder(1, "Zhang San")
    .age(18).sex("Male "). desc("Test mit Builder-Modus").build();

Builder-Modus im Android-Quellcode

• AlertDialog-Quellcode

• Universal-Image-Loader-Bildbibliothek

• OkHttp's Request-Quellcode

Vorteile:

• Gute Kapselung, die Verwendung des Builder-Modus ermöglicht es dem Client, die Details der internen Zusammensetzung des nicht zu kennen Produkt

• Builder ist unabhängig und einfach zu erweitern (kann abstrahiert werden - Schnittstelle, Abstrakte Klasse)

Nachteile:

• generiert redundante Builder-Objekte und Director-Objekte und verbraucht Speicher

Zusammenfassung: Builder-Muster wird normalerweise als Builder von Konfigurationsklassen verwendet, um die Konstruktion und Präsentation von zu trennen Konfiguration und isoliert außerdem die Konfiguration von der Zielklasse, um zu viele Setter-Methoden zu vermeiden.

Ich glaube, dass Sie die Methode beherrschen, nachdem Sie den Fall in diesem Artikel gelesen haben. Weitere spannende Informationen finden Sie in anderen verwandten Artikeln auf der chinesischen PHP-Website!

Empfohlene Lektüre:

Axios-Implementierung der Dateninteraktionsschritte, detaillierte Erklärung

Angular Component-Anwendungsfall, detaillierte Erklärung

Das obige ist der detaillierte Inhalt vonWelche Möglichkeiten gibt es, den Builder-Modus zu verwenden?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!