Java设计模式之 建造者模式反思

应用场景：

当创建一个复杂对象要牵扯到创建其他好几个对象时或者牵扯很多属性，也就是这个复杂对象的创建要通过一定的算法整合其他对象才能生成，这时候就可以使用建造者模式。官方说法：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。用户就只需要指定需要建造的类型就可以得到它们，而具体建造的过程和细节就不需要知道了。

stringBuilder这个类就是使用的建造者模式，其中的append方法，当我们传入一个字符串时，它不是由自己构建，而是传给父类的append方法，构建完成后返回。

比如我们自己要捏人物，人物基础的属性有头、手臂、腿，附加属性有翅膀、引擎。应用创建者模式，当传入基础属性时，捏出普通人，传入基础属性加附加属性时捏出漫威的英雄。

class Person{
    private String arms;//胳膊
    private String legs;//腿
    private String head;//头
    private String wing;//翅膀
    private String engine;//引擎

    public void setArms(String arms) {
        this.arms = arms;
    }

    public void setLegs(String legs) {
        this.legs = legs;
    }

    public void setHead(String head) {
        this.head = head;
    }

    public void setWing(String wing) {
        this.wing = wing;
    }

    public void setEngine(String engine) {
        this.engine = engine;
    }

    @Override
    public String toString() {
        return "头："+head+" 手臂:"+arms+" 腿:"+legs+" 翅膀:"+wing+" 引擎:"+engine;
    }
}
abstract class Builder{
    protected Person person = new Person();
    public abstract void buildHead(String head);
    public abstract void buildArms(String arms);
    public abstract void buildLegs(String legs);
    public abstract void buildWing(String wing);
    public abstract void buildEngine(String engine);
    public abstract Person create();
}
class ConcreteBuilder extends Builder{

    @Override
    public void buildHead(String head) {
        person.setHead(head);
    }

    @Override
    public void buildArms(String arms) {
        person.setArms(arms);
    }

    @Override
    public void buildLegs(String legs) {
        person.setLegs(legs);
    }

    @Override
    public void buildWing(String wing) {
        person.setWing(wing);
    }

    @Override
    public void buildEngine(String engine) {
        person.setEngine(engine);
    }

    @Override
    public Person create() {
        return person;
    }
}
class Director {
    Builder builder;

    public Director(Builder builder) {
        this.builder = builder;
    }
    public void construct(String head,String arms,String legs){
        builder.buildHead(head);
        builder.buildArms(arms);
        builder.buildLegs(legs);
    }
    public void construct(String head,String arms,String legs,String wing){
        builder.buildHead(head);
        builder.buildArms(arms);
        builder.buildLegs(legs);
        builder.buildWing(wing);
    }
    public void construct(String head,String arms,String legs,String wing,String engine){
        builder.buildHead(head);
        builder.buildArms(arms);
        builder.buildLegs(legs);
        builder.buildWing(wing);
        builder.buildEngine(engine);
    }
}
public class BuilderTest {
    public static void main(String[] args) {
        Builder builder = new ConcreteBuilder();
        Director director = new Director(builder);
        director.construct("铁头","铁臂","铁腿");
        Person person1 = builder.create();
        System.out.println(person1.toString());
        director.construct("银头","银臂","银腿","银翅膀");
        Person person2 = builder.create();
        System.out.println(person2.toString());
        director.construct("金头","金臂","金腿","金翅膀","金引擎");
        Person person3 = builder.create();
        System.out.println(person3.toString());
    }
}

所有的构造过程都是在Builder和Director中完成的，客户端不必知道产品内部组成的细节，将产品本身与产品的创建过程解耦，使得相同的创建过程可以创建不同的产品对象。

建造者模式很容易进行扩展。如果有新的需求，通过实现一个新的建造者类就可以完成，基本上不用修改之前已经测试通过的代码，因此也就不会对原有功能引入风险。符合开闭原则。