建造者模式

概述

当复杂的构建过程通常不变，改变的只是内部的实现算法和业务逻辑时使用；
将复杂的构建过程和具体的内部实现相分离，使得构建过程公用化。

UML

​

结构

产品(Product)：需要被建造的目标；
抽象建造者(Builder)：规划好建造者类要执行的任务，如需要实现A项任务，B项任务和C项任务，需要返回指定产品；
具体建造者(ConcreteBuilderA和ConcreteBuilderB)：具体实现每项任务，如怎样实现A项任务，B项任务和C项任务；
指挥者(Director)：指挥完成任务的顺序和方式，如先完成A项任务再完成B项任务，再有选择地完成C项任务，需要指定具体的建造者和安排建造顺序。

代码

package com.builder;
// 以下有两个类
/**
 * 产品类
 */
public class Product {
    private String componentA;
    private String componentB;

    public String getComponentA() {
        return componentA;
    }

    public void setComponentA(String componentA) {
        this.componentA = componentA;
    }

    public String getComponentB() {
        return componentB;
    }

    public void setComponentB(String componentB) {
        this.componentB = componentB;
    }

    public void show() {
        System.out.println(toString());
    }

    @Override
    public String toString() {
        return "Product [componentA=" + componentA + ", componentB="
                + componentB + "]";
    }
}

/**
 * 创建者抽象类
 */
public abstract class Builder {
    protected Product product = new Product();
    public abstract void buildOne();
    public abstract void buildTwo();
    public Product getResult() {
        return product;
    }
}

package com.builder;
// 以下有三个类
/**
 * 建造者A类
 */
public class ConcreteBuilderA extends Builder {

    @Override
    public void buildOne() {
        product.setComponentA("建造者A组件1");
    }

    @Override
    public void buildTwo() {
        product.setComponentB("建造者A组件2");
    }
}

/**
 * 建造者B类
 */
public class ConcreteBuilderB extends Builder {

    @Override
    public void buildOne() {
        product.setComponentA("建造者B组件1");
    }

    @Override
    public void buildTwo() {
        product.setComponentB("建造者B组件2");
    }
}

/**
 * 指挥者类
 */
public class Director {

    private Builder builder;

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

    public void construct() {
        builder.buildOne();
        builder.buildTwo();
    }

}

/**
 * 测试类
 */
public class TestMain {
    public static void main(String[] args) {
        Builder builderA = new ConcreteBuilderA();
        Director director = new Director(builderA);
        director.construct();
        Product productA = builderA.getResult();
        productA.show();
        
        Builder builderB = new ConcreteBuilderB();
        director = new Director(builderB);
        director.construct();
        Product productB = builderB.getResult();
        productB.show();
    }
}

  优缺点

优点：建造者独立，便于扩展，如果有新的内部逻辑只需继承/实现建造者即可，细节修改不容易影响其他逻辑；
缺点：结构相对固化，不同的构造过程难以使用同一个指挥者，如果内部细节变化过多需要更多的建造者类。

才疏学浅，如文中有错误，感谢大家指出。