构建者模式

代码

package cn.test;

public class Test {
    public static void main(String[] args) {
        //不使用构建者
        Person person = new Person();
        System.out.println("设置field1之前有非常复杂的逻辑");
        person.setField1("name");
        System.out.println("设置field2之前有非常复杂的逻辑");
        person.setField2("age");
        System.out.println("设置field3之前有非常复杂的逻辑");
        person.setField3("gender");
        System.out.println(person);

        System.out.println("-------------------------------");

        //使用构建者
        Person person1 = new PersonConcrete(new Person())
                .setField1("name")
                .setField2("age")
                .setField3("gender")
                .build();
        System.out.println(person1);
    }
}

class Person {
    private String field1;
    private String field2;
    private String field3;

    public String getField1() {
        return field1;
    }

    public void setField1(String field1) {
        this.field1 = field1;
    }

    public String getField2() {
        return field2;
    }

    public void setField2(String field2) {
        this.field2 = field2;
    }

    public String getField3() {
        return field3;
    }

    public void setField3(String field3) {
        this.field3 = field3;
    }

    @Override
    public String toString() {
        return "Person{" +
                "field1='" + field1 + '\'' +
                ", field2='" + field2 + '\'' +
                ", field3='" + field3 + '\'' +
                '}';
    }
}

interface Builder {
    Builder setField1(String filed1);

    Builder setField2(String filed2);

    Builder setField3(String filed3);

    Person build();
}

class PersonConcrete implements Builder {

    private Person person;

    public PersonConcrete(Person person) {
        this.person = person;
    }

    @Override
    public Builder setField1(String filed1) {
        System.out.println("设置field1之前有非常复杂的逻辑");
        person.setField1(filed1);
        return this;
    }

    @Override
    public Builder setField2(String filed2) {
        System.out.println("设置field2之前有非常复杂的逻辑");
        person.setField2(filed2);
        return this;
    }

    @Override
    public Builder setField3(String filed3) {
        System.out.println("设置field3之前有非常复杂的逻辑");
        person.setField3(filed3);
        return this;
    }

    @Override
    public Person build() {
        return person;
    }
}

输出

设置field1之前有非常复杂的逻辑
设置field2之前有非常复杂的逻辑
设置field3之前有非常复杂的逻辑
Person{field1='name', field2='age', field3='gender'}
-------------------------------
设置field1之前有非常复杂的逻辑
设置field2之前有非常复杂的逻辑
设置field3之前有非常复杂的逻辑
Person{field1='name', field2='age', field3='gender'}

Process finished with exit code 0

总结

构建者模式将构建复杂对象的逻辑剥离开来,放在单独的实现了builder接口的concrete类里来执行,外部实例化的时候通过链式调用来获得对象.

该模式的主要优点如下:

• 各个具体的建造者相互独立,有利于系统的扩展.
  • 例子中用PersonConcrete类来构建实例,也可以再创建新的StudentConcrete类来构建另一个指定的实例
• 客户端不必知道产品内部组成的细节,便于控制细节风险.
  • 客户端通过链式调用,不需要内部组成的细节

其缺点如下:

• 产品的组成部分必须相同，这限制了其使用范围
  • 上例中必须有3个属性field1,field2,field3.
• 如果产品的内部变化复杂，该模式会增加很多的建造者类