建造者模式与常见写法
Builder 模式,又称为"建造者模式" / "生成器模式"。它将复杂对象的构建过程 和最终表示相分离,让你可以分步创建不同形式或配置的复杂对象。
平时我们见到的 Builder,大多是《Effective Java》里的静态内部类写法,你可以认为是一种简化的变体。
最典型的就是 OkHttp,比如 OkHttpClient 实例的构建:
kotlin
val client: OkHttpClient = OkHttpClient.Builder()
.connectTimeout(10, TimeUnit.SECONDS) // 设置连接超时
.readTimeout(10, TimeUnit.SECONDS) // 设置读取超时
.build()
Request 请求对象的构建:
kotlin
val request = Request.Builder()
.url("https://juejin.cn/") // 设置请求地址
.build()
又或是 AlertDialog 的构建:
kotlin
AlertDialog.Builder(this)
.setTitle("Title")
.setMessage("This is a dialog")
.setPositiveButton("OK") { dialog, _ ->
Toast.makeText(this, "OK clicked", Toast.LENGTH_SHORT).show()
dialog.dismiss()
}
.setNegativeButton("Cancel") { dialog, _ ->
Toast.makeText(this, "Cancel clicked", Toast.LENGTH_SHORT).show()
dialog.dismiss()
}
.show()
我们通常在对象的构建过程比较复杂,或者需要配置的可选参数非常多时,使用 Builder 模式。
AlertDialog 中的 Builder 源码剖析
我们分析一下 androidx.appcompat.app.AlertDialog 的源码,首先进入 Builder。Builder 其实是 AlertDialog 中的一个静态内部类,AlertDialog.Builder(this) 是该类的构造函数。
java
// AlertDialog.java
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;
}
构造函数中创建了 AlertController.AlertParams 对象,保存了对话框主题的资源 ID。
其中 AlertController.AlertParams 也是一个静态内部类,成员都是对话框的配置:
java
// AlertController.java
public int mIconId = 0;
public Drawable mIcon;
public int mIconAttrId = 0;
public CharSequence mTitle;
public View mCustomTitleView;
public CharSequence mMessage;
public CharSequence mPositiveButtonText;
public Drawable mPositiveButtonIcon;
public DialogInterface.OnClickListener mPositiveButtonListener;
public CharSequence mNegativeButtonText;
public Drawable mNegativeButtonIcon;
public DialogInterface.OnClickListener mNegativeButtonListener;
比如我们调用的 setTitle,实际上会去给配置赋值,同时返回了构建器自身,这样才能链式调用。
java
// AlertDialog.java
public Builder setTitle(@Nullable CharSequence title) {
P.mTitle = title;
return this;
}
最后看 show 干了什么:
java
// AlertDialog.java
public AlertDialog show() {
final AlertDialog dialog = create();
dialog.show();
return dialog;
}
create() 会根据之前设定的配置,创建 AlertDialog 对象。其中大部分的配置会通过 P.apply(dialog.mAlert) 交给 AlertController 进行处理,一些窗口的行为则会直接设置到 dialog 上,比如窗口是否可取消。
java
// AlertDialog.java
public @NonNull AlertDialog create() {
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;
}
show() 则是启动并显示对话框,这里面的代码就不看了。
简单来说,Builder 用于让外部调用设置参数,AlertParams 是参数存放的地方,只有在最后的 show()(内部是 create())调用时,才会根据参数构建最终的 AlertDialog 对象。
就像买菜做饭一样,你可以不断地挑选食材放进菜篮子,最终炒出来的菜品取决于今天买的食材,没选的配料就不放或用家里已有的(默认)。
建造者模式与链式调用的边界
Builder 模式和链式调用有什么关联关系呢?
前者是设计模式,是解决一类问题的思想;后者呢?则是调用方法的另一种便捷方式。
不过 Builder 模式中,一般都会使用链式调用。Builder 还有不带链式调用的形式,以前面的 AlertDialog 为例:
kotlin
val builder = AlertDialog.Builder(this)
builder.setTitle("Title")
builder.setMessage("This is a dialog")
val dialog = builder.create()
dialog.show()
哪怕不返回 this,只要有分步配置、最后统一构建的结构,这依然是 Builder 设计模式。
实战:封装可配置的 DefaultTopBar
顶部应用栏(TopAppBar)的结构有多种可能性,比如左侧是返回按钮,中间是标题,右侧是空的。也可能右侧有一个操作按钮,也可能左侧没有返回按钮,中间也可能是一个搜索框。
对于这种对象的构建就可以应用建造者模式,那我们就来实现一个应用 Builder 模式的顶部栏。
顶部栏 XML 布局
创建 view_default_top_bar.xml 文件:
xml
<?xml version="1.0" encoding="utf-8"?>
<merge xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto"
xmlns:tools="http://schemas.android.com/tools">
<ImageView
android:id="@+id/defaultTopBarStartIcon"
android:layout_width="48dp"
android:layout_height="48dp"
android:layout_marginStart="4dp"
android:padding="12dp"
android:scaleType="centerInside"
android:visibility="gone"
app:layout_constraintBottom_toBottomOf="parent"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toTopOf="parent"
app:tint="?attr/colorOnSurface"
tools:visibility="visible" />
<TextView
android:id="@+id/defaultTopBarTitle"
android:layout_width="0dp"
android:layout_height="0dp"
android:ellipsize="end"
android:fontFamily="sans-serif-medium"
android:gravity="center"
android:includeFontPadding="false"
android:maxLines="1"
android:paddingStart="56dp"
android:paddingEnd="56dp"
android:textColor="?attr/colorOnSurface"
android:textSize="18sp"
app:layout_constraintBottom_toBottomOf="parent"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toTopOf="parent" />
<View
android:id="@+id/defaultTopBarDivider"
android:layout_width="0dp"
android:layout_height="1dp"
android:background="?attr/colorOutlineVariant"
app:layout_constraintBottom_toBottomOf="parent"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintStart_toStartOf="parent" />
</merge>
因为 DefaultTopBar 组件类本身就继承自 ConstraintLayout,所以布局的根节点使用 merge,将子控件直接添加到父容器中,减少一层不必要的嵌套。
DefaultTopBar 与 Builder 实现
然后创建组件类 DefaultTopBar:
kotlin
fun Int.dp(context: Context) =
(this * context.resources.displayMetrics.density + 0.5f).toInt()
/**
* 默认顶部栏
*/
class DefaultTopBar private constructor(
context: Context
) : ConstraintLayout(context) {
private val startIconView: ImageView
private val titleView: TextView
init {
// 加载自定义的布局
LayoutInflater.from(context).inflate(R.layout.view_default_top_bar, this, true)
startIconView = findViewById(R.id.defaultTopBarStartIcon)
titleView = findViewById(R.id.defaultTopBarTitle)
// 默认隐藏起始图标
startIconView.visibility = GONE
setBackgroundColor(
MaterialColors.getColor(this, com.google.android.material.R.attr.colorSurface),
)
minimumHeight = 56.dp(context)
}
}
并在类内部定义 Builder,支持设置标题、左侧图标以及左侧图标的点击事件:
kotlin
// 定义在 DefaultTopBar 类内部
/**
* 顶部栏构建器
*/
class Builder(private val context: Context) {
private var titleText: CharSequence = ""
private var startIconRes: Int? = null
private var startContentDescription: CharSequence? = null
private var startClickListener: (() -> Unit)? = null
fun setTitle(title: CharSequence): Builder = apply {
titleText = title
}
fun setStartIcon(
@DrawableRes iconRes: Int,
contentDescription: CharSequence? = null,
): Builder = apply {
startIconRes = iconRes
startContentDescription = contentDescription
}
fun setStartClickListener(listener: () -> Unit): Builder = apply {
startClickListener = listener
}
/**
* 创建顶部栏实例
*/
fun build(): DefaultTopBar = DefaultTopBar(context).apply {
titleView.text = titleText
startIconRes?.let { iconRes ->
startIconView.setImageResource(iconRes)
startIconView.contentDescription = startContentDescription
// 起始图标可见
startIconView.visibility = VISIBLE
startIconView.setOnClickListener { startClickListener?.invoke() }
}
}
}
页面接入与效果
这样一个顶部栏其实就完成了,调用示例:
kotlin
class MainActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
enableEdgeToEdge()
setContentView(R.layout.activity_main)
ViewCompat.setOnApplyWindowInsetsListener(findViewById(R.id.main)) { v, insets ->
val systemBars = insets.getInsets(WindowInsetsCompat.Type.systemBars())
v.setPadding(systemBars.left, systemBars.top, systemBars.right, systemBars.bottom)
insets
}
// 获取根布局
val root = findViewById<ConstraintLayout>(R.id.main)
// 创建顶部栏对象
val defaultTopBar = DefaultTopBar.Builder(this)
.setTitle("Default Top Bar")
.setStartIcon(R.drawable.ic_arrow_back_24, "Back")
.setStartClickListener {
Toast.makeText(this, "Clicked start icon", Toast.LENGTH_SHORT).show()
}
.build()
// 添加到根布局
root.addView(
defaultTopBar,
ConstraintLayout.LayoutParams(
ViewGroup.LayoutParams.MATCH_PARENT,
ViewGroup.LayoutParams.WRAP_CONTENT,
).apply {
topToTop = ConstraintLayout.LayoutParams.PARENT_ID
startToStart = ConstraintLayout.LayoutParams.PARENT_ID
endToEnd = ConstraintLayout.LayoutParams.PARENT_ID
}
)
}
}
其中的返回箭头 ic_arrow_back_24.xml:
xml
<?xml version="1.0" encoding="utf-8"?>
<vector xmlns:android="http://schemas.android.com/apk/res/android"
android:width="24dp"
android:height="24dp"
android:tint="?attr/colorOnSurface"
android:viewportWidth="24"
android:viewportHeight="24">
<path
android:fillColor="@android:color/white"
android:pathData="M20,11H7.83l5.59,-5.59L12,4l-8,8 8,8 1.41,-1.41L7.83,13H20v-2z" />
</vector>
运行效果:

封装 attachTo 简化挂载
另外,还可以增加一个方法,用来方便地将 TopBar 添加到容器中:
kotlin
/**
* 将顶部栏添加到父布局的顶部
*/
fun attachTo(
parent: ConstraintLayout,
layoutParams: LayoutParams = LayoutParams(
LayoutParams.MATCH_PARENT,
LayoutParams.WRAP_CONTENT,
).apply {
topToTop = LayoutParams.PARENT_ID
startToStart = LayoutParams.PARENT_ID
endToEnd = LayoutParams.PARENT_ID
}
) {
parent.addView(
this,
layoutParams
)
}
现在 MainActivity 中的调用变为了:
kotlin
// 获取根布局
val root = findViewById<ConstraintLayout>(R.id.main)
// 创建顶部栏并添加到根布局
DefaultTopBar.Builder(this)
.setTitle("Default Top Bar")
.setStartIcon(R.drawable.ic_arrow_back_24, "Back")
.setStartClickListener {
Toast.makeText(this, "Clicked start icon", Toast.LENGTH_SHORT).show()
}
.build()
.attachTo(root)
经典 GoF 建造者模式实现
前面我们提到,静态内部类(DefaultTopBar.Builder)属于简化变体,只是在给同一个对象配置参数。而经典的 GoF 建造者模式更强调:同样的构建步骤,生产出不同形态的产品。
还是以顶部栏为例,不管是普通的标题栏还是带搜索框的标题栏,都可以简化为左、中、右的插槽,只是放入的控件不同。
那我们就可以将其抽象出来:最终产品(TopBar)、抽象建造者(TopBarBuilder)、具体建造者(普通栏 / 搜索栏)、指挥者(TopBarDirector)。
产品和抽象建造者:
抽象建造者应用了开闭原则,抽象出接口,将实现细节交给子类完成。
kotlin
/**
* 产品
*/
class TopBar(context: Context) : LinearLayout(context) {
init {
orientation = HORIZONTAL
gravity = Gravity.CENTER_VERTICAL
minimumHeight = 56.dp(context)
setPadding(8.dp(context), 0, 8.dp(context), 0)
}
fun setStartView(view: View) = addView(view)
fun setCenterView(view: View) {
addView(view, LayoutParams(0, LayoutParams.WRAP_CONTENT, 1f))
}
fun setEndView(view: View) = addView(view)
}
kotlin
/**
* 抽象建造者
*/
interface TopBarBuilder {
fun buildStart()
fun buildCenter()
fun buildEnd()
fun getResult(): TopBar
}
然后实现之前的普通标题栏,以及搜索栏两个具体建造者:
kotlin
class NormalTopBarBuilder(
private val context: Context,
private val title: String,
private val onBack: () -> Unit,
) : TopBarBuilder {
private val topBar = TopBar(context)
override fun buildStart() {
val backIcon = ImageView(context).apply {
setImageResource(R.drawable.ic_arrow_back_24)
setPadding(12.dp(context), 12.dp(context), 12.dp(context), 12.dp(context))
setOnClickListener { onBack() }
}
topBar.setStartView(backIcon)
}
override fun buildCenter() {
val titleView = TextView(context).apply {
text = title
textSize = 18f
gravity = Gravity.CENTER
}
topBar.setCenterView(titleView)
}
override fun buildEnd() {
// 占位
topBar.setEndView(Space(context).apply {
layoutParams = LinearLayout.LayoutParams(48.dp(context), 48.dp(context))
})
}
override fun getResult(): TopBar = topBar
}
kotlin
class SearchTopBarBuilder(
private val context: Context,
private val hint: String,
private val onBack: () -> Unit,
private val onSearch: (String) -> Unit,
) : TopBarBuilder {
private val topBar = TopBar(context)
private lateinit var searchInput: EditText
override fun buildStart() {
val backIcon = ImageView(context).apply {
setImageResource(R.drawable.ic_arrow_back_24)
setPadding(12.dp(context), 12.dp(context), 12.dp(context), 12.dp(context))
setOnClickListener { onBack() }
}
topBar.setStartView(backIcon)
}
override fun buildCenter() {
searchInput = EditText(context).apply {
this.hint = this@SearchTopBarBuilder.hint
isSingleLine = true
}
topBar.setCenterView(searchInput)
}
override fun buildEnd() {
val searchBtn = TextView(context).apply {
text = "Search"
setPadding(12.dp(context), 12.dp(context), 12.dp(context), 12.dp(context))
setOnClickListener { onSearch(searchInput.text.toString()) }
}
topBar.setEndView(searchBtn)
}
override fun getResult(): TopBar = topBar
}
最后是指挥者,负责构建的顺序:
kotlin
class TopBarDirector {
fun construct(builder: TopBarBuilder): TopBar {
builder.buildStart()
builder.buildCenter()
builder.buildEnd()
return builder.getResult()
}
}
调用方式:
kotlin
// 获取根布局
val root = findViewById<ConstraintLayout>(R.id.main)
val director = TopBarDirector()
// 以下两种顶部栏按需二选一添加(同时添加到同一 ConstraintLayout 且未设置约束会重叠)
// 1. 普通顶部栏
val normalBar = director.construct(
NormalTopBarBuilder(this, "详情页") { finish() }
)
root.addView(
normalBar, ConstraintLayout.LayoutParams(
ConstraintLayout.LayoutParams.MATCH_PARENT,
ConstraintLayout.LayoutParams.WRAP_CONTENT
)
)
// 2. 搜索顶部栏
/*
val searchBar = director.construct(
SearchTopBarBuilder(this, "输入关键词", onBack = { finish() }) { keyword ->
Toast.makeText(this, "搜索:$keyword", Toast.LENGTH_SHORT).show()
}
)
root.addView(
searchBar, ConstraintLayout.LayoutParams(
ConstraintLayout.LayoutParams.MATCH_PARENT,
ConstraintLayout.LayoutParams.WRAP_CONTENT
)
)
*/
运行效果:

静态内部类变体适合参数比较多的场景,日常开发用得最多。而 GoF 模式适合步骤固定,但不同实现产出不同形态的场景。
不过在 Kotlin 中,对于简单的参数配置,使用默认参数加上命名参数就够用了。