设计模式之建造者设计模式

这是设计模式系列的第二篇——建造者设计模式，我希望推送的文章是一个系列的，尽量保持一样的写作风格，尽量把我理解的阐述清楚，关于建造者设计模式主要从以下几个方面来学习，具体如下：

1. 概述
2. 本质
3. 关键概念
4. 具体实现
5. 总结

概述

建造者设计模式(Builder Pattern)属于创建型设计模式，主要用于创建复杂的对象，可将复杂对象的构建过程抽象出来，通过不同实现的构建者和装配者最终组装出不同的对象，可以非常方便的增加不同实现的构建者、组装者而不用修改以前的代码。

本质

建造者设计模式(Builder Pattern)分离了对象子组件的构造过程和组装过程，实现了构建与组装的解耦，不同的构建器相同的组装顺序以及相同的构建器不同的组装顺序都可以创建出不同的对象，使得构建与组装充分解耦，进而实现构建算法与组装算法的解耦，从而实现更好的复用。

关键概念

• 构建者(Builder)：构建不同的子组件且返回子组件或者提供获取复杂对象的方法，将构建过程抽象成接口或抽象类，方便扩展具体的不同的构建者。
• 组装者(Dirctor)：通过某个具体的构建者构建相关的子组件，同时对外提供组成复杂产品对象的方法。

当需要生成复杂对象时，直接通过某个具体的组装者获得想要的具体对象即可，至于组装过程与构建过程使用者不需要关心，分别由具体的组装者与具体的构建者内部完成。当然复杂对象可以理解为具有很多属性的对象。

具体实现

下面以手机的组装过程来说明建造者设计模式的具体实现，产品类如下：

/**
 * 产品
 * @author jzman
 */
public class Phone {
    private Screen screen;
    private Camera camera;
    private Cpu cpu;
    //省略getter、setter、toString 方法
    //...
}

//子组件
class Screen{
    private String name;
    //...
}
//子组件
class Camera{
    private String name;
    //...
}
//子组件
class Cpu{
    private String name;
    //...
}

抽象的构建者：

/**
 * 构建者
 * @author jzman
 */
public interface PhoneBuilder {
    Screen builderScreen();
    Camera builderCamera();
    Cpu builderCpu();
}

具体的构建者：

/**
 * 具体的构建者
 * @author jzman
 */
public class MiPhoneBuilder implements PhoneBuilder{

    @Override
    public Screen builderScreen() {
        System.out.println("构建屏幕...");
        return new Screen("Mi-screen");
    }

    @Override
    public Camera builderCamera() {
        System.out.println("构建相机...");
        return new Camera("Mi-camera");
    }

    @Override
    public Cpu builderCpu() {
        System.out.println("构建屏幕...");
        return new Cpu("Mi-cpu");
    }
}

抽象的组装者：

/**
 * 抽象的组装者
 * @author jzman
 */
public interface PhoneDirector {
    Phone directPhone();
}

具体的构建者：

/**
 * 具体的组装者
 * @author jzman
 */
public class MiPhoneDirector implements PhoneDirector{
    private PhoneBuilder builder;
    
    public MiPhoneDirector(PhoneBuilder builder) {
        this.builder = builder;
    }

    @Override
    public Phone directPhone() {
        Phone phone = new Phone();
        phone.setScreen(builder.builderScreen());
        phone.setCamera(builder.builderCamera());
        phone.setCpu(builder.builderCpu());
        return phone;
    }
}

使用者直接通过某个具体的组装者获取最终的产品，具体如下：

public class Client {
    public static void main(String[] args) {
        PhoneBuilder builder = new MiPhoneBuilder();
        MiPhoneDirector director = new MiPhoneDirector(builder);
        Phone phone = director.directPhone();
        System.out.println(phone);
    }
}

执行结果如下：

构建屏幕...
构建相机...
构建屏幕...
Phone [screen=Screen [name=Mi-screen], camera=Camera [name=Mi-camera], cpu=Cpu [name=Mi-cpu]]

最终，使用者通过具体的组装者 MiPhoneDirector 组装出一个具有明显组装特征的手机，即一个屏幕是 Mi-screen 、相机是 Mi-camera、CPU 是 Mi-cpu 的手机。

总结

建造者设计模式(Builder Pattern) 一般用于具有共同特性的复杂对象，其对象本身与构建、组装过程分离，可做到复杂对象属性的可配置，当然，如果复杂对象内部过于复杂，势必会需要创建更多的构建者类，使得构建过程繁琐，我觉得开发中使用建造者设计模式主要用来做一些封装，使得代码写起来更灵活，如 Picasso、Glide 的 API 就有建造者设计模式的使用，使得复杂对象的一些属性可以做到可配置，非常方便。

可以选择关注微信公众号：jzman-blog 获取最新更新，一起交流学习!