设计模式之建造者模式

概述

建造者模式也被称为生产器模式，它是创建一个复杂对象的创建型模式，其将构建复杂对象的过程和它的部件解耦，使得构建过程和部件的表示分离开来。

举个栗子

我们需要购买一台计算机，首先要求整改计算机的CPU，主板，或者其他部件都是什么牌子的，什么样的配置，根据自己的需求来变化。但是这些部件组装成计算的过程是一样的，我们无需知道这些部件是怎么组装的，我们只需要提供相关部件的牌子和配置就可以了。对于这种就可以采用建造者模式，将部件和组装过程分离。使得构建过程和部件都可以自由扩展，两者之间的耦合也降到最低。

定义

将一个复杂对象的构造与它的表示分离，使得同样的构建过程可以创建不同的表示。

我要组装一台计算机，计算机被抽象为Computer类，它有三个部件：CPU，主板，内存

public class Computer {
    private String mCpu;
    private String mMainboard;
    private String mRam;

    public String getmCpu() {
        return mCpu;
    }

    public void setmCpu(String mCpu) {
        this.mCpu = mCpu;
    }

    public String getmMainboard() {
        return mMainboard;
    }

    public void setmMainboard(String mMainboard) {
        this.mMainboard = mMainboard;
    }

    public String getmRam() {
        return mRam;
    }

    public void setmRam(String mRam) {
        this.mRam = mRam;
    }
}

创建Builder类规范产品的组建

商家组装计算机有一套组装方法的模板，就是一个抽象的Builder类，其里面提供了安装CPU，主板和内存的方法，以及组装成计算机的create方法

public abstract class Builder {
    public abstract void buildCpu(String cpu);
    public abstract void buildMainBoard(String mainBoard);
    public abstract void buildRam(String ram);
    public abstract Computer create();
}

商家实现了抽象的Builder类，ComputerBuilder类用于组装计算机，代码如下所示：

public class ComputerBuilder extends Builder {
    private Computer mComputer = new Computer();

    @Override
    public void buildCpu(String cpu) {
        mComputer.setmCpu(cpu);
    }

    @Override
    public void buildMainBoard(String mainBoard) {
        mComputer.setmMainboard(mainBoard);
    }

    @Override
    public void buildRam(String ram) {
        mComputer.setmRam(ram);
    }

    @Override
    public Computer create() {
        return mComputer;
    }
}

统一组装过程

先安装主板，再安装CPU，最后安装内存并组成计算机：

public class Director  {
    Builder mBuilder = null;
    public Director(Builder builder){
        this.mBuilder = builder;
    }
    public Computer CreateComputer(String cpu,String mainBoard,String ram){
        //规范建造流程
        this.mBuilder.buildCpu(cpu);
        this.mBuilder.buildMainBoard(mainBoard);
        this.mBuilder.buildRam(ram);
        return mBuilder.create();
    }
}

客户端调用

我们只需要自己想要的CPU，主板和内存就可以了。至于商家怎么组装的我们不管。

public class CreateComputer {
    public static void main(String[] args) {
        Builder builder = new ComputerBuilder();
        Director director = new Director(builder);
        //组装计算机
        director.CreateComputer("i7","高级主板","256G内存");
    }
}

使用创建者的场景和优缺点

• 使用场景

1. 当创建复杂对象的算法应该独立于该对象的组成部分以及他们的装配方式时。
2. 不同的方法，不同的执行顺序，产生不同的事件结果时。
3. 多个部件或零件都可以被装配到一个对象中，但是产生的运行结果又不相同时
4. 产品类非常复杂，或者产品类中的调用顺序不同而产生了不同的效果。
5. 在创建一些复杂的对象时，这些对象的内部组成构件间的建造顺序是稳定的，但是对象的内部组成构件面临着复杂的变化

• 优点

1. 使用建造者模式可以使客户端不必知道产品内部组成的细节
2. 具体的建造者类之间是相互独立的，容易扩展
3. 由于具体的建造者是独立的，因此可以对建造过程逐步细化，而不对其他的模块产生任何影响

• 缺点

1. 产生多余的Builder对象以及Director类