Java 设计模式——建造者模式（Builder Pattern）

Java 设计模式——建造者模式（Builder Pattern）

一.简介

1.定义

将一个复杂对象的构建与它表示分离，使用同样的构建过程可以创建不同的表示

2.主要作用

在用户不知道对象建造过程和细节的情况下就可以直接创建复杂对象

3.如何使用

用户只需给出指定复杂对象的类型和内容，建造者模式负责按顺序创造对象（把内部建造过程和细节隐藏起来）

4.解决的问题

（1）.方便用户创建复杂的对象（不需要知道实现的过程）
（2）.代码复用性&封装性

5.注意事项

与工厂模式区别：建造者模式更关心零件的装配与顺序，一般用来创建比较复杂的对象

二.实现方式

通过Client、Director、Builder和Product形成的建造者模式

1.一般有以下几个角色

抽象建造者（builder）：描述具体建造者的公共接口，一般用来定义建造细节的方法，并不涉及具体的对象部件的创建。
具体建造者（ConcreteBuilder）：描述具体建造者，并实现抽象建造者公共接口。
指挥者（Director）：调用具体建造者来创建复杂对象（产品）的各个部分，并按照一定顺序（流程）来建造复杂对象。   
产品（Product）：描述一个由一系列部件组成较为复杂的对象。

2.举例

构建一个机器人需要：头部，身体，和腿
步骤：
    1、创建抽象建造者定义造机器人步骤
    
    2、创建工人具体实现造机器人步骤
    
    3、创建指挥者（Diretor）指挥工人施工
    
    4、验收，检查是否建造完成

3.具体代码

建造者：Builder.java

/**
 * 建造者，定义具体构建的细节
 */
public abstract class Builder {

    public abstract void buildHead();

    public abstract void buildBody();

    public abstract void buildLegs();

    // 获取完工后的产品
    public abstract Robot getRobot();
}

产品：Robot.java

/**
 * 要生产的机器人产品
 */
public class Robot {

    private String head;

    private String body;

    private String legs;

    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 getLegs() {
        return legs;
    }

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

    @Override
    public String toString() {
        return "Robot{" +
                "head='" + head + '\'' +
                ", body='" + body + '\'' +
                ", legs='" + legs + '\'' +
                "机器人建造完成}";
    }
}

具体建造者：RobotBuilder.java

/**
 * 建造工人（具体建造者）
 */
public class RobotBuilder extends Builder {
    private Robot robot;

    public RobotBuilder(){
        robot = new Robot();
    }

    @Override
    public void buildHead() {
        //一系列复杂构建过程（省略）
        robot.setHead("头部");
    }

    @Override
    public void buildBody() {
        robot.setBody("身体");
    }

    @Override
    public void buildLegs() {
        robot.setLegs("双腿");
    }

    @Override
    public Robot getRobot() {
        return robot;
    }
}

指挥者：Director.java

/**
 * 指挥者：用于控制各个部件的构建顺序
 */
public class Director {

    // 指挥者构建机器人
    public Robot create(Builder builder){
        builder.buildHead();
        builder.buildBody();
        builder.buildLegs();
        return builder.getRobot();
    }
}

Test类

/**
 * Test类
 */
public class Main {

    public static void main(String[] args) {

        Director director = new Director();
        Robot robot = director.create(new RobotBuilder());
        System.out.println(robot);
        //结果：Robot{head='头部', body='身体', legs='双腿'机器人建造完成}
    }
}

四、总结

###（1）优点
1、产品的建造和表示分离，实现了解耦。

2、将复杂产品的创建步骤分解在不同的方法中，使得创建过程更加清晰

3、增加新的具体建造者无需修改原有类库的代码，易于拓展，符合“开闭原则“。

###（2）缺点
1、产品必须有共同点，限制了使用范围。

2、如内部变化复杂，会有很多的建造类，难以维护。