欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页

建造者模式

程序员文章站 2022-05-04 22:21:40
...

本文参考:《修炼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、多个部件或者零件,都可以装配到一个对象中,但是产生的运行结果又不相同。