建造者(构造器)模式--设计模式

今天将讲述设计模式的另一篇--建造者(构造器)模式,网上的资料也有很多,但感觉都是大而同,小而不同,希望本篇可以为大家增加点对建造者模式的认识和理解.

介绍

1.1 建造者(构建器)模式

建造者(构建器)--Builder模式, 是将一个复杂对象的构建与表示相分离,是的同样的构建过程可以有不同的创建表示.

将一个复杂的对象分解了多个简单的对象, 然后一步步的构建成.达到了将变与不变相分离, 即组成部分是不变的, 但是是每一部分又可以达到灵活选择.

Builder模式隐藏了复杂对象的创建过程, 将复杂对象在创建过程加以抽象, 通过子类基础或重载的方式,动态创建具有符合属性的对象.

1.2 Builder优缺点

优点

• 各个具体的构建器都是相互独立的, 利于系统的扩展
• 客户端不必知道具体产品内部的实现

缺点

• 产品组成部分必须要相同, 限制了使用范围
• 假如产品内部变化复杂, 会增加更多的建造者类

Builder模式和工厂模式的关注点是不同的, Builder模式更注重产品零件的组装过程, 而工厂模式更加注重产品零件的创建过程, 两者是可以结合起来使用的

1.3 适用场景

• 隔离复杂对象的创建和使用，同样的方法不同的执行顺序，从而产生不同事件的结果
• 初始化对象时，参数很多或者很多参数都具有默认值
• 不适合创建差异化很大的产品类，如果产品内部变化负责时，会导致定义很多建造者来实现变化，增加类的数量，增加了运行成本

结构和实现

Builder模式有产品、具体构造者、抽象构造者以及指挥者四个元素组成。

2.1 角色

Builder模式主要的角色如下

• 产品角色(Product)：是包含多个组成部件的复杂对象，而有具体的建造者来创建其各自的部件
• 抽象建造者(Builder)：一个包含创建产品各个子部件抽象方法的一个接口，通常还包含返回产品的方法getProduct()
• 具体构造者(Concrete Builder)：用来实现Builder接口，完成复杂产品各个子部件的具体创建方法
• 指挥者(Director)：完成复杂对象的创建以及装配，指挥中不会涉及具体产品的信息。

2.2 结构

而UML类图

结构代码

2.2.1 产品角色：包含多个组成部件的复杂对象

class Product
{
    private String partA;
    private String partB;
    private String partC;
    public void setPartA(String partA)
    {
        this.partA=partA;
    }
    public void setPartB(String partB)
    {
        this.partB=partB;
    }
    public void setPartC(String partC)
    {
        this.partC=partC;
    }
    public void show()
    {
        //显示产品的特性
    }
}

2.2.2 抽象建造者：包含创建各个子部件的抽象方法

abstract class Builder
{
    //创建产品对象
    protected Product product=new Product();
    public abstract void buildPartA();
    public abstract void buildPartB();
    public abstract void buildPartC();
    //返回产品对象
    public Product getResult()
    {
        return product;
    }
}

2.2.3 具体建造者：实现抽象建造者

public class ConcreteBuilder extends Builder
{
    public void buildPartA()
    {
        product.setPartA("建造 PartA");
    }
    public void buildPartB()
    {
        product.setPartA("建造 PartB");
    }
    public void buildPartC()
    {
        product.setPartA("建造 PartC");
    }
}

2.2.4 指挥者：调用建造者方法完成对复杂对象的创建过程。

class Director
{
    private Builder builder;
    public Director(Builder builder)
    {
        this.builder=builder;
    }
    //产品构建与组装方法
    public Product construct()
    {
        builder.buildPartA();
        builder.buildPartB();
        builder.buildPartC();
        return builder.getResult();
    }
}

 2.2.5 客户端

public class Client
{
    public static void main(String[] args)
    {
        Builder builder=new ConcreteBuilder();
        Director director=new Director(builder);
        Product product=director.construct();
        product.show();
    }
}

实例：用Builder模式创建共享单车的例子

3.1 产品类：包含多个组成部件的复杂对象

车包括架构，座位以及轮胎。

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; 
    } 
    public ISeat getSeat() { 
        return seat; 
    } 
    public void setSeat(ISeat seat) { 
        this.seat = seat; 
    } 
    public ITire getTire() { 
        return tire; 
    } 
    public void setTire(ITire tire) { 
        this.tire = tire; 
    } 
} 

3.2 Builder：包含创建产品各个子部件抽象方法的一个接口

包含返回产品的方法getProduct()

// 抽象 builder 类 
public abstract class Builder { 
    abstract void buildFrame(); 
    abstract void buildSeat(); 
    abstract void buildTire(); 
    abstract Bike createBike(); 
}

3.3 ConcreteBuilder类：用来实现Builder接口

完成复杂产品各个子部件的具体创建方法

// 具体 builder 类 
public class MobikeBuilder extends Builder{ 
    private Bike mBike = new Bike(); 
    @Override 
    void buildFrame() { 
        mBike.setFrame(new AlloyFrame()); 
    } 
    @Override 
    void buildSeat() { 
        mBike.setSeat(new DermisSeat()); 
    } 
    @Override 
    void buildTire() { 
        mBike.setTire(new SolidTire()); 
    } 
    @Override 
    Bike createBike() { 
        return mBike; 
    } 
} 

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

3.4 指挥类：完成复杂对象的创建以及装配

指挥中不会涉及具体产品的信息。

public class Director { 
    private Builder mBuilder = null; 
    public Director(Builder builder) { 
        mBuilder = builder; 
    } 
    public Bike construct() { 
        mBuilder.buildFrame(); 
        mBuilder.buildSeat(); 
        mBuilder.buildTire(); 
        return mBuilder.createBike(); 
    } 
}

3.5 客户端调用

public class Click { 
    public static void main(String[] args) { 
        showBike(new OfoBuilder()); 
        showBike(new MobikeBuilder()); 
    } 
    private void showBike(Builder builder) {
        Director director = new Director(builder); 
        Bike bike = director.construct(); 
        bike.getFrame().frame(); 
        bike.getSeat().seat(); 
        bike.getTire().tire(); 
    } 
} 

总结扩展

Builder模式在应用过程中可以根据需求需要改变，如果创建的产品类只有一种，只需要一个具体建造者，可以省略抽象建造者，甚至可以去除指挥者的角色。

通过上述讲解，希望大家对设计模式--构造器(建造者)--Builder模式有所理解！！！