1.模式定义:将一个复杂对象的创建与他的表示分离，使得同样的构建过程可以创建不同的表示

2.标准的建造者代码

如下，假如要组装品牌电脑，组装可以用很多不同厂商的硬件，而且组装的先后顺序也会不同，那么这样一个复杂的类如果由我们在new的时候处理的话那就很麻烦了，面对这种复杂的情况我们就应该用建造者模式。
比如我们可以抽象一个建造方法接口出来，让不同的建造者去实现组装，如下面的Apple建造者，当然我们也还可以再创建一个华为的建造者出来。
让建造者按照自己厂商的要求去实现品牌的生产组装，我们用的时候调用ProductBuilder去获得一台所想要的品牌组装电脑就可以了。

class Product{
    public String productName;
    public String companyName;
    public String mainBoard;    //1.先安装主板，当然这里的顺序并不是固定的，只是做一个假设
    public String cpu;          //2.再安装cpu，当然这里的顺序并不是固定的，只是做一个假设
    public String memory;       //3.再安装内存，当然这里的顺序并不是固定的，只是做一个假设
}
interface ProductBuilder{
    void builderProductName(String productName);
    void builderProductCompanyName(String companyName);
    void builderMainBoard(String mainBoard);
    void builderCPU(String cpu);
    void builderMemory(String memory);
    Product build();
}
class AppleConCreateProductBuilder implements ProductBuilder{
    private Product product = new Product();
    @Override
    public void builderProductName(String productName) {
        this.product.productName = productName;
    }
    @Override
    public void builderProductCompanyName(String companyName) {
        this.product.companyName = companyName;
    }
    @Override
    public void builderMainBoard(String mainBoard) {
        this.product.mainBoard = mainBoard;
    }
    @Override
    public void builderCPU(String cpu) {
        this.product.cpu = cpu;
    }
    @Override
    public void builderMemory(String memory) {
        this.product.memory = memory;
    }
    @Override
    public Product build() {
        return this.product;
    }
}
class Director{  //经理,监督建造
    private ProductBuilder builder;
    public Director(ProductBuilder productBuilder){
        this.builder = productBuilder;
    }
    public Product buildProduct(String productName,String companyName,String mainBoard,String cpu,String memory){
        builder.builderProductName(productName);
        builder.builderProductCompanyName(companyName);
        builder.builderCPU(mainBoard);
        builder.builderMainBoard(cpu);
        builder.builderMemory(memory);
        return builder.build();
    }
}
public class BuilderTest {
    public static void main(String[] args) {
        ProductBuilder productBuilder = new AppleConCreateProductBuilder();
        Director director = new Director(productBuilder);
        Product product = director.buildProduct("macBookAir12","apple","jiJia","m1","32G");
        System.out.println(product);
    }
}

3.上面的版本是比较复杂的一个版本，其实可以简化，代码如下：

class Product{
    public final String productName;
    public final String companyName;
    public final String mainBoard;    //1.先安装主板
    public final String cpu;          //2.再安装cpu
    public final String memory;       //3.再安装内存
    public Product(String productName,String companyName,String mainBoard,String cpu,String memory){
        this.productName = productName;
        this.companyName = companyName;
        this.mainBoard = mainBoard;
        this.cpu = cpu;
        this.memory = memory;
    }
    public Product build(){
        /*
        在这里实现组装操作
         */
        return this;
    }
}
public class BuilderTest {
    public static void main(String[] args) {
        Product product = new Product("macBookAir12","apple","jiJia","m1","32G").build();
        System.out.println(product);
    }
}

应用场景
1.需要生成的对象具有复杂的内部结构
2.需要生成的对象内部属性本身相互依赖
3.与不可变对象配合使用

优点：
1、建造者独立，易扩展。
2、便于控制细节风险。

Spring源码中的应用
1.org.springframework.web.servlet.mvc.method.RequestMappingInfo
2.org.springframework.beans.factory.support.BeanDefinitionBuilder