图解设计模式之Builder模式

Builder模式即建造者模式，在这里，我就不使用《图解设计模式》一书中的程序作为示例了，而是换一个让人更加清晰易懂的例子。

示例程序

示例程序的内容是"造人"

Person 类

// Person 类
public class Person {
    
    private String head;
    
    private String body;
    
    private String hand;
    
    private String foot;
    
    public String getHead(){
        return head;
    }
    
    public void setHead(String head){
        this.head = head;
    }
    
    public String getBody(){
        return body;
    }
    
    public void setBody(String body){
        this.body = body;
    }
    
    public String getHand() {
        return hand;
    }
    
    public void setHand(String hand) {
        this.hand = hand;
    }
    
    public String getFoot() {
        return foot;
    }
    
    public void setFoot(String foot) {
        this.foot = foot;
    }
}

Builder接口

// Builder接口
public interface Builder {
    void makeHead();
    void makeBody();
    void makeHand();
    void makeFoot();
    Person createPerson();
}

SmartPersonBuilder 类

// SmartPersonBuilder
public class SmartPersonBuilder implements Builder {
    Person p;
    public SmartPersonBuilder(){
        p = new Person();
    }
    
    @Override
    public void makeHead(){
        p.setHead("smart head");
    }
    
    @Override
    public void makeBody(){
        p.setBody("normal body");
    }
    
    @Override
    public void makeHand(){
        p.setHand("normal hand");
    }
    
    @Override
    public void makeFoot(){
        p.setFoot("normal foot");
    }
    
    @Override
    public Person createPerson(){
        return p;
    }
    
}

StrongPeronBuilder 类

// StrongPeronBuilder
public class StrongPersonBuilder implements Builder {
    Person p;
    public StrongPersonBuilder(){
        p = new Person();
    }
    
    @Override
    public void makeHead(){
        p.setHead("normal head");
    }
    
    @Override
    public void makeBody(){
        p.setBody("strong body");
    }
    
    @Override
    public void makeHand(){
        p.setHand("normal hand");
    }
    
    @Override
    public void makeFoot(){
        p.setFoot("normal foot");
    }
    
    @Override
    public Person createPerson(){
        return p;
    }
    
}   

Director 类

// director
public class Director {
    
    public Person construct(Builder builder){
        builder.makeHead();
        builder.makeBody();
        builder.makeHand();
        builder.makeFoot();
        return builder.createPerson();
    }
}

Main 类

// Main
public class Main {
    public static void main(String[] args){
        Director director = new Director();
        Person p1 = director.construct(new SmartPersonBuilder());
        Person p2 = director.construct(new StrongPersonBuilder());
        
        // p1 smart person
        System.out.println(p1.getHead());
        System.out.println(p1.getBody());
        System.out.println(p1.getHand());
        System.out.println(p1.getFoot());
        
        // p2 strong person
        System.out.println(p2.getHead());
        System.out.println(p2.getBody());
        System.out.println(p2.getHand());
        System.out.println(p2.getFoot());
    }
}
    

Builder模式中的角色

Builder

Builder角色负责定义用于生成示例的接口。Builder角色中准备了用于生成示例的方法；示例程序中，由Builder接口扮演这个角色。

ConcreteBuilder

ConcreteBuilder即具体的建造者，在本示例中由SmartPersonBuilder和StrongPeronBuilder类扮演了这个角色。

Director

Director这个角色的用处用原书的话来说就是：监工。Director角色负责使用Builder接口来生成具体的实例。本示例程序中，由Director类扮演这个角色。

Client

Client为使用者，该角色的作用就是使用Builer模式，示例程序中，由Main类扮演这个角色。

Builder模式的UML图

Builder

对于Builder模式的思考

为什么需要Director角色

Builder模式的关键在于，将“要做什么”与“做出来” 分离；将“如何装配” 与 “完成装配” 分离。Director知道要做什么，而Builder负责做出来这件事。Director是一个指挥官，Builder负责实施。如果没有了Director,就需要Client承担指挥官这样一个角色，这是我们不想看到的，我们需要组装的过程被隐藏在Director角色中，Client角色只需要调用Director角色，让Director指挥Builder完成组装这件事就好。请用心体会面向对象的奥妙之处。

Builder模式有什么优点

1. 封装性
   使用Builder模式，用户可以不需要知道产品内部的细节，做到了解耦。
2. 利于系统的扩展
   试想一下我们的示例，除了smart person 和 strong person 以外，如果我还想创建一个产品类别：pretty person。我们只需要在创建一个PrettyPersonBuilder类即可，对于Client使用者来说，是及其友好的。

Builder模式的使用场景

Builder模式用于组装复杂的实例。当产品类非常复杂，或者说产品类中的调用顺序不同就产生不同的效能的时候，我们就可以使用Builder模式。举个例子：比如老板需要工程师组装汽车，不同种类的汽车的功能不同。我们最好的办法就是创建不同模式的汽车Builder类。