更高效地刷新 RecyclerView | DiffUtil二次封装-阿里云开发者社区

每次数据变化都全量刷新整个列表是很奢侈的，不仅整个列表会闪烁一下，而且所有可见表项都会重新执行一遍onBindViewHolder()并重绘列表（即便它并不需要刷新）。若表项视图复杂，会显著影响列表性能。

更高效的刷新方式应该是：只刷新数据发生变化的表项。RecyclerView.Adapter有 4 个非全量刷新方法，分别是：notifyItemRangeInserted()、notifyItemRangeChanged()、notifyItemRangeRemoved、notifyItemMoved()。调用它们时都需指定变化范围，这要求业务层了解数据变化的细节，无疑增加了调用难度。

DiffUtil模版代码

androidx.recyclerview.widget包下有一个工具类叫DiffUtil，它利用了一种算法计算出两个列表间差异，并且可以直接应用到RecyclerView.Adapter上，自动实现非全量刷新。

使用DiffUtil的模版代码如下：

val oldList = ... // 老列表
val newList = ... // 新列表
val adapter：RecyclerView.Adapter = ...

// 1.定义比对方法
val callback = object : DiffUtil.Callback() {
    override fun getOldListSize(): Int = oldList.size
    override fun getNewListSize(): Int = newList.size
    override fun areItemsTheSame(oldItemPosition: Int, newItemPosition: Int): Boolean {
        // 分别获取新老列表中对应位置的元素
        val oldItem = oldList[oldItemPosition]
        val newItem = newList[newItemPosition]
        return ... // 定义什么情况下新老元素是同一个对象（通常是业务id）
    }
    override fun areContentsTheSame(oldItemPosition: Int, newItemPosition: Int): Boolean {
        val oldItem = oldList[oldItemPosition]
        val newItem = newList[newItemPosition]
        return ... // 定义什么情况下同一对象内容是否相同 (由业务逻辑决定)
    }
    override fun getChangePayload(oldItemPosition: Int, newItemPosition: Int): Any? {
        val oldItem = oldList[oldItemPosition]
        val newItem = newList[newItemPosition]
        return ... // 具体定义同一对象内容是如何地不同 (返回值会作为payloads传入onBindViewHoder())
    }
}
// 2.进行比对并输出结果
val diffResult = DiffUtil.calculateDiff(callback)
// 3. 将比对结果应用到 adapter
diffResult.dispatchUpdatesTo(adapter)

DiffUtil需要 3 个输入，一个老列表，一个新列表，一个DiffUtil.Callback，其中的Callback的实现和业务逻辑有关，它定义了如何比对列表中的数据。

判定列表中数据是否相同分为递进三个层次：

是否是同一个数据：对应areItemsTheSame()
若是同一个数据，其中具体内容是否相同：对应areContentsTheSame()（当areItemsTheSame()返回true时才会被调用）
若同一数据的具体内容不同，则找出不同点：对应getChangePayload()（当areContentsTheSame()返回false时才会被调用）

DiffUtil输出 1 个比对结果DiffResult，该结果可以应用到RecyclerView.Adapter上：

// 将比对结果应用到Adapter
public void dispatchUpdatesTo(final RecyclerView.Adapter adapter) {
    dispatchUpdatesTo(new AdapterListUpdateCallback(adapter));
}

// 将比对结果应用到ListUpdateCallback
public void dispatchUpdatesTo(@NonNull ListUpdateCallback updateCallback) {...}

// 基于 RecyclerView.Adapter 实现的列表更新回调
public final class AdapterListUpdateCallback implements ListUpdateCallback {
    private final RecyclerView.Adapter mAdapter;
    public AdapterListUpdateCallback(@NonNull RecyclerView.Adapter adapter) {
        mAdapter = adapter;
    }
    @Override
    public void onInserted(int position, int count) {
        // 区间插入
        mAdapter.notifyItemRangeInserted(position, count);
    }
    @Override
    public void onRemoved(int position, int count) {
        // 区间移除
        mAdapter.notifyItemRangeRemoved(position, count);
    }
    @Override
    public void onMoved(int fromPosition, int toPosition) {
        // 移动
        mAdapter.notifyItemMoved(fromPosition, toPosition);
    }
    @Override
    public void onChanged(int position, int count, Object payload) {
        // 区间更新
        mAdapter.notifyItemRangeChanged(position, count, payload);
    }
}

DiffUtil将比对结果以ListUpdateCallback回调的形式反馈给业务层。插入、移除、移动、更新这四个回调表示列表内容四种可能的变化，对于RecyclerView.Adapter来说正好对应着四个非全量更新方法。

DiffUtil.Callback与业务解耦

不同的业务场景，需要实现不同的DiffUtil.Callback，因为它和具体的业务数据耦合。这使得它无法和上一篇介绍的类型无关适配器一起使用。

有没有办法可以使 DiffUtil.Callback的实现和具体业务数据解耦？

这里的业务逻辑是“比较数据是否一致”的算法，是不是可以把这段逻辑写在数据类体内？

拟定了一个新接口：

interface Diff {
    // 判断当前对象和给定对象是否是同一对象
    fun isSameObject(other: Any): Boolean
    // 判断当前对象和给定对象是否拥有相同内容 
    fun hasSameContent(other: Any): Boolean
    // 返回当前对象和给定对象的差异
    fun diff(other: Any): Any
}

然后让数据类实现该接口：

data class Text(
    var text: String,
    var type: Int,
    var id: Int
) : Diff {
    override fun isSameObject(other: Any): Boolean = this.id == other.id
    override fun hasSameContent(other: Any): Boolean = this.text == other.text
    override fun diff(other: Any?): Any? {
        return when {
            other !is Text -> null
            this.text != other.text -> {"text change"}
            else -> null
        }
    }
}

这样DiffUtil.Callback的逻辑就可以和业务数据解耦：

// 包含任何数据类型的列表
val newList: List<Any> = ... 
val oldList: List<Any> = ...
val callback = object : DiffUtil.Callback() {
    override fun getOldListSize(): Int = oldList.size
    override fun getNewListSize(): Int = newList.size
    override fun areItemsTheSame(oldItemPosition: Int, newItemPosition: Int): Boolean {
        // 将数据强转为Diff
        val oldItem = oldList[oldItemPosition] as? Diff
        val newItem = newList[newItemPosition] as? Diff
        if (oldItem == null || newItem == null) return false
        return oldItem.isSameObject(newItem)
    }
    override fun areContentsTheSame(oldItemPosition: Int, newItemPosition: Int): Boolean {
        val oldItem = oldList[oldItemPosition] as? Diff
        val newItem = newList[newItemPosition] as? Diff
        f (oldItem == null || newItem == null) return false
        return oldItem.hasSameContent(newItem)
    }
    override fun getChangePayload(oldItemPosition: Int, newItemPosition: Int): Any? {
        val oldItem = oldList[oldItemPosition] as? Diff
        val newItem = newList[newItemPosition] as? Diff
        if (oldItem == null || newItem == null) return null
        return oldItem.diff(newItem)
    }
}

转念一想，所有非空类的基类Any中就包含了这些语义：

public open class Any {
    // 用于判断当前对象和另一个对象是否是同一个对象
    public open operator fun equals(other: Any?): Boolean
    // 返回当前对象哈希值
    public open fun hashCode(): Int
}

这样就可以简化Diff接口：

interface Diff {
    infix fun diff(other: Any?): Any?
}

保留字infix表示这个函数的调用可以使用中缀表达式，以增加代码可读性（效果见下段代码）。

数据实体类和DiffUtil.Callback的实现也被简化：

data class Text(
    var text: String,
    var type: Int,
    var id: Int
) : Diff {
    override fun hashCode(): Int = this.id
    override fun diff(other: Any?): Any? {
        return when {
            other !is Text -> null
            this.text != other.text -> {"text diff"}
            else -> null
        }
    }
    override fun equals(other: Any?): Boolean {
        return (other as? Text)?.text == this.text
    }
}

val callback = object : DiffUtil.Callback() {
    override fun getOldListSize(): Int = oldList.size
    override fun getNewListSize(): Int = newList.size
    override fun areItemsTheSame(oldItemPosition: Int, newItemPosition: Int): Boolean {
        val oldItem = oldList[oldItemPosition]
        val newItem = newList[newItemPosition]
        return oldItem.hashCode() == newItem.hashCode()
    }
    override fun areContentsTheSame(oldItemPosition: Int, newItemPosition: Int): Boolean {
        val oldItem = oldList[oldItemPosition]
        val newItem = newList[newItemPosition]
        return oldItem == newItem
    }
    override fun getChangePayload(oldItemPosition: Int, newItemPosition: Int): Any? {
        val oldItem = oldList[oldItemPosition] as? Diff
        val newItem = newList[newItemPosition] as? Diff
        if (oldItem == null || newItem == null) return null
        return oldItem diff newItem // 中缀表达式
    }
}

DiffUtil.calculateDiff()异步化

比对算法是耗时的，将其异步化是稳妥的。

androidx.recyclerview.widget包下已经有一个可直接使用的AsyncListDiffer：

// 使用时必须指定一个具体的数据类型
public class AsyncListDiffer<T> {
    // 执行比对的后台线程
    Executor mMainThreadExecutor;
    // 用于将比对结果抛到主线程
    private static class MainThreadExecutor implements Executor {
        final Handler mHandler = new Handler(Looper.getMainLooper());
        MainThreadExecutor() {}
        @Override
        public void execute(@NonNull Runnable command) {
            mHandler.post(command);
        }
    }
    // 提交新列表数据
    public void submitList(@Nullable final List<T> newList){
        // 在后台执行比对...
    }
    ...
}

它在后台线程执行比对，并将结果抛到主线程。可惜的是它和类型绑定，无法和无类型适配器一起使用。

无奈只能参考它的思想重新写一个自己的：

class AsyncListDiffer(
    // 之所以使用listUpdateCallback，目的是让AsyncListDiffer的适用范围不局限于RecyclerView.Adapter
    var listUpdateCallback: ListUpdateCallback,
    // 自定义协程的调度器，用于适配既有代码，把比对逻辑放到既有线程中，而不是新起一个
    dispatcher: CoroutineDispatcher 
) : DiffUtil.Callback(), CoroutineScope by CoroutineScope(SupervisorJob() + dispatcher) {
    // 可装填任何类型的新旧列表
    var oldList = listOf<Any>()
    var newList = listOf<Any>()
    // 用于标记每一次提交列表
    private var maxSubmitGeneration: Int = 0
    // 提交新列表
    fun submitList(newList: List<Any>) {
        val submitGeneration = ++maxSubmitGeneration
        this.newList = newList
        // 快速返回：没有需要更新的东西
        if (this.oldList == newList) return
        // 快速返回：旧列表为空，全量接收新列表
        if (this.oldList.isEmpty()) {
            this.oldList = newList
            // 保存列表最新数据的快照
            oldList = newList.toList()
            listUpdateCallback.onInserted(0, newList.size)
            return
        }
        // 启动协程比对数据
        launch {
            val diffResult = DiffUtil.calculateDiff(this@AsyncListDiffer)
            // 保存列表最新数据的快照
            oldList = newList.toList()
            // 将比对结果抛到主线程并应用到ListUpdateCallback接口
            withContext(Dispatchers.Main) {
                // 只保留最后一次提交的比对结果，其他的都被丢弃
                if (submitGeneration == maxSubmitGeneration) {
                    diffResult.dispatchUpdatesTo(listUpdateCallback)
                }
            }
        }
    }

    override fun getOldListSize(): Int = oldList.size
    override fun getNewListSize(): Int = newList.size
    override fun areItemsTheSame(oldItemPosition: Int, newItemPosition: Int): Boolean {
        val oldItem = oldList[oldItemPosition]
        val newItem = newList[newItemPosition]
        return oldItem.hashCode() == newItem.hashCode()
    }
    override fun areContentsTheSame(oldItemPosition: Int, newItemPosition: Int): Boolean {
        val oldItem = oldList[oldItemPosition]
        val newItem = newList[newItemPosition]
        return oldItem == newItem
    }
    override fun getChangePayload(oldItemPosition: Int, newItemPosition: Int): Any? {
        val oldItem = oldList[oldItemPosition] as? Diff
        val newItem = newList[newItemPosition] as? Diff
        if (oldItem == null || newItem == null) return null
        return oldItem diff newItem
    }
}

AsyncListDiffer实现了DiffUtil.Callback和CoroutineScope接口，并且将后者的实现委托给了CoroutineScope(SupervisorJob() + dispatcher)实例，这样做的好处是在AsyncListDiffer内部任何地方可以无障碍地启动协程，而在外部可以通过AsyncListDiffer的实例调用cancel()释放协程资源。

让无类型适配器持有AsyncListDiffer就大功告成了：

class VarietyAdapter(
    private var proxyList: MutableList<Proxy<*, *>> = mutableListOf(),
    dispatcher: CoroutineDispatcher = Dispatchers.IO // 默认在IO共享线程池中执行比对
) : RecyclerView.Adapter<ViewHolder>() {
    // 构建数据比对器
    private val dataDiffer = AsyncListDiffer(AdapterListUpdateCallback(this), dispatcher)
    // 业务代码通过为dataList赋值实现填充数据
    var dataList: List<Any>
        set(value) {
            // 将填充数据委托给数据比对器
            dataDiffer.submitList(value)
        }
        // 返回上一次比对后的数据快照
        get() = dataDiffer.oldList
        
        override fun onDetachedFromRecyclerView(recyclerView: RecyclerView) {
            dataDiffer.cancel() // 当适配器脱离RecyclerView时释放协程资源
    }
    ...
}

只列出了VarietyAdapter和AsyncListDiffer相关的部分，它的详细讲解可以点击代理模式应用 | 每当为 RecyclerView 新增类型时就很抓狂。

然后就可以像这样使用：

var itemNumber = 1
// 构建适配器
val varietyAdapter = VarietyAdapter().apply {
    // 为列表新增两种数据类型
    addProxy(TextProxy())
    addProxy(ImageProxy())
    // 初始数据集（包含两种不同的数据）
    dataList = listOf(
        Text("item ${itemNumber++}"),
        Image("#00ff00"),
        Text("item ${itemNumber++}"),
        Text("item ${itemNumber++}"),
        Image("#88ff00"),
        Text("item ${itemNumber++}")
    )
    // 预加载（上拉列表时预加载下一屏内容）
    onPreload = {
        // 获取老列表快照（深拷贝）
        val oldList = dataList
        // 在老列表快照尾部添加新内容
        dataList = oldList.toMutableList().apply {
            addAll(
                listOf(
                    Text("item ${itemNumber++}", 2),
                    Text("item ${itemNumber++}", 2),
                    Text("item ${itemNumber++}", 2),
                    Text("item ${itemNumber++}", 2),
                    Text("item ${itemNumber++}", 2),
                )
            )
        }
    }
}
// 应用适配器
recyclerView?.adapter = varietyAdapter
recyclerView?.layoutManager = LinearLayoutManager(this)

Talk is cheap, show me the code

预告

下一篇会介绍一种超简便的RecyclerView预加载方法。

更高效地刷新 RecyclerView | DiffUtil二次封装

DiffUtil模版代码

DiffUtil.Callback与业务解耦

DiffUtil.calculateDiff()异步化

Talk is cheap, show me the code

预告

推荐阅读

热门文章

最新文章

相关电子书

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

更高效地刷新 RecyclerView | DiffUtil二次封装

DiffUtil模版代码

DiffUtil.Callback与业务解耦

DiffUtil.calculateDiff()异步化

Talk is cheap, show me the code

预告

推荐阅读

热门文章

最新文章

相关电子书