[工作中的设计模式]建造者模式builder

一、模式解析

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

  以上是对建造者模式的官方定义,简单说就是对于复杂对象的创建,由一个建造者封装了对象组件的生成,由专门的指挥者来负责指挥对象生产和组件装配,调用者仅需要通知指挥者建造者进行生产,即可从对象本身获取完整对象。

  要点为:

  1、 模式的主要参与者为:抽象建造者,具体建造者,指挥者。

  2、具体建造者负责具体实施生产

  3、指挥者仅负责提供解决方案和流程

  4、最终的产品创建细节和产品交付由具体建造者负责

二、模式代码

定义产品的模块组成

package build.patten;

/**
 * 产品的组成部分
 * @author zjl
 * @time 2016-1-29
 *
 */
public class Part {
    public String name;

    public Part(String name) {
        super();
        this.name = name;
    }
    @Override
    public String toString() {
        // TODO Auto-generated method stub
        return this.name.toString();
    }
}

2、定义产品,产品由三个部分组成,因此保存一个组成部分的列表

package build.patten;

import java.util.ArrayList;
import java.util.List;

/**
 * 产品,可以包含A,B,C三个部分
 * @author zjl
 * @time 2016-1-29
 *
 */
public class Product {
    List<Part> parts=new ArrayList<Part>();
    @Override
    public String toString() {
        // TODO Auto-generated method stub
        return parts.toString();
    }
    
}

3、抽象的建造者,规定了对产品各部分的建造接口

package build.patten;

public interface IBuild {
    public void buildPartA();
    public void buildPartB();
    public void buildPartC();
    public Product getResult();
}

4、具体建造者,实现抽象建造者的方法,可以有一个或多个

package build.patten;

public class ConcreteBuild implements IBuild {
    Product product=new Product();

    @Override
    public void buildPartA() {
        // TODO Auto-generated method stub
        product.parts.add(new Part("partA"));
    }

    @Override
    public void buildPartB() {
        // TODO Auto-generated method stub
        product.parts.add(new Part("partB"));
    }

    @Override
    public void buildPartC() {
        // TODO Auto-generated method stub
        product.parts.add(new Part("partC"));
    }

    @Override
    public Product getResult() {
        // TODO Auto-generated method stub
        return product;
    }

}

4、指挥者类,负责告诉建造者,应该以什么样的逻辑完成产品的创建

package build.patten;

public class Director {
    IBuild build;
    public Director(IBuild build){
        this.build=build;
    }
    
    public void build(){
        this.build.buildPartA();
        this.build.buildPartB();
        this.build.buildPartC();
    }
}

5、客户端

package build.patten;

public class Client {
    public static void main(String[] args) {
        IBuild build=new ConcreteBuild();
        Director director=new Director(build);
        director.build();
        Product product=build.getResult();
        System.out.println(product);
    }
    
}

6、运行结果,也就是创建的产品

[partA, partB, partC]

三、应用场景

建造者模式由于需要中间的指挥者来完成对产品各部分的建设,其实在工作中用的还是比较少,不过最近正在装修,似乎可以找到类似的原型:

在装修的过程中,我们将房子交给装修公司后,由设计师和工人来共同完成对房子的装修,其中设计师负责进行设计,规定房子如何装;具体干活:比如泥工,木工,电工均由工人完成。

整个装修过程比较复杂,因此我们选取简单的一块,比如门的设计和安装来举例:我的房子是两室一厨一卫,所以共需要四个门,门的牌子和材质可以有不同的选择,设计师负责进行选择,工人仅需要安装即可。

四、场景代码

1、定义门,

package build.example;

public class Door {
    //名称
    public String name;
    //材料
    public String type;
    //位置
    public String pos;
    public Door(String name,String pos){
        this.name=name;
        this.pos=pos;
    }
    
    @Override
    public String toString() {
        // TODO Auto-generated method stub
        return pos+"的位置安装厂家为"+name+"的"+type+"门";
    }

}

定义房子,也就是最终交付的成果

package build.example;

import java.util.ArrayList;
import java.util.List;

/**
 * 房子装修,可以请装修工人对房子进行装修
 * 不同人的房子可能装法不同
 * 假设装修两室一厅,共四个门,厨卫+两个卧室
 * @author zjl
 * @time 2016-1-29
 *
 */
public class House {
    List<Door> doors=new ArrayList<Door>();
    @Override
    public String toString() {
        // TODO Auto-generated method stub
        return doors.toString();
    }
}

3、定义工人,工人会装木门,也会装合金门

package build.example;
/**
 * 抽象的装修工人,定义了装修工人会的技能
 * 此处仅以装门来考虑
 * @author zjl
 * @time 2016-1-29
 *
 */
public abstract class AbstractWorker {

    public abstract void fixMumen(Door door);
    public abstract void fixHejinmen(Door door);
    public abstract House getHouse();
    
}

4、定义一个具体的工人,每个工人手艺不一样,所以可以选择的工人很多,但他们都必须会装门

package build.example;

public class ConcreteWorkerA extends AbstractWorker {
    public House house=new House();
    @Override
    public House getHouse(){
        return house;
    }
    @Override
    public void fixMumen(Door door) {
        door.type="木";
        house.doors.add(door);
        
    }

    @Override
    public void fixHejinmen(Door door) {
        door.type="合金";
        house.doors.add(door);
    }

}

5、设计师,负责设计门如何安装

package build.example;
/**
 * 设计师,负责设计门的的种类和选材
 * @author zjl
 * @time 2016-1-29
 *
 */
public class Designer {
    AbstractWorker worker;
    public Designer(AbstractWorker worker){
        this.worker=worker;
    }
    public void bulid() {
        worker.fixMumen(new Door("A厂家", "厨房"));
        worker.fixMumen(new Door("A厂家", "厕所"));
        worker.fixHejinmen(new Door("A厂家", "主卧"));
        worker.fixHejinmen(new Door("A厂家", "次卧"));
    }

}

6、我自己,只负责催进度和要结果

package build.example;

public class Client {
    public static void main(String[] args) {
        AbstractWorker worker=new ConcreteWorkerA();
        Designer designer=new Designer(worker);
        designer.bulid();
        House house=worker.getHouse();
        System.out.println(house);
    }
}

7、生产结果

[厨房的位置安装厂家为A厂家的木门, 
厕所的位置安装厂家为A厂家的木门,
主卧的位置安装厂家为A厂家的合金门,
次卧的位置安装厂家为A厂家的合金门]

五、模式疑问

  1、产品的交付,在模式标准中有建造者进行完成,似乎感觉由指挥者直接完成整个产品的返回似乎也可以,具体区别以后补充

  2、指挥者的存在是建造者模式的关键,将顺序剥离了建造者,其实我们完全可以将建造顺序和过程封装到抽象建造者内,此时建造者模式就变成了模板模式。

  3、针对第二点,为什么有了原型模式后,还会有建造者模式,其实建造者模式可以有多个指挥者,不同的指挥者可以设计出不同的建造顺序和逻辑,从而产生出不同的产品,例如我们装修时,找不同的设计师,设计出不同的风格,那么用的材料和牌子也会不同,此时原型模式由于在父类中规定了建造流程,反而无法达到此效果。

posted @ 2016-01-31 23:46  孤子  阅读(232)  评论(0编辑  收藏  举报