Java设计模式之构建者模式

一、定义：

将一个复杂对象分解成多个相对简单的部分，然后根据不同需要分别创建它们，最后构建成该复杂对象。

二、角色：

建造者模式包含的角色如下：
Director：导演类(指挥者)，负责安排已有模块的顺序，然后通知Builder开始建造。

Builder：抽象Builder类，规范产品的组建，一般由子类实现。

ConcreteBuilder：具体建造者，实现抽象Builder类定义的所有方法，并且返回一个组建好的对象。

Product：具体的产品类。

三、具体实现：

我们以台式机DIY组装成完整的台式电脑这个场景实现以下建造者模式：

1、创建产品类：

package com.hongri.designpattern.create;

/**
 * @author：hongri
 * @date：4/5/22
 * @description：创建产品类
 */
public class Computer {
    private String mCpu;
    private String mRam;
    private String mMainBoard;

    public String getCpu() {
        return mCpu;
    }

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

    public String getRam() {
        return mRam;
    }

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

    public String getMainBoard() {
        return mMainBoard;
    }

    public void setMainBoard(String mMainBoard) {
        this.mMainBoard = mMainBoard;
    }

    @Override
    public String toString() {
        return "Computer{" +
                "mCpu='" + mCpu + '\'' +
                ", mRam='" + mRam + '\'' +
                ", mMainBoard='" + mMainBoard + '\'' +
                '}';
    }
}

2、创建Builder接口：

package com.hongri.designpattern.create;

/**
 * @author：hongri
 * @date：4/5/22
 * @description：创建Builder类，规范产品的组建
 */
public abstract class Builder {
    public abstract void buildCpu(String cpu);
    public abstract void buildRam(String ram);
    public abstract void buildMainBoard(String mainBoard);
    public abstract Computer create();
}

3、Builder具体实现类：

package com.hongri.designpattern.create;

/**
 * @author：hongri
 * @date：4/5/22
 * @description：Builder具体实现类
 */
public class ComputerBuilder extends Builder {

    private Computer computer = new Computer();

    @Override
    public void buildCpu(String cpu) {
        computer.setCpu(cpu);
    }

    @Override
    public void buildRam(String ram) {
        computer.setRam(ram);
    }

    @Override
    public void buildMainBoard(String mainBoard) {
        computer.setMainBoard(mainBoard);
    }

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

4、导演类来进行统一组装：

package com.hongri.designpattern.create;

/**
 * @author：hongri
 * @date：4/5/22
 * @description：导演类 - 用来统一组装过程
 */
public class Director {
    Builder builder;
    public Director(Builder builder) {
        this.builder = builder;
    }

    public Computer createComputer(String cpu, String mainBoard, String ram) {
        builder.buildMainBoard(mainBoard);
        builder.buildCpu(cpu);
        builder.buildRam(ram);

        return builder.create();
    }
}

5、客户端调用导演类：

        /**
         * 建造者模式
         */
        Builder builder = new ComputerBuilder();
        Director director = new Director(builder);
        //组装计算机
        Computer computer = director.createComputer("Intel i7", "华硕", "kingston");
        System.out.println("computer:" + computer);

//日志打印如下：
computer:Computer{mCpu='Intel i7', mRam='kingston', mMainBoard='华硕'}

四、适用场景及优缺点：

适用场景：

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

优缺点：

优点：

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

缺点：
产生多余的Builder对象以及导演类。

参考：
Java设计模式综述