谜一般的设计模式：建造者模式

建造者模式

在软件工程领域，设计模式是一套通用的可复用的解决方案，用来解决在软件设计过程中产生的通用问题。它不是一个可以直接转换成源代码的设计，只是一套在软件系统设计过程中程序员应该遵循的最佳实践准则

上面那句是在网上看见的，觉得很有道理，我们不要为了设计模式而设计模式。往往一个简单的流程，非要弄个设计模式进来，反而脱裤子放屁。

• 简单描述：将一个复杂对象的构建与其表示分离，使得同样的构建过程可以创建不同的表示。

• 应用场景：

  1. 相同的方法，不同的执行顺序，产生不同的事件结果时，可以采用建造者模式。

  2. 多个部件或零件，都可以装配到一个对象中，但是产生的运行结果又不相同时，则可以使用该模式。

  3. 产品类非常复杂，或者产品类中的调用顺序不同产生了不同的效能，这个时候使用建造者模式非常合适。

  4. 在对象创建过程中会使用到系统中的一些其他对象，这些对象在产品对象的创建过程中不易得到时，也可以采用建造者模式封装该对象的创建过程。

这里先引用下GOF里的样例代码

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

    public void show() {
        //显示产品的特性
    }
}
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;
    }
}
public class ConcreteBuilder extends Builder {
    public void buildPartA() {
        product.setPartA("建造 PartA");
    }

    public void buildPartB() {
        product.setPartB("建造 PartB");
    }

    public void buildPartC() {
        product.setPartC("建造 PartC");
    }
}
public class Director {
    private Builder builder;

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

    //产品构建与组装方法
    public Product construct() {
        builder.buildPartA();
        builder.buildPartB();
        builder.buildPartC();
        return builder.getResult();
    }
}
public class Client {
    public static void main(String[] args) {
        Builder builder = new ConcreteBuilder();
        Director director = new Director(builder);
        Product product = director.construct();
        product.show();
    }
}

上面的代码，执行的结果是无论如何构建这个对象，执行的顺序都是由Director里面的construct决定，我觉得按照如下改动，会灵活许多

@Data
public class Product {
    private String partA;
    private String partB;
    private String partC;
}

@Data
public abstract class BaseBuilder {
    Product product = new Product();

    public abstract BaseBuilder setPartA();
    public abstract BaseBuilder setPartB();
    public abstract BaseBuilder setPartC();

    public Product build(){
        return product;
    }
}
public class BuildNormal extends BaseBuilder {
    @Override
    public BaseBuilder setPartA() {
        product.setPartA("aaa");
        return this;
    }
    @Override
    public BaseBuilder setPartB() {
        return this;
    }
    @Override
    public BaseBuilder setPartC() {
        return this;
    }
}
public class BuildOther extends BaseBuilder {
    @Override
    public BaseBuilder setPartA() {
        product.setPartA("aaa");
        return this;
    }
    @Override
    public BaseBuilder setPartB() {
        product.setPartB("bbbbb");
        return this;
    }
    @Override
    public BaseBuilder setPartC() {
        return this;
    }
    public static void main(String[] args) {
        BaseBuilder builder = new BuildNormal();
        Product normal = builder.setPartA().setPartB().build();
        Product other = new BuildOther().setPartB().build();
        System.out.println(JSON.toJSONString(normal));
        System.out.println(JSON.toJSONString(other));
    }
}

这个代码是去掉的指挥者，直接通过扩展builder来实现不同的构建业务，以及每个构建的顺序可以任意指定。