建造者模式

一、 概述

建造者模式又称为生成器模式，它将客户端与包含多个组成部分的复杂对象的创建过程分离，客户端无须知道复杂对象的内部组成部分与装配方式，只需要知道所需建造者的类型。它关注如何一步一步创建一个的复杂对象，不同的具体建造者定义了不同的创建过程，且具体建造者相互独立，增加新的建造者非常方便，无须修改已有代码，系统具有较好的扩展性。

建造者模式的定义为：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。建造者模式是一种对象创建型模式。

结构图为：

二、代码设计

建造者模式中主要包含抽象建造者Builder、具体建造者ConcreteBuilder、产品角色类Product以及指挥者Director。

产品角色类Product是一个复杂对象，典型代码为：

1
2
3
4
5
6
7
8
public class Product {
  private String partA;
  private String partB;
  private String partC;
  //partA的setter和getter
  //partB的setter和getter
  //partC的setter和getter
}

抽象建造者类Builder中定义产品的创建方法和返回方法，典型代码为：

1
2
3
4
5
6
7
8
9
10
11
12
public 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;
  }
}

在ConcreteBuilder中实现了buildPartX()方法，通过调用Product的setPartX()方法可以给产品对象的成员属性设置。

指挥者类Director一方面隔离客户与创建过程，另一方面控制产品的创建过程。典型代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class Director {
  private Builder builder;
  
  public Director(Builder builder) {
    this.builder = builder;
  }
  
  public void setBuilder(Builder builder) {
    this.builder = builder;
  }
  
  //产品构建与组装方法
  public Product construct() {
    builder.biuldPartA();
    builder.buildPartB();
    builder.buildPartC();
    return builder.getResult();
  }
}

客户端类调用代码为：

1
2
3
Builder builder = new ConcreteBuilder();
Director director = new Director(builder);
Product product = director.construct();

三、 demo

某视频播放软件，完整模式下显示菜单、播放列表、主窗口、控制条；精简模式下只显示主窗口和控制条；记忆模式下显示主窗口、控制条、播放列表。

产品角色类Product设计如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
public class Page {

  String menu;

  String playList;

  String mainWindow;

  String controlStrip;

  public String getMenu() {
    return menu;
  }

  public void setMenu(String menu) {
    this.menu = menu;
  }

  public String getPlayList() {
    return playList;
  }

  public void setPlayList(String playList) {
    this.playList = playList;
  }

  public String getMainWindow() {
    return mainWindow;
  }

  public void setMainWindow(String mainWindow) {
    this.mainWindow = mainWindow;
  }

  public String getControlStrip() {
    return controlStrip;
  }

  public void setControlStrip(String controlStrip) {
    this.controlStrip = controlStrip;
  }
}

抽象建造者类Builder设计如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
public abstract class PageBuilder {

    protected Page page = new Page();

    public abstract void buildMenu();

    public abstract void buildPlayList();

    public abstract void buildMainWindow();

    public abstract void buildControlStrip();

    public Page createPage() {
        return page;
    }

    public boolean isShowMenu() {
        return true;
    }

    public boolean isShowPlayList() {
        return true;
    }

    public boolean isShowMainWindow() {
        return true;
    }

    public boolean isShowControlStrip() {
        return true;
    }

}

具体建造者类ConcreBuilder设计如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class CompleteBuilder extends PageBuilder{
    @Override
    public void buildMenu() {
        page.setMenu("完整模式：显示菜单");
    }

    @Override
    public void buildPlayList() {
        page.setPlayList("完整模式：显示播放列表");
    }

    @Override
    public void buildMainWindow() {
        page.setMainWindow("完整模式：显示主窗口");
    }

    @Override
    public void buildControlStrip() {
        page.setControlStrip("完整模式：显示控制条");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
public class MemoryBuilder extends PageBuilder{
    @Override
    public void buildMenu() {
        page.setMenu("记忆模式：显示菜单");
    }

    @Override
    public void buildPlayList() {
        page.setPlayList("记忆模式：显示播放列表");
    }

    @Override
    public void buildMainWindow() {
        page.setMainWindow("记忆模式：显示主窗口");
    }

    @Override
    public void buildControlStrip() {
        page.setControlStrip("记忆模式：显示控制条");
    }

    @Override
    public boolean isShowMenu() {
        return false;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
public class SimpleBuilder extends PageBuilder{
    @Override
    public void buildMenu() {
        page.setMenu("简单模式：显示菜单");
    }

    @Override
    public void buildPlayList() {
        page.setPlayList("简单模式：显示播放列表");
    }

    @Override
    public void buildMainWindow() {
        page.setMainWindow("简单模式：显示主窗口");
    }

    @Override
    public void buildControlStrip() {
        page.setControlStrip("简单模式：显示控制条");
    }

    @Override
    public boolean isShowMenu() {
        return false;
    }

    @Override
    public boolean isShowPlayList() {
        return false;
    }
}

指挥者类Director设计如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
public class PageController {

    public Page construct(PageBuilder pb) {
        Page page;
        if (pb.isShowMenu()) {
            pb.buildMenu();
        }

        if (pb.isShowPlayList()) {
            pb.buildPlayList();
        }

        if (pb.isShowMainWindow()) {
            pb.buildMainWindow();
        }

        if (pb.isShowControlStrip()) {
            pb.buildControlStrip();
        }

        page = pb.createPage();
        return page;
    }

}

客户端调用如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
public static void main(String args[]) {
  PageController pc = new PageController();
  Page page;

  PageBuilder pb;
  pb = new CompleteBuilder();
  page = pc.construct(pb);
  System.out.println("Complete Menu: " + page.getMenu());
  System.out.println("Complete Play List: " + page.getPlayList());
  System.out.println("Complete Main Window: " + page.getMainWindow());
  System.out.println("Complete Control Strip: " + page.getControlStrip());
  System.out.println("----------------------");

  pb = new SimpleBuilder();
  page = pc.construct(pb);
  System.out.println("Simple Menu: " + page.getMenu());
  System.out.println("Simple Play List: " + page.getPlayList());
  System.out.println("Simple Main Window: " + page.getMainWindow());
  System.out.println("Simple Control Strip: " + page.getControlStrip());
  System.out.println("----------------------");

  pb = new MemoryBuilder();
  page = pc.construct(pb);
  System.out.println("Memory Menu: " + page.getMenu());
  System.out.println("Memory Play List: " + page.getPlayList());
  System.out.println("Memory Main Window: " + page.getMainWindow());
  System.out.println("Memory Control Strip: " + page.getControlStrip());
  System.out.println("----------------------");
}

运行结果如下：

四、 总结

1. 优点

  • 客户端不必知道产品内部组成的细节，将产品本身与产品的创建过程解耦，使得相同的创建过程可以创建不同的产品对象。
  • 每一个具体建造者都相对独立，而与其他的具体建造者无关，因此可以很方便地替换具体建造者或增加新的具体建造者，用户使用不同的具体建造者即可得到不同的产品对象。由于指挥者类针对抽象建造者编程，增加新的具体建造者无须修改原有类库的代码，系统扩展方便，符合“开闭原则”。
  • 可以更加精细地控制产品的创建过程。将复杂产品的创建步骤分解在不同的方法中，使得创建过程更加清晰，也更方便使用程序来控制创建过程。

2. 缺点

  • 建造者模式所创建的产品一般具有较多的共同点，其组成部分相似，如果产品之间的差异性很大，例如很多组成部分都不相同，不适合使用建造者模式。
  • 如果产品的内部变化复杂，可能会导致需要定义很多具体建造者类来实现这种变化，导致系统变得很庞大，增加系统的理解难度和运行成本。

3. 适用场景

  • 需要生成的产品对象有复杂的内部结构，这些产品对象通常包含多个成员属性。
  • 需要生成的产品对象的属性相互依赖，需要指定其生成顺序。
  • 对象的创建过程独立于创建该对象的类。在建造者模式中通过引入了指挥者类，将创建过程封装在指挥者类中，而不在建造者类和客户类中。
  • 隔离复杂对象的创建和使用，并使得相同的创建过程可以创建不同的产品。
赏

谢谢你请我吃糖果

微信

扫一扫，分享到微信

微信分享二维码

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

<br><br><br>愿你我都被世界温柔以待<br><br>QQ:969406418<br>欢迎交流