建造者模式在Android组件化中的运用

一、简介

建造者模式（Builder Pattern）使用多个简单的对象一步一步构建成一个复杂的对象。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。通过建造者模式，可以让一个包含多构造函数，多可选参数和滥用setters方法的复杂事物简单化。

假设你有一个包含大量属性的类（类新建之后就不可改变），就像下面的User类一样。

public class User {
    private final String firstName;    //required
    private final String lastName;    //required
    private final int age;    //optional
    private final String phone;    //optional
    private final String address;    //optional
    ...
}

现在想象一下，在你的类中有一些属性是必须的，有一些是可选的。你会如何创建这个类的实例？因为所有的属性都被声明成final类型，所以你必须在构造方法中设置它们，但是你也想让这个类的客户端有忽略可选属性的机会。

1.1 方案一

一个首先想到的可选方案是提供多个构造方法。第一个构造方法是只接收必须属性作为参数，第二个是接收所有必须属性和第一个可选属性，第三个是接收所有必须属性和两个可选属性，依次类推。实现起来如下所示：

public User(String firstName, String lastName) {
    this(firstName, lastName, 0);
}

public User(String firstName, String lastName, int age) {
    this(firstName, lastName, age, '');
}

public User(String firstName, String lastName, int age, String phone) {
    this(firstName, lastName, age, phone, '');
}

public User(String firstName, String lastName, int age, String phone, String address) {
    this.firstName = firstName;
    this.lastName = lastName;
    this.age = age;
    this.phone = phone;
    this.address = address;
}

1.2 方案二

遵循JavaBean的规则，有一个默认的无参构造方法并且都有getter和setter方法。就像这样：

public class User {
    private String firstName; // required
    private String lastName; // required
    private int age; // optional
    private String phone; // optional
    private String address;  //optional

    public String getFirstName() {
        return firstName;
    }
    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }
    public String getLastName() {
        return lastName;
    }
    public void setLastName(String lastName) {
        this.lastName = lastName;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getPhone() {
        return phone;
    }
    public void setPhone(String phone) {
        this.phone = phone;
    }
    public String getAddress() {
        return address;
    }
    public void setAddress(String address) {
        this.address = address;
    }
}

这种方法看起来很容易阅读和维护。在客户端里我可以只创建一个空对象，然后只设置那些我感兴趣的属性。那么，这种方法有什么问题？这种解决方案有两个主要的问题。

• 第一个问题是该类的实例状态不固定。如果你想创建一个User对象，该对象的5个属性都要赋值，那么直到所有的setXX方法都被调用之前，该对象都没有一个完整的状态。这意味着在该对象状态还不完整的时候，一部分客户端程序可能看见这个对象并且以为该对象已经构造完成。
• 第二个不足是User类是易变的。你将会失去不可变对象带来的所有优点。

1.3 方案三

建造者模式实现

public class User {
    private final String firstName; // required
    private final String lastName; // required
    private final int age; // optional
    private final String phone; // optional
    private final String address; // optional

    private User(UserBuilder builder) {
        this.firstName = builder.firstName;
        this.lastName = builder.lastName;
        this.age = builder.age;
        this.phone = builder.phone;
        this.address = builder.address;
    }

    public String getFirstName() {
        return firstName;
    }

    public String getLastName() {
        return lastName;
    }

    public int getAge() {
        return age;
    }

    public String getPhone() {
        return phone;
    }

    public String getAddress() {
        return address;
    }

    public static class UserBuilder {
        private final String firstName;
        private final String lastName;
        private int age;
        private String phone;
        private String address;

        public UserBuilder(String firstName, String lastName) {
            this.firstName = firstName;
            this.lastName = lastName;
        }

        public UserBuilder age(int age) {
            this.age = age;
            return this;
        }

        public UserBuilder phone(String phone) {
            this.phone = phone;
            return this;
        }

        public UserBuilder address(String address) {
            this.address = address;
            return this;
        }

        public User build() {
            return new User(this);
        }

    }
}

使用建造者模式有如下优势：

• User构造方法是私有的，这意味着该类不能在客户端代码里直接实例化。
• 该类是不可变的。所有属性都是final类型的，在构造方法里面被赋值。另外，我们只为它们提供了getter方法。
• builder类使用流式接口风格，让客户端代码阅读起来更容易。
• builder类构造方法只接收必须属性，为了确保这些属性在构造方法里赋值，只有这些属性被定义成final类型。
• 现在，试图创建一个新的User对象的客户端代码看起来如何那？让我们来看一下：

public User getUser() {
    return new User.UserBuilder('Jhon', 'Doe')
    .age(30)
    .phone('1234567')
    .address('Fake address 1234')
    .build();
}

需要注意的是要在builder的参数拷贝到建造对象之后再验证参数，这样验证的就是建造对象的字段，而不是builder的字段。这么做的原因是builder类不是线程安全的，如果我们在创建真正的对象之前验证参数，参数值可能被另一个线程在参数验证完和参数被拷贝完成之间的某个时间修改。这段时间周期被称作“脆弱之窗”。

正确姿势：

public User build() {
    User user = new user(this);
    if (user.getAge() > 120) {  // user的成员变量user.getAge()
        throw new IllegalStateException(“Age out of range”); // thread-safe
    }
    return user;
}

错误姿势：

public User build() {
    if (age > 120) {  // UserBuilder的成员变量age
        throw new IllegalStateException(“Age out of range”); // bad, not thread-safe
    }
    // This is the window of opportunity for a second thread to modify the value of age
    return new User(this);
}

除了上述使用建造者模式的优点之外，建造者模式还有的一个优点是builder可以作为参数传递给一个方法，让该方法拥有为客户端创建一个或者多个对象的能力，而不需要知道创建对象的任何细节。为了这么做你可能通常需要一个如下所示的简单接口：

public interface Builder<T> {
    T build();
}

借用之前的User例子，UserBuilder类可以实现Builder。如此，我们可以有如下的代码：

UserCollection buildUserCollection(Builder<? extends User> userBuilder){...}

例如：

public List<User> buildUserList(Builder<User> userBuilder){
    List<User> mList = new ArrayList<>();
    for (int i = 0; i < 5; i ++) {
        mList.add(userBuilder.build());
    }

    return mList;
}

二、实践

2.1 Android源码中(AlertDialog.Builder)

  AlertDialog.Builder builder = new AlertDialog.Builder(this);
  builder.setTitle("Dialog");
  builder.setMessage("这是 android.support.v7.app.AlertDialog 中的样式");
  builder.setNegativeButton("取消", null);
  builder.setPositiveButton("确定", null);
  builder.show();

2.2 开源库(UniversalImageLoader,Glide)初始化配置

    public static Glide get(Context context) {
        if (glide == null) {
            synchronized (Glide.class) {
                if (glide == null) {
                    Context applicationContext = context.getApplicationContext();
                    List<GlideModule> modules = new ManifestParser(applicationContext).parse();

                    GlideBuilder builder = new GlideBuilder(applicationContext);
                    for (GlideModule module : modules) {
                        module.applyOptions(applicationContext, builder);
                    }
                    glide = builder.createGlide();
                    for (GlideModule module : modules) {
                        module.registerComponents(applicationContext, glide);
                    }
                }
            }
        }

        return glide;
    }

2.3 通用组件封装

在我们的项目开发过程中，会包含很多的功能。如二维码扫描、图片选择、地址选择等。（1）起初使用这些功能，我们直接在应用工程中开发功能代码，需要修改的话直接改主工程代码；

（2）明显第一种方式对于复用不是太友好，于是我们将组件抽成module，通过module依赖的形式引用。module提供config接口供外部实现，在实现类中配置参数，实现自己需要的效果。如下所示：

    public class ScanModuleConfigImpl implements IScanModuleConfig {
        @Override
        public int getMaskColor() {
            return ResourcesUtils.getColor(R.color.scan_mask);
        }

        @Override
        public int getAngleColor() {
            return ResourcesUtils.getColor(R.color.white);
        }

        @Override
        public int getTitleBarHeight() {
            return 70;
        }

        @Override
        public float getTitleTextSize() {
            return 18;
        }

        @Override
        public int getTipAlpha() {
            return 0xff;
        }

        @Override
        public Drawable getSlideIcon() {
            return ResourcesUtils.getDrawable(R.drawable.ic_scan_slider);
        }

        @Override
        public String getCustomTitle() {
            return ResourcesUtils.getString(R.string.scan_title);
        }

        @Override
        public String getTip() {
            return  ResourcesUtils.getString(R.string.scan_tips);
        }

        @Override
        public int getTipMargin() {
            return 33;
        }

        @Override
        public int getScanFrameTopMargin() {
            return -1;
        }

        @Override
        public int getScanFrameLeftMargin() {
            return -1;
        }

        @Override
        public int getScanFrameRightMargin() {
            return -1;
        }

        @Override
        public boolean isRequestFullScreen() {
            return true;
        }
    }

（3）第二种实现方式已经很灵活，但是书写起来还是略微复杂，且不利于阅读。想到建造者模式：将一个复杂的构建与其表示相分离，使得同样的构建过程可以创建不同的表示。考虑到这些组件基本都是功能独立且与业务解耦，我们其实可以将这样组件看成是一个复杂对象。核心功能是不变的部分（如二维码扫码组件的扫码功能和图片选择器的图片展示），因为在不同应用中使用，视觉和一些细节会有差异，这样我们可以将这些视为可变部分。如下图所示，是基于建造者模式设计的二维码扫描组件。

如上图所示，QrScan是组件提供给外部操作组件的操作类。用户通过设置QrScanConfigration来初始化得到不同表现形式的二维码扫描组件，这里QrScanConfigration对象是基于建造者模式构建的。在组件内部，通过QrScanProxy统一分发处理QrScanConfigration携带的配置信息。基于建造者模式，封装组件，并通过Maven管理，可通过如下方式使用组件：

• build.gradle配置中导入组件

    compile 'com.netease.scan:lib-qr-scan:1.0.0'
  

• AndroidManifest配置

    // 设置权限
    <uses-permission android:name="android.permission.VIBRATE"/>
    <uses-permission android:name="android.permission.CAMERA" />
    <uses-feature android:name="android.hardware.camera" />
    <uses-feature android:name="android.hardware.camera.autofocus" />
  
    // 注册activity
    <activity android:name="com.netease.scan.ui.CaptureActivity"
            android:screenOrientation="portrait"
            android:theme="@style/Theme.AppCompat.NoActionBar"/>
  

• 初始化
  在需要使用此组件的Activity的onCreate方法中，或者在自定义Application的onCreate方法中初始化。

    public class MyApplication extends Application {
        @Override
        public void onCreate() {
            super.onCreate();
  
    //        // 默认配置
    //        QrScanConfiguration configuration = QrScanConfiguration.createDefault(this);
  
            // 自定义配置
            QrScanConfiguration configuration = new QrScanConfiguration.Builder(this)
                    .setTitleHeight(53)
                    .setTitleText("来扫一扫")
                    .setTitleTextSize(18)
                    .setTitleTextColor(R.color.white)
                    .setTipText("将二维码放入框内扫描~")
                    .setTipTextSize(14)
                    .setTipMarginTop(40)
                    .setTipTextColor(R.color.white)
                    .setSlideIcon(R.mipmap.capture_add_scanning)
                    .setAngleColor(R.color.white)
                    .setMaskColor(R.color.black_80)
                    .setScanFrameRectRate((float) 0.8)
                    .build();
            QrScan.getInstance().init(configuration);
        }
    }
  

• 启动组件相关方法（在QrScan.java类中已经提供）

  • 开启扫描界面

      public void launchScan(Context context, IScanModuleCallBack callback) {
          QrScanProxy.getInstance().setCallBack(callback);
          CaptureActivity.launch(context);
      }
    

  • 关闭扫描界面

      public void finishScan(CaptureActivity activity) {
          activity.finish();
      }
    

  • 重启扫描功能

      public void restartScan(CaptureActivity activity) {
          activity.restartCamera();
      }
    

• 启动扫描并处理扫描结果

    QrScan.getInstance().launchScan(MainActivity.this, new IScanModuleCallBack() {
                        @Override
                        public void OnReceiveDecodeResult(final Context context, String result) {
                            mCaptureContext = (CaptureActivity)context;
  
                            AlertDialog dialog = new AlertDialog.Builder(mCaptureContext)
                                    .setMessage(result)
                                    .setCancelable(false)
                                    .setNegativeButton("取消", new DialogInterface.OnClickListener() {
                                        @Override
                                        public void onClick(DialogInterface dialog, int which) {
                                            dialog.dismiss();
                                            QrScan.getInstance().restartScan(mCaptureContext);
                                        }
                                    })
                                    .setPositiveButton("关闭", new DialogInterface.OnClickListener() {
                                        @Override
                                        public void onClick(DialogInterface dialog, int which) {
                                            dialog.dismiss();
                                            QrScan.getInstance().finishScan(mCaptureContext);
                                        }
                                    })
                                    .create();
                            dialog.show();
                        }
                    });
  

  最终运行效果如下图所示：                                                            

类似的，图片选择器，也可拆分可变和不可变部分，基于建造者模式封装实现。

• 调用

 ImageSelectorConfiguration configuration = new ImageSelectorConfiguration.Builder(this)
                .setMaxSelectNum(9)
                .setSpanCount(4)
                .setSelectMode(ImageSelectorConstant.MODE_MULTIPLE)
                .setTitleHeight(48)
                .build();

• 实现效果

以上是本人在项目开发过程中关于Builder模式实践总结的一些思考，可能会有考虑不周的地方，欢迎大家批评指正。关于组件复用，大家如果有更好的方式，期待能够一起交流讨论～

三、参考

1. 建造者模式实践
2. javacodegeeks

附录

1. 二维码扫描组件源码
2. 图片选择器源码

本文来自网易实践者社区，经作者郑睿授权发布。