建造者模式

本文参考：《修炼Java开发技术：在架构中体验设计模式和算法之美   于广编著》。

 

  在软件开发过程中，当遇到一个“复杂的对象”，该对象由好多部分组成，各个部分的组合比较稳定或者有一定的依赖次序，但各个部分自身却会经常面临着变化时，冷䲽隔离出“复杂对象的各个部分”的变化，从而保持系统中的“稳定构件算法”，这就是建造者模式的任务。

  建造者模式是将复杂的内部创建封装在内部，对于外部调用的人来说，只需要使传入建造者和建造工具，关于内部是如何建造成成品的，调用者无需关心。

 

适用场景：

1、需要生成的产品有复杂的内部结构。

2、需要生成的产品对象的属性互相依赖。

3、在对象的创建过程中会使用到其他的对象。

 

建造者模式的结构：

Director<>--(聚合)--> Builder <|--(泛化)-- ConcreteBuilder<--(依赖)--Product

 

Builer(抽象建造者)：它为创建一个产品product对象的各个部件指定抽象接口，在该接口中一般声明两类方法，一类buildPartX()，它们用于创建复杂对象的各个部件；另一类方法时getResult()，它们用于返回复杂对象。Builder既可以是抽象类，也可以是接口。

ConcreteBuilder(具体建造者):它实现了Builder接口，实现各个部件的具体构造和装配方法，定义并明确它所创建的复杂对象，也可以提供一个方法返回创建好的复杂产品对象。

Product(产品角色)：它是被构建的复杂对象，包含多个组成部件，集体建造者创建该产品的内部表示并定义它的装配过程。

Director(指挥者)：指挥者又被称为导演类，它负责安排复杂对象的建造次序，指挥者与抽象建造者之间存在关联关系，可以在其构件方法construct()中调用建造者对象的部件构造与装配方法，完成建造复杂对象的任务。客户端一般与指挥者进行交互，在客户端确定具体建造者的类型，并实例化具体建造者对象，然后通过指挥者类的构造函数或者setter方法将该对象传入指挥者类中。

 

举例说明：

加入要通过一个汽车工厂组装一辆汽车。其中汽车由车头、车身和车位3部分组成，它的基本组装步骤如下：1、组装车头；2、组装车身；3、组装车尾。

不管要创建吉普车、卡车、公交车，它们都可以各自重新定义车头、车身和车尾的组装方法。而通过这些被重新定义的方法和相同的组装步骤，就可以组装具有不同属性的各类汽车。

由此可以知道，上述场景满足Builder模式的应用场景所提到的如下条件：

1、对象的创建：我的需要创建对象；

2、创建的是一个复合对象：汽车的头部，车身，尾部等复合对象；

3、关注对象创建的各部分的创建过程：吉普车和卡车等对车头、车身、车尾的组装方法不尽相同。

设计类如下：

CarDirector：汽车组装操作的封装类；

CarBuilder:汽车组装抽象类；

JeepBuilder:吉普车组装类，继承CarBuilder类；

Car:汽车类，包括车头、车身、车尾等属性。由JeepBuilder等创建。

package org.dyb.design.builder;

public class Car {
    private String head;//车头
    private String body;//车身
    private String tail;//车尾
    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 getTail() {
        return tail;
    }
    public void setTail(String tail) {
        this.tail = tail;
    }
    @Override
    public String toString(){
        return head+"-"+body+"-"+tail;
    }
}

 

package org.dyb.design.builder;

public abstract class CarBuilder {
    public abstract void makeHead();
    public abstract void makeBody();
    public abstract void makeTail();
    public abstract Car getCar();//得到汽车对象
}

 

package org.dyb.design.builder;

public class JeepBuilder extends CarBuilder {
    private Car car = new Car();
    @Override
    public void makeHead() {
        car.setHead("jeep head");
    }

    @Override
    public void makeBody() {
        car.setBody("jeep body");
    }

    @Override
    public void makeTail() {
        car.setTail("jeep tail");
    }

    @Override
    public Car getCar() {
        return car;
    }

}

 

package org.dyb.design.builder;

public class CarDirector {
 
    public void makeCar(CarBuilder builder){
        builder.makeHead();//组装车头
        builder.makeBody();//组装车身
        builder.makeTail();//组装车尾
    }
}

 测试：

package org.dyb.design.builder;

import org.junit.Test;

public class TestBuilder {

    @Test
    public void test(){
        CarDirector carDirector = new CarDirector();
        CarBuilder b = new JeepBuilder();
        carDirector.makeCar(b);
        Car car = b.getCar();
        System.out.println(car.toString());
    }
}

 结果：jeep head-jeep body-jeep tail

 

建造者模式与工厂模式的区别：

关注点不同。工厂模式只关心你要的是什么，而不关心东西的具体细节是什么。建造者模式则关心的是这个东西的具体细节的创建。

 

建造者模式的总结：

优点：

1、封装性。

  可以使客户端不必知道产品内部组成的细节。

2、建造者独立，容易扩展。

3、便于控制细节风险。

  因为具体的建造者是独立的，因此可以对建造者建造过程逐步细化，而不对其他的模块产生任何影响。

 

使用场景：

1、相同的方法，不同的执行顺序，产生不同的事件结果。

2、多个部件或者零件，都可以装配到一个对象中，但是产生的运行结果又不相同。