阅读 3780

是时候提高你撸RecycleView的效率了

前言

在项目开发中,总离不开列表,说到列表,就会有无穷无尽的 Adapter 需要你去实现。从而出现了很多优秀的 adapter 库。 不过很多库功能都很全面了,有很多个类,很多功能,但是实际上只用其中的一两个我感觉是很多人的现状。所以自己实现一个使用起来顺手的是一个不错的选择,特别是用在一些不是很复杂的列表时。

效果

先看看使用效果,激发一下你为数不多继续阅读的激情:

//单类型列表,默认 LinearLayoutManager
recycleView.setup<NumberInfo> {
    dataSource(initData())
    adapter {
        addItem(R.layout.layout_item) {
            bindViewHolder { data, _, _ ->
                setText(R.id.number, data?.number.toString())
            }
        }
    }
}

//多类型列表
recycleView.setup<Any> {
    withLayoutManager { LinearLayoutManager(context) }
    dataSource(data)
    adapter {
        addItem(R.layout.item_setion_header) {
            isForViewType { data, _ -> data is SectionHeader }
            bindViewHolder { data, _, _ ->
                val header = data as SectionHeader
                setText(R.id.section_title, header.title)
            }
        }
        addItem(R.layout.item_user) {
            isForViewType { data, _ -> data is User }
            bindViewHolder { data, _, _ ->
                val user = data as User
                setText(R.id.name, user.name)
                setImageResource(R.id.avatar, user.avatarRes)
                //如果你的控件找不到方便赋值的方法,可以通过 findViewById 去查找
                val phone = findViewById<TextView>(R.id.phone)
                phone.text = user.phone
            }
        }
    }
}
复制代码

嗯....,感觉还可以,最少的情况下可以把一个列表代码用 10 几行就完成了。

完整代码地址

先贴完整代码地址,没地址的文章是没灵魂的:EfficientAdapter
我把它命名为 EfficientAdapter ,意为高效的意思,事实上它只有 3 个文件。
至于如何使用,在地址上已经描述了,所以这篇文章主要是讲一下实现的思路。

实现思路

对 Adapter 的封装,其实无非就是对 Adapter 里面的几个回调方法进行封装罢了,最常用的方法是先定义好一个存放 ViewHolder 的列表,然后在各个回调中获取这些 ViewHolder,然后实现逻辑。

那么其中最操蛋的是哪个回调方法的封装呢?我认为是 getItemViewType。事实上你可以在很多框架中看到让你实现获取 ViewType 的回调方法。

一步一步来,先说 ViewHolder 的封装

在 EfficientAdapter 里面,我把 ViewHolder 的封装写成了 BaseViewHolder:

class BaseViewHolder(parent: ViewGroup, resource: Int) : RecyclerView.ViewHolder(
        LayoutInflater.from(parent.context).inflate(resource, parent, false)
)
复制代码

这就是我的封装,够简单吧。

想什么呢,当然没这么简单,想要在上面使用效果代码中那样实现 ViewHolder 的具体逻辑,还需要有 isForViewType,bindViewHolder 等方法。所以我要定义一个类,去提供这些方法:

abstract class ViewHolderCreator<T> {
    abstract fun isForViewType(data: T?, position: Int): Boolean
    abstract fun getResourceId(): Int
    abstract fun onBindViewHolder(
            data: T?, items: MutableList<T>?,
            position: Int,  holder: ViewHolderCreator<T>
    )

    var itemView: View? = null

    fun registerItemView(itemView: View?) {
        this.itemView = itemView
    }

    fun <V : View> findViewById(viewId: Int): V {
        checkItemView()
        return itemView!!.findViewById(viewId)
    }

    private fun checkItemView() {
        if (itemView == null) {
            throw NullPointerException("itemView is null")
        }
    }
}
复制代码

在 ViewHolderCreator 中,getResourceId 和 onBindViewHolder 方法相信都知道是干嘛的,而 isForViewType 方法是用来判断 ViewType 的,注意它返回类型是 Boolean,这个方法会在下面讲到。因为我想在 onBindViewHolder 中能方便的拿到 view,所以有了 registerItemView 和 findViewById 等其他方法。

以上就是 ViewHolder 的所有封装,接下来就对 Adapter 的封装。

open class EfficientAdapter<T> : RecyclerView.Adapter<RecyclerView.ViewHolder>() {
    var items: MutableList<T>? = mutableListOf()
    private val typeHolders: SparseArrayCompat<ViewHolderCreator<T>> = SparseArrayCompat()
}
复制代码

Adapter 首先需要一个泛型用来表示传入的实体类类型,定义了一个 item 列表用来做数据源。ViewHolder 的集合使用一个 SparseArrayCompat 去存储。之所以用 SparseArray ,是因为我想把 ViewType 做为 key。

所以,在 onCreateViewHolder 回调方法中,需要根据 viewType 参数在 typeHolders 中取到具体的 ViewHolderCreator:

private fun getHolderForViewType(viewType: Int): ViewHolderCreator<T>? {
    return typeHolders.get(viewType)
}

override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): RecyclerView.ViewHolder {
    val holder = getHolderForViewType(viewType)
            ?: throw NullPointerException("No Holder added for ViewType $viewType")
    return BaseViewHolder(parent, holder.getResourceId())
}
复制代码

这样,就可以通过 getHolderForViewType 方法,在 typeHolders 中获取到对应的 ViewHolderCreator,然后根据 ViewHolderCreator 中的信息去创建一个新的 ViewHolder。如果找不到,就抛一个空指针异常。

同样道理,onBindViewHolder 回调方法也可以这么做:

override fun onBindViewHolder(viewHolder: RecyclerView.ViewHolder, position: Int) {
    onBindViewHolder(viewHolder, position, mutableListOf())
}

override fun onBindViewHolder(viewHolder: RecyclerView.ViewHolder, position: Int, payloads:MutableList<Any>) {
    val holder = getHolderForViewType(viewHolder.itemViewType)
            ?: throw NullPointerException("No Holder added for ViewType " + viewHolder.itemViewType)
    holder.registerItemView(viewHolder.itemView)
    holder.onBindViewHolder(items?.get(position), items, position, holder)
}
复制代码

注意的是 onBindViewHolder 回调方法有两个,他们的区别就不说了,这里两个都实现了逻辑,当然你也可以只实现一个。

还剩下 getItemCount 和 getItemViewType 回调方法了,getItemCount 其实没什么好说的:

override fun getItemCount(): Int = items?.size ?: 0
复制代码

先不说如何实现 getItemViewType ,先说说怎么添加数据到 typeHolders 中:

fun register(holder: ViewHolderCreator<T>) = apply {
    var viewType: Int = typeHolders.size()
    while (typeHolders.get(viewType) != null) {
        viewType++
    }
    typeHolders.put(viewType, holder)
}
复制代码

typeHolders 的类型是 SparseArrayCompat,这里我用 ViewType 作为 key,register 方法中,可以看到没每注册一次,viewType 就自动加一(因为 typeHolders 的长度会变长),达到了不会重复的效果,到时候在实现 getItemViewType 的时候,就直接取出来即可。避免了具体业务的干扰。

最后看看 getItemViewType 的实现:

override fun getItemViewType(position: Int): Int {
    if (items == null) {
        throw NullPointerException("adapter data source is null")
    }
    for (i in 0 until typeHolders.size()) {
        val holder = typeHolders.valueAt(i)
        val data = items?.getOrNull(position)
        if (holder.isForViewType(data, position)) {
            return typeHolders.keyAt(i)
        }
    }

    //找不到匹配的 viewType
    throw NullPointerException(
            "No holder added that matches at position=$position in data source")
}
复制代码

该方法的思路是通过遍历 typeHolders,通过 ViewHolderCreator 的 isForViewType 方法来判断是否符合条件,如果符合,则在 typeHolders 中取出 viewType 出来返回。

因为 typeHolders 中的 viewType 是自增的,所以 getItemViewType 的返回值会是 0,1,2,3...

isForViewType 在实际中如何实现?

举个例子:
如果你的数据源由多个实体类组成,比如:

private List<Object> data = new ArrayList<>();
data.add(new User("Marry", 17, R.drawable.icon2, "123456789XX"));
data.add(new SectionHeader("My Images"));
data.add(new Image(R.drawable.cover1));
复制代码

那么在构建 EfficientAdapter 时,泛型传入的自然是 Object,然后在 isForViewType 方法中你可以这样区分类型:

 // 代表这是 User 类型
 public boolean isForViewType(Object data, int position) {
   return data instanceof User;
}

 // 代表这是 SectionHeader 类型
 public boolean isForViewType(Object data, int position) {
   return data instanceof SectionHeader;
}

 // 代表这是 Image 类型
 public boolean isForViewType(Object data, int position) {
   return data instanceof Image;
}
复制代码

如果你的数据源只有一个实体类,但是实体类里面有某个字段可以区分类型,你可以这样:

 // 代表这是 User 类型
 public boolean isForViewType(ListInfo data, int position) {
   return data.type = ListInfo.USER
}

 // 代表这是 SectionHeader 类型
 public boolean isForViewType(ListInfo data, int position) {
   return data.type = ListInfo.HEADER
}

 // 代表这是 Image 类型
 public boolean isForViewType(ListInfo data, int position) {
   return data.type = ListInfo.IMAGE
}
复制代码

其他情况可以根据具体的情况而定。

到这里,已经完成 Adapter 的封装了,接下来可以定义一些数据源的增删查改的方法,比如:

//绑定 RecyclerView
fun attach(recyclerView: RecyclerView) = apply { recyclerView.adapter = this }

//提交数据
fun submitList(list: MutableList<T>) {
    this.items?.clear()
    this.items?.addAll(list)
    notifyDataSetChanged()
}
复制代码

到这里,已经可以简单粗暴的使用了:

adapter = EfficientAdapter<SectionHeader>()
        .register(object : ViewHolderCreator<SectionHeader>() {
            override fun isForViewType(data: SectionHeader?, position: Int) = data != null
            override fun getResourceId() = R.layout.item_setion_header

            override fun onBindViewHolder(
                    data: SectionHeader?,
                    items: MutableList<SectionHeader>?, position: Int,
                    holder: ViewHolderCreator<SectionHeader>
            ) {
                setText(R.id.section_title, data.title)
            }
        }).attach(recycle_view)
adapter?.submitList(data)
复制代码

但和使用效果差别有点大啊。所以,接下来就是 kotlin 发挥的时候了。

扩展函数 与 DSL

相信学过 kotlin 的都知道这两个东西,他们可以为我们的代码提供更多的可能。

ViewHolderCreator DSL

由于 ViewHolderCreator 是一个抽象类,对它进行 DSL 封装需要一个默认的实现类(也许可以直接封装,但是我只能想到这种方法):

class ViewHolderDsl<T>(private val resourceId: Int) : ViewHolderCreator<T>() {
    private var viewType: ((data: T?, position: Int) -> Boolean)? = null
    private var viewHolder: ((data: T?, position: Int, holder: ViewHolderCreator<T>) -> Unit)? = null

    fun isForViewType(viewType: (data: T?, position: Int) -> Boolean) {
        this.viewType = viewType
    }

    fun bindViewHolder(holder: (data: T?, position: Int, holder: ViewHolderCreator<T>) -> Unit) {
        viewHolder = holder
    }

    override fun isForViewType(data: T?, position: Int): Boolean {
        return viewType?.invoke(data) ?: (data != null)
    }

    override fun getResourceId() = resourceId

    override fun onBindViewHolder(
            data: T?, items: MutableList<T>?, position: Int, holder: ViewHolderCreator<T>,
            payloads: MutableList<Any>
    ) {
        viewHolder?.invoke(data, position, holder)
    }
}
复制代码

代码比较清晰,就是对三个抽象方法的实现。由于 getResourceId 比较简单,所以直接放在构造方法中传值就好。

实现好了 ViewHolderDsl,我们给 EfficientAdapter 定义一个扩展函数,用 DSL 的方式去调用 register 方法:

fun <T : Any> EfficientAdapter<T>.addItem(resourceId: Int, init: ViewHolderDsl<T>.() -> Unit) {
    val holder = ViewHolderDsl<T>(resourceId)
    holder.init()
    register(holder)
}
复制代码

比较简单,就是创建好 ViewHolderDsl 后,调用 register 方法即可。

到这里,其实已经可以用了,只要我们再写一个函数,用 DSL 的方式创建 Adapter 即可:

fun <T : Any> efficientAdapter(init: EfficientAdapter<T>.() -> Unit): EfficientAdapter<T> {
    val adapter = EfficientAdapter<T>()
    adapter.init()
    return adapter
}
复制代码

所以上面那个简单粗暴的示例代码就可以变成这样:

adapter = efficientAdapter<Any> {
    addItem(R.layout.item_setion_header) {
        isForViewType { it != null }
        bindViewHolder { data, _, _ ->
            setText(R.id.section_title, data.title)
        }
    }
}.attach(recycle_view)
adapter?.submitList(data)
复制代码

代码又清晰和简单了很多。由于在 ViewHolderDsl 中,isForViewType 的默认实现是 data!=null,所以如果是单类型列表,这个方法可以直接不写。

虽然代码简单了很多,但这样总要定义 adapter 对象和绑定 RecycleView,所以更加优雅的方式就是给 RecycleView 定义一个扩展函数,把这些操作都包装起来。

首先我们实现一个叫 RecycleSetup 的类,在这个类里面,把 RecycleView 的配置以及 Adapter 操作,数据源操作等通通包装起来:

class RecycleSetup<T> internal constructor(private val recyclerView: RecyclerView) {

    var items = mutableListOf<T>()
    var adapter: EfficientAdapter<T>? = null
    var context = recyclerView.context

    fun dataSource(items: MutableList<T>) {
        this.items.clear()
        this.items = items
    }

    fun withLayoutManager(init: RecycleSetup<T>.() -> RecyclerView.LayoutManager) =
            apply { recyclerView.layoutManager = init() }

    fun adapter(init: EfficientAdapter<T>.() -> Unit) {
        this.adapter = EfficientAdapter()
        init.invoke(adapter!!)
        recyclerView.adapter = adapter
        adapter?.submitList(this.items)
    }

    fun submitList(list: MutableList<T>) {
        this.items.clear()
        this.items = list
        adapter?.submitList(this.items)
    }

    fun getItem(position: Int): T = items[position]
}
复制代码

代码简单,相信大家都能看懂。

有了这个类,最后,就可以给 RecycleView 实现扩展函数了:

fun <T> RecyclerView.setup(block: RecycleSetup<T>.() -> Unit): RecycleSetup<T> {
    val setup = RecycleSetup<T>(this).apply(block)
    if (layoutManager == null) {
        layoutManager = LinearLayoutManager(context)
    }
    return setup
}

fun <T> RecyclerView.submitList(items: MutableList<T>) {
    if (adapter != null && adapter is EfficientAdapter<*>) {
        (adapter as EfficientAdapter<T>).submitList(items)
    }
}
复制代码

layoutManager 为空就默认实现 LinearLayoutManager。最后,上面那个简单粗暴的代码就可以写成跟一开始说那个效果一样了:

recycleView.setup<SectionHeader> {
    adapter {
        addItem(R.layout.item_setion_header) {
            bindViewHolder { data, _, _ ->
                setText(R.id.section_title, data.title)
            }
        }
    }
}
recycleView.submitList(data)
复制代码

完整代码和例子都在这里 EfficientAdapter ,有兴趣可以看看。

总结

其实,整篇文章的代码思路都比较简单,其中比较有意思的是 viewType 自加一这里,在使用的时候用户只需要实现 isForViewType 即可,这可以避免了你的实体类需要继承某一个 Base 类。

当然相比各个大佬们的库,这个算是比较简单的,所以写这篇文章的原因是分享自己在封装代码的时候的一个思路,一步一步从零到有。相信很多人都需要这种东西,比整天搬砖有意思,也会学到一点点知识。

Thank you for 看完整篇文章,完!