Java Builder 模式在实际项目中的应用案例

建造者模式（Builder Pattern）是一种创建型设计模式，它通过将对象的构造过程与表示分离，使得相同的构造过程可以创建不同的表示。这种模式特别适用于创建复杂对象的场景，因为它可以简化对象的构建过程，提高代码的可读性和可维护性。以下是几个实际项目中的应用案例：

快餐套餐构建器

假设我们需要构建一个快餐套餐，套餐包括主食、饮料和甜品。使用建造者模式，我们可以灵活地构建不同的套餐组合。

// 产品类
public class Meal {
    private String mainItem;
    private String drink;
    private String dessert;

    // Getter 和 Setter
    public String getMainItem() { return mainItem; }
    public void setMainItem(String mainItem) { this.mainItem = mainItem; }
    public String getDrink() { return drink; }
    public void setDrink(String drink) { this.drink = drink; }
    public String getDessert() { return dessert; }
    public void setDessert(String dessert) { this.dessert = dessert; }

    @Override
    public String toString() {
        return "Meal [Main Item: " + mainItem + ", Drink: " + drink + ", Dessert: " + dessert + "]";
    }
}

// 抽象建造者
public interface MealBuilder {
    void buildMainItem();
    void buildDrink();
    void buildDessert();
    Meal getMeal();
}

// 具体建造者：儿童套餐
public class KidsMealBuilder implements MealBuilder {
    private Meal meal = new Meal();

    @Override
    public void buildMainItem() {
        meal.setMainItem("Chicken Nuggets");
    }

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

    @Override
    public void buildDessert() {
        meal.setDessert("Ice Cream");
    }

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

// 具体建造者：健身餐
public class FitnessMealBuilder implements MealBuilder {
    private Meal meal = new Meal();

    @Override
    public void buildMainItem() {
        meal.setMainItem("Grilled Chicken");
    }

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

    @Override
    public void buildDessert() {
        meal.setDessert("Greek Yogurt");
    }

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

// 指挥者
public class MealDirector {
    private MealBuilder mealBuilder;

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

    public Meal construct() {
        return mealBuilder.buildMainItem().buildDrink().buildDessert();
    }
}

// 客户端
public class Client {
    public static void main(String[] args) {
        MealDirector director = new MealDirector(new KidsMealBuilder());
        Meal meal = director.construct();
        System.out.println(meal);

        director = new MealDirector(new FitnessMealBuilder());
        meal = director.construct();
        System.out.println(meal);
    }
}

复杂的电子邮件消息

假设我们正在开发一个系统，该系统需要创建复杂的电子邮件消息。邮件消息包含多个字段，如收件人、主题、正文等。为了简化创建邮件的过程，我们可以使用建造者模式。

public class Email {
    private String to;
    private String subject;
    private String body;
    private List<String> attachments;

    // 私有构造函数
    private Email() {}

    public String getTo() {
        return to;
    }

    public String getSubject() {
        return subject;
    }

    public String getBody() {
        return body;
    }

    public List<String> getAttachments() {
        return attachments;
    }

    // 静态内部类，作为建造者
    public static class Builder {
        private final String to;
        private final String subject;
        private final String body;
        private List<String> attachments = new ArrayList<>();

        public Builder(String to, String subject, String body) {
            this.to = to;
            this.subject = subject;
            this.body = body;
        }

        public Builder addAttachment(String attachment) {
            attachments.add(attachment);
            return this;
        }

        public Email build() {
            Email email = new Email();
            email.to = to;
            email.subject = subject;
            email.body = body;
            email.attachments = attachments;
            return email;
        }
    }
}

// 使用建造者模式创建对象
public class EmailClient {
    public static void main(String[] args) {
        // 使用建造者模式创建Email对象
        Email email = new Email.Builder("example@example.com", "Hello", "This is the body of the email")
                .addAttachment("file1.txt")
                .addAttachment("file2.txt")
                .build();

        System.out.println("To: " + email.getTo());
        System.out.println("Subject: " + email.getSubject());
        System.out.println("Body: " + email.getBody());
        System.out.println("Attachments: " + email.getAttachments());
    }
}

汽车构建器

假设我们有一个汽车类，它有多个属性，例如品牌、型号、颜色、发动机等。如果直接用一个构造函数来创建这样的对象，那么构造函数的参数列表可能会变得非常长，而且很多参数可能不是必须的，这样就导致了“可伸缩构造函数”问题。使用Builder模式可以很好地解决这个问题。

public class Car {
    private String brand;
    private String model;
    private String color;
    private String engine;

    private Car(Builder builder) {
        this.brand = builder.brand;
        this.model = builder.model;
        this.color = builder.color;
        this.engine = builder.engine;
    }

    public static class Builder {
        private String brand;
        private String model;
        private String color;
        private String engine;

        public Builder(String brand, String model) {
            this.brand = brand;
            this.model = model;
        }

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

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

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

// 客户端代码
public class Client {
    public static void main(String[] args) {
        Car car = new Car.Builder("Toyota", "Camry")
                .color("Red")
                .engine("V6")
                .build();

        System.out.println("Brand: " + car.brand);
        System.out.println("Model: " + car.model);
        System.out.println("Color: " + car.color);
        System.out.println("Engine: " + car.engine);
    }
}

深度对象层次结构

在处理深度对象层次结构时，Builder模式通过将复杂的对象构建过程分解为多个步骤，每个步骤负责创建或配置一部分对象，最终组合成完整的对象。

public class ComplexObject {
    private PartA partA;
    private PartB partB;
    private PartC partC;

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

    public static class Builder {
        private PartA partA;
        private PartB partB;
        private PartC partC;

        public Builder(PartA partA, PartB partB, PartC partC) {
            this.partA = partA;
            this.partB = partB;
            this.partC = partC;
        }

        public Builder withPartA(PartA partA) {
            this.partA = partA;
            return this;
        }

        public Builder withPartB(PartB partB) {
            this.partB = partB;
            return this;
        }

        public Builder withPartC(PartC partC