设计模式——建造者模式

定义

将一个复杂对象的构建和表示分离，使得同样的而构建方式可创建不同的表示。它是将一个复杂的对象分解为多个简单的对象，然后一步一步构建而成。它将变与不变相分离，即产品的组成部分是不变的，但每一部分是可以灵活选择的。

该模式的主要优点如下：

• 封装性好，构建和表示分离。
• 扩展性好，各个具体的建造者相互独立，有利于系统的解耦。
• 客户端不必知道产品内部组成的细节，建造者可以对创建过程逐步细化，而不对其它模块产生任何影响，便于控制细节风险。

其缺点如下：

• 产品的组成部分必须相同，这限制了其使用范围。
• 如果产品的内部变化复杂，如果产品内部发生变化，则建造者也要同步修改，后期维护成本较大。

建造者（Builder）模式和工厂模式的关注点不同：建造者模式注重零部件的组装过程，而工厂方法模式更注重零部件的创建过程，但两者可以结合使用。

模式的结构与实现

建造者（Builder）模式由产品、抽象建造者、具体建造者、指挥者等 4 个要素构成，现在我们来分析其基本结构和实现方法。

1. 模式的结构

• 建造者（Builder）模式的主要角色如下。
• 产品角色（Product）：它是包含多个组成部件的复杂对象，由具体建造者来创建其各个零部件。
• 抽象建造者（Builder）：它是一个包含创建产品各个子部件的抽象方法的接口，通常还包含一个返回复杂产品的方法 getResult()。
• 具体建造者(Concrete Builder）：实现 Builder 接口，完成复杂产品的各个部件的具体创建方法。
• 指挥者（Director）：它调用建造者对象中的部件构造与装配方法完成复杂对象的创建，在指挥者中不涉及具体产品的信息。

2. 模式的实现

图 1 给出了建造者（Builder）模式的主要结构，现在将其实践一下。
我们以文章为例，我们都知道所以文章通过标题、横线、内容、列表等不同组件进行组合。通过这些组合我们可以写出各种华美的文章。但是我们也知道，一篇文章的组成部件总共也就那几种，变化的是内容。因此我们可以通过不同的内容以及构造顺序来构造出不同的文章
(1) 产品角色：Article

public class Article {
    private String title;
    private String content;
    private String author;

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }

    public String getAuthor() {
        return author;
    }

    public void setAuthor(String author) {
        this.author = author;
    }
}

(2) 抽象建造者：包含创建产品各个子部件的抽象方法.

public interface ArticleBuilder {

    public ArticleBuilder addTitle(String title);

    public ArticleBuilder addContent(String conetnt);

    public ArticleBuilder addAuthor(String author);

    public ArticleBuilder addLine();

    public Article buildArticle();
}

(3) 具体建造者：实现了抽象建造者接口。

public class ConcreateArticleBuilder implements ArticleBuilder {
    private StringBuilder temp_content;
    private String title;
    private String author;

    public ConcreateArticleBuilder(){
        temp_content = new StringBuilder();
        title = "";
        author = "";
    }

    @Override
    public ArticleBuilder addTitle(String title) {
        this.title = title;
        return this;
    }

    @Override
    public ArticleBuilder addContent(String conetnt) {
        temp_content.append(conetnt+"\n");
        return this;
    }

    @Override
    public ArticleBuilder addAuthor(String author) {
        this.author = author;
        return this;
    }

    @Override
    public ArticleBuilder addLine() {
        this.temp_content.append("--------------------\n");
        return this;
    }

    @Override
    public Article buildArticle() {
        Article article = new Article();
        article.setAuthor(author);
        article.setContent(temp_content.toString());
        article.setTitle(title);
        return article;
    }
}

(4) 指挥者：调用建造者中的方法完成复杂对象的创建。

此处省略，指挥者在实例场景应用中并不常见，其实所作的工作就是代替Client去进行设计要建造的产品，如果是有几种定制好建造顺序和内容的产品，通过通过指挥者来根据产品种类数量进行多个方法的封装，每种方法返回一个制造完成的实例。但是由于本例中顺序变化的同时，内容也在变。所以指挥者在此处就不适合出现了

(5) 客户类

public class BuilderClient {
    public static void main(String[] args) {
        ArticleBuilder builder = new ConcreateArticleBuilder();

        Article article = builder.addTitle("文章标题")
                                .addContent("内容段落1")
                                .addLine()
                                .addContent("内容段落2")
                                .addAuthor("法外狂徒张三")
                                .buildArticle();

        System.out.println(article.getTitle());
        System.out.println(article.getContent());
        System.out.println(article.getAuthor());
    }
}

总结

本例不是一个建造者类图的完美体现，毕竟还少了个指挥者。但是这种方式我认为是更贴近实际开发的。在SpringBoot中，创建SpringBoot上下文时，差不多就以这种形式来为上下文增加配置的

适用场景

1. 相同方法不同顺序产生了不同对象的实例
2. 将多个部件装配到同一个对象中来产生不同的结构