研磨设计模式（七）生成器模式

1. 概述

在生活上，我们经常需要一个指南，按照一定的步骤去完成一件事情，很多符合条件的人都可以按照指南上的步骤去完成这件事情，但是不用关心这些个人是如何完成这些步骤的。这类情况就有点像是设计模式中的生成器模式(Builder)。

2. 生成器模式

定义：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

生成器模式结构图如下

其中:

• Builder:生成器接口，定义创建一个Product对象所需的各个部件的操作。
• ConcreteBuilder:具体的生成器实现，实现各个部件的创建，并负责组装Product对象的各个部件，同时还提供一个让用户获取组装完成后的产品对象的方法。
• Director: 指导者，也被称为导向者，主要用来使用Builder接口，以一个统一的过程来构建所需要的Product对象。
• Product:产品，表示被生成器构建的复杂对象，包含多个部件。

下面用代码实现一下
（1）先看看生成器的接口定义，示例代码如下：

/**
 * 生成器接口，定义创建一个产品对象所需的各个部件的操作
 */
public interface Builder {
    /**
     * 示意方法，构建某个部件
     */
    public void buildPart();
}

（2）再看看具体的生成器实现，示例代码如下：

/**
 * 具体的生成器实现对象
 */
public class ConcreteBuilder implements Builder {
    /**
     * 生成器最终构建的产品对象
     */
    private Product resultProduct;
    /**
     * 获取生成器最终构建的产品对象
     * @return 生成器最终构建的产品对象
     */
    public Product getResult() {
       return resultProduct;
    }

    public void buildPart() {
       //构建某个部件的功能处理
    }
}

（3）看看相应的产品对象的接口示意，示例代码如下：

/**
 * 被构建的产品对象的接口
 */
public interface Product {
    //定义产品的操作
}

（4）再来看看指导者的实现示意，示例代码如下：

/**
 * 指导者，指导使用生成器的接口来构建产品的对象
 */
public class Director {
    /**
     * 持有当前需要使用的生成器对象
     */
    private Builder builder;

    /**
     * 构造方法，传入生成器对象
     * @param builder 生成器对象
     */
    public Director(Builder builder) {
       this.builder = builder;
    }

    /**
     * 示意方法，指导生成器构建最终的产品对象
     */
    public void construct() {
       //通过使用生成器接口来构建最终的产品对象
       builder.buildPart();
    }
}

代码实现就到此结束了，下面用个具体实例的来加强理解。

3. 使用生成器模式

在前几年的手机里，诺基亚和三星占了很大的市场份额。大家应该还记得诺基亚的强大，手机一摔，直接分成3块，机身、电池和手机后盖，然后再把它们组装回去，又可以继续用了~~

现在，我就把手机当做（Product），诺基亚和三星手机便是手机的不同实现，而机身、电池和手机后盖就是手机的部件（Part），这些部件是制造商分别生产的。把这三个部件组装在一起，就可以使用该手机了。而组装步骤很简单：

1. 将电池装上机身。
2. 将手机后盖盖上。

现在就可以用代码来实现一下这个场景。

（1）先是手机的三个组成部件类，这些部件只有一个brand字段代表品牌，其它细节便在此略过了~

1、机身(Body)

/**
 * 机身
 */
public class Body {
    // 所属品牌
    private String brand;
    // ..其它细节

    public Body(String brand) {
        this.brand = brand;
    }
    public String getBrand() {
        return brand;
    }
}

2、电池(Battery)

/**
 * 电池
 */
public class Battery {
    // 所属品牌
    private String brand;
    // ..其它细节

    public Battery(String brand) {
        this.brand = brand;
    }
    public String getBrand() {
        return brand;
    }
}

3、手机后盖(BackCover)

/**
 * 手机后盖
 */
public class BackCover {
    // 所属品牌
    private String brand;
    //..其它细节

    public BackCover(String brand) {
        this.brand = brand;
    }
    public String getBrand() {
        return brand;
    }
}

（2）手机类(Phone)，有三个字段分别对应上面的三个部件类，并提供各自的getter和setter方法

/**
 * 手机
 */
public class Phone {

    private Body body;//机身
    private Battery battery;//电池
    private BackCover backCover;//后盖

    public void setBody(Body body) {
        this.body = body;
    }
    public void setBattery(Battery battery) {
        this.battery = battery;
    }
    public void setBackCover(BackCover backCover) {
        this.backCover = backCover;
    }
    public Body getBody() {
        return body;
    }
    public Battery getBattery() {
        return battery;
    }
    public BackCover getBackCover() {
        return backCover;
    }
}

（3）生成器接口，定义了创建一个手机(Phone)对象所需的各个部件的操作

/**
 * 生产器接口，定义创建手机所需的各个部件的操作
 */
public interface Builder {
    /**
     * 构建机身
     */
    public void buildBody();
    /**
     * 构建电池
     */
    public void buildBattery();
    /**
     * 构建后盖
     */
    public void buildBackCover();
}

（4）具体生成器的实现，一个是诺基亚(Nokia)的实现，一个是三星(Samsung)的实现

1、诺基亚(Nokia)的生成器实现

/**
 * 诺基亚实现生成器对象
 */
public class NokiaBuilder implements Builder{

    private Phone phone = new Phone();
    /**
     * 具体构建诺基亚机身
     */
    public void buildBody() {
        Body body = new Body("Nokia");
        phone.setBody(body);
    }
    /**
     * 具体构建诺基亚电池
     */
    public void buildBattery() {
        Battery battery = new Battery("Nokia");
        phone.setBattery(battery);
    }
    /**
     * 具体构建诺基亚后盖
     */
    public void buildBackCover() {
        BackCover backCover = new BackCover("Nokia");
        phone.setBackCover(backCover);
    }

    public Phone getPhone() {
        return phone;
    }
}

2、三星(Samsung)的生成器实现

/**
 * 三星实现生成器对象
 */
public class SamsungBuilder implements Builder{

    private Phone phone = new Phone();
    /**
     * 具体构建三星机身
     */
    public void buildBody() {
        Body body = new Body("Samsung");
        phone.setBody(body);
    }
    /**
     * 具体构建三星电池
     */
    public void buildBattery() {
        Battery battery = new Battery("Samsung");
        phone.setBattery(battery);
    }
    /**
     * 具体构建三星后盖
     */
    public void buildBackCover() {
        BackCover backCover = new BackCover("Samsung");
        phone.setBackCover(backCover);
    }

    public Phone getPhone() {
        return phone;
    }
}

（5）指导者(Director)，指导生成器进行具体的产品构建

public class Director {

    /**
     * 生成器对象，通过构造方法传进来
     */
    private Builder builder;

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

    /**
     * 指导生成器构建产品
     */
    public void construct(){
        //1.构建机身
        builder.buildBody();
        //2.构建电池
        builder.buildBattery();
        //3.构建后盖
        builder.buildBackCover();
    }
}

（6）客户端(Client)来测试一下

public class Client {

    public static void main(String[] args) {
        // 创建具体的生成器
        NokiaBuilder builder = new NokiaBuilder();
        // SamsungBuilder builder = new SamsungBuilder();
        // 创建指导者，并将生成器传入
        Director director = new Director(builder);
        // 指导者指导生成器构建产品
        director.construct();
        // 经过以上步骤，此时生成器中的手机对象便构建完毕
        Phone phone = builder.getPhone();
        // 将手机各个组件的品牌输出，看看是否一致
        System.out.println("机身：" + phone.getBody().getBrand());
        System.out.println("电池：" + phone.getBattery().getBrand());
        System.out.println("后盖：" + phone.getBackCover().getBrand());
    }
}

最终输出结果

机身：Nokia
电池：Nokia
后盖：Nokia

那么到此，生成器模式的使用就结束了，你可以发现，如果不使用生成器模式的话，那么在组装手机的时候，在每个具体的实现里都要重复这几个步骤，而生成器模式可以很好的将这些步骤“外包”给别人(指导者)，分工鲜明。

4. 思考生成器模式

我觉得生成器模式最重要的两个角色就是生成器（Builder）和指导者（Director）

• 生成器：生成器定义了一个产品所需的各个部件的构建操作，但是如果它还要负责各个部件组装成一个产品的话，那就有点累了，这样子就不能完全关心自己分内的事情一样。就像是一个老师，除了专门教书外，还要管理学生的生活问题，这样子实在是浪费人才。
• 指导者:指导者知道如何将各个产品的部件组合成一个产品，不管他所接待的生产器给他生成的部件是如何实现的，生成器可以放心地将让指导者去捣鼓它生成的部件。就像是邓爷爷说的“不管白猫黑猫，抓到老鼠就是好猫”，给我一只猫（注意必须是猫哟），不管是黑的白的还是黄的花的，我都会训练它去给你抓老鼠~

不过要注意了，指导者的构建过程必须的统一的、固定不变的，变化的部分还是放在生成器中吧~

以上一部分内容参考至《研磨设计模式》