建造者模式

建造者模式主要将构造器和set方法组合，打通整个对象创建的过程，创建者模式主要包含以下四个角色

  1. 产品（Product）：要创建的复杂对象
  2. 抽象创建者（Abstract Builder）：定义构建产品的接口，通常包含创建和获取产品的方法
  3. 具体创建者（Concrete Builder）：实现抽象创建者定义的接口，为产品的各个部分提供具体实现
  4. 指挥者（Director）：负责调用具体创建者来构建产品的各个部分，控制构建过程。

用法

假设我们要创建一个html文档对象，它包含了标题，段落，图像等元素，我们可以用建造者模式创建对象

产品

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class HtmlDocument {
    private String header = "";
    private String body = "";
    private String footer = "";
    public void addHeader(String header) {
        this.header = header;
    }
    public void addBody(String body) {
        this.body = body;
    }
    public void addFooter(String footer) {
        this.footer = footer;
    }
    @Override
    public String toString() {
        return "" + header + "" + body + "
                " + footer + "";
    }
}

抽象创建者

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public abstract class HtmlDocumentBuilder {
    protected HtmlDocument document;

    public HtmlDocument getDocument() {
        return document;
    }

    public void createNewHtmlDocument() {
        document = new HtmlDocument();
    }

    public abstract void buildHeader();

    public abstract void buildBody();

    public abstract void buildFooter();
}

具体创建者

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class ArticleHtmlDocumentBuilder extends HtmlDocumentBuilder {
    @Override
    public void buildHeader() {
        document.addHeader("Article Header");
    }

    @Override
    public void buildBody() {
        document.addBody("Article Body");
    }

    @Override
    public void buildFooter() {
        document.addFooter("Article Footer");
    }
}

指挥者

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class HtmlDirector {
    private HtmlDocumentBuilder builder;

    public HtmlDirector(HtmlDocumentBuilder builder) {
        this.builder = builder;
    }

    public void constructDocument() {
        builder.createNewHtmlDocument();
        builder.buildHeader();
        builder.buildBody();
        builder.buildFooter();
    }

    public HtmlDocument getDocument() {
        return builder.getDocument();
    }
}

创建对象：

1
2
3
4
5
6
7
8
9
public class Main {
    public static void main(String[] args) {
        HtmlDocumentBuilder articleBuilder = new ArticleHtmlDocumentBuilder();
        HtmlDirector director = new HtmlDirector(articleBuilder);
        director.constructDocument();
        HtmlDocument document = director.getDocument();
        System.out.println("Constructed HTML Document: \n" + document);
    }
}

但是在实际使用时，我们不需要写的这么复杂，可以在产品内部定义创建者内部类

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
43
44
45
46
47
48
49
50
public class HtmlDocument {
    private String header = "";
    private String body = "";
    private String footer = "";
    public void addHeader(String header) {
        this.header = header;
    }
    public void addBody(String body) {
        this.body = body;
    }
    public void addFooter(String footer) {
        this.footer = footer;
    }
    @Override
    public String toString() {
        return "" + header + "" + body + "
                " + footer + "";
    }
    public static class Builder {
        protected HtmlDocument document;
        public Builder() {
            document = new HtmlDocument();
        }
        public Builder addHeader(String header) {
            document.addHeader(header);
            return this;
        }
        public Builder addBody(String body) {
            document.addBody(body);
            return this;
        }
        public Builder addFooter(String footer) {
            document.addFooter(footer);
            return this;
        }
        public HtmlDocument build() {
            return document;
        }
    }
}
    public class Main {
        public static void main(String[] args) {
            HtmlDocument.ArticleBuilder builder = new HtmlDocument.ArticleBuilder();
            HtmlDocument document = builder.addHeader("This is the header")
                    .addBody("This is the body")
                    .addFooter("This is the footer")
                    .build();
            System.out.println("Constructed HTML Document: \n" + document);
        }
    }

建造者模式是用来创建一种类型的复杂对象，通过设置不同的可选参数，“定制化”地创建不同的对象