Android Builder 模式

源码地址

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

使用场景

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

简单实现

说明：举个计算机的简单组装例子。分为构建主板、设置操作系统、设置显示器 3 部分。

计算机抽象类，即 Product 对象

public abstract class Computer {
    protected String mBoard;
    protected String mDisplay;
    protected String mOS;

    public Computer() {

    }
    // 设置主板
    public void setBoard(String board) {
        mBoard = board;
    }
    // 设置显示器
    public void setDisplay(String display) {
        mDisplay = display;
    }
    //设置操作系统
    public abstract void setOS();

    @Override
    public String toString() {
        return "Computer{" +
                "mBoard='" + mBoard + '\'' +
                ", mDisplay='" + mDisplay + '\'' +
                ", mOS='" + mOS + '\'' +
                '}';
    }
}

具体的Computer类，Macbook

public class Macbook extends Computer {
    public Macbook() {
    }

    @Override
    public void setOS() {
        mOS = "Mac OS X 10.10";
    }
}

抽象builder类

public abstract class Builder {
    // 设置主板
    public abstract void buildBoard(String board);
    // 设置显示器
    public abstract void buildDisplay(String display);
    // 设置操作系统
    public abstract void buildOS();
    // 创建 Computer
    public abstract Computer create();
}

具体的builder类，MacbookBuilder

public class MacbookBuilder extends Builder {
    private Computer mComputer = new Macbook();

    @Override
    public void buildBoard(String board) {
        mComputer.setBoard(board);
    }

    @Override
    public void buildDisplay(String display) {
        mComputer.setDisplay(display);
    }

    @Override
    public void buildOS() {
        mComputer.setOS();
    }

    @Override
    public Computer create() {
        return mComputer;
    }
}

负责构造 Computer

public class Director {
    Builder mBuilder;

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

    /**
     * 构建对象
     */
    public void construct(String board, String display) {
        mBuilder.buildBoard(board);
        mBuilder.buildDisplay(display);
        mBuilder.buildOS();
    }
}

测试类

public class Test {
    public static void main(String[] args) {
        // 构建器
        Builder builder = new MacbookBuilder();
        // Director
        Director pcDirector = new Director(builder);
        // 封装构建过程，4核、内存2GB、Mac系统
        pcDirector.construct("Intel 主板", "Retina 显示器");
        // 构建计算机，输出相关信息
        System.out.println("Computer Info : " + builder.create().toString());
    }
}

输出结果：

Computer Info : Computer [mBoard=Intel 主板, mDisplay=Retina 显示器, mOS=Mac OS X 10.10]

上面示例中，通过具体的 MacbookBuilder 来构建 Macbook 对象，二 Director 封装了构建复杂产品对象的过程，对外隐藏构建细节。Builder 与 Director 一起将一个附在对象的构建与它的表示分离，使得同样的构建过程可以创建不同的对象。

在实际开发过程中，Director 角色经常会被省略。而直接使用一个 Builder 来进行对象的组装，这个 Builder 通常为链式调用，对应的每个 setter 方法返回自身，即 return this。其大致代码如下：

new TestBuilder().setA("A").setB("B").create();

Android 源码中的 Builder 模式

最常见的 AlertDialog.Builder。详情请自行搜索。

开发实际使用

此时参考别人写好的 CustomerPopupWindow 类，如下

public class CustomPopupWindow extends PopupWindow {
    private View mContentView;
    private View mParentView;
    private CustomPopupWindowListener mListener;
    private boolean isOutsideTouch;
    private boolean isFocus;
    private Drawable mBackgroundDrawable;
    private int mAnimationStyle;
    private boolean isWrap;

    private CustomPopupWindow(Builder builder) {
        this.mContentView = builder.contentView;
        this.mParentView = builder.parentView;
        this.mListener = builder.listener;
        this.isOutsideTouch = builder.isOutsideTouch;
        this.isFocus = builder.isFocus;
        this.mBackgroundDrawable = builder.backgroundDrawable;
        this.mAnimationStyle = builder.animationStyle;
        this.isWrap = builder.isWrap;
        initLayout();
    }

    public static Builder builder() {
        return new Builder();
    }

    private void initLayout() {
        mListener.initPopupView(mContentView);
        setWidth(isWrap ? LayoutParams.WRAP_CONTENT : LayoutParams.MATCH_PARENT);
        setHeight(isWrap ? LayoutParams.WRAP_CONTENT : LayoutParams.MATCH_PARENT);
        setFocusable(isFocus);
        setOutsideTouchable(isOutsideTouch);
        setBackgroundDrawable(mBackgroundDrawable);
        if (mAnimationStyle != -1)//如果设置了动画则使用动画
            setAnimationStyle(mAnimationStyle);
        setContentView(mContentView);
    }

    /**
     * 获得用于展示popup内容的view
     */
    public View getContentView() {
        return mContentView;
    }

    /**
     * 用于填充contentView,必须传ContextThemeWrapper(比如activity)不然popupwindow要报错
     */
    public static View inflateView(ContextThemeWrapper context, int layoutId) {
        return LayoutInflater.from(context)
                .inflate(layoutId, null);
    }

    public void show() {//默认显示到中间
        if (mParentView == null) {
            showAtLocation(mContentView, Gravity.CENTER | Gravity.CENTER_HORIZONTAL, 0, 0);
        } else {
            showAtLocation(mParentView, Gravity.CENTER | Gravity.CENTER_HORIZONTAL, 0, 0);
        }
    }

    public static final class Builder {
        private View contentView;
        private View parentView;
        private CustomPopupWindowListener listener;
        private boolean isOutsideTouch = true;//默认为true
        private boolean isFocus = true;//默认为true
        private Drawable backgroundDrawable = new ColorDrawable(0x00000000);//默认为透明
        private int animationStyle = -1;
        private boolean isWrap;

        private Builder() {
        }

        public Builder contentView(View contentView) {
            this.contentView = contentView;
            return this;
        }

        public Builder parentView(View parentView) {
            this.parentView = parentView;
            return this;
        }

        public Builder isWrap(boolean isWrap) {
            this.isWrap = isWrap;
            return this;
        }

        public Builder isOutsideTouch(boolean isOutsideTouch) {
            this.isOutsideTouch = isOutsideTouch;
            return this;
        }

        public Builder isFocus(boolean isFocus) {
            this.isFocus = isFocus;
            return this;
        }

        public Builder backgroundDrawable(Drawable backgroundDrawable) {
            this.backgroundDrawable = backgroundDrawable;
            return this;
        }

        public Builder animationStyle(int animationStyle) {
            this.animationStyle = animationStyle;
            return this;
        }
      
        public Builder customListener(CustomPopupWindowListener listener) {
            this.listener = listener;
            return this;
        }

        public CustomPopupWindow build() {
            if (contentView == null)
                throw new IllegalStateException("contentView is required");
            if (listener == null)
                throw new IllegalStateException("CustomPopupWindowListener is required");

            return new CustomPopupWindow(this);
        }
    }

    public interface CustomPopupWindowListener {
        public void initPopupView(View contentView);
    }
}

总结

• 优点
  1. 良好的封装性，使用建造者模式可以使客户端不必知道产品内部组成的细节；
  2. 建造者独立，容易扩展。
• 缺点
  1. 会产生多余的 Builder 对象以及 Director 对象，消耗内存。