一、生活场景

基于建造者模式，描述软件开发的流程。

1、代码实现

/**
 * 基于建造者模式描述软件开发
 */
public class C01_InScene {public static void main(String[] args) {BuilderSoft builderSoft = new SoftImpl () ;
        ProjectManager manager = new ProjectManager(builderSoft) ;
        manager.createSoft();}
}

/**
 * 手机软件产品开发
 */
class MobileSoft {
    // 设计
    private String design ;
    // 架构
    private String frame ;
    // 开发
    private String develop ;
    // 上线
    private String online ;
    // 省略 GET SET 方法
}
/**
 * 手机软件流程抽象类
 */
abstract class BuilderSoft {
    // 前期工作
    public abstract void earlyWork () ;
    // 中期工作
    public abstract void midWork () ;
    // 后期工作
    public abstract void lateWork () ;
    // 手机软件完成
    public abstract MobileSoft builderSoft () ;}

/**
 * 手机软件具体实现
 */
class SoftImpl extends BuilderSoft {private MobileSoft mobileSoft = new MobileSoft();
    @Override
    public void earlyWork() {System.out.println("软件前期设计...");
    }
    @Override
    public void midWork() {System.out.println("软件中期架构...");
        System.out.println("软件中期开发...");
    }
    @Override
    public void lateWork() {System.out.println("软件后期上线...");
    }
    @Override
    public MobileSoft builderSoft() {return mobileSoft ;}
}
/**
 * 项目经理：把控项目进度
 */
class ProjectManager {
    private BuilderSoft builderSoft ;
    ProjectManager (BuilderSoft builderSoft){this.builderSoft = builderSoft ;}
    // 统筹项目周期
    public void createSoft (){builderSoft.earlyWork();
        builderSoft.midWork();
        builderSoft.lateWork();
        // MobileSoft mobileSoft = builderSoft.builderSoft() ;
        // return mobileSoft ;
    }
}

2、代码结构图

二、建造者模式

1、基础概念

建造模式是对象的创建模式。建造模式可以将一个产品的内部属性描述与产品的生产过程分割，从而可以使一个建造过程生成具有不同的内部表象的产品对象。也就是使用一个中介对象封装一系列的对象交互，使其各个对象不需要显示的相互调用，而且可以单独的改变对象之间的交互。

2、核心角色

1)、抽象建造者（Builder）角色

给出一个抽象接口，以规范产品对象的各个组成成分的建造。模式中直接创建产品对象的是具体建造者角色。

2)、具体建造者（ConcreteBuilder）角色

完成的任务包括：1. 实现抽象建造者 Builder 所声明的接口，给出完成创建产品实例的操作。2. 在建造完成后，提供产品的实例。

3)、导演者（Director）角色

担任这个角色的类调用具体建造者角色以创建产品对象。

4)、产品（Product）角色

产品便是建造的对象。一般来说，一个系统中会有多个产品类，而且这些产品类并不一定有共同的接口，而完全可以是不相关联的。

3、模式图解

4、源码实现

/**
 * 建造者模式代码
 */
public class C02_Builder {public static void main(String[] args) {Builder builder = new ConcreteBuilder();
        Director director = new Director(builder);
        director.construct();
        Product product = builder.builderProduct();
        System.out.println(product.getAct1());
        System.out.println(product.getAct2());
    }
}
/**
 * 产品类
 */
class Product {
    /* 定义一些产品的操作 */
    private String act1;
    private String act2;
    public String getAct1() {return act1;}
    public void setAct1(String act1) {this.act1 = act1;}
    public String getAct2() {return act2;}
    public void setAct2(String act2) {this.act2 = act2;}
}
/**
 * Builder 抽象建造者类
 */
abstract class Builder{public abstract void builderact1();
    public abstract void builderact2();
    public abstract Product builderProduct();}
/**
 * 具体建造者类
 */
class ConcreteBuilder extends Builder{private Product product = new Product();
    @Override
    public void builderact1() {product.setAct1("操作一：执行...");
    }
    @Override
    public void builderact2() {product.setAct2("操作二：执行...");
    }
    @Override
    public Product builderProduct() {return product;}
}
/**
 *  Director 导演者类
 */
class Director{
    /* 使用建造者抽象类 */
    private Builder builder;
    Director(Builder builder){this.builder = builder;}
    /* 负责调用各个建造方法 */
    public void construct(){builder.builderact1();
        builder.builderact2();}
}

三、实际应用

1、JDK 中应用

分析

1)、Appendable 定义多个 append() 抽象方法，抽象建造者。

2)、AbstractStringBuilder 实现 Appendable 接口，已经作为了建造者，只是抽象类无法实例化。

3)、StringBuilder 继承 AbstractStringBuilder，即作为具体建造者，也作为指挥者。

2、Spring 中应用

源码实现

// 系列方法
public BeanDefinitionBuilder setParentName(String parentName);
public BeanDefinitionBuilder setFactoryMethod(String factoryMethod);
public BeanDefinitionBuilder setFactoryMethodOnBean(String factoryMethod, String factoryBean);
public BeanDefinitionBuilder addConstructorArgValue(@Nullable Object value);
public BeanDefinitionBuilder addConstructorArgReference(String beanName);
public BeanDefinitionBuilder addPropertyValue(String name, @Nullable Object value);
// 构建 Bean
public AbstractBeanDefinition getRawBeanDefinition() {return this.beanDefinition;}
public AbstractBeanDefinition getBeanDefinition() {this.beanDefinition.validate();
    return this.beanDefinition;
}

上面两处建造者模式的实际应用，都有点形散而神不散的感觉。

四、优缺点分析

• 优点：减少类之间的相互依赖，降低耦合度。
• 缺点：ConcreateBuilder 变得臃肿庞大，逻辑复杂。

五、源代码地址

GitHub 地址：知了一笑
https://github.com/cicadasmile
码云地址：知了一笑
https://gitee.com/cicadasmile