设计模式(Java语言)- 建造者模式

  前言

  在日常的生活中,我们可以经常看到建造者模式的影子。比如,建造房子,那么房子就是一个产品,房子由门,窗,墙,地板等部门组成。然后包工头在建造房子的时候就根据设计好的图纸来建造,但是包工头并不是亲自来建造房子的,而是通过指挥工人来施工。再比如组装电脑,可以根据不同的厂商来组装成不同类型的包括cpu,gpu等都不一样的电脑。

  建造者模式定义

  建造者模式,也称之为创建者模式,将一个复杂的对象的构建和它的表示分离,使得同样的构建过程可以创建出不同的表示,这样的设计模式称之为建造者模式。建造者模式将一个复杂的对象分解成多个简单的对象,然后利用简单的对象一步步构建出复杂的对象。它是变与不变相互分离,即一个产品的组成部分是相同的,但是每个部分产品确实可以依据具体情况来灵活选择。

  建造者模式的应用场景

  需要生成的产品对象具有复杂的内部结构,隔离产品构建和表示,比如:

  1、Java中的java.lang.StringBuilder、java.lang.StringBuffer类使用到了建造者模式。

  2、mybatis 中的SqlSessionFactoryBuilder使用到了建造者模式。

  建造者模式的角色

  1、产品(product):被创建的复杂对象,内部具有多个属性等,由具体的建造者来构建。比如电脑,房子等都是产品角色。

  2、抽象建造者(abstract builder): 抽象建造者是对产品构建过程的规范,比如建造房子需要哪些步骤才可以。类似于房子的设计图纸,所有的房子都是按照图纸建造出来的。

  3、具体建造者(concrete builder):具体建造者构建产品过程中每个步骤的具体体现。比如建造房子是需要地板,那么这个地板是用木板还是瓷砖来做的,都是由具体建造者角色来决定的。

  4、指挥者(director):指挥者就是根据具体建造者的步骤,依据不同的顺序来构建出具体的产品。比如每个包工头建造的房子的顺序都不一样,有的可以要先砌好墙,然后再砌地板,但是无论顺序怎么样,最终造出来的房子是一样的。

  建造者模式UML类图

  

 

   代码实现

  首先,我先用上面组装电脑的例子用代码实现一下。

  第一步,创建产品:computer

  

/**
 * @InterfaceName: Computer
 * @description:
 * @author: rainple
 * @create: 2020-05-07 12:42
 **/
public class Computer {


    private String gpu;
    private String cpu;
    private String ram;
    private String mainboard;
    private String power;

    public String getGpu() {
        return gpu;
    }

    public void setGpu(String gpu) {
        this.gpu = gpu;
    }

    public String getCpu() {
        return cpu;
    }

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

    public String getRam() {
        return ram;
    }

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

    public String getMainboard() {
        return mainboard;
    }

    public void setMainboard(String mainboard) {
        this.mainboard = mainboard;
    }

    public String getPower() {
        return power;
    }

    public void setPower(String power) {
        this.power = power;
    }

    @Override
    public String toString() {
        return "Computer{" +
                "gpu='" + gpu + '\'' +
                ", cpu='" + cpu + '\'' +
                ", ram='" + ram + '\'' +
                ", mainboard='" + mainboard + '\'' +
                ", power='" + power + '\'' +
                '}';
    }
}

  生成抽象Builder类

/**
 * @className: Builder
 * @description:
 * @author: rainple
 * @create: 2020-05-07 12:45
 **/
public abstract class Builder {

    /**
     * 组装显卡
     */
    abstract void buildGpu();

    /**
     * 组装cpu
     */
    abstract void buildCpu();

    /**
     * 组装内存
     */
    abstract void buildRam();

    /**
     * 组装主板
     */
    abstract void buildMainboard();

    /**
     * 组装电源
     */
    abstract void buildPower();

    /**
     * 获取电脑
     * @return
     */
    abstract Computer getComputer();

}

  创建一个mac电脑

  

/**
 * @className: MacComputer
 * @description:
 * @author: rainple
 * @create: 2020-05-07 12:47
 **/
public class MacComputerBuilder extends Builder {

    private Computer computer;

    public MacComputerBuilder() {
        computer = new Computer();
    }

    @Override
    void buildGpu() {
        computer.setGpu("atx");
        System.out.println("mac book is building gpu");
    }

    @Override
    void buildCpu() {
        computer.setCpu("intel i7");
        System.out.println("mac book is building cpu");
    }

    @Override
    void buildRam() {
        computer.setRam("三星");
        System.out.println("mac book is building ram");
    }

    @Override
    void buildMainboard() {
        computer.setMainboard("microStar");
        System.out.println("mac book is building main board");
    }

    @Override
    void buildPower() {
        computer.setPower("战斧");
        System.out.println("mac book is building power");
    }

    @Override
    Computer getComputer() {
        return computer;
    }
}

  指挥者

/**
 * @className: Derector
 * @description:
 * @author: rainple
 * @create: 2020-05-07 12:52
 **/
public class Director {

    private Builder builder;

    public Director(Builder builder) {
        this.builder = builder;
    }

    public void setBuilder(Builder builder) {
        this.builder = builder;
    }

    /**
     * 组装电脑,组装的顺序可以不同,但是最终组装出来的电脑是一致的
     * @return
     */
    public Computer build() {
        builder.buildGpu();
        builder.buildCpu();
        builder.buildMainboard();
        builder.buildPower();
        builder.buildRam();
        return builder.getComputer();
    }
}

  测试

/**
 * @className: Client
 * @description:
 * @author: rainple
 * @create: 2020-05-07 12:54
 **/
public class Client {

    public static void main(String[] args) {
        Builder builder = new MacComputerBuilder();
        Director director = new Director(builder);
        Computer build = director.build();
        System.out.println(build);
    }

}

  //mac book is building gpu

  //mac book is building cpu

  //mac book is building main board
  //mac book is building power
  //mac book is building ram
  //Computer{gpu='atx', cpu='intel i7', ram='三星', mainboard='microStar', power='战斧'}

 

  当我们在需要创建其它品牌的电脑时,我们只需要集成Builder即可,

/**
 * @className: HuaweiComputer
 * @description:
 * @author: rainple
 * @create: 2020-05-08 12:42
 **/
public class HuaweiComputerBuilder extends Builder {

    private Computer computer;

    public HuaweiComputerBuilder() {
        computer = new Computer();
    }

    @Override
    void buildGpu() {
        computer.setGpu("显卡");
    }

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

    @Override
    void buildRam() {
        computer.setRam("内存");
    }

    @Override
    void buildMainboard() {
        computer.setMainboard("主板");
    }

    @Override
    void buildPower() {
        computer.setPower("电源");
    }

    @Override
    Computer getComputer() {
        return computer;
    }
}

  测试

/**
 * @className: Client
 * @description:
 * @author: rainple
 * @create: 2020-05-07 12:54
 **/
public class Client {

    public static void main(String[] args) {
        Builder builder = new MacComputerBuilder();
        Director director = new Director(builder);
        Computer build = director.build();
        System.out.println(build);
        director.setBuilder(new HuaweiComputerBuilder());
        build = director.build();
        System.out.println(build);
    }

}

  结果:

mac book is building gpu
mac book is building cpu
mac book is building main board
mac book is building power
mac book is building ram
Computer{gpu='atx', cpu='intel i7', ram='三星', mainboard='microStar', power='战斧'}
Computer{gpu='显卡', cpu='cpu', ram='内存', mainboard='主板', power='电源'}

 

  建造者模式的优缺点

  优点:

  1、可以分步构建复杂的对象

  2、能够解决复杂对象内部结构频繁的需求变动的问题

  3、用户新增不同产品时,只需要新增具体的构建者即可,不需要修改原有的产品的构建流程

  缺点:

  1、建造者模式不适用与存有较大差异的产品对象

  2、如果产品的内部变化复杂,可能会导致需要定义很多具体建造者类来实现这种变化,导致系统变得很庞大

 

喜欢我写的博客的同学可以关注订阅号【Java解忧杂货铺】,里面不定期发布一些技术干活,也可以免费获取大量最新最流行的技术教学视频

 

 

  

posted @ 2020-05-08 12:57  rainple  阅读(254)  评论(0编辑  收藏  举报