Android基于DataBinding封装RecyclerView实现快速列表开发

1. 前语

在移动运用开发中，列表组件是一个非常常见的 UI 组件，绝大多数运用开发中都会运用到列表组件进行界面的开发，在 Android 开发中列表组件一般运用官方供给的 RecyclerView ，而 RecyclerView 的惯例开发需求手动创立对应的 Adapter、ViewHolder 代码，且每个 RecyclerView 的运用都需求编写这种的样板代码，存在重复代码，降低了开发功率，所以为了进步列表的开发功率（偷闲）就有了各种对 RecyclerView 封装的结构来简化其开发流程，本篇便是其间一种结构的完结。

先给结构起个姓名吧，emmm… 起名什么的真的是太难了，比写代码难多了，终究绞尽脑汁的想了一个 ardf，英文 “android rapid development framework” 的缩写，即 “Android 快速开发结构”，很好，现已完结这个结构的 50% 工作了。

2. 完结思路

姓名想好了，下一步便是想想怎么来完结，结构的中心目的是简化开发流程，关于 RecyclerView 开发来说，RecyclerView 的创立 和 item 的布局肯定是必不可少的，所以只能从 Adapter 和 ViewHolder 来着手简化，Adapter 和 ViewHolder 的作用首要是为了加载 item 的布局和对 item 的展现数据和事情进行处理，假如能把这一块做成通用的就不必每次都创立 Adapter 和 ViewHolder 了。

终究想到了运用 DataBinding 来进行封装，经过 DataBinding 的扩展将 item 布局、列表数据及事情都经过 xml 设置到 Adapter 里，在 Adapter 里再经过 DataBinding 加载 item 的布局文件终究创立 ViewHolder 并进行数据绑定，然后减少 Adapter 和 ViewHolder 的开发代码。

DataBinding 是 Google 官方的一个数据绑定结构，凭借该库，您能够声明式的将运用中的数据源绑定到布局中的界面组件上，完结经过数据驱动界面更新，然后降低布局和逻辑的耦合性，使代码逻辑更加清晰。更多关于 DataBinding 的介绍请查阅 Google 官方文档：DataBinding

封装后与封装前的开发流程比照：

能够发现，运用 ardf后不需求再创立 Adapter 和 ViewHolder，且设置数据的办法改成了运用 DataBinding 绑定的办法，降低了界面与逻辑的耦合，然后大幅度的减少样板代码编写，提升开发功率。

3. 运用

既然是为了进步开发功率、简化开发流程的结构，那就先看看实践运用作用怎么样，是不是有说的那么好，show me the code 走起。

3.1 扩展特点介绍

ardf经过 DataBinding 的 BindingAdapter 扩展了 RecycleView 一系列特点，用于在 xml 布局中对 RecyclerView 进行快捷装备，无需编写 java/kotlin 代码即可完结对 RecyclerView 的悉数装备，包含列表数据、item 布局、事情等，详细可装备特点如下:

特点名	类型	描述
data	List	RecycleView显现的数据调集
itemLayout	int	item 布局的资源id
itemViewType	ItemViewTypeCreator	多 type item 的生成器，用于获取 item 类型和对应类型的 layout 资源 id
itemClick	OnItemClickListener	item 点击事情，将item点击事情在布局里直接代理到 ViewModel 里
itemEventHandler	Any	item 内部事情处理器，用于代理 item 内部事情的处理

详细运用办法可参阅 3.3、3.4、3.5、3.6 的运用介绍。

3.2 项目装备

在项目 Module 的 build.gradle 文件中增加封装好的依赖库，现已上传 mavenCentral，如下：

dependencies {
    implementation 'com.loongwind.ardf:recyclerview-ext:1.0.0'
}

因 ardf基于 DataBinding 完结，所以需求运用该库的 Module 的 build.gradle 里的 android 装备下启用 DataBinding，启用办法如下：

android {
    ...
    buildFeatures {
        dataBinding true
    }
}

一起在插件中增加 kotlin-kapt的插件，如下：

plugins {
    id 'com.android.application'
    id 'org.jetbrains.kotlin.android'
    id 'kotlin-kapt'
}

ardf 的运用装备就完结了，点击 Sync Now同步 build.gradle 生效后即可进行代码开发。

3.3 简略运用

先看一下结合 MVVM 架构如何快速完结简略的列表数据显现以及列表数据更新功用。

3.3.1 预备列表数据

先创立一个 ViewModel 用于寄存列表的数据，这儿首要演示列表的开发就直接用一个普通的类而不是 Jetpack 的 ViewModel 库，代码如下：

class RecycleViewModel(){
    val data = ArrayList<String>()
    init {
        for (i in 0..5){
            data.add("Item $i")
        }
    }
}

代码很简略，有一个 List 类型的 data 变量，里边寄存的是 String 类型的数据，在初始化的时分向里边增加了 5 条测验数据。

3.3.2 创立 item 布局

创立列表的 item 布局文件 layout_item.xml， 简略增加一个 TextView 进行演示，代码如下：

<?xml version="1.0" encoding="utf-8"?>
<layout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto">
    <data>
        <!--经过 DataBinding 接纳 item 数据-->
        <variable
            name="item"
            type="String" />
    </data>
    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:orientation="vertical"
        android:paddingVertical="2dp">
        <TextView
            android:id="@+id/text"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:gravity="center"
            android:padding="15dp"
            android:text="@{item}" // 运用 DataBinding 进行数据绑定
            android:background="#7AEDEBEB"/>
    </LinearLayout>
</layout>

布局里经过 DataBinding 传入了一个 String 类型的 item 变量，并将这个变量绑定到了 TextView 的 text 特点上，即对 TextView 设置显现的字符串值，这儿需求注意以下两点：

• 变量名必须为 item，由于这是结构里封装好的，称号不对无法主动接纳传递过来的数据
• item 的数据类型需跟前面 ViewModel 中界说的列表中的数据类型共同，也便是与上面界说的 data 里子元素类型共同

3.3.3 创立 RecyclerView

数据和 item 布局都预备好了，下面便是在页面的 activity_recycleview_simple.xml 布局里创立 RecyclerView 了，代码如下：

<?xml version="1.0" encoding="utf-8"?>
<layout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto">
    <data>
        <!--  经过 DataBinding 接纳 ViewModel 实例  -->
        <variable
            name="viewModel"
            type="com.loongwind.ardf.demo.RecycleViewModel" />
    </data>
    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="match_parent">
        <androidx.recyclerview.widget.RecyclerView
            android:layout_width="match_parent"
            android:layout_height="match_parent"
            app:layoutManager="androidx.recyclerview.widget.LinearLayoutManager"
            app:data="@{viewModel.data}"  // 绑定列表数据
            app:itemLayout="@{@layout/layout_item}"/>  // 绑定 item 布局
    </LinearLayout>
</layout>

布局里经过 DataBinding 接纳一个 RecycleViewModel 类型的 viewModel 变量，也便是第 1 步预备数据的 RecycleViewModel 类的实例。

xml 里 RecyclerView 设置首要分为三步：

• 设置 layoutManger
• 经过 data特点绑定列表数据
• 经过 itemLayout 特点绑定 item 布局

一定不要忘了设置 layoutManger，在实践开发中经常有小伙伴忘记设置这个特点导致列表不显现而排查半响原因浪费很多的时刻

3.3.4 Activity 中运用

接下来便是在 Activity 中运用了，即加载第 3 步创立的 layout 布局，并将 RecycleViewModel 的实例经过 DataBinding 传到布局里去。代码如下：

class RecycleViewSimpleActivity : AppCompatActivity(){
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        // 加载页面显现布局，经过 DataBindingUtil.setContentView 办法加载
        // ActivityRecycleviewSimpleBinding 是 DataBinding 插件依据布局文件主动生成
        val binding = DataBindingUtil.setContentView<ActivityRecycleviewSimpleBinding>(
            this,
            R.layout.activity_recycleview_simple
        )
        // 绑定数据
        binding.viewModel = RecycleViewModel(this)
    }
}

经过 DataBinding 加载界面布局，然后绑定界面数据源。代码完结就完结了，运转一下看看作用：

能够发现整个完结过程中没有触及 Adapter 和 ViewHolder，是不是比较省时省力。

3.3.5 数据更新

列表数据现已展现出来了，但却是静态数据，那么如何完结列表数据的动态更新呢，这就需求用到 DataBinding 供给的可观察者目标 Observable ，它是一个数据容器，里边寄存的是咱们需求的实践数据，当 Observable 中的数据发生改变时就会通知订阅它的观察者，Observable 供给了一个 List 的观察者容器 ObservableArrayList ，这儿咱们只需求将本来界说的 List 类型的 data 修改为 ObservableArrayList 即可，代码如下：

val data = ObservableArrayList<String>()

当咱们对 data 中的数据进行更新的时分，就会主动改写界面更新界面上显现的数据，下面为了演示在页面布局里增加两个按钮别离进行增加数据和删去数据的操作，如下：

<?xml version="1.0" encoding="utf-8"?>
<layout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto">
    <data>
        <variable
            name="viewModel"
            type="com.loongwind.ardf.demo.RecycleViewModel" />
    </data>
    <androidx.constraintlayout.widget.ConstraintLayout
        android:layout_width="match_parent"
        android:layout_height="match_parent">
        <androidx.recyclerview.widget.RecyclerView
            android:layout_width="match_parent"
            android:layout_height="0dp"
            app:layout_constraintVertical_weight="1"
            app:layout_constraintTop_toTopOf="parent"
            app:layout_constraintBottom_toTopOf="@+id/add_item"
            app:layoutManager="androidx.recyclerview.widget.LinearLayoutManager"
            app:data="@{viewModel.data}"
            app:itemLayout="@{@layout/layout_item}"/>
        <Button
            android:id="@+id/add_item"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            app:layout_constraintBottom_toBottomOf="parent"
            app:layout_constraintLeft_toLeftOf="parent"
            android:layout_marginStart="20dp"
            android:layout_marginBottom="20dp"
            app:layout_constraintRight_toLeftOf="@id/del_item"
            android:text="增加item"
            android:onClick="@{()->viewModel.addItem()}"/>
        <Button
            android:id="@+id/del_item"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            app:layout_constraintTop_toTopOf="@id/add_item"
            app:layout_constraintRight_toRightOf="parent"
            app:layout_constraintLeft_toRightOf="@id/add_item"
            android:layout_marginEnd="20dp"
            android:text="删去item"
            android:onClick="@{()->viewModel.deleteItem()}"/>
    </androidx.constraintlayout.widget.ConstraintLayout>
</layout>

按钮的点击事情也是经过 DataBinding 绑定到 ViewModel 的对应办法，也便是这儿的 addItem()、deleteItem()，ViewModel 中代码如下：

class RecycleViewModel(var view: IView){
    ...
    fun addItem(){
        data.add("Item ${data.size}")
    }
    fun deleteItem(){
        data.removeAt(data.size - 1)
    }
}

演示代码简略完结了增加 item 和删去 item 的办法。运转一下看一下作用：

3.4 item 点击事情

item 的点击事情处理是列表开发中常见的事情处理，如点击列表 item 跳转到对应的详情页，ardf也对 item 的点击事情进行了封装，只需求在 xml 中经过 itemClick 为 RecyclerView 绑定点击事情即可，代码如下：

<androidx.recyclerview.widget.RecyclerView
            android:layout_width="match_parent"
            android:layout_height="match_parent"
            app:layoutManager="androidx.recyclerview.widget.LinearLayoutManager"
            app:data="@{viewModel.data}"
            app:itemLayout="@{@layout/layout_item}"
            app:itemClick="@{(item,position)-> viewModel.onItemClick(item)}"/>

经过 DataBinding 将 item 的点击事情代理到 ViewModel 的 onItemClick 办法，onItemClick 办法是咱们在 ViewModel 中自界说创立的，如下：

class RecycleViewModel(var view: IView){
    ...
    fun onItemClick(item:Any?){
        if(item is String){
            view.toast(item)
        }
    }
}

onItemClick 的参数是一个 Any? 类型，在布局 xml 中传入的是 item 的数据，所以需求判断数据类型与 item 的数据类型是否共同，再进行业务处理。

此处为了便利展现测验作用，经过自界说 IView 接口完结了 Toast 弹窗提示

运转作用如下：

3.5 Item 内部事情

关于杂乱的业务或许需求在 item 内部进行事情处理，比方 item 上有可操作按钮、挑选框等，ardf也对 item 内部事情的处理进行了封装，只需求在 xml 中经过 itemEventHandler 特点为 RecyclerView 绑定Item内部点击事情即可，如下：

<androidx.recyclerview.widget.RecyclerView
            android:layout_width="match_parent"
            android:layout_height="match_parent"
            app:layoutManager="androidx.recyclerview.widget.LinearLayoutManager"
            app:data="@{viewModel.data}"
            app:itemLayout="@{@layout/layout_item}"
            app:itemEventHandler="@{viewModel}"/>

经过 itemEventHandler 将 ViewModel 传递到了 item 布局，在 item 布局里将 item 的内部事情代理到 ViewModel 内进行处理，item 布局代码如下：

<?xml version="1.0" encoding="utf-8"?>
<layout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto">
    <data>
        <variable
            name="item"
            type="String" />
        <variable
            name="handler"
            type="com.loongwind.ardf.demo.RecycleViewModel" />
    </data>
    <androidx.constraintlayout.widget.ConstraintLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content">
        <TextView
            android:id="@+id/text"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            app:layout_constraintTop_toTopOf="parent"
            app:layout_constraintLeft_toLeftOf="parent"
            app:layout_constraintRight_toRightOf="parent"
            android:gravity="center"
            android:padding="15dp"
            android:text="@{item}"/>
        <Button
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            app:layout_constraintTop_toTopOf="parent"
            app:layout_constraintBottom_toBottomOf="parent"
            app:layout_constraintRight_toRightOf="parent"
            android:text="删去"
            android:layout_marginRight="10dp"
            android:onClick="@{()->handler.eventDeleteItem(item)}"/>
    </androidx.constraintlayout.widget.ConstraintLayout>
</layout>

item 布局里经过 handler接纳传进来的 itemEventHandler目标，类型需跟 itemEventHandler 传递的类型共同，这儿演示在 item 布局里增加一个删去按钮，再将删去按钮的点击事情代理到 ViewModel 的 eventDeleteItem办法，该办法也是在 ViewModel 中自界说创立的，如下：

class RecycleViewModel(var view: IView){
    ...
    fun eventDeleteItem(item:String){
        data.remove(item)
    }
}

该办法接纳了一个 String 类型的 item 数据，完结从列表中移除该 item 数据，作用如下所示：

3.6 不同类型的 item 布局

RecyclerView 是支撑不同类型的 item 布局的，ardf也经过供给 itemViewType特点的装备来完结不同类型 item 布局的展现。

itemViewType 特点需传入一个 ItemViewTypeCreator类型的目标，ItemViewTypeCreator是一个接口类型，界说如下：

interface ItemViewTypeCreator{
    /**
     * 经过 item 下标和数据回来布局类型
     * @param position item 下标
     * @param item item 数据
     * @return item 布局类型
     */
    fun getItemViewType(position: Int, item: Any?) : Int
    /**
     * 经过 item 布局类型回来布局资源 id
     * @param viewType item 数据类型
     * @return item 布局资源 id
     */
    fun getItemLayout(viewType: Int) : Int
}

在 ViewModel 创立一个 ItemViewTypeCreator 的目标实例，如下：

class MultiItemViewModel(var view: IView){
    // List 的 item 数据类型改为 Any
    val data = ObservableArrayList<Any>()
    // 界说多 item 布局类型的创立器
    val itemViewTypes = object : BaseBindingAdapter.ItemViewTypeCreator{
        override fun getItemViewType(position: Int, item: Any?): Int {
            // 经过 item 数据类型回来不同的布局类型
            return if(item is String){
                0
            }else{
                1
            }
        }
        override fun getItemLayout(viewType: Int): Int {
            // 依据不同的布局类型回来不同的布局资源 id
            return if(viewType == 0){
                R.layout.layout_item
            }else{
                R.layout.layout_item2
            }
        }
    }
    init {
        // 增加测验数据
        for (i in 0..10){
            // 双数增加字符串数据，奇数增加 User 数据
            if(i % 2 == 0){
                data.add("Item $i")
            }else{
                data.add(User(name = "Name $i", img = "https://picsum.photos/200"))
            }
            println(data)
        }
    }
}

创立了一个 MultiItemViewModel 类用于演示完结不同类型 item 布局的处理，实例化一个 ItemViewTypeCreator 类的目标完结 item 类型和布局的回来。

将 data 类型修改为 ObservableArrayList<Any>用于寄存不同类型的 item 数据。

User 的 item 布局《代码如下：

<?xml version="1.0" encoding="utf-8"?>
<layout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto">
    <data>
        <!-- DataBinding 接纳 item 数据，数据类型为 User -->
        <variable
            name="item"
            type="com.loongwind.ardf.demo.User" />
    </data>
    <androidx.constraintlayout.widget.ConstraintLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:background="#3703A9F4">
        <!-- 用户头像，并绑定点击事情 -->
        <ImageView
            android:layout_width="32dp"
            android:layout_height="32dp"
            android:src="@mipmap/ic_launcher"
            app:layout_constraintLeft_toLeftOf="parent"
            app:layout_constraintTop_toTopOf="parent"
            app:layout_constraintBottom_toBottomOf="parent"
            android:layout_marginLeft="30dp"
            android:onClick="@{()->handler.omImgClick(item)}"/>
        <!-- 用户称号 -->
        <TextView
            android:id="@+id/text"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            app:layout_constraintTop_toTopOf="parent"
            app:layout_constraintLeft_toLeftOf="parent"
            app:layout_constraintRight_toRightOf="parent"
            android:gravity="center"
            android:padding="15dp"
            android:text="@{item.name}"/>
    </androidx.constraintlayout.widget.ConstraintLayout>
</layout>

将接纳的 item 数据类型换成 User。

终究在页面布局中的 RecyclerView 上装备 itemViewType 特点，如下：

<androidx.recyclerview.widget.RecyclerView
            android:layout_width="match_parent"
            android:layout_height="match_parent"
            app:layoutManager="androidx.recyclerview.widget.LinearLayoutManager"
            app:data="@{viewModel.data}"
            app:itemViewType="@{viewModel.itemViewTypes}"/>

运转一下看一下作用:

4. 源码解析

上面介绍了 ardf 的运用办法，ardf的中心完结是封装了通用的 Adapter 和 ViewHolder，然后经过 DataBinding 的 @BindingAdapter扩展支撑将 RecyclerView 的常用设置在 xml 里进行装备。

整体结构关系图如下：

从图上能够发现，ardf中心为以下三个模块：

• ViewHolder 的封装：BindingViewHolder，完结 item 数据和内部事情的绑定
• Adapter 的封装： BaseBindingAdapter、DefaultBindingAdapter，完结列表数据改变的监听、依据 item 布局创立 ViewHolder 并绑定事情
• @BindingAdapter 扩展：setData办法，关联 RecyclerView 与 Adapter

接下来将从源码层面向大家介绍该封装的详细完结。

4.1 ViewHolder

创立一个 BindingViewHolder 类继承自 RecyclerView.ViewHolder ：

class BindingViewHolder<T, BINDING : ViewDataBinding>(val binding: BINDING)
    : RecyclerView.ViewHolder(binding.root){
    fun bind(t: T?) {
        binding.setVariable(BR.item, t)
    }
    fun setItemEventHandler(handler:Any?){
        binding.setVariable(BR.handler, handler)
    }
}

该类有两个泛型，T为 item 的数据类型，BINDING为 item 布局生成的 ViewDataBinding 类。传入的参数 binding 即为 BINDING 类型，然后经过 binding.root获取布局的实践 View 将其传给 RecyclerView.ViewHolder。

BindingViewHolder 还对外供给了两个办法，bind和 setItemEventHandler办法。

bind 是用于绑定数据，即将 item 的数据和布局绑定起来，这儿是经过 binding.setVariable(BR.item, t)将数据传递到布局里的 item 变量；

setItemEventHandler 是设置 item 内部事情处理的目标，绑定到布局的 handler 变量。

这儿的 BR.item和 BR.handler是 DataBinding 依据布局里运用的变量主动生成的，所以为了生成这两个变量，建了一个空的布局文件，界说了这两个变量，如下：

<?xml version="1.0" encoding="utf-8"?>
<layout xmlns:android="http://schemas.android.com/apk/res/android">
    <data>
        <variable
            name="item"
            type="Object" />
        <variable
            name="handler"
            type="Object" />
    </data>
</layout>

4.2 Adapter

创立好通用的 ViewHolder 以后，接下来便是封装通用的 Adapter，为了便于扩展先创立一个笼统的 BaseBindingAdapter界说如下：

abstract class BaseBindingAdapter<T:Any, BINDING : ViewDataBinding> :
    RecyclerView.Adapter<BindingViewHolder<T, BINDING>>() {
        ...
}

跟 BindingViewHolder 一样有两个泛型，Adapter 的 ViewHolder 泛型类型便是上面创立的 BindingViewHolder。

4.2.1 数据处理

类界说好后，接下来便是详细的完结，由于需求向 Adapter 中设置数据，所以需求界说一个 data 变量用于接纳列表的数据源，并重写其 set 办法，代码如下：

/**
 * 列表数据
 */
var data: List<T>? = null
    @SuppressLint("NotifyDataSetChanged")
    set(data) {
        field = data
        // 判断假如是 ObservableList 类型，则为其增加 changeCallback 回调
        if (data is ObservableList<*>) {
            // 假如 listener 为空则创立 ObserverListChangeListener 目标，传入当时 Adapter
            if (listener == null) {
                listener = ObserverListChangeListener(this)
            }
            // 将已增加的 listener 移除，防止增加多个导致重复回调
            (data as ObservableList<T>).removeOnListChangedCallback(listener)
            // 设置 List 数据改变回调
            data.addOnListChangedCallback(listener)
        }
        // 改写界面数据
        notifyDataSetChanged()
    }

data 用于接纳设置的列表数据，重写了 set 办法，假如设置的数据类型是 ObservableList 则为其增加数据改变的回调。回调ObserverListChangeListener的代码如下：

class ObserverListChangeListener<T>(private val adapter:  RecyclerView.Adapter<*>) : ObservableList.OnListChangedCallback<ObservableList<T>>() {
    @SuppressLint("NotifyDataSetChanged")
    override fun onChanged(sender: ObservableList<T>) {
        adapter.notifyDataSetChanged()
    }
    override fun onItemRangeRemoved(sender: ObservableList<T>, positionStart: Int, itemCount: Int) {
        adapter.notifyItemRangeRemoved(positionStart, itemCount)
    }
    override fun onItemRangeMoved(sender: ObservableList<T>, fromPosition: Int, toPosition: Int, itemCount: Int) {
        adapter.notifyItemMoved(fromPosition, toPosition)
    }
    override fun onItemRangeInserted(sender: ObservableList<T>, positionStart: Int, itemCount: Int) {
        adapter.notifyItemRangeInserted(positionStart, itemCount)
    }
    override fun onItemRangeChanged(sender: ObservableList<T>, positionStart: Int, itemCount: Int) {
        adapter.notifyItemRangeChanged(positionStart, itemCount)
    }
}

结构参数传入了 RecyclerView.Adapter ，在每个数据改变的回调中调用 Adapter 的对应改写数据的办法，完结数据改变主动改写界面。

数据有了，getItemCount办法的完结就有了，一起为了便利依据 position 获取 item 的数据，这儿也提取了一个 getItem办法，完结如下：

    fun getItem(position: Int): T? {
        return data?.getOrNull(position)
    }
        override fun getItemCount(): Int {
        return data?.size ?: 0
    }

4.2.2 创立布局

界说一个 layoutRes用于接纳 item 布局的资源 id，如下：

    @get:LayoutRes
    abstract val layoutRes: Int

这儿界说的是一个笼统 get 办法，需求子类去完结回来详细的 item 布局的资源 id。

界说 itemViewTypeCreator用于接纳有多种 item 布局类型时的布局数据：

var itemViewTypeCreator: ItemViewTypeCreator? = null

完结 getItemViewType处理 item 布局类型：

   override fun getItemViewType(position: Int): Int {
        return itemViewTypeCreator?.getItemViewType(position, getItem(position))
            ?: super.getItemViewType(position)
    }

代码很好了解，假如 ItemViewTypeCreator 不为空则调用 getItemViewType 办法回来布局类型，假如为空则调用 super 办法，即默认的 item 布局类型。

然后完结 onCreateViewHolder办法，源码如下：

override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): BindingViewHolder<T, BINDING> {
    val layout = itemViewTypeCreator?.getItemLayout(viewType) ?: layoutRes
    val binding = DataBindingUtil.inflate<BINDING>(LayoutInflater.from(parent.context), layout, parent, false)
    val holder = BindingViewHolder<T, BINDING>(binding)
    bindClick(holder, binding)
    return holder
}

先判断 itemViewTypeCreator是否为空，不为空就调用 getItemLayout办法获取布局 id，为空则直接运用 layoutRes；获取到 item 布局的资源 id 后就能够经过 DataBindingUtil.inflate办法创立布局的 ViewDataBinding，再经过 binding 创立 ViewHolder 并回来。

4.2.3 绑定数据&事情

onCreateViewHolder 中创立完 holder 后还调用了一个 bindClick办法，用于绑定 item 的事情，bindClick的完结如下：

    protected fun bindClick(holder: BindingViewHolder<*, *>, binding: BINDING) {
        binding.root.setOnClickListener {
            val position = holder.layoutPosition
            itemClickListener?.onItemClick(getItem(position), position)
        }
    }

经过 binding.root获取 item 的 View 目标，然后对其设置点击事情，在事情的处理里调用 itemClickListener?.onItemClick，即布局里传入的 item 点击事情， itemClickListener的界说如下：

var itemClickListener: OnItemClickListener<T>? = null
interface OnItemClickListener<T> {
    fun onItemClick(t: T?, position: Int)
}

终究完结 onBindViewHolder办法进行数据绑定：

override fun onBindViewHolder(holder: BindingViewHolder<T, BINDING>, position: Int) {
    holder.bind(getItem(position))
    holder.setItemEventHandler(itemEventHandler)
}

先调用 holder.bind绑定数据，然后调用 holder.setItemEventHandler设置 item 内部事情的处理目标。

完好的 BaseBindingAdapter源码如下：

abstract class BaseBindingAdapter<T:Any, BINDING : ViewDataBinding> :
    RecyclerView.Adapter<BindingViewHolder<T, BINDING>>() {
    var itemClickListener: OnItemClickListener<T>? = null
    private var listener: ObserverListChangeListener<T>? = null
    var itemViewTypeCreator: ItemViewTypeCreator? = null
    var itemEventHandler : Any? = null
    var data: List<T>? = null
        @SuppressLint("NotifyDataSetChanged")
        set(data) {
            field = data
            //假如是ObservableList则为其增加changeCallback
            if (data is ObservableList<*>) {
                if (listener == null) {
                    listener = ObserverListChangeListener(this)
                }
                (data as ObservableList<T>).removeOnListChangedCallback(listener)
                data.addOnListChangedCallback(listener)
            }
            notifyDataSetChanged()
        }
    @get:LayoutRes
    abstract val layoutRes: Int
    fun getItem(position: Int): T? {
        return data?.getOrNull(position)
    }
    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): BindingViewHolder<T, BINDING> {
        val layout = itemViewTypeCreator?.getItemLayout(viewType) ?: layoutRes
        val binding = DataBindingUtil.inflate<BINDING>(LayoutInflater.from(parent.context), layout, parent, false)
        val holder = BindingViewHolder<T, BINDING>(binding)
        bindClick(holder, binding)
        return holder
    }
    override fun getItemViewType(position: Int): Int {
        return itemViewTypeCreator?.getItemViewType(position, getItem(position))
            ?: super.getItemViewType(position)
    }
    override fun onBindViewHolder(holder: BindingViewHolder<T, BINDING>, position: Int) {
        holder.bind(getItem(position))
        holder.setItemEventHandler(itemEventHandler)
    }
    override fun getItemCount(): Int {
        return data?.size ?: 0
    }
    interface OnItemClickListener<T> {
        fun onItemClick(t: T?, position: Int)
    }
    protected fun bindClick(holder: BindingViewHolder<*, *>, binding: BINDING) {
        binding.root.setOnClickListener {
            val position = holder.layoutPosition
            itemClickListener?.onItemClick(getItem(position), position)
        }
    }
    interface ItemViewTypeCreator{
        fun getItemViewType(position: Int, item: Any?) : Int
        fun getItemLayout(viewType: Int) : Int
    }
}

4.2.4 通用 Adapter

BaseBindingAdapter类有一个 get 的 layoutRes 是笼统办法，需求子类传入一个 item 布局资源 id ，这儿界说了一个通用也是默认的 DefaultBindingAdapter类：

class DefaultBindingAdapter(@param:LayoutRes @field:LayoutRes override val layoutRes: Int)
    : BaseBindingAdapter<Any, ViewDataBinding>()

只传入了一个参数，即 item 布局 id，将其作为 layoutRes 的 get 回来值。

4.3 @BindingAdapter

Adapter 预备好后，就能够经过 @BindingAdapter 将其与 RecyclerView 进行关联，完结在 xml 中装备数据源、布局和相关事情等数据。

DataBinding 完结在 xml 里绑定数据的本质是经过调用 View 对应特点的 set 办法来完结，假如 View 没有对应的 set 办法，就需求经过 @BindingAdapter 来扩展一个 set 办法来完结。这儿为 RecyclerView 扩展了一个 setData 的办法，源码如下：

@BindingAdapter(value = ["data", "itemLayout", "itemClick","itemViewType", "itemEventHandler"], requireAll = false)
fun setData(
    recyclerView: RecyclerView,
    data: List<Any>?,
    @LayoutRes itemLayout: Int,
    listener: BaseBindingAdapter.OnItemClickListener<Any>?,
    itemViewTypeCreator: BaseBindingAdapter.ItemViewTypeCreator?,
    itemEventHandler: Any?
) {
    val adapter = recyclerView.adapter
    if (adapter == null) {
        val defaultBindingAdapter = DefaultBindingAdapter(itemLayout)
        defaultBindingAdapter.data = data
        defaultBindingAdapter.itemClickListener = listener
        defaultBindingAdapter.itemViewTypeCreator = itemViewTypeCreator
        defaultBindingAdapter.itemEventHandler = itemEventHandler
        recyclerView.adapter = defaultBindingAdapter
    } else if (adapter is BaseBindingAdapter<*, *>) {
        (adapter as BaseBindingAdapter<Any, ViewDataBinding>).data = data
        adapter.itemViewTypeCreator = itemViewTypeCreator
        adapter.itemClickListener = listener
        adapter.itemEventHandler = itemEventHandler
    }
}

要让 DataBinding 识别这个 set 办法需求在办法上加 @BindingAdapter 的注解，一起在注解中声明其在 xml 可装备的对应特点的称号，其传入的数据与该办法的参数除第一个参数以外一一对应，第一个参数则运用的 View 自身；注解上还有一个 requireAll参数，表明是否需求一切特点都在 xml 里装备了才干匹配运用该办法，这儿设置的 false，即表明不必全都装备也能匹配到该办法。

详细完结首要获取 RecyclerView 当时的 adapter，假如当时 adapter 为空则创立一个 DefaultBindingAdapter ，然后设置列表数据、item 点击事情、多 item 布局类型的创立器、item 内部事情处理器，终究把 adapter 设置给 RecyclerView；假如 adapter 不为空，且类型为 BaseBindingAdapter则从头设置一遍 adapter 的对应数据 。

整个封装的完结逻辑和源码到这儿就介绍完了，发现代码其实并不多，封装的完结也并不杂乱，可是实践的运用作用却是非常不错的。

5. 终究

基于 DataBInding 对 RecyclerView 进行封装后，在进行列表功用的开发时无需再进行重复的 Adapter、ViewHolder 的样板代码编写，让开发者能更专注于列表功用业务自身的 item UI 布局的还原、数据逻辑的处理，然后进步开发功率，且大大的降低了布局与逻辑的耦合性，也便于在开发时进行对应的单元测验然后更好的进步开发质量。

源码地址：ardf

mavenCentral：com.loongwind.ardf:recyclerview-ext:1.0.0

我正在参与技能社区创作者签约计划招募活动，点击链接报名投稿