Java设计模式之--建造者（生成器）模式

Builder Pattern：建造者模式，又称生成器模式：将一个复杂的构建与其表示相分离，使得同样的构建过程可以创建不同的表示。
这句话可能看不太懂，我们先举例子再回来看这句话。

一.例子

假设我们现在要做一款游戏，其中有男人和女人，他们都是由头、身体、四肢构成，但是男人和女人每个部分的具体实现是不一样的。很容易，我们可以写出以下代码：
首先有一个Person类，男人和女人都是这个类的一个对象（这里简化了男人和女人，就没有弄出男人和女人类，他们都统一是Person这个类）：

package com.sheliming.builder;
public class Person {
    private String head;
    private String body;
    private String foot;

    //get set方法，toString方法 此处省略。。
}

这时候就会出现一个问题，如果想创建一个男人的时候，我们需要先new一个对象，然后构造他头部的方法、在调用构造身体的方法、在调用构造四肢的方法，这样就是把创建对象的过程暴露给使用者，增加了类的使用难度，并且使用者容易漏掉。
这时候就需要builder模式登场了！首先有一个PersonBuilder的接口：

package com.sheliming.builder;
public interface PersonBuilder {
    void builderHead();
    void builderBody();
    void builderFoot();
    Person builderPersion(); //组装
}

然后有一个构造男人的buider和一个构造女人的builder：

package com.sheliming.builder;
public class ManBuilder implements PersonBuilder {
    private Person person;
    public ManBuilder() {
        person = new Person();//创建一个Person实例,用于调用set方法
    }
    @Override
    public void builderHead() {
        person.setHead("建造男人头部分");
    }
    @Override
    public void builderBody() {
        person.setBody("建造男人身体部分");
    }
    @Override
    public void builderFoot() {
        person.setFoot("建造男人四肢部分");
    }
    @Override
    public Person builderPersion() {
        return person;
    }
}

package com.sheliming.builder;

public class WomanBuilder implements PersonBuilder {
    private Person person;
    public WomanBuilder() {
        person = new Person();//创建一个Person实例,用于调用set方法
    }
    @Override
    public void builderHead() {
        person.setHead("建造女人头部分");
    }
    @Override
    public void builderBody() {
        person.setBody("建造女人身体部分");
    }
    @Override
    public void builderFoot() {
        person.setFoot("建造女人四肢部分");
    }
    @Override
    public Person builderPersion() {
        return person;
    }
}

有了具体的builder之后，还是需要一步步的调用其中的方法去创建，这时候我们需要一个指挥者来封装创建的步骤：

package com.sheliming.builder;
/**
 * 指挥者类，用来控制建造的过程，让用户不用感知建造的细节
 */
public class PersonDirector {
    private PersonBuilder personBuilder;

    public PersonDirector(PersonBuilder personBuilder) {
        this.personBuilder = personBuilder;
    }

    public Person createPerson() {
        personBuilder.builderHead();
        personBuilder.builderBody();
        personBuilder.builderFoot();
        return personBuilder.builderPersion();
    }
}

这样，使用者可以这样调用：

package com.sheliming.builder;
public class Test {
    public static void main(String[] args) {
        PersonDirector manPersonDirector = new PersonDirector(new ManBuilder());
        Person man = manPersonDirector.createPerson();
        System.out.println(man);

        PersonDirector womanPersonDirector = new PersonDirector(new WomanBuilder());
        Person woman = womanPersonDirector.createPerson();
        System.out.println(woman);
    }
}

运行结果：就很容易的创建了两个对象。我们只要创建对应对象的builder类，并不用关系里面创建的过程。

Person{head='建造男人头部分', body='建造男人身体部分', foot='建造男人四肢部分'}
Person{head='建造女人头部分', body='建造女人身体部分', foot='建造女人四肢部分'}

二.总结

回头再来看看一开始的定义：“将一个复杂的构建与其表示相分离，使得同样的构建过程可以创建不同的表示”。
构建我们放到Director中，表示我们放到每个对象的Builder类中，这样我们就使用了相同的Director构建出了不同的对象，我们以后需要扩展的时候只需要增加对应的Builder就可以了，这就符合了“开闭原则”。