Builder mode usage tutorial

This time I will bring you a tutorial on how to use the Builder mode. What are the precautions when using the Builder mode. The following is a practical case, let’s take a look.

Overview

Builder pattern: Separates the construction of a complex object from its representation, so that the same construction process can create different representations.

Usage scenarios

• The same method, different execution order, produces different event results

• Multiple components or parts can be assembled into one object, but the running results are different

• The product class is very complex, or the product Different calling orders in the class have different effects

• When initializing an object is particularly complex, such as when there are many parameters and many parameters have default values

The following uses a Person example to analyze the use of the overlapping constructor pattern, JavaBeans pattern, and Builder pattern. The Person class has two required parameters (id and name) and 5 optional parameters (age, sex, phone, address and desc)

Overlapping constructor pattern

In this pattern, you provide the first constructor with only required parameters, the second with one optional parameter, the third with two optional parameters, and so on , the last constructor contains all optional parameters. Let’s take a look at its programming implementation:

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

From the above code, when you want to create an instance, use the constructor with the shortest parameter list, but the list contains all the parameters to be set:

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

Overlapping constructors work, but when there are many parameters, the creation and use code will be difficult to write and difficult to read

JavaBeans Pattern

Adopt Javabean writing method, write a bunch of setter methods for attributes, generate objects, and then call the setter method to assign values ​​to the attributes.

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

This pattern makes up for the shortcomings of the overlapping constructor pattern. Creating instances is easy, and the resulting code is easy to read:

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

JavaBeans Pattern Because the construction process is divided into several calls, JavaBeans may be in an inconsistent state during the construction process. Classes cannot ensure consistency simply by checking the validity of constructor parameters.

Builder pattern

The Builder pattern can ensure the safety like the overlapping constructor and the readability like the JavaBean pattern.

/**
 * 使用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 is immutable, and all default parameter values ​​are placed in a separate place. The builder's setter method returns the builder itself so that it can be called in a chain. The following is the client usage code:

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

Builder mode in Android source code

• AlertDialog source code

• Universal-Image-Loader picture library

• OkHttp Request source code

Advantages:

• Good encapsulation, using builder mode can prevent the client from knowing the details of the internal composition of the product

• Builder is independent and easy to extend (can be abstracted - interface, Abstract class)

Disadvantages:

• will generate redundant Builder objects and Director objects, consuming memory

Summary: Builder pattern is usually used as a builder of configuration classes to separate the construction and presentation of configurations. , and also isolates the configuration from the target class to avoid too many setter methods.

# I believe you have mastered the method after reading the case in this article. For more exciting information, please pay attention to other related articles on the php Chinese website!

Recommended reading:

How does JS store original values ​​and reference values

Detailed explanation of the use of common JS functions

The above is the detailed content of Builder mode usage tutorial. For more information, please follow other related articles on the PHP Chinese website!