建造者模式

一定义

将一个复杂对象的构建和它的表示分离，使同样的构建构成可以创建不同的表示。
建造者模式也是属于创建型模型，是23种GOF之一。
从定义可以看出，建造者模式适用于一个复杂的对象的建造，而且在建造的过程中，客户端不必知道产品内部组成的细节。

二使用场景

建造者模式适用于一个具有较多的零件的复杂产品的创建过程，由于需求的变化，组成这个复杂产品的各个零件经常猛烈变化，但是它们的组合方式却相对稳定。
建造者模式适用于以下几种场景：

1相同的方法，不同的执行顺序，产生不同的结果时
2 多个部件或零件，都可以装配到一个对象中，但是产生的结果又不相同。
3 产品类非常复杂，或者产品类中的调用顺序不同产生不同的作用。
4 当初始化一个对象特别复杂，参数多，而且很多参数都具有默认值时。

三模式结构

建造者模式主要有四个角色

Product:要创建的产品类对象
Builder：建造者的抽象类，规范产品对象的各个组成部分的建造，一般由子类实现具体的建造过程。
ConcreteBuilder:具体的Builder类，根据不同的业务逻辑，具体化对象的各个组成部分的创建。
Director：调用具体的建造者，来创建对象的各个部分，在指导者中不涉及具体产品的信息，只负责保证对象各部分完整创建或按某种顺序创建。

四模拟场景

我们以计算机的组装过程为例，使用建造者模式，首先我们简化计算机的组装过程，这里只考虑三个主要部件，分别为主板，显示器和操作系统，任何计算机都是有以上三个部分组成的。

1 首先定义产品类

我们以MacBook产品为例

/*
 * 产品类，Product角色
 * @author Jackson
 * @version 1.0.0
 * since 2018 12 24
 */
public class MacBook {

    private String mBoard;
    private String mDisplay;
    private String mOs;

    public String getBoard() {
        return mBoard;
    }

    public void setBoard(String board) {
        mBoard = board;
    }

    public String getDisplay() {
        return mDisplay;
    }

    public void setDisplay(String display) {
        mDisplay = display;
    }


    public String getOs() {
        return mOs;
    }

    public void setOs(String os) {
        mOs = os;
    }

    @Override
    public String toString() {
        return "MacBook:" + "mBoard=" + mBoard + ",mDisplay=" + mDisplay + ",mOs=" + mOs;
    }


}

2 构建抽象的Builder类

抽象的Builder类主要是建造MacBook产品的各个组成部分，并返回MacBook产品。

/*
 * 抽象Builder类
 * @author Jackson
 * @version 1.0.0
 * since 2018 12 24
 */
public abstract class Builder {
    // 设置主板
    public abstract void builderBoard(String board);

    // 设置显示器
    public abstract void builderDisplay(String display);

    // 设置操作系统
    public abstract void builderOs(String os);

    // 创建Computer
    public abstract MacBook getComputer();
}

3 具体的Builder类

具体实例化各个部分的创建

/*
 * 具体的Builder类
 * @author Jackson
 * @version 1.0.0
 * since 2018 12 24
 */
public class MacbookBulder extends Builder{


    private MacBook mMacBook=new MacBook();

    @Override
    public void builderBoard(String board) {
        mMacBook.setBoard(board);

    }

    @Override
    public void builderDisplay(String display) {
        mMacBook.setDisplay(display);

    }

    @Override
    public void builderOs(String os) {
        mMacBook.setOs(os);

    }

    @Override
    public MacBook getComputer() {
        return mMacBook;
    }
}

4 Director类

Director类的主要作用是调用具体的builder，来构建对象的各个部分，Director类起到封装作用，避免高层模块深入到建造者内部的实现类。

public class Director {

    Builder mBuilder=null;

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

    public void constract(String board,String display,String os){
        mBuilder.builderBoard(board);
        mBuilder.builderDisplay(display);
        mBuilder.builderOs(os);
    }
}

5 客户端代码

  Builder builder=new MacbookBulder();
  Director director=new Director(builder);
  director.constract("英特尔主板","Retina显示器","Mac OS X系统");
  System.out.println(builder.getComputer().toString());

从上面的代码可以看到，MacBook产品是通过MacBookBuilder构建的，Director封装了构建复杂产品对象的过程，对外隐藏了构建细节。Builder和Director一起将一个复杂的对象的构建与表示分离。

实际在开发中，Director常常被忽略，而是直接通过Builder的方式链式组装，同是，builder是一个静态内部类。

public class ThinkPad {

    private String mBoard;
    private String mDisplay;
    private String mOs;

    private ThinkPad(Builder builder){
        this.mBoard=builder.mBoard;
        this.mDisplay=builder.mDisplay;
        this.mOs=builder.mOs;
    }

    public String getBoard() {
        return mBoard;
    }
    
    public String getDisplay() {
        return mDisplay;
    }
    

    public String getOs() {
        return mOs;
    }

    
    static class Builder{

        private String mBoard;
        private String mDisplay;
        private String mOs;

        public Builder setBoard(String board){
            this.mBoard=board;
            return this;
        }

        public Builder setDisplay(String display){
            this.mDisplay=display;
            return this;
        }

        public Builder setOs(String os){
            this.mOs=os;
            return this;
        }

        public ThinkPad builder(){
            return new ThinkPad(this);
        }
    }
}

客户端通过链式调用组装方法。

ThinkPad thinkPad=
   new ThinkPad.Builder().setBoard("Intel").setDisplay("JDI").setOs("Windows 10").builder();

 System.out.println("ThinkPad:"+"board="+thinkPad.getBoard()+" 
display="+thinkPad.getDisplay()+" os="+thinkPad.getOs());

在Android中，最常用的使用了Builder模式的事AlertDialog，AlertDialog的是哦用那个方法如下：

new AlertDialog.Builder(this)
                .setIcon(R.mipmap.ic_launcher)
                .setTitle("Title")
                .setPositiveButton("确认", new DialogInterface.OnClickListener() {
                    @Override
                    public void onClick(DialogInterface dialog, int which) {
                        
                    }
                })
                .setNegativeButton("取消", new DialogInterface.OnClickListener() {
                    @Override
                    public void onClick(DialogInterface dialog, int which) {
                        
                    }
                })
                .create()
                .show();

查看AlertDialog的源码可以看到，

package android.support.v7.app;

import static android.support.annotation.RestrictTo.Scope.LIBRARY_GROUP;

import android.app.Dialog;
import android.content.Context;
import android.content.DialogInterface;
import android.database.Cursor;
import android.graphics.drawable.Drawable;
import android.os.Bundle;
import android.os.Message;
import android.support.annotation.ArrayRes;
import android.support.annotation.AttrRes;
import android.support.annotation.DrawableRes;
import android.support.annotation.NonNull;
import android.support.annotation.Nullable;
import android.support.annotation.RestrictTo;
import android.support.annotation.StringRes;
import android.support.annotation.StyleRes;
import android.support.v7.appcompat.R;
import android.util.TypedValue;
import android.view.ContextThemeWrapper;
import android.view.KeyEvent;
import android.view.View;
import android.widget.AdapterView;
import android.widget.Button;
import android.widget.ListAdapter;
import android.widget.ListView;


public class AlertDialog extends AppCompatDialog implements DialogInterface {

    final AlertController mAlert;

    /**
     * No layout hint.
     */
    static final int LAYOUT_HINT_NONE = 0;

    /**
     * Hint layout to the side.
     */
    static final int LAYOUT_HINT_SIDE = 1;


 /**
  * 构造方法
   */

    protected AlertDialog(@NonNull Context context) {
        this(context, 0);
    }

   
    protected AlertDialog(@NonNull Context context, @StyleRes int themeResId) {
        super(context, resolveDialogTheme(context, themeResId));
        mAlert = new AlertController(getContext(), this, getWindow());
    }

    protected AlertDialog(@NonNull Context context, boolean cancelable,
            @Nullable OnCancelListener cancelListener) {
        this(context, 0);
        setCancelable(cancelable);
        setOnCancelListener(cancelListener);
    }

   .............................省略..........

   ----------------------------------  获取属性 -------------------------------------------------
    public Button getButton(int whichButton) {
        return mAlert.getButton(whichButton);
    }

    @Override
    public void setTitle(CharSequence title) {
        super.setTitle(title);
        mAlert.setTitle(title);
    }
    public void setCustomTitle(View customTitleView) {
        mAlert.setCustomTitle(customTitleView);
    }
    public void setMessage(CharSequence message) {
        mAlert.setMessage(message);
    }

    public void setView(View view) {
        mAlert.setView(view);
    }

  .............................省略..........

   ----------------------------------  内部静态builder ------------------------------------------------
    public static class Builder {
        private final AlertController.AlertParams P;
        private final int mTheme;

        public Builder(@NonNull Context context) {
            this(context, resolveDialogTheme(context, 0));
        }

        public Builder(@NonNull Context context, @StyleRes int themeResId) {
            P = new AlertController.AlertParams(new ContextThemeWrapper(
                    context, resolveDialogTheme(context, themeResId)));
            mTheme = themeResId;
        }
        @NonNull
        public Context getContext() {
            return P.mContext;
        }

  .............................省略..........
        ----------------------------------  设置属性 -------------------------------------------------
        public Builder setTitle(@StringRes int titleId) {
            P.mTitle = P.mContext.getText(titleId);
            return this;
        }

        public Builder setTitle(@Nullable CharSequence title) {
            P.mTitle = title;
            return this;
        }

        public Builder setCustomTitle(@Nullable View customTitleView) {
            P.mCustomTitleView = customTitleView;
            return this;
        }

        public Builder setMessage(@StringRes int messageId) {
            P.mMessage = P.mContext.getText(messageId);
            return this;
        }

        public Builder setMessage(@Nullable CharSequence message) {
            P.mMessage = message;
            return this;
        }

     .............................省略..........

        public AlertDialog create() {
            // We can't use Dialog's 3-arg constructor with the createThemeContextWrapper param,
            // so we always have to re-set the 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;
        }

   
        public AlertDialog show() {
            final AlertDialog dialog = create();
            dialog.show();
            return dialog;
        }
    }

}

建造者模式

一 定义

二 使用场景

三 模式结构

四 模拟场景