设计模式-建造者模式

1、概述

建造者模式又称生成器模式，所属创建型设计模式，它提供了一种最佳的创建对象方式，将多个简单的对象一步一步构建成一个复杂的对象。对于用户而言，无需知道创建过程和内部组成细节，只需直接使用创建好的对象即可。

建造者模式的结构需要产品（Product）、抽象建造者（Builder）、具体建造者（ConcreteBuilder）、指挥者（Director）四个角色。

产品（Product）：表明需要构建的产品对象
抽象建造者（Builder）：抽象出来的构建者类，用于定义创建对象所需的步骤以及创建的步骤的调用过程
具体建造者（ConcreteBuilder）：抽象建造者的具体实现，对于不同的创建过程可以用不同的类进行实现
指挥者（Director）：使用 Builder 的类，提供给调用方使用，调用方通过使用指挥者来获取产品

2、优缺点

工厂模式一般都是创建一个产品，注重的是把这个产品创建出来就行，只要创建出来，不关心这个产品的组成部分。从代码上看，工厂模式就是一个方法，用这个方法就能生产出产品。

建造者模式也是创建一个产品，但是不仅要把这个产品创建出来，还要关系这个产品的组成细节，组成过程。从代码上看，建造者模式在建造产品时，这个产品有很多方法，建造者模式会根据这些相同方法但是不同执行顺序建造出不同组成细节的产品。
建造者模式可以帮助我们创建复杂的对象，同时保持代码的可读性和灵活性。通过将对象的构建过程与其表示分离，我们可以使用同样的构建过程创建不同的表示。在实际开发中，当遇到需要创建复杂对象的场景时，可以考虑使用建造者模式。

3、实现方式

假设我们要创建一个表示汽车的复杂对象，汽车包含发动机、轮胎和座椅等部分。我们可以使用建造者模式来实现这个需求。

//测试类
public class Test {
    public static void main(String[] args) {
        System.out.println("==================================");
        CarBuilder luxuryCarBuilder = new LuxuryCarBuilder();
        CarDirector luxuryCarDirector = new CarDirector(luxuryCarBuilder);
        luxuryCarDirector.constructCar();
        Car luxuryCar = luxuryCarDirector.getCar();
        System.out.println("豪华汽车：" + luxuryCar);

        CarBuilder economyCarBuilder = new EconomyCarBuilder();
        CarDirector economyCarDirector = new CarDirector(economyCarBuilder);
        economyCarDirector.constructCar();
        Car economyCar = economyCarDirector.getCar();
        System.out.println("经济型汽车：" + economyCar);
    }
}

/*
产品（Product）：表明需要构建的产品对象
抽象建造者（Builder）：抽象出来的构建者类，用于定义创建对象所需的步骤以及创建的步骤的调用过程
具体建造者（ConcreteBuilder）：抽象建造者的具体实现，对于不同的创建过程可以用不同的类进行实现
指挥者（Director）：使用 Builder 的类，提供给调用方使用，调用方通过使用指挥者来获取产品
*/

//定义产品
public class Car {
    private String engine;
    private String tires;
    private String seats;

    public void setEngine(String engine) {
        this.engine = engine;
    }

    public void setTires(String tires) {
        this.tires = tires;
    }

    public void setSeats(String seats) {
        this.seats = seats;
    }

    @Override
    public String toString() {
        return "Car{" +
                "engine='" + engine + '\'' +
                ", tires='" + tires + '\'' +
                ", seats='" + seats + '\'' +
                '}';
    }
}

//抽象建造者（Builder）
public interface CarBuilder {
    void buildEngine();
    void buildTires();
    void buildSeats();
    Car getCar();
}

//具体建造者（ConcreteBuilder）
public class LuxuryCarBuilder implements CarBuilder {
    private Car car;

    public LuxuryCarBuilder() {
        car = new Car();
    }

    @Override
    public void buildEngine() {
        car.setEngine("高性能发动机");
    }

    @Override
    public void buildTires() {
        car.setTires("高级轮胎");
    }

    @Override
    public void buildSeats() {
        car.setSeats("豪华座椅");
    }

    @Override
    public Car getCar() {
        return car;
    }
}

public class EconomyCarBuilder implements CarBuilder {
    private Car car;

    public EconomyCarBuilder() {
        car = new Car();
    }

    @Override
    public void buildEngine() {
        car.setEngine("节能发动机");
    }

    @Override
    public void buildTires() {
        car.setTires("普通轮胎");
    }

    @Override
    public void buildSeats() {
        car.setSeats("经济座椅");
    }

    @Override
    public Car getCar() {
        return car;
    }
}


//指挥者（Director）
public class CarDirector {
    private CarBuilder carBuilder;

    public CarDirector(CarBuilder carBuilder) {
        this.carBuilder = carBuilder;
    }

    public void constructCar() {
        carBuilder.buildEngine();
        carBuilder.buildTires();
        carBuilder.buildSeats();
    }

    public Car getCar() {
        return carBuilder.getCar();
    }
}

示例2

//测试类
public class Test {
    public static void main(String[] args) {
        Director director1 = new Director(new ConcreteBuilder1());
        Product product1 = director1.construct();
        System.out.println(product1);
        System.out.println("==================================");

        Director director2 = new Director(new ConcreteBuilder2());
        Product product2 = director2.construct();
        System.out.println(product2);
    }
}


// 产品类，定义产品的三个部分
public class Product {
    private Object part1;
    private Object part2;
    private Object part3;

    public void setPart1(Object part1) {
        this.part1 = part1;
    }

    public void setPart2(Object part2) {
        this.part2 = part2;
    }

    public void setPart3(Object part3) {
        this.part3 = part3;
    }

    @Override
    public String toString() {
        return "Product{" +
                "part1=" + part1 +
                ", part2=" + part2 +
                ", part3=" + part3 +
                '}';
    }
}

// 抽象建造者类，构建了一个产品对象，并定义了构建产品三个部分所需要的三个方法以及获取产品的方法
public abstract class Builder {
    protected Product product = new Product();

    public abstract void buildPart1();
    public abstract void buildPart2();
    public abstract void buildPart3();
    public abstract Product getProduct();
}

// 具体建造者 1
public class ConcreteBuilder1 extends Builder{
    @Override
    public void buildPart1() {
        product.setPart1("builder 1 set part 1.");
    }

    @Override
    public void buildPart2() {
        product.setPart2("builder 1 set part 2.");
    }

    @Override
    public void buildPart3() {
        product.setPart3("builder 1 set part 3.");
    }

    @Override
    public Product getProduct() {
        System.out.println("builder 1 build product.");
        return product;
    }
}

// 具体建造者 2
public class ConcreteBuilder2 extends Builder {
    @Override
    public void buildPart1() {
        product.setPart1("builder 2 set part 1.");
    }

    @Override
    public void buildPart2() {
        product.setPart2("builder 2 set part 2.");
    }

    @Override
    public void buildPart3() {
        product.setPart3("builder 2 set part 3.");
    }

    @Override
    public Product getProduct() {
        System.out.println("builder 2 build product.");
        return product;
    }
}

// 指挥者对象
public class Director {
    private Builder builder;

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

    public Product construct() {
        builder.buildPart1();
        builder.buildPart2();
        builder.buildPart3();
        Product product = builder.getProduct();
        return product;
    }
}

4、应用场景

例如在日常生活中，我们在烹饪一道菜、制作一款手工艺品或者生产一款手机、一台汽车、一架飞机等等，这些东西在制造过程中的工艺流程都非常复杂，购买者并不关心其是如何生成的，而生产者会根据产品的需求，虽然产品大致的生产过程及组件都是相通的，但是不同型号的产品对应的某些组件可能不一样，这个时候就需要产品生产方能够根据消费者的选择，提供一个灵活的方法来生产需求的产品，这个时候就可以使用建造者模式来进行生产。