Java创建型模式之建造者模式怎么实现

1. 引言

在软件开发中，设计模式是解决常见问题的经典解决方案。创建型模式是设计模式的一种，主要关注对象的创建过程。建造者模式（Builder Pattern）是一种创建型设计模式，它允许你创建复杂对象的不同表示，同时隐藏对象的构造细节。本文将详细介绍建造者模式的概念、结构、实现方式以及在实际开发中的应用。

2. 建造者模式概述

2.1 定义

建造者模式（Builder Pattern）是一种创建型设计模式，它将一个复杂对象的构建与其表示分离，使得同样的构建过程可以创建不同的表示。建造者模式通常用于创建具有多个组成部分的复杂对象，这些组成部分的创建过程可能比较复杂，且需要按照一定的顺序进行。

2.2 适用场景

建造者模式适用于以下场景：

• 当创建复杂对象的算法应该独立于该对象的组成部分以及它们的装配方式时。
• 当构造过程必须允许被构造的对象有不同的表示时。
• 当需要逐步构建复杂对象，并且希望隐藏对象的内部结构时。

2.3 优点

• 分离构建与表示：建造者模式将对象的构建过程与表示分离，使得同样的构建过程可以创建不同的表示。
• 灵活性强：通过使用不同的具体建造者，可以创建不同的产品对象。
• 易于扩展：增加新的具体建造者无需修改现有代码，符合开闭原则。

2.4 缺点

• 增加复杂性：建造者模式引入了多个类，增加了系统的复杂性。
• 代码冗余：如果产品的组成部分较少，使用建造者模式可能会导致代码冗余。

3. 建造者模式的结构

建造者模式通常包含以下几个角色：

1. 产品（Product）：表示被构建的复杂对象。它包含多个组成部分，这些组成部分由具体建造者创建。
2. 抽象建造者（Builder）：定义创建产品各个组成部分的抽象接口。
3. 具体建造者（Concrete Builder）：实现抽象建造者接口，具体实现各个组成部分的创建和装配。
4. 指挥者（Director）：负责调用具体建造者来构建产品，它知道如何构建产品，但不关心产品的具体组成部分。

3.1 类图

classDiagram
    class Product {
        +String partA
        +String partB
        +String partC
    }

    class Builder {
        <<abstract>>
        +buildPartA()
        +buildPartB()
        +buildPartC()
        +getResult() : Product
    }

    class ConcreteBuilder {
        -Product product
        +buildPartA()
        +buildPartB()
        +buildPartC()
        +getResult() : Product
    }

    class Director {
        -Builder builder
        +construct()
    }

    Product <-- ConcreteBuilder : creates
    Builder <|-- ConcreteBuilder
    Director --> Builder : uses

4. 建造者模式的实现

4.1 产品类

首先，我们定义一个产品类 Product，它包含多个组成部分。

public class Product {
    private String partA;
    private String partB;
    private String partC;

    public void setPartA(String partA) {
        this.partA = partA;
    }

    public void setPartB(String partB) {
        this.partB = partB;
    }

    public void setPartC(String partC) {
        this.partC = partC;
    }

    @Override
    public String toString() {
        return "Product{" +
                "partA='" + partA + '\'' +
                ", partB='" + partB + '\'' +
                ", partC='" + partC + '\'' +
                '}';
    }
}

4.2 抽象建造者类

接下来，我们定义一个抽象建造者类 Builder，它包含创建产品各个组成部分的抽象方法。

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;
    }
}

4.3 具体建造者类

然后，我们定义一个具体建造者类 ConcreteBuilder，它实现抽象建造者类中的方法，具体实现各个组成部分的创建。

public class ConcreteBuilder extends Builder {
    @Override
    public void buildPartA() {
        product.setPartA("Part A");
    }

    @Override
    public void buildPartB() {
        product.setPartB("Part B");
    }

    @Override
    public void buildPartC() {
        product.setPartC("Part C");
    }
}

4.4 指挥者类

最后，我们定义一个指挥者类 Director，它负责调用具体建造者来构建产品。

public class Director {
    private Builder builder;

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

    public void construct() {
        builder.buildPartA();
        builder.buildPartB();
        builder.buildPartC();
    }
}

4.5 客户端代码

在客户端代码中，我们使用指挥者类来构建产品。

public class Client {
    public static void main(String[] args) {
        Builder builder = new ConcreteBuilder();
        Director director = new Director(builder);
        director.construct();
        Product product = builder.getResult();
        System.out.println(product);
    }
}

4.6 输出结果

运行客户端代码后，输出结果如下：

Product{partA='Part A', partB='Part B', partC='Part C'}

5. 建造者模式的变体

5.1 链式调用

在实际开发中，我们经常使用链式调用来简化建造者模式的使用。通过在每个建造方法中返回 this，可以在客户端代码中实现链式调用。

public class Product {
    private String partA;
    private String partB;
    private String partC;

    public Product setPartA(String partA) {
        this.partA = partA;
        return this;
    }

    public Product setPartB(String partB) {
        this.partB = partB;
        return this;
    }

    public Product setPartC(String partC) {
        this.partC = partC;
        return this;
    }

    @Override
    public String toString() {
        return "Product{" +
                "partA='" + partA + '\'' +
                ", partB='" + partB + '\'' +
                ", partC='" + partC + '\'' +
                '}';
    }
}

在客户端代码中，可以这样使用：

public class Client {
    public static void main(String[] args) {
        Product product = new Product()
                .setPartA("Part A")
                .setPartB("Part B")
                .setPartC("Part C");
        System.out.println(product);
    }
}

5.2 静态内部类

另一种常见的变体是使用静态内部类来实现建造者模式。这种方式可以避免创建多个类，同时保持代码的简洁性。

public class Product {
    private String partA;
    private String partB;
    private String partC;

    private Product(Builder builder) {
        this.partA = builder.partA;
        this.partB = builder.partB;
        this.partC = builder.partC;
    }

    public static class Builder {
        private String partA;
        private String partB;
        private String partC;

        public Builder setPartA(String partA) {
            this.partA = partA;
            return this;
        }

        public Builder setPartB(String partB) {
            this.partB = partB;
            return this;
        }

        public Builder setPartC(String partC) {
            this.partC = partC;
            return this;
        }

        public Product build() {
            return new Product(this);
        }
    }

    @Override
    public String toString() {
        return "Product{" +
                "partA='" + partA + '\'' +
                ", partB='" + partB + '\'' +
                ", partC='" + partC + '\'' +
                '}';
    }
}

在客户端代码中，可以这样使用：

public class Client {
    public static void main(String[] args) {
        Product product = new Product.Builder()
                .setPartA("Part A")
                .setPartB("Part B")
                .setPartC("Part C")
                .build();
        System.out.println(product);
    }
}

6. 建造者模式的应用

6.1 Java中的StringBuilder

在Java中，StringBuilder 类就是一个典型的建造者模式的例子。StringBuilder 允许你逐步构建一个字符串，而不需要每次都创建一个新的字符串对象。

public class StringBuilderExample {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        sb.append("Hello");
        sb.append(" ");
        sb.append("World");
        String result = sb.toString();
        System.out.println(result);
    }
}

6.2 Android中的AlertDialog

在Android开发中，AlertDialog.Builder 类也是一个建造者模式的例子。它允许你逐步构建一个对话框，而不需要直接操作 AlertDialog 类的构造函数。

AlertDialog.Builder builder = new AlertDialog.Builder(context);
builder.setTitle("Title");
builder.setMessage("Message");
builder.setPositiveButton("OK", new DialogInterface.OnClickListener() {
    public void onClick(DialogInterface dialog, int id) {
        // User clicked OK button
    }
});
builder.setNegativeButton("Cancel", new DialogInterface.OnClickListener() {
    public void onClick(DialogInterface dialog, int id) {
        // User cancelled the dialog
    }
});
AlertDialog dialog = builder.create();
dialog.show();

7. 总结

建造者模式是一种非常有用的创建型设计模式，它通过将复杂对象的构建过程与其表示分离，使得同样的构建过程可以创建不同的表示。建造者模式适用于创建具有多个组成部分的复杂对象，并且这些组成部分的创建过程可能比较复杂。通过使用建造者模式，可以提高代码的灵活性和可维护性，同时隐藏对象的构造细节。

在实际开发中，建造者模式的应用非常广泛，例如Java中的 StringBuilder 和Android中的 AlertDialog.Builder 都是建造者模式的典型例子。通过理解和掌握建造者模式，可以帮助我们更好地设计和实现复杂的对象创建过程。