设计模式与代码的结构特性

本文选择建造者模式进行分析。

一、简单介绍

　　建造者模式，就是简化并管理一个对象的创建与使用的模式方法。将一个复杂对象的构建与表示分离，使得用户在创建不同的对象时，在不知道建造细节的情况下，就可以使用外表相同的构建过程创建对象。

二、适用对象

1、一个复杂对象的创建使用，相同的方法，不同的执行顺序，最终事件结果不同

2、一个复杂对象的创建使用，不同的部件组成，产生结果不同

3、一个复杂对象的创建时，构造的对象有不同表示

4、要求这些不同的对象结果有差异却又不大，具有一定共性。

 

三、举个例子

对于汽车这个对象。

工厂->通过制造获得汽车（知道组装过程与具体零件）

消费者->通过消费获得汽车（知道车的型号）

消费者不用知道汽车的具体零件与组装过程。

 

四、主要结构

1、Builder：（建造者）声明产品的建造过程，有ConcreteBuilder的公共接口。（厂家）

2、ConcreteBuilder：（具体建造过程）实现Builder的接口，明确定义构造和装配该产品的各个部件的具体方法，定义创建的表示，同时提供一个检索产品的接口。

3、Director：（指挥者）构造使用Builder接口的对象。隔离用户与生产过程；控制产品生产过程。（中间商）

4、Product：（产品）最终的复杂构造对象。由ConcreteBuilder直接创建该产品的内部表示并定义它的装配过程，包含定义组成部件的类，包括将这些部件装配成最终产品的接口。

　　简单总结一下：Director指挥整个构造过程；Builder是各部件的创造请求集合；ConcreteBuilder是各部件的创造具体实现；最终构建成复杂完整的Product。

 

五、代码示例（单车）

1、客户端：

public class Click {

    public static void main(String[] args) { 

        showBike(new OfoBuilder()); //ofo

　　　　　showBike(new MobikeBuilder()); //摩拜

    } 
    private void showBike(Builder builder) {
        Director director = new Director(builder);   //只用Director
　　　　　Bike bike = director.construct();           //用户只需要找指挥者不需要知道具体生产过程
　　　　　bike.getFrame().frame();                    //得到具体产品参数（需求）来生产
        bike.getSeat().seat(); 
        bike.getTire().tire(); 
 　　} 

} 

2、指挥者Director：

public class Director { 
    private Builder mBuilder = null; 
    public Director(Builder builder) {     //让指挥者找生产者安排生产
        mBuilder = builder; 
    } 
}

3、抽象建造声明Builder：

public abstract class Builder { 
    abstract void buildFrame(); //架构
    abstract void buildSeat();  //座椅
    abstract void buildTire();  //轮胎
    abstract Bike createBike(); //组装

　　 public Bike construct() {          //过程
        this.buildFrame(); 
        this.buildSeat(); 
        this.buildTire(); 
        return mBuilder.createBike(); 
    } 

} 

4、具体建造过程：

　　不同产品需要不同的具体建造过程。

//摩拜

public class MobikeBuilder extends Builder{

    private Bike mBike = new Bike(); 

    void buildFrame() { 
        mBike.setFrame(new AlloyFrame()); 
    } 
     
    void buildSeat() { 
        mBike.setSeat(new DermisSeat()); 
    } 
    
    void buildTire() { 
        mBike.setTire(new SolidTire()); 
    } 
    
    Bike createBike() { 
        return mBike; 
    } 
} 

//ofo

public class OfoBuilder extends Builder{ 
    private Bike mBike = new Bike(); 
    
    void buildFrame() { 
        mBike.setFrame(new CarbonFrame()); 
    } 
    
    void buildSeat() { 
        mBike.setSeat(new RubberSeat()); 
    } 
     
    void buildTire() { 
        mBike.setTire(new InflateTire()); 
    } 
    
    Bike createBike() { 
        return mBike; 
    } 
} 

5、产品Product：

public class Bike { 

    private IFrame frame; //框架
    private ISeat seat; //座位
    private ITire tire; //轮胎
    
    public IFrame getFrame() { 
        return frame;
    } 
    public void setFrame(IFrame frame) { 
        this.frame = frame;        //调用不同的set
    } 
    public ISeat getSeat() { 
        return seat; 
    } 
    public void setSeat(ISeat seat) { 
        this.seat = seat;          //调用不同的set
    } 
    public ITire getTire() { 
        return tire; 
    } 
    public void setTire(ITire tire) { 
        this.tire = tire;           //调用不同的set
    } 
} 

六、总结一下
1、使用建造者模式后，用户创建一个产品对象是不用知道产品的内部细节，只需要给一些需求
2、不同的建造者（厂家）之间是相互独立的，接口耦合到指挥者，便于扩展系统。
3、具体的建造过程也是相互独立，接口耦合到建造者，具体过程可以逐步细化，而对其他模块过程没有影响。
4、要求不同的产品具有较多的共性，比如相似的组成部件、相似的组装过程。如果变化太大，具体的建造过程就要很多，系统会比较复杂。
5、建造者模式最后返回的是一个较完整的产品。抽象工厂模式返回一串产品族。
6、使用建造者模式，用户通过指挥者指导产品生产，指挥者找生产者建造各部件生产并组装。使用抽象工厂模式，用户直接找工厂生产一系列产品（零件）。