前言
在平时的开发中，我们经常会需要开发一个列表页，这时我们第一时间就能想到 RecyclerView，添加一个 Adapter，复写其中的方法，再添加一个 ViewHolder，等等。
当我们的列表越来越多的时候，就会让人很抓狂，不仅每次都要写很多重复代码，而且 Adapter 类的数量也会越来越多。
有没有什么办法能够优雅的避免每次添加重复代码吗？今天给大家分享一个简单的 Adapter 封装，可以让我们少写 90% 的重复代码。
通常的做法
一般情况下，我们要实现一个列表的步骤是这样的
添加一个 Adapter
public class SampleAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolder> {
private List<String> dataList;
public SampleAdapter(List<String> dataList) {
this.dataList = dataList;
}
@Override
public RecyclerView.ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
if (viewType == 0) {
// 加载View
View view = new View(parent.getContext());
return new SampleViewHolder1(view);
} else {
// 加载View
View view = new View(parent.getContext());
return new SampleViewHolder2(view);
}
}
@Override
public void onBindViewHolder(RecyclerView.ViewHolder holder, int position) {
if (holder instanceof SampleViewHolder1) {
((SampleViewHolder1) holder).bind(dataList.get(position));
} else {
((SampleViewHolder2) holder).bind(dataList.get(position));
}
}
@Override
public int getItemCount() {
return dataList.size();
}
@Override
public int getItemViewType(int position) {
return position % 2;
}
private class SampleViewHolder1 extends RecyclerView.ViewHolder {
public SampleViewHolder1(View itemView) {
super(itemView);
}
public void bind(String data) {
// ...
}
}
private class SampleViewHolder2 extends RecyclerView.ViewHolder {
public SampleViewHolder2(View itemView) {
super(itemView);
}
public void bind(String data) {
// ...
}
}
}
这里省略了部分代码。
可以看出，其实 Adapter 里面的都是重复代码，既然是重复代码，那么一定有办法抽象出来。
封装 Adapter
我们的目标是创造一个通用的 Adapter，那么就要在 Adapter 上做文章。
由于 Adapter 只有一个，而 ViewHolder 可能有多个，为了使 Adapter 和 ViewHolder 能够形成一对多的关系，而且 Adapter 可以随时根据 position 获取对应的 ViewHolder，我们需要一个桥梁
public interface RAdapterDelegate<T> {
Class<? extends RViewHolder<T>> getViewHolderClass(int position);
}
桥梁已经有了，需要我们在 Activity 中实现，我们让它作为构造 Adapter 的参数传入
public RAdapter(List<T> dataList, RAdapterDelegate<T> delegate) {
this.dataList = dataList;
this.delegate = delegate;
}
然后考虑多种布局方式，其实不过是每一个 ViewHolder 对应一个唯一的整数，我们很容易就能想到将 ViewHolder 放在一个 List 中，每一个 ViewHolder 对应一个下标，下标即可作为 viewType。
private List<Class<? extends RViewHolder<T>>> viewHolderClassList = new ArrayList<>();
@Override
public int getItemViewType(int position) {
Class<? extends RViewHolder<T>> clazz = delegate.getViewHolderClass(position);
if (!viewHolderClassList.contains(clazz)) {
viewHolderClassList.add(clazz);
}
return viewHolderClassList.indexOf(clazz);
}
接下来到了构造 ViewHolder 的时候了，构造 ViewHolder 需要一个 View，作为构造函数的参数传入，这样我们就不能把 layout 作为 ViewHolder 的属性了，因为必须在初始化 ViewHolder 之前得到它。
总不能让 layout 也从 Delegate 中获取吧，这样太蠢了，那么有什么方法能够把 ViewHolder 和 layout 绑定，并且在 ViewHolder 初始化之前得到 layout 呢？
我们可以用注解，是的，将 ViewHolder 的 class 和 layout 绑定起来，就能实现我们想要的效果。
新建一个注解类
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface RLayout {
@LayoutRes int value();
}
ViewHolder 需要添加注解，将 layout 绑定起来。
有了 ViewHolder 类和 View，我们就可以构造 ViewHolder 了
@Override
public RViewHolder<T> onCreateViewHolder(ViewGroup parent, int viewType) {
try {
Class<? extends RViewHolder<T>> clazz = viewHolderClassList.get(viewType);
int resId = getLayoutResId(clazz);
View view = LayoutInflater.from(parent.getContext()).inflate(resId, parent, false);
Constructor constructor = clazz.getConstructor(View.class);
RViewHolder<T> viewHolder = (RViewHolder<T>) constructor.newInstance(view);
viewHolder.setAdapter(this);
return viewHolder;
} catch (Exception e) {
throw new IllegalStateException("create view holder error", e);
}
}
// 考虑到 ViewHolder 的继承，这里会去遍历 ViewHolder 的父类
private int getLayoutResId(Class<?> clazz) {
if (clazz == RViewHolder.class) {
return 0;
}
RLayout bind = clazz.getAnnotation(RLayout.class);
if (bind == null) {
// 找不到去父类找
return getLayoutResId(clazz.getSuperclass());
}
return bind.value();
}
采用了反射的方式构造出 ViewHolder。
接下来就比较简单了，就剩下给 ViewHolder 填充内容了
@Override
public void onBindViewHolder(RViewHolder<T> holder, int position) {
try {
holder.setPosition(position);
holder.setData(dataList.get(position));
holder.refresh();
} catch (Exception e) {
Log.e(TAG, "bind view holder error", e);
}
}
接下来看一下 ViewHolder 基类的代码
public abstract class RViewHolder<T> extends RecyclerView.ViewHolder {
protected Context context;
protected View itemView;
protected RAdapter<T> adapter;
protected T data;
protected int position;
public RViewHolder(View itemView) {
super(itemView);
this.itemView = itemView;
context = itemView.getContext();
ViewBinder.bind(this, itemView);
}
public void setAdapter(RAdapter<T> adapter) {
this.adapter = adapter;
}
public void setData(T t) {
this.data = t;
}
public void setPosition(int position) {
this.position = position;
}
public abstract void refresh();
}
添加了一些属性，方便我们使用。
下面我们使用封装好的 Adapter，实现一开始的那个列表
// Activity 中
List<String> dataList = new ArrayList<>();
RAdapterDelegate<String> delegate = (RAdapterDelegate<String>) position -> {
if (position % 2 == 0) {
return SampleViewHolder1.class;
} else {
return SampleViewHolder2.class;
}
};
RAdapter<String> adapter = new RAdapter<>(dataList, delegate);
recyclerView.setAdapter(adapter);
// SampleViewHolder
// 通过注解指定 layoutResId
@RLayout(R.layout.sample_view_holder)
public class SampleViewHolder extends RViewHolder<String> {
public SampleViewHolder(View itemView) {
super(itemView);
}
@Override
public void refresh() {
// 这里实现渲染逻辑
}
}
有没有感觉代码量骤降？而且是一劳永逸。
当然大家也可以基于该 Adapter 继续扩展更多功能。
混淆配置
由于我们是通过反射来构造 ViewHolder，因此要避免构造方法被混淆工具移除，添加以下配置即可
-keepclassmembers class * extends 包名.RViewHolder {
public <init>(android.view.View);
}
源码
总结
今天的内容比较简单，提供了一种对 RecyclerView Adapter 封装的思路，减少重复代码。
