共计 16501 个字符,预计需要花费 42 分钟才能阅读完成。
请点赞关注,你的反对对我意义重大。
🔥 Hi,我是小彭。本文已收录到 GitHub · Android-NoteBook 中。这里有 Android 进阶成长常识体系,有气味相投的敌人,关注公众号 [彭旭锐] 带你建设外围竞争力。
前言
ViewBinding 是 Android Gradle Plugin 3.6 中新增的个性,用于更加轻量地实现视图绑定(即视图与变量的绑定),能够了解为轻量版本的 DataBinding。在这篇文章里,我将总结 ViewBinding 应用办法 & 原理,示例程序 AndroidFamilyDemo · KotlinDelegate 有用请记得给 Star,给小彭一点创作的能源。
前置常识:
- Kotlin | 委托机制 & 原理 & 利用
- Kotlin | 扩大函数(终于晓得为什么 with 用 this,let 用 it)
- Java | 对于泛型能问的都在这里了(含 Kotlin)
- Android | Fragment 外围原理 & 面试题 (AndroidX 版本)
学习路线图
1. 意识 ViewBinding
1.1 ViewBinding 用于解决什么问题?
ViewBinding 是 Android Gradle Plugin 3.6 中新增的个性,用于更加轻量地实现视图绑定(即视图与变量的绑定),能够了解为轻量版本的 DataBinding。
1.2 ViewBinding 与其余视图绑定计划比照
在 ViewBinding 之前,业界曾经有过几种视图绑定计划了,想必你也用过。那么,ViewBinding 作为后起之秀就肯定比前者香吗?我从多个维度比照它们的区别:
角度 | findViewById | ButterKnife | Kotlin Synthetics | DataBinding | ViewBinding | ❓ |
---|---|---|---|---|---|---|
简洁性 | ✖ | ✖ | ✔ | ✔ | ✔ | ❓ |
编译期查看 | ✖ | ✖ | ✖ | ✔ | ✔ | ❓ |
编译速度 | ✔ | ✖ | ✔ | ✖ | ✔ | ❓ |
反对 Kotlin & Java | ✔ | ✔ | ✖ | ✔ | ✔ | ❓ |
收敛模板代码 | ✖ | ✖ | ✔ | ✖ | ✖ | ❓ |
- 1、简洁性: findViewById 和 ButterKnife 须要在代码中申明很多变量,其余几种计划代码简洁读较好;
- 2、编译查看: 编译期间次要有两个方面的查看:类型查看 + 只能拜访以后布局中的 id。findViewById、ButterKnife 和 Kotlin Synthetics 在这方面体现较差;
- 3、编译速度: findViewById 的编译速度是最快的,而 ButterKnife 和 DataBinding 中存在注解解决,编译速度略逊色于 Kotlin Synthetics 和 ViewBinding;
- 4、反对 Kotlin & Java: Kotlin Synthetics 只反对 Kotlin 语言;
- 5、收敛模板代码: 基本上每种计划都带有一定量的模板代码,只有 Kotlin Synthetics 的模板代码是较少的。
能够看到,并没有一种绝对优势的办法,但越往后整体的成果是有晋升的。另外,❓是什么呢?
1.3 ViewBinding 的实现原理
AGP 插件会为每个 XML 布局文件创建一个绑定类文件 xxxBinding
,绑定类中会持有布局文件中所有带 android:id
属性的 View 援用。例如,有布局文件为 fragment_test.xml
,则插件会生成绑定类 FragmentTestBinding.java
。
那么,所有 XML 布局文件都生成 Java 类,会不会导致包体积霎时增大?不会的,未应用的类会在混同时被压缩。
2. ViewBinding 的根本用法
这一节咱们来介绍 ViewBinding 的应用办法,内容不多。
提醒: ViewBinding 要求在 Android Gradle Plugin 版本在至多在 3.6 以上。
2.1 增加配置
视图绑定性能按模块级别启用,启用的模块须要在模块级 build.gralde 中增加配置。例如:
build.gradle
android {
...
viewBinding {enabled = true}
}
对于不须要生成绑定类的布局文件,能够在根节点申明 tools:viewBindingIgnore="true"
。例如:
<LinearLayout
...
tools:viewBindingIgnore="true" >
...
</LinearLayout>
2.2 视图绑定
绑定类中提供了 3 个视图绑定 API:
// 绑定到视图 view 上
fun <T> bind(view : View) : T
// 应用 inflater 解析布局,再绑定到 View 上
fun <T> inflate(inflater : LayoutInflater) : T
// 应用 inflater 解析布局,再绑定到 View 上
fun <T> inflate(inflater : LayoutInflater, parent : ViewGroup?, attachToParent : Boolean) : T
- 1、在 Activity 中应用
MainActivity.kt
class TestActivity: AppCompatActivity(R.layout.activity_test) {
private lateinit var binding: ActivityTestBinding
override fun onCreate(savedInstanceState: Bundle?) {super.onCreate(savedInstanceState)
binding = ActivityTestBinding.inflate(layoutInflater)
setContentView(binding.root)
binding.tvDisplay.text = "Hello World."
}
}
- 2、在 Fragment 中应用
TestFragment.kt
class TestFragment : Fragment(R.layout.fragment_test) {
private var _binding: FragmentTestBinding? = null
private val binding get() = _binding!!
override fun onViewCreated(root: View, savedInstanceState: Bundle?) {_binding = FragmentTestBinding.bind(root)
binding.tvDisplay.text = "Hello World."
}
override fun onDestroyView() {super.onDestroyView()
// 置空
_binding = null
}
}
2.3 防止内存泄露
这里有一个暗藏的内存泄露问题,你须要了解分明(严格来说这并不是 ViewBinding 的问题,即便你采纳其它视图绑定计划也要思考这个问题)。
问题:为什么 Fragment#onDestroyView() 里须要置空绑定类对象,而 Activity 里不须要?
答:Activity 实例和 Activity 视图的生命周期是同步的,而 Fragment 实例和 Fragment 视图的生命周期并不是齐全同步的,因而须要在 Fragment 视图销毁时,手动回收绑定类对象,否则造成内存泄露。例如:detach Fragment,或者 remove Fragment 并且事务进入返回栈,此时 Fragment 视图销毁但 Fragment 实例存在。对于 Fragment 生命周期和事务在我之前的一篇文章里探讨过:Android | Fragment 外围原理 & 面试题 (AndroidX 版本)
总之,在视图销毁然而管制类对象实例还存活的机会,你就须要手动回收绑定类对象,否则造成内存泄露。
2.4 ViewBinding 绑定类源码
反编译如下:
ActivityTestBinding.java
public final class ActivityTestBinding implements ViewBinding {
private final ConstraintLayout rootView;
public final TextView tvDisplay;
private ActivityTestBinding (ConstraintLayout paramConstraintLayout1, TextView paramTextView)
this.rootView = paramConstraintLayout1;
this.tvDisplay = paramTextView;
}
public static ActivityTestBinding bind(View paramView) {TextView localTextView = (TextView)paramView.findViewById(2131165363);
if (localTextView != null) {return new ActivityMainBinding((ConstraintLayout)paramView, localTextView);
}else {paramView = "tvDisplay";}
throw new NullPointerException("Missing required view with ID:".concat(paramView));
}
public static ActivityMainBinding inflate(LayoutInflater paramLayoutInflater) {return inflate(paramLayoutInflater, null, false);
}
public static ActivityMainBinding inflate(LayoutInflater paramLayoutInflater, ViewGroup paramViewGroup, boolean paramBoolean) {paramLayoutInflater = paramLayoutInflater.inflate(2131361821, paramViewGroup, false);
if (paramBoolean) {paramViewGroup.addView(paramLayoutInflater);
}
return bind(paramLayoutInflater);
}
public ConstraintLayout getRoot() {return this.rootView;}
}
3. ViewBinding 与 Kotlin 委托双剑合璧
到这里,ViewBinding 的应用教程曾经说完了。然而回过头看,有没有发现一些局限性呢?
- 1、创立和回收 ViewBinding 对象须要反复编写样板代码,特地是在 Fragment 中应用的案例;
- 2、binding 属性是可空的,也是可变的,应用起来不不便。
那么,有没有可优化的计划呢?咱们想起了 Kotlin 属性委托,对于 Kotlin 委托机制在我之前的一篇文章里探讨过:Kotlin | 委托机制 & 原理。如果你还不太理解 Kotlin 委托,上面的内容对你会有些难度。上面,我将带你一步步封装 ViewBinding 属性委托工具。首先,咱们梳理一下咱们要委托的内容与需要,以及相应的解决办法:
需要 | 解决办法 |
---|---|
须要委托 ViewBinding#bind() 的调用 | 反射 |
须要委托 binding = null 的调用 | 监听 Fragment 视图生命周期 |
冀望 binding 属性申明为非空不可变变量 | ReadOnlyProperty<F, V> |
3.1 ViewBinding + Kotlin 委托 1.0
咱们当初较简单的 Fragment 中尝试应用 Kotlin 委托优化:
FragmentViewBindingPropertyV1.kt
private const val TAG = "ViewBindingProperty"
public inline fun <reified V : ViewBinding> viewBindingV1() = viewBindingV1(V::class.java)
public inline fun <reified T : ViewBinding> viewBindingV1(clazz: Class<T>): FragmentViewBindingPropertyV1<Fragment, T> {val bindMethod = clazz.getMethod("bind", View::class.java)
return FragmentViewBindingPropertyV1 {bindMethod(null, it.requireView()) as T
}
}
/**
* @param viewBinder 创立绑定类对象
*/
class FragmentViewBindingPropertyV1<in F : Fragment, out V : ViewBinding>(private val viewBinder: (F) -> V
) : ReadOnlyProperty<F, V> {
private var viewBinding: V? = null
@MainThread
override fun getValue(thisRef: F, property: KProperty<*>): V {
// 曾经绑定,间接返回
viewBinding?.let {return it}
// Use viewLifecycleOwner.lifecycle other than lifecycle
val lifecycle = thisRef.viewLifecycleOwner.lifecycle
val viewBinding = viewBinder(thisRef)
if (lifecycle.currentState == Lifecycle.State.DESTROYED) {
Log.w(TAG, "Access to viewBinding after Lifecycle is destroyed or hasn't created yet. "+"The instance of viewBinding will be not cached.")
// We can access to ViewBinding after Fragment.onDestroyView(), but don't save it to prevent memory leak} else {lifecycle.addObserver(ClearOnDestroyLifecycleObserver())
this.viewBinding = viewBinding
}
return viewBinding
}
@MainThread
fun clear() {viewBinding = null}
private inner class ClearOnDestroyLifecycleObserver : LifecycleObserver {private val mainHandler = Handler(Looper.getMainLooper())
@MainThread
@OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
fun onDestroy(owner: LifecycleOwner) {owner.lifecycle.removeObserver(this)
mainHandler.post {clear() }
}
}
}
应用示例:
class TestFragment : Fragment(R.layout.fragment_test) {private val binding : FragmentTestBinding by viewBindingV1()
override fun onViewCreated(root: View, savedInstanceState: Bundle?) {binding.tvDisplay.text = "Hello World."}
}
洁净清新!后面提出的三个需要也都实现了,当初我为你解答细节:
- 问题 1、为什么能够应用 V::class.java,不是泛型擦除了吗? 利用了 Kotlin 内敛函数 + 实化类型参数,编译后函数体整体被复制到调用处,V::class.java 其实是 FragmentTestBinding::class.java。具体分析见:Java | 对于泛型能问的都在这里了(含 Kotlin)
- 问题 2、ReadOnlyProperty<F, V> 是什么? ReadOnlyProperty 是不可变属性代理,通过 getValue(…) 办法实现委托行为。第一个类型参数 F 是属性所有者,第二个参数 V 是属性类型,因为咱们在 Fragment 中定义属性,属性类型为 ViewBinding,所谓定义类型参数为 <in F : Fragment, out V : ViewBinding>;
- 问题 3、解释下 getValue(…) 办法? 间接看正文:
FragmentViewBindingPropertyV1.kt
@MainThread
override fun getValue(thisRef: F, property: KProperty<*>): V {
// 1、viewBinding 不为空阐明曾经绑定,间接返回
viewBinding?.let {return it}
// 2、Fragment 视图的生命周期
val lifecycle = thisRef.viewLifecycleOwner.lifecycle
// 3、实例化绑定类对象
val viewBinding = viewBinder(thisRef)
if (lifecycle.currentState == Lifecycle.State.DESTROYED) {// 4.1 如果视图生命周期为 DESTROYED,阐明视图被销毁,此时不缓存绑定类对象(防止内存透露)} else {
// 4.2 定义视图生命周期监听者
lifecycle.addObserver(ClearOnDestroyLifecycleObserver())
// 4.3 缓存绑定类对象
this.viewBinding = viewBinding
}
return viewBinding
}
- 问题 4、为什么 onDestroy() 要采纳 Handler#post(Message) 实现? 因为 Fragment#viewLifecycleOwner 告诉生命周期事件 ON_DESTROY 的机会在 Fragment#onDestroyView 之前。如果不应用 post 的形式,那么业务方要是在 onDestroyView 中拜访了 binding,则会二次执行 getValue() 这是不必要的。
3.2 ViewBinding + Kotlin 委托 2.0
V1.0 版本应用了反射,真的肯定要反射吗?反射调用 bind 函数的目标就是取得一个 ViewBinding 绑定类对象,或者咱们能够试试把创建对象的行为交给内部去定义,相似这样用一个 lambda 表达式实现工厂函数:
FragmentViewBindingPropertyV2.kt
inline fun <F : Fragment, V : ViewBinding> viewBindingV2(crossinline viewBinder: (View) -> V,
// 相似于创立工厂
crossinline viewProvider: (F) -> View = Fragment::requireView
) = FragmentViewBindingPropertyV2 { fragment: F ->
viewBinder(viewProvider(fragment))
}
class FragmentViewBindingPropertyV2<in F : Fragment, out V : ViewBinding>(private val viewBinder: (F) -> V
) : ReadOnlyProperty<F, V> {// 以下源码雷同 ...}
应用示例:
class TestFragment : Fragment(R.layout.fragment_test) {private val binding by viewBindingV2(FragmentTestBinding::bind)
override fun onViewCreated(root: View, savedInstanceState: Bundle?) {binding.tvDisplay.text = "Hello World."}
}
洁净清新!不应用反射也能够实现,当初我为你解答细节:
- 问题 5、(View) -> V 是什么? Kotlin 高阶函数,能够把 lambda 表达式间接作为参数传递,其中 View 是函数参数,而 T 是函数返回值。lambda 表达式实质上是「能够作为值传递的代码块」。在老版本 Java 中,传递代码块须要应用匿名外部类实现,而应用 lambda 表达式甚至连函数申明都不须要,能够间接传递代码块作为函数值;
- 问题 6、Fragment::requireView 是什么? 把函数 requireView() 作为参数传递。Fragment#requireView() 会返回 Fragment 的根节点,但要留神在 onCreateView() 之前调用 requireView() 会抛出异样;
- 问题 7、FragmentTestBinding::bind 是什么? 把函数 bind() 作为参数传递,bind 函数的参数为 View,返回值为 ViewBinding,与函数申明 (View) -> V 匹配。
3.3 ViewBinding + Kotlin 委托最终版
V2.0 版本曾经实现了针对 Fragment 的属性代理,然而理论场景中只会在 Fragment 中应用 ViewBinding 吗?显然并不是,咱们还有其余一些场景:
- Activity
- Fragment
- DialogFragment
- ViewGroup
- RecyclerView.ViewHolder
所以,咱们有必要将委托工具适当封装得更通用些,残缺代码和演示工程你能够间接下载查看:AndroidFamilyDemo · KotlinDelegate
ViewBindingProperty.kt
// -------------------------------------------------------
// ViewBindingProperty for Activity
// -------------------------------------------------------
@JvmName("viewBindingActivity")
inline fun <V : ViewBinding> ComponentActivity.viewBinding(crossinline viewBinder: (View) -> V,
crossinline viewProvider: (ComponentActivity) -> View = ::findRootView
): ViewBindingProperty<ComponentActivity, V> = ActivityViewBindingProperty { activity: ComponentActivity ->
viewBinder(viewProvider(activity))
}
@JvmName("viewBindingActivity")
inline fun <V : ViewBinding> ComponentActivity.viewBinding(crossinline viewBinder: (View) -> V,
@IdRes viewBindingRootId: Int
): ViewBindingProperty<ComponentActivity, V> = ActivityViewBindingProperty { activity: ComponentActivity ->
viewBinder(activity.requireViewByIdCompat(viewBindingRootId))
}
// -------------------------------------------------------
// ViewBindingProperty for Fragment / DialogFragment
// -------------------------------------------------------
@Suppress("UNCHECKED_CAST")
@JvmName("viewBindingFragment")
inline fun <F : Fragment, V : ViewBinding> Fragment.viewBinding(crossinline viewBinder: (View) -> V,
crossinline viewProvider: (F) -> View = Fragment::requireView
): ViewBindingProperty<F, V> = when (this) {
is DialogFragment -> DialogFragmentViewBindingProperty { fragment: F ->
viewBinder(viewProvider(fragment))
} as ViewBindingProperty<F, V>
else -> FragmentViewBindingProperty { fragment: F ->
viewBinder(viewProvider(fragment))
}
}
@Suppress("UNCHECKED_CAST")
@JvmName("viewBindingFragment")
inline fun <F : Fragment, V : ViewBinding> Fragment.viewBinding(crossinline viewBinder: (View) -> V,
@IdRes viewBindingRootId: Int
): ViewBindingProperty<F, V> = when (this) {is DialogFragment -> viewBinding(viewBinder) { fragment: DialogFragment ->
fragment.getRootView(viewBindingRootId)
} as ViewBindingProperty<F, V>
else -> viewBinding(viewBinder) { fragment: F ->
fragment.requireView().requireViewByIdCompat(viewBindingRootId)
}
}
// -------------------------------------------------------
// ViewBindingProperty for ViewGroup
// -------------------------------------------------------
@JvmName("viewBindingViewGroup")
inline fun <V : ViewBinding> ViewGroup.viewBinding(crossinline viewBinder: (View) -> V,
crossinline viewProvider: (ViewGroup) -> View = {this}
): ViewBindingProperty<ViewGroup, V> = LazyViewBindingProperty { viewGroup: ViewGroup ->
viewBinder(viewProvider(viewGroup))
}
@JvmName("viewBindingViewGroup")
inline fun <V : ViewBinding> ViewGroup.viewBinding(crossinline viewBinder: (View) -> V,
@IdRes viewBindingRootId: Int
): ViewBindingProperty<ViewGroup, V> = LazyViewBindingProperty { viewGroup: ViewGroup ->
viewBinder(viewGroup.requireViewByIdCompat(viewBindingRootId))
}
// -------------------------------------------------------
// ViewBindingProperty for RecyclerView#ViewHolder
// -------------------------------------------------------
@JvmName("viewBindingViewHolder")
inline fun <V : ViewBinding> RecyclerView.ViewHolder.viewBinding(crossinline viewBinder: (View) -> V,
crossinline viewProvider: (RecyclerView.ViewHolder) -> View = RecyclerView.ViewHolder::itemView
): ViewBindingProperty<RecyclerView.ViewHolder, V> = LazyViewBindingProperty { holder: RecyclerView.ViewHolder ->
viewBinder(viewProvider(holder))
}
@JvmName("viewBindingViewHolder")
inline fun <V : ViewBinding> RecyclerView.ViewHolder.viewBinding(crossinline viewBinder: (View) -> V,
@IdRes viewBindingRootId: Int
): ViewBindingProperty<RecyclerView.ViewHolder, V> = LazyViewBindingProperty { holder: RecyclerView.ViewHolder ->
viewBinder(holder.itemView.requireViewByIdCompat(viewBindingRootId))
}
// -------------------------------------------------------
// ViewBindingProperty
// -------------------------------------------------------
private const val TAG = "ViewBindingProperty"
interface ViewBindingProperty<in R : Any, out V : ViewBinding> : ReadOnlyProperty<R, V> {
@MainThread
fun clear()}
class LazyViewBindingProperty<in R : Any, out V : ViewBinding>(private val viewBinder: (R) -> V
) : ViewBindingProperty<R, V> {
private var viewBinding: V? = null
@Suppress("UNCHECKED_CAST")
@MainThread
override fun getValue(thisRef: R, property: KProperty<*>): V {
// Already bound
viewBinding?.let {return it}
return viewBinder(thisRef).also {this.viewBinding = it}
}
@MainThread
override fun clear() {viewBinding = null}
}
abstract class LifecycleViewBindingProperty<in R : Any, out V : ViewBinding>(private val viewBinder: (R) -> V
) : ViewBindingProperty<R, V> {
private var viewBinding: V? = null
protected abstract fun getLifecycleOwner(thisRef: R): LifecycleOwner
@MainThread
override fun getValue(thisRef: R, property: KProperty<*>): V {
// Already bound
viewBinding?.let {return it}
val lifecycle = getLifecycleOwner(thisRef).lifecycle
val viewBinding = viewBinder(thisRef)
if (lifecycle.currentState == Lifecycle.State.DESTROYED) {
Log.w(TAG, "Access to viewBinding after Lifecycle is destroyed or hasn't created yet. "+"The instance of viewBinding will be not cached.")
// We can access to ViewBinding after Fragment.onDestroyView(), but don't save it to prevent memory leak} else {lifecycle.addObserver(ClearOnDestroyLifecycleObserver(this))
this.viewBinding = viewBinding
}
return viewBinding
}
@MainThread
override fun clear() {viewBinding = null}
private class ClearOnDestroyLifecycleObserver(private val property: LifecycleViewBindingProperty<*, *>) : LifecycleObserver {
private companion object {private val mainHandler = Handler(Looper.getMainLooper())
}
@MainThread
@OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
fun onDestroy(owner: LifecycleOwner) {mainHandler.post { property.clear() }
}
}
}
class FragmentViewBindingProperty<in F : Fragment, out V : ViewBinding>(viewBinder: (F) -> V
) : LifecycleViewBindingProperty<F, V>(viewBinder) {override fun getLifecycleOwner(thisRef: F): LifecycleOwner {
try {return thisRef.viewLifecycleOwner} catch (ignored: IllegalStateException) {error("Fragment doesn't have view associated with it or the view has been destroyed")
}
}
}
class DialogFragmentViewBindingProperty<in F : DialogFragment, out V : ViewBinding>(viewBinder: (F) -> V
) : LifecycleViewBindingProperty<F, V>(viewBinder) {override fun getLifecycleOwner(thisRef: F): LifecycleOwner {return if (thisRef.showsDialog) {thisRef} else {
try {thisRef.viewLifecycleOwner} catch (ignored: IllegalStateException) {error("Fragment doesn't have view associated with it or the view has been destroyed")
}
}
}
}
// -------------------------------------------------------
// Utils
// -------------------------------------------------------
@RestrictTo(RestrictTo.Scope.LIBRARY)
class ActivityViewBindingProperty<in A : ComponentActivity, out V : ViewBinding>(viewBinder: (A) -> V
) : LifecycleViewBindingProperty<A, V>(viewBinder) {override fun getLifecycleOwner(thisRef: A): LifecycleOwner {return thisRef}
}
fun <V : View> View.requireViewByIdCompat(@IdRes id: Int): V {return ViewCompat.requireViewById(this, id)
}
fun <V : View> Activity.requireViewByIdCompat(@IdRes id: Int): V {return ActivityCompat.requireViewById(this, id)
}
/**
* Utility to find root view for ViewBinding in Activity
*/
fun findRootView(activity: Activity): View {val contentView = activity.findViewById<ViewGroup>(android.R.id.content)
checkNotNull(contentView) {"Activity has no content view"}
return when (contentView.childCount) {1 -> contentView.getChildAt(0)
0 -> error("Content view has no children. Provide root view explicitly")
else -> error("More than one child view found in Activity content view")
}
}
fun DialogFragment.getRootView(viewBindingRootId: Int): View {val dialog = checkNotNull(dialog) {"DialogFragment doesn't have dialog. Use viewBinding delegate after onCreateDialog"}
val window = checkNotNull(dialog.window) {"Fragment's Dialog has no window"}
return with(window.decorView) {if (viewBindingRootId != 0) requireViewByIdCompat(viewBindingRootId) else this
}
}
4. 总结
ViewBinding 是一个轻量级的视图绑定计划,Android Gradle 插件会为每个 XML 布局文件创建一个绑定类。在 Fragment 中应用 ViewBinding 须要留神在 Fragment#onDestroyView() 里置空绑定类对象防止内存透露。但这会带来很多反复编写样板代码,应用属性委托能够收敛模板代码,保障调用方代码洁净清新。
角度 | findViewById | ButterKnife | Kotlin Synthetics | DataBinding | ViewBinding | ViewBindingProperty |
---|---|---|---|---|---|---|
简洁性 | ✖ | ✖ | ✔ | ✔ | ✔ | ✔ |
编译期查看 | ✖ | ✖ | ✖ | ✔ | ✔ | ✔ |
编译速度 | ✔ | ✖ | ✔ | ✖ | ✔ | ✔ |
反对 Kotlin & Java | ✔ | ✔ | ✖ | ✔ | ✔ | ✔ |
收敛模板代码 | ✖ | ✖ | ✔ | ✖ | ✖ | ✔ |
参考资料
- View Binding 视图绑定 —— 官网文档
- View Binding 与 Kotlin 委托属性的奇妙联合,辞别垃圾代码!—— Kirill Rozov 著,仍然范特稀西 译
- 谁才是 ButterKnife 的终结者?—— fundroid 著
- 深入研究 ViewBinding 在 include, merge, adapter, fragment, activity 中应用 —— Flywith24 著