建造者模式

2023-04-25  本文已影响0人  长点点

一、什么是建造者模式

建造者模式（Builder Pattern）是一种创建型设计模式，它可以将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的展示。建造者模式可以让用户在不知道内部构建细节的情况下，更精细地控制对象的构造流程。

建造者模式的主要角色有：

建造者模式uml图

二、安卓源码中的实例

安卓开发中经常使用到建造者模式，例如AlertDialog、Notification、StringBuilder等类都是采用了建造者模式来创建对象。下面以AlertDialog为例，分析其源码实现。

AlertDialog是一个常用的对话框类，它可以显示标题、消息、图标、按钮等组件，也可以自定义布局。AlertDialog的构造方法是私有的，不能直接创建对象，而是通过Builder类来构建。Builder类是AlertDialog的一个静态内部类，它实现了抽象建造者的角色，提供了各种设置对话框属性的方法，例如setTitle、setMessage、setIcon、setPositiveButton等。这些方法都返回Builder对象本身，实现了链式调用。Builder类还提供了一个create方法，用于返回一个AlertDialog对象。这个方法会调用AlertDialog的私有构造方法，并将Builder对象作为参数传入。在AlertDialog的构造方法中，会根据Builder对象的属性来设置对话框的各个组件，并创建一个AlertController对象来管理对话框的显示和交互。AlertController类相当于指挥者的角色，它负责调用合适的Builder方法来组合对话框。

下面是AlertDialog和Builder类的部分源码：

public class AlertDialog extends Dialog implements DialogInterface {
    // 省略其他代码

    // 私有构造方法
    protected AlertDialog(Context context, int themeResId) {
        super(context, resolveDialogTheme(context, themeResId));
        mWindow.alwaysReadCloseOnTouchAttr();
        mAlert = new AlertController(getContext(), this, getWindow());
    }

    // 静态内部类Builder
    public static class Builder {
        // 产品对象
        private final AlertController.AlertParams P;
        // 主题资源ID
        private int mTheme;

        // 构造方法
        public Builder(Context context) {
            this(context, resolveDialogTheme(context, 0));
        }

        // 构造方法
        public Builder(Context context, int themeResId) {
            P = new AlertController.AlertParams(new ContextThemeWrapper(
                    context, resolveDialogTheme(context, themeResId)));
            mTheme = themeResId;
        }

        // 设置标题
        public Builder setTitle(@StringRes int titleId) {
            P.mTitle = P.mContext.getText(titleId);
            return this;
        }

        // 设置标题
        public Builder setTitle(CharSequence title) {
            P.mTitle = title;
            return this;
        }

        // 省略其他设置方法

        // 创建对话框对象
        public AlertDialog create() {
            // Context has already been wrapped with the appropriate theme.
            final AlertDialog dialog = new AlertDialog(P.mContext, mTheme);
            P.apply(dialog.mAlert);
            dialog.setCancelable(P.mCancelable);
            if (P.mCancelable) {
                dialog.setCanceledOnTouchOutside(true);
            }
            dialog.setOnCancelListener(P.mOnCancelListener);
            dialog.setOnDismissListener(P.mOnDismissListener);
            if (P.mOnKeyListener != null) {
                dialog.setOnKeyListener(P.mOnKeyListener);
            }
            return dialog;
        }
    }
}

使用Builder类创建AlertDialog对象的示例代码如下：

AlertDialog.Builder builder = new AlertDialog.Builder(this);
builder.setTitle("提示")
       .setMessage("确定要退出吗？")
       .setIcon(R.drawable.ic_launcher)
       .setPositiveButton("确定", new DialogInterface.OnClickListener() {
           @Override
           public void onClick(DialogInterface dialog, int which) {
               finish();
           }
       })
       .setNegativeButton("取消", null)
       .create()
       .show();

从上面的代码可以看出，使用建造者模式可以让用户更灵活地构建对话框对象，而不需要关心对话框的内部实现细节。

三、Kotlin实现建造者模式

下面以一个电脑类为例，举例如何用Kotlin实现建造者模式。

我们要根据不同的配置来构建一个电脑类的实例，希望可以自由配置电脑CPU、RAM、显示器、键盘以及USB端口，从而组装出不同的Computer实例。如果使用Java来实现的话，最好的选择就是使用构建者模式。但是如果使用Kotlin来实现的话，有一个更简单的方法，那就是使用命名参数和默认参数。

命名参数是指在调用函数时，可以通过参数名来指定参数值，而不需要按照参数顺序来传递。默认参数是指在定义函数时，可以给参数指定一个默认值，这样在调用函数时，如果没有传递该参数，就会使用默认值。利用这两个特性，我们可以直接在电脑类的主构造函数中定义所有的属性，并给它们赋予默认值。然后在创建电脑对象时，只需要传递需要修改的属性即可。这样就避免了定义一个额外的Builder类，并且代码更加简洁。

下面是电脑类的Kotlin实现：

class Computer(
    val cpu: String = "Intel Core i5",
    val ram: Int = 8,
    val monitor: String = "Dell 24寸",
    val keyboard: String = "罗技无线键盘",
    val usb: Int = 4
) {
    override fun toString(): String {
        return "Computer(cpu='$cpu', ram=$ram, monitor='$monitor', keyboard='$keyboard', usb=$usb)"
    }
}

创建电脑对象的示例代码如下：

val computer1 = Computer()
println(computer1)

val computer2 = Computer(cpu = "AMD Ryzen 7", ram = 16, monitor = "华硕 27```markdown
寸\") .build()
println(computer2)

val computer3 = Computer(keyboard = "雷柏机械键盘", usb = 6) .build()
println(computer3)

输出结果如下：

Computer(cpu='Intel Core i5', ram=8, monitor='Dell 24寸', keyboard='罗技无线键盘', usb=4)
Computer(cpu='AMD Ryzen 7', ram=16, monitor='华硕 27寸', keyboard='罗技无线键盘', usb=4)
Computer(cpu='Intel Core i5', ram=8, monitor='Dell 24寸', keyboard='雷柏机械键盘', usb=6)

从上面的代码可以看出，使用Kotlin的命名参数和默认参数，可以非常方便地实现建造者模式，而不需要定义额外的Builder类。当然，这种方法也有一些局限性，例如不能保证对象的不可变性，不能控制对象的创建顺序，不能实现复杂的构造逻辑等。因此，在实际开发中，需要根据具体的需求和场景来选择合适的方法。

四、Java实现建造者模式

下面以一个计算机类为例，举例如何用Java实现建造者模式。

我们要根据不同的配置来构建一个计算机类的实例，希望可以自由配置计算机CPU、RAM、硬盘、显卡、主板、电源等部件，从而组装出不同的Computer实例。如果使用Java的构造方法或者setter方法来实现的话，会有以下几个问题：

因此，使用建造者模式可以解决这些问题，让用户更方便地构建复杂对象。具体步骤如下：

下面是计算机类和Builder类的部分源码：

public class Computer {
    // 必选属性
    private String cpu;
    private String ram;
    // 可选属性
    private String hardDisk;
    private String keyboard;
    private String mouse;

    // 私有构造方法
    private Computer(Builder builder) {
        this.cpu = builder.cpu;
        this.ram = builder.ram;
        this.hardDisk = builder.hardDisk;
        this.keyboard = builder.keyboard;
        this.mouse = builder.mouse;
    }

    // 静态内部类Builder
    public static class Builder {
        // 必选属性
        private String cpu;
        private String ram;
        // 可选属性
        private String hardDisk;
        private String keyboard;
        private String mouse;

        // 公有构造方法
        public Builder(String cpu, String ram) {
            this.cpu = cpu;
            this.ram = ram;
        }

        // 设置硬盘
        public Builder setHardDisk(String hardDisk) {
            this.hardDisk = hardDisk;
            return this;
        }

        // 设置键盘
        public Builder setKeyboard(String keyboard) {
            this.keyboard = keyboard;
            return this;
        }

        // 设置鼠标
        public Builder setMouse(String mouse) {
            this.mouse = mouse;
            return this;
        }

        // 返回产品对象
        public Computer build() {
            return new Computer(this);
        }
    }
}

创建计算机对象的示例代码如下：

Computer computer1 = new Computer.Builder("Intel Core i7", 16).build();
System.out.println(computer1);

Computer computer2 = new Computer.Builder("AMD Ryzen 9", 32)
                    .setHardDisk("Samsung SSD 1TB")
                    .setKeyboard("Logitech G915")
                    .setMouse("Logitech G502")
                    .build();
System.out.println(computer2);

输出结果如下：

Computer{cpu='Intel Core i7', ram=16, hardDisk='null', keyboard='null', mouse='null'}
Computer{cpu='AMD Ryzen 9', ram=32, hardDisk='Samsung SSD 1TB', keyboard='Logitech G915', mouse='Logitech G502'}

从上面的代码可以看出，使用建造者模式可以让用户更清晰地构建复杂对象，而不需要关心对象的内部实现细节。同时，使用Builder类可以保证对象的不可变性和线程安全性，以及对象创建过程的顺序性和逻辑性。

五、优缺点和使用场景

语言 优点 缺点 使用场景
Kotlin 代码简洁，调用方便，实现灵活 对象可变，不能保证线程安全，不能控制创建顺序和逻辑 需要创建简单、灵活、可变的对象
Java 对象不可变，可以保证线程安全，可以控制创建顺序和逻辑 代码冗长，调用繁琐，实现固定 需要创建复杂、固定、不可变的对象
Kotlin的优点：
Kotlin的缺点：
Kotlin适用于以下场景：
Java的优点：
Java的缺点：
Java适用于以下场景：

六、与其他相似设计模式对比

设计模式 相似之处 不同之处 使用场景
建造者模式 都是创建型模式，都可以将对象的创建过程封装起来，对客户端隐藏细节 建造者模式有指导者这个角色，直接返回一个组装好的复杂产品，而其他创建型模式返回的是单一或相关的产品，建造者模式更关注产品的构造过程和表示，而其他创建型模式更关注产品的创建 建造者模式适用于创建复杂对象的情况，特别是当对象的构造过程涉及到多个步骤或者条件判断时
工厂方法模式 都是创建型模式，都可以将对象的创建过程封装起来，对客户端隐藏细节 工厂方法模式只关注对象的创建，而建造者模式关注对象的构造过程和表示，工厂方法模式只有一个抽象产品类，而建造者模式有多个部件类 工厂方法模式适用于创建单一产品的情况，建造者模式适用于创建复杂产品的情况
抽象工厂模式 都是创建型模式，都可以将对象的创建过程封装起来，对客户端隐藏细节 抽象工厂模式返回一系列相关的产品，这些产品位于不同的产品等级结构，构成了一个产品族，而建造者模式返回一个组装好的复杂产品，抽象工厂模式没有指导者这个角色 抽象工厂模式适用于创建多个产品族的情况，建造者模式适用于创建复杂产品的情况
原型模式 都是创建型模式，都可以将对象的创建过程封装起来，对客户端隐藏细节 原型模式通过复制一个现有的对象生成新对象，而建造者模式通过调用不同的方法生成新对象，原型模式不需要指导者和抽象建造者这两个角色 原型模式适用于创建重复或相似的对象的情况，建造者模式适用于创建复杂对象的情况
上一篇下一篇

猜你喜欢

热点阅读