【设计模式|创建型】建造者模式（Builder Pattern）

背景

假设我们要建造一座房子，这个房子有很多不同的部分，比如墙壁、地板、屋顶等等。我们可以使用建造者模式来创建这座房子。

首先，我们定义一个房子类 House，它有一些属性，比如墙壁、地板和屋顶。然后，我们创建一个建造者类 HouseBuilder，它有一些方法用于构建房子的不同部分。最后，我们创建一个指挥者类 HouseDirector，它负责指导建造者如何构建房子。

解释

建造者模式（Builder Pattern）是一种创建型设计模式，旨在通过将对象的构建过程分离为不同的步骤，使得可以逐步构建复杂的对象。该模式将对象的构建与其表现分离开，使得构建过程可以重复使用，同时也方便了对对象构建过程的控制。

示例一

以建造一座房子为例

public class House {
    private String wall;
    private String floor;
    private String roof;
    
    public void setWall(String wall) {
        this.wall = wall;
    }
    
    public void setFloor(String floor) {
        this.floor = floor;
    }
    
    public void setRoof(String roof) {
        this.roof = roof;
    }
    
    // ... 其他方法
}

public class HouseBuilder {
    private House house;
    
    public HouseBuilder() {
        house = new House();
    }
    
    public void buildWall(String wall) {
        house.setWall(wall);
    }
    
    public void buildFloor(String floor) {
        house.setFloor(floor);
    }
    
    public void buildRoof(String roof) {
        house.setRoof(roof);
    }
    
    public House getHouse() {
        return house;
    }
}

public class HouseDirector {
    private HouseBuilder builder;
    
    public HouseDirector(HouseBuilder builder) {
        this.builder = builder;
    }
    
    public void constructHouse() {
        builder.buildWall("brick");
        builder.buildFloor("wood");
        builder.buildRoof("tile");
    }
}

测试

public class Main {
    public static void main(String[] args) {
        HouseBuilder builder = new HouseBuilder();
        HouseDirector director = new HouseDirector(builder);
        
        director.constructHouse();
        
        House house = builder.getHouse();
        
        System.out.println("Wall: " + house.getWall());
        System.out.println("Floor: " + house.getFloor());
        System.out.println("Roof: " + house.getRoof());
    }
}

运行结果：

Wall: brick
Floor: wood
Roof: tile 

示例二

下面是一个实际应用中的场景实例，以创建一份订单为例：

首先，定义一个产品类Order，包含订单的各个属性：

public class Order {
    private String customerId;
    private List<String> items;

    public void setCustomerId(String customerId) {
        this.customerId = customerId;
    }

    public void setItems(List<String> items) {
        this.items = items;
    }

    @Override
    public String toString() {
        return "Order{" +
                "customerId='" + customerId + '\'' +
                ", items=" + items +
                '}';
    }
}

然后，定义一个抽象建造者类OrderBuilder，用于规定订单创建的步骤和方法：

public abstract class OrderBuilder {
    protected Order order;

    public void createOrder() {
        order = new Order();
    }

    public abstract void setCustomerId(String customerId);

    public abstract void setItems(List<String> items);

    public Order getOrder() {
        return order;
    }
}

接下来，定义具体的建造者类SpecificOrderBuilder，实现OrderBuilder中的抽象方法，完成订单的实际构建过程：

public class SpecificOrderBuilder extends OrderBuilder {
    @Override
    public void setCustomerId(String customerId) {
        order.setCustomerId(customerId);
    }

    @Override
    public void setItems(List<String> items) {
        order.setItems(items);
    }
}

最后，定义一个指导者类OrderDirector，用于控制具体的构建过程：

public class OrderDirector {
    private OrderBuilder orderBuilder;

    public OrderDirector(OrderBuilder orderBuilder) {
        this.orderBuilder = orderBuilder;
    }

    public void setOrderBuilder(OrderBuilder orderBuilder) {
        this.orderBuilder = orderBuilder;
    }

    public Order constructOrder(String customerId, List<String> items) {
        orderBuilder.createOrder();
        orderBuilder.setCustomerId(customerId);
        orderBuilder.setItems(items);
        return orderBuilder.getOrder();
    }
}

使用建造者模式创建订单：

public class Main {
    public static void main(String[] args) {
        List<String> items = new ArrayList<>();
        items.add("item1");
        items.add("item2");
        
        OrderBuilder orderBuilder = new SpecificOrderBuilder();
        OrderDirector orderDirector = new OrderDirector(orderBuilder);
        Order order = orderDirector.constructOrder("customer1", items);
        
        System.out.println(order);
    }
}