【设计模式】建造者模式一学就会

建造者模式（Builder Pattern）是创建型设计模式之一，旨在将复杂对象的构建过程与其表示分离，使得同样的构建过程可以创建不同的表示。建造者模式特别适用于需要构建复杂对象的场景，通过逐步构建对象，避免了构造函数参数过多的问题。本文将详细介绍建造者模式的概念、结构、实现方法及其优缺点。

建造者模式的结构

建造者模式主要包含以下几个角色：

1. 产品（Product）：要创建的复杂对象。
2. 抽象建造者（Builder）：定义创建产品各个部件的接口。
3. 具体建造者（ConcreteBuilder）：实现 Builder 接口，完成复杂产品各个部件的具体构造方法。
4. 指挥者（Director）：负责安排复杂对象的建造过程，指导 Builder 构建产品。

建造者模式的实现

以下是使用 Java 实现建造者模式的详细代码示例。

1. 定义产品类

产品类是要构建的复杂对象。

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 + "]";
    }
}

2. 定义抽象建造者接口

抽象建造者接口定义了创建产品各个部件的方法。

public interface Builder {
    void buildPartA();
    void buildPartB();
    void buildPartC();
    Product getResult();
}

3. 实现具体建造者类

具体建造者类实现了抽象建造者接口，负责产品的具体构造。

public class ConcreteBuilder implements Builder {
    private Product product = new Product();

    @Override
    public void buildPartA() {
        product.setPartA("PartA built by ConcreteBuilder");
    }

    @Override
    public void buildPartB() {
        product.setPartB("PartB built by ConcreteBuilder");
    }

    @Override
    public void buildPartC() {
        product.setPartC("PartC built by ConcreteBuilder");
    }

    @Override
    public Product getResult() {
        return product;
    }
}

4. 定义指挥者类

指挥者类负责安排产品构建的顺序。

public class Director {
    private Builder builder;

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

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

5. 测试建造者模式

在客户端代码中使用建造者模式创建产品。

public class BuilderPatternTest {
    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);
    }
}

运行结果：

Product [partA=PartA built by ConcreteBuilder, partB=PartB built by ConcreteBuilder, partC=PartC built by ConcreteBuilder]

建造者模式的优缺点

优点

1. 封装性：将构建复杂对象的过程封装在具体建造者中，客户端不需要了解细节。
2. 可扩展性：通过引入新的具体建造者，可以创建不同的产品变体。
3. 易于控制细节：指挥者可以灵活地控制产品构建的顺序和细节。

缺点

1. 复杂性增加：对于简单对象的创建，引入建造者模式会使代码变得复杂。
2. 多样性受限：每个具体建造者只能构建一种产品的具体表示。

应用场景

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

1. 需要创建复杂对象：对象的创建过程包含多个步骤，并且步骤的顺序和细节可能有所不同。
2. 对象的创建过程需要独立于对象的表示：同样的创建过程可以创建不同的表示。
3. 需要灵活控制对象的创建过程：可以根据需求动态调整对象的创建顺序和细节。

实例应用

以下是一个简单的实例应用，展示如何使用建造者模式创建一份复杂的套餐（Meal）。

1. 定义产品类

public class Meal {
    private String drink;
    private String mainCourse;
    private String side;

    public void setDrink(String drink) {
        this.drink = drink;
    }

    public void setMainCourse(String mainCourse) {
        this.mainCourse = mainCourse;
    }

    public void setSide(String side) {
        this.side = side;
    }

    @Override
    public String toString() {
        return "Meal [drink=" + drink + ", mainCourse=" + mainCourse + ", side=" + side + "]";
    }
}

2. 定义抽象建造者接口

public interface MealBuilder {
    void buildDrink();
    void buildMainCourse();
    void buildSide();
    Meal getMeal();
}

3. 实现具体建造者类

public class VegMealBuilder implements MealBuilder {
    private Meal meal = new Meal();

    @Override
    public void buildDrink() {
        meal.setDrink("Orange Juice");
    }

    @Override
    public void buildMainCourse() {
        meal.setMainCourse("Vegetable Burger");
    }

    @Override
    public void buildSide() {
        meal.setSide("French Fries");
    }

    @Override
    public Meal getMeal() {
        return meal;
    }
}

public class NonVegMealBuilder implements MealBuilder {
    private Meal meal = new Meal();

    @Override
    public void buildDrink() {
        meal.setDrink("Coke");
    }

    @Override
    public void buildMainCourse() {
        meal.setMainCourse("Chicken Burger");
    }

    @Override
    public void buildSide() {
        meal.setSide("Onion Rings");
    }

    @Override
    public Meal getMeal() {
        return meal;
    }
}

4. 定义指挥者类

public class MealDirector {
    private MealBuilder mealBuilder;

    public MealDirector(MealBuilder mealBuilder) {
        this.mealBuilder = mealBuilder;
    }

    public void constructMeal() {
        mealBuilder.buildDrink();
        mealBuilder.buildMainCourse();
        mealBuilder.buildSide();
    }
}

5. 测试建造者模式

public class BuilderPatternMealTest {
    public static void main(String[] args) {
        MealBuilder vegMealBuilder = new VegMealBuilder();
        MealDirector vegMealDirector = new MealDirector(vegMealBuilder);
        vegMealDirector.constructMeal();
        Meal vegMeal = vegMealBuilder.getMeal();
        System.out.println("Veg Meal: " + vegMeal);

        MealBuilder nonVegMealBuilder = new NonVegMealBuilder();
        MealDirector nonVegMealDirector = new MealDirector(nonVegMealBuilder);
        nonVegMealDirector.constructMeal();
        Meal nonVegMeal = nonVegMealBuilder.getMeal();
        System.out.println("Non-Veg Meal: " + nonVegMeal);
    }
}

运行结果：

Veg Meal: Meal [drink=Orange Juice, mainCourse=Vegetable Burger, side=French Fries]
Non-Veg Meal: Meal [drink=Coke, mainCourse=Chicken Burger, side=Onion Rings]

结论

建造者模式是一种有效的创建型设计模式，它通过将对象的创建过程与其表示分离，使得对象的构建更加灵活和可扩展。本文详细介绍了建造者模式的概念、结构、实现方法及其优缺点，并通过一个实例应用展示了如何使用建造者模式构建复杂的对象。希望本文能够帮助你更好地理解和应用建造者模式，提高代码的可维护性和可扩展性