一、生活场景

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

1、代码实现

1/**
2 * 基于建造者模式描述软件开发
3 */
4public class C01_InScene {
5    public static void main(String[] args) {
6        BuilderSoft builderSoft = new SoftImpl () ;
7        ProjectManager manager = new ProjectManager(builderSoft) ;
8        manager.createSoft();
9    }
10}
11
12/**
13 * 手机软件产品开发
14 */
15class MobileSoft {
16    // 设计
17    private String design ;
18    // 架构
19    private String frame ;
20    // 开发
21    private String develop ;
22    // 上线
23    private String online ;
24    // 省略 GET SET 方法
25}
26/**
27 * 手机软件流程抽象类
28 */
29abstract class BuilderSoft {
30    // 前期工作
31    public abstract void earlyWork () ;
32    // 中期工作
33    public abstract void midWork () ;
34    // 后期工作
35    public abstract void lateWork () ;
36    // 手机软件完成
37    public abstract MobileSoft builderSoft () ;
38}
39
40/**
41 * 手机软件具体实现
42 */
43class SoftImpl extends BuilderSoft {
44    private MobileSoft mobileSoft = new MobileSoft();
45    @Override
46    public void earlyWork() {
47        System.out.println("软件前期设计...");
48    }
49    @Override
50    public void midWork() {
51        System.out.println("软件中期架构...");
52        System.out.println("软件中期开发...");
53    }
54    @Override
55    public void lateWork() {
56        System.out.println("软件后期上线...");
57    }
58    @Override
59    public MobileSoft builderSoft() {
60        return mobileSoft ;
61    }
62}
63/**
64 * 项目经理：把控项目进度
65 */
66class ProjectManager {
67    private BuilderSoft builderSoft ;
68    ProjectManager (BuilderSoft builderSoft){
69        this.builderSoft = builderSoft ;
70    }
71    // 统筹项目周期
72    public void createSoft (){
73        builderSoft.earlyWork();
74        builderSoft.midWork();
75        builderSoft.lateWork();
76        // MobileSoft mobileSoft = builderSoft.builderSoft() ;
77        // return mobileSoft ;
78    }
79}

2、代码结构图

二、建造者模式

1、基础概念

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

2、核心角色

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

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

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

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

3)、导演者（Director）角色

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

4)、产品（Product）角色

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

3、模式图解

4、源码实现

1/**
2 * 建造者模式代码
3 */
4public class C02_Builder {
5    public static void main(String[] args) {
6        Builder builder = new ConcreteBuilder();
7        Director director = new Director(builder);
8        director.construct();
9        Product product = builder.builderProduct();
10        System.out.println(product.getAct1());
11        System.out.println(product.getAct2());
12    }
13}
14/**
15 * 产品类
16 */
17class Product {
18    /*定义一些产品的操作*/
19    private String act1;
20    private String act2;
21    public String getAct1() {
22        return act1;
23    }
24    public void setAct1(String act1) {
25        this.act1 = act1;
26    }
27    public String getAct2() {
28        return act2;
29    }
30    public void setAct2(String act2) {
31        this.act2 = act2;
32    }
33}
34/**
35 * Builder 抽象建造者类
36 */
37abstract class Builder{
38    public abstract void builderact1();
39    public abstract void builderact2();
40    public abstract Product builderProduct();
41}
42/**
43 * 具体建造者类
44 */
45class ConcreteBuilder extends Builder{
46    private Product product = new Product();
47    @Override
48    public void builderact1() {
49        product.setAct1("操作一：执行...");
50    }
51    @Override
52    public void builderact2() {
53        product.setAct2("操作二：执行...");
54    }
55    @Override
56    public Product builderProduct() {
57        return product;
58    }
59}
60/**
61 *  Director 导演者类
62 */
63class Director{
64    /*使用建造者抽象类*/
65    private Builder builder;
66    Director(Builder builder){
67        this.builder = builder;
68    }
69    /*负责调用各个建造方法*/
70    public void construct(){
71        builder.builderact1();
72        builder.builderact2();
73    }
74}

三、实际应用

1、JDK中应用

分析

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

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

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

2、Spring中应用

源码实现

1// 系列方法
2public BeanDefinitionBuilder setParentName(String parentName);
3public BeanDefinitionBuilder setFactoryMethod(String factoryMethod);
4public BeanDefinitionBuilder setFactoryMethodOnBean(String factoryMethod, String factoryBean);
5public BeanDefinitionBuilder addConstructorArgValue(@Nullable Object value);
6public BeanDefinitionBuilder addConstructorArgReference(String beanName);
7public BeanDefinitionBuilder addPropertyValue(String name, @Nullable Object value);
8// 构建Bean
9public AbstractBeanDefinition getRawBeanDefinition() {
10    return this.beanDefinition;
11}
12public AbstractBeanDefinition getBeanDefinition() {
13    this.beanDefinition.validate();
14    return this.beanDefinition;
15}

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

四、优缺点分析

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

五、源代码地址

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

Java描述设计模式(06)：建造者模式