本文介绍了Android中的建造者模式，解释了建造者模式的概念，用于将复杂对象的构建与表示分离。以Paginate开源库为例，详细阐述了抽象建造者、具体建造者、导演者和产品角色在代码中的体现，展示了如何在实际开发中运用建造者模式提高代码的封装性和可读性。
前言
最近在进行Android编程的时候，通过自己的体会和查看学习别人的代码对Android建造者模式有了自己的理解，这里就做一个笔记，以供参考。建造者模式是一种常见的软件设计模式，因为我目前主要在Android平台上进行编程，所以就用Android代码举例子。如果写的不是很详细的话，请见谅。
什么是建造者模式
首先，什么是建造者模式。建造者模式是设计模式的一种，它将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
如下图[百度百科]：
建造者模式一般有四个角色：
- 抽象建造者（Builder）角色：给出一个抽象接口，以规范产品对象的各个组成成分的建造。
- 具体建造者（ConcreteBuilder）角色：担任这个角色的是与应用程序紧密相关的一些类，它们在应用程序调用下创建产品的实例。这个角色要完成的任务包括：1.实现抽象建造者Builder所声明的接口，给出一步一步地完成创建产品实例的操作。2.在建造过程完成后，提供产品的实例。
- 导演者（Director）角色：担任这个角色的类调用具体建造者角色以创建产品对象。
- 产品（Product）角色：产品便是建造中的复杂对象。
一般来说，每有一个产品者，就有一个相应的具体建造者。这些产品应当有一样数目的零件，而每有一个零件就相应地在所有的建造者角色里有一个建造方法。
这些都是一些定义类的语言，后面举例子。
Android例子
Android中AlertDialog是一个建造者模式的例子，可以有着不同的样式和呈现，这样通过Builder就可以有效实现构建和表示的分离。
不过我后面要提的例子是Paginate，它是Github上的一个开源库。它的作用是：Library for creating simple pagination functionality upon RecyclerView and AbsListView。（为AbsListView和RecyclerView 提供简单的分页功能。）
它的构造是：
paginate = Paginate.with(refreshView, this)
.setLoadingTriggerThreshold(2)
.addLoadingListItem(loadListener != null)
.build();它的主干代码如下：
AbsListViewPaginate.java
package com.paginate.abslistview;
import android.database.DataSetObserver;
import android.widget.AbsListView;
import android.widget.AdapterView;
import android.widget.BaseAdapter;
import android.widget.HeaderViewListAdapter;
import com.paginate.Paginate;
public final class AbsListViewPaginate extends Paginate implements EndScrollListener.Callback {
private final AbsListView absListView;
private final Callbacks callbacks;
private EndScrollListener scrollListener;
private WrapperAdapter wrapperAdapter;
AbsListViewPaginate(AbsListView absListView,
Paginate.Callbacks callbacks,
int loadingTriggerThreshold,
AbsListView.OnScrollListener onScrollListener,
boolean addLoadingListItem,
LoadingListItemCreator loadingListItemCreator) {
this.absListView = absListView;
this.callbacks = callbacks;
// Attach scrolling listener in order to perform end offset check on each scroll event
scrollListener = new EndScrollListener(this);
scrollListener.setThreshold(loadingTriggerThreshold);
scrollListener.setDelegate(onScrollListener);
absListView.setOnScrollListener(scrollListener);
if (addLoadingListItem) {
BaseAdapter adapter;
if (absListView.getAdapter() instanceof BaseAdapter) {
adapter = (BaseAdapter) absListView.getAdapter();
} else if (absListView.getAdapter() instanceof HeaderViewListAdapter) {
adapter = (BaseAdapter) ((HeaderViewListAdapter) absListView.getAdapter()).getWrappedAdapter();
} else {
throw new IllegalStateException("Adapter needs to be subclass of BaseAdapter");
}
// Wrap existing adapter with new adapter that will add loading row
wrapperAdapter = new WrapperAdapter(adapter, loadingListItemCreator);
adapter.registerDataSetObserver(dataSetObserver);
((AdapterView) absListView).setAdapter(wrapperAdapter);
}
}
@Override
public void setHasMoreDataToLoad(boolean hasMoreDataToLoad) {
if (wrapperAdapter != null) {
wrapperAdapter.displayLoadingRow(hasMoreDataToLoad);
}
}
@Override
public void onEndReached() {
if (!callbacks.isLoading() && !callbacks.hasLoadedAllItems()) {
callbacks.onLoadMore();
}
}
@Override
public void unbind() {
// Swap back original scroll listener
absListView.setOnScrollListener(scrollListener.getDelegateScrollListener());
// Swap back source adapter
if (absListView.getAdapter() instanceof WrapperAdapter) {
WrapperAdapter wrapperAdapter = (WrapperAdapter) absListView.getAdapter();
BaseAdapter adapter = (BaseAdapter) wrapperAdapter.getWrappedAdapter();
adapter.unregisterDataSetObserver(dataSetObserver);
((AdapterView) absListView).setAdapter(adapter);
}
}
private final DataSetObserver dataSetObserver = new DataSetObserver() {
@Override
public void onChanged() {
wrapperAdapter.displayLoadingRow(!callbacks.hasLoadedAllItems());
wrapperAdapter.notifyDataSetChanged();
}
@Override
public void onInvalidated() {
wrapperAdapter.displayLoadingRow(!callbacks.hasLoadedAllItems());
wrapperAdapter.notifyDataSetInvalidated();
}
};
public static class Builder {
private final AbsListView absListView;
private final Paginate.Callbacks callbacks;
private int loadingTriggerThreshold = 5;
private AbsListView.OnScrollListener onScrollListener;
private boolean addLoadingListItem = true;
private LoadingListItemCreator loadingListItemCreator;
public Builder(AbsListView absListView, Paginate.Callbacks callbacks) {
this.absListView = absListView;
this.callbacks = callbacks;
}
/**
* Set the offset from the end of the list at which the load more event needs to be triggered. Default offset
* if 5.
*
* @param threshold number of items from the end of the list.
* @return {@link com.paginate.abslistview.AbsListViewPaginate.Builder}
*/
public Builder setLoadingTriggerThreshold(int threshold) {
this.loadingTriggerThreshold = threshold;
return this;
}
/**
* Paginate is using OnScrollListener in order to detect when list is scrolled near the end. That means that
* internal listener is attached on AbsListView. Since AbsListView can have only one OnScrollListener it is
* needed to use this method to add additional OnScrollListener (as delegate).
*
* @param onScrollListener that will be called when list is scrolled.
* @return {@link com.paginate.abslistview.AbsListViewPaginate.Builder}
*/
public Builder setOnScrollListener(AbsListView.OnScrollListener onScrollListener) {
this.onScrollListener = onScrollListener;
return this;
}
/**
* Setup loading row. If loading row is used original adapter set on AbsListView will be wrapped with
* internal adapter that will add loading row as the last item in the list. Paginate will observer the
* changes upon original adapter and remove loading row if there is no more data to load. By default loading
* row will be added.
*
* @param addLoadingListItem true if loading row needs to be added, false otherwise.
* @return {@link com.paginate.abslistview.AbsListViewPaginate.Builder}
* @see {@link com.paginate.Paginate.Callbacks#hasLoadedAllItems()}
* @see {@link com.paginate.abslistview.AbsListViewPaginate.Builder#setLoadingListItemCreator(LoadingListItemCreator)}
*/
public Builder addLoadingListItem(boolean addLoadingListItem) {
this.addLoadingListItem = addLoadingListItem;
return this;
}
/**
* Set custom loading list item creator. If no creator is set default one will be used.
*
* @param loadingListItemCreator Creator that will ne called for inflating and binding loading list item.
* @return {@link com.paginate.abslistview.AbsListViewPaginate.Builder}
*/
public Builder setLoadingListItemCreator(LoadingListItemCreator loadingListItemCreator) {
this.loadingListItemCreator = loadingListItemCreator;
return this;
}
/**
* Create pagination functionality upon AbsListView.
*
* @return {@link Paginate} instance.
*/
public Paginate build() {
if (absListView.getAdapter() == null) {
throw new IllegalStateException("Adapter needs to be set!");
}
if (loadingListItemCreator == null) {
loadingListItemCreator = LoadingListItemCreator.DEFAULT;
}
return new AbsListViewPaginate(absListView, callbacks, loadingTriggerThreshold, onScrollListener,
addLoadingListItem, loadingListItemCreator);
}
}
}Paginate.java
package com.paginate;
import android.support.v7.widget.RecyclerView;
import android.widget.AbsListView;
import com.paginate.abslistview.AbsListViewPaginate;
import com.paginate.recycler.RecyclerPaginate;
public abstract class Paginate {
public interface Callbacks {
/** Called when next page of data needs to be loaded. */
void onLoadMore();
/**
* Called to check if loading of the next page is currently in progress. While loading is in progress
* {@link com.paginate.Paginate.Callbacks#onLoadMore} won't be called.
*
* @return true if loading is currently in progress, false otherwise.
*/
boolean isLoading();
/**
* Called to check if there is more data (more pages) to load. If there is no more pages to load, {@link
* com.paginate.Paginate.Callbacks#onLoadMore} won't be called and loading row, if used, won't be added.
*
* @return true if all pages has been loaded, false otherwise.
*/
boolean hasLoadedAllItems();
}
/**
* Use this method to indicate that there is or isn't more data to load. If there isn't any more data to load
* loading row, if used, won't be displayed as the last item of the list. Adding/removing loading row is done
* automatically each time when underlying adapter data is changed. Use this method to explicitly add/remove
* loading row.
*
* @param hasMoreDataToLoad true if there is more data to load, false otherwise.
*/
abstract public void setHasMoreDataToLoad(boolean hasMoreDataToLoad);
/**
* Call unbind to detach list (RecyclerView or AbsListView) from Paginate when pagination functionality is no
* longer needed on the list.
* <p/>
* Paginate is using scroll listeners and adapter data observers in order to perform required checks. It wraps
* original (source) adapter with new adapter that provides loading row if loading row is used. When unbind is
* called original adapter will be set on the list and scroll listeners and data observers will be detached.
*/
abstract public void unbind();
/**
* Create pagination functionality upon RecyclerView.
*
* @param recyclerView RecyclerView that will have pagination functionality.
* @param callback pagination callbacks.
* @return {@link com.paginate.recycler.RecyclerPaginate.Builder}
*/
public static RecyclerPaginate.Builder with(RecyclerView recyclerView, Callbacks callback) {
return new RecyclerPaginate.Builder(recyclerView, callback);
}
/**
* Create pagination functionality upon AbsListView.
*
* @param absListView AbsListView that will have pagination functionality (ListView or GridView).
* @param callback pagination callbacks.
* @return {@link com.paginate.abslistview.AbsListViewPaginate.Builder}
*/
public static AbsListViewPaginate.Builder with(AbsListView absListView, Callbacks callback) {
return new AbsListViewPaginate.Builder(absListView, callback);
}
}由上面贴出的大段代码可以看出：
这个构建方法使用的是建造者模式。通过Builder来构建产品对象, 不对外隐藏构建细节。
Builder为AbsListViewPaginate的内部类，而AbsListViewPaginate是继承自Paginate的子类。
Product:
一般Product角色都是如下：
/**
* Computer产品抽象类, 为了例子简单, 只列出这几个属性
*
* @author mrsimple
*
*/
public abstract class Computer {
protected int mCpuCore = 1;
protected int mRamSize = 0;
protected String mOs = "Dos";
protected Computer() {
}
// 设置CPU核心数
public abstract void setCPU(int core);
// 设置内存
public abstract void setRAM(int gb);
// 设置操作系统
public abstract void setOs(String os);
}但是在Paginate类中，它直接将成员变量定义在了Builder类里，如下：
public static class Builder {
private final AbsListView absListView;
private final Paginate.Callbacks callbacks;
private int loadingTriggerThreshold = 5;
private AbsListView.OnScrollListener onScrollListener;
private boolean addLoadingListItem = true;
private LoadingListItemCreator loadingListItemCreator;所以这一部分产品应该没有单独列出来。
builder角色:
一般builder角色都如下：
/**
* builder抽象类
*
*/
public abstract class Builder {
// 设置CPU核心数
public abstract void buildCPU(int core);
// 设置内存
public abstract void buildRAM(int gb);
// 设置操作系统
public abstract void buildOs(String os);
// 创建Computer
public abstract Computer create();
}但是在Paginate类中，也同样是在Builder类里做了处理，并没有单独写出来：
public Builder setLoadingListItemCreator(LoadingListItemCreator loadingListItemCreator) {
this.loadingListItemCreator = loadingListItemCreator;
return this;
}
/**
* Create pagination functionality upon AbsListView.
*
* @return {@link Paginate} instance.
*/
public Paginate build() {
if (absListView.getAdapter() == null) {
throw new IllegalStateException("Adapter needs to be set!");
}
if (loadingListItemCreator == null) {
loadingListItemCreator = LoadingListItemCreator.DEFAULT;
}
return new AbsListViewPaginate(absListView, callbacks, loadingTriggerThreshold, onScrollListener,
addLoadingListItem, loadingListItemCreator);
}
}具体建造者：
具体建造者应该是这里的builder类：它为成员变量赋值，并最后用builder方法创建出了当前类的对象。
导演者：
导演者一般是最后在客户端调用的时候面对客户端的一个角色，但是它通常可以省略。如下：
public class Director {
Builder mBuilder = null;
/**
*
* @param builder
*/
public Director(Builder builder) {
mBuilder = builder;
}
/**
* 构建对象
*
* @param cpu
* @param ram
* @param os
*/
public void construct(int cpu, int ram, String os) {
mBuilder.buildCPU(cpu);
mBuilder.buildRAM(ram);
mBuilder.buildOs(os);
}
}但是在Paginate类中，这一部分被省略了，而直接使用build方法构建了对象。
其实写这么多，主要是为了记忆怎么使用构造者模式，它有着非常明显的优势：良好的封装性， 使用建造者模式可以使客户端不必知道产品内部组成的细节。写这篇笔记也是为了让我自己能更好地了解如何使用构造者模式，同时也是对Paginate类的一个简单的分析，如果写的不详细的话，见谅~
扫一扫
729
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
