AsyncListDiffer-RecyclerView最好的伙伴

导读,近些年来 Android 一直在优化 RecyclerView 刷新效率,相继出了 DiffUtil,AsyncListDiffer ,我在我的开源库 Flap 中也支持了 AsyncListDiffer, 不过还有很多人根本不知道它的存在,于是我找了篇文章,不了解的可以看看,希望对大家有所帮助。

自Android5.0以来,RecyclerView渐渐取代ListView成为Android开发中使用最多的列表控件,对于RecyclerView的使用相信大家都不陌生。 但对于RecyclerView的高效刷新,却是很多人不知道的。

简单粗暴的刷新方式

Adapter.notifyDataSetChanged();

这种方式想必是大家曾经用的最多的一种刷新Adapter的方式,它的缺点很明显:

  • 无脑刷新整个RecyclerView可视区域,每个item重绘,如果你的onBindViewHolder逻辑处理稍微复杂一些,则容易造成卡顿
  • 无法触发RecyclerView的item动画,用户体验极差。

局部刷新方式

为了解决上述问题,RecyclerView推出了局部刷新的方式

Adapter.notifyItemChanged(int)
Adapter.notifyItemInserted(int)
Adapter.notifyItemRangeChanged(int, int)
Adapter.notifyItemRangeInserted(int, int)
Adapter.notifyItemRangeRemoved(int, int)

局部刷新只会刷新指定position的item,这样完美解决了上述简单粗暴刷新方式的缺点,但是:

  • 局部刷新需要指定item的position,如果你只更新了一条数据,那么你可以很容易知道position位置,但是如果你更新的是整个列表,你需要计算出所有你需要刷新的position,那么这将是一场灾难

DiffUtil

Google似乎也注意到了这一点,因此在support-recyclerview-v7:24.2.0中,推出了一个用于计算哪些位置需要刷新的工具类:DiffUtil。

使用DiffUtil,有3个步骤

1.自实现DiffUtil.callback

private DiffUtil.Callback diffCallback = new DiffUtil.Callback() {
    @Override
    public int getOldListSize() {
        // 返回旧数据的长度
        return oldList == null ? 0 : oldList.size();
    }

    @Override
    public int getNewListSize() {
        // 返回新数据的长度
        return newList == null ? 0 : newList.size();
    }

    @Override
    public boolean areItemsTheSame(int oldItemPosition, int newItemPosition) {
        // 返回两个item是否相同
        // 例如:此处两个item的数据实体是User类,所以以id作为两个item是否相同的依据
        // 即此处返回两个user的id是否相同
        return TextUtils.equals(oldList.get(oldItemPosition).getId(), newList.get(oldItemPosition).getId());
    }

    @Override
    public boolean areContentsTheSame(int oldItemPosition, int newItemPosition) {
        // 当areItemsTheSame返回true时,我们还需要判断两个item的内容是否相同
        // 此处以User的age作为两个item内容是否相同的依据
        // 即返回两个user的age是否相同
        return oldList.get(oldItemPosition).getAge() == newList.get(newItemPosition).getAge();
    }
};

2.计算得到DiffResult

 DiffUtil.DiffResult diffResult = DiffUtil.calculateDiff(diffCallback);

3.将DiffResult设置给Adapter

 // 注意此处一定要将新数据设置给Adapter
 // 否则会造成ui刷新了但数据未更新的bug
 mAdapter.setData(newList);
 diffResult.dispatchUpdatesTo(mAdapter);

这样我们就实现了局部刷新位置的计算和局部刷新的实现,相比notifyDataSetChanged(),性能大大提高。

本文到此结束?

不不不,还早着呢,咱们理智分析一下:

  • 首先DiffUtil.calculateDiff()这个方法是执行在主线程的,如果新旧数据List比较大,那么这个方法铁定是会阻塞主线程的
  • 计算出DiffResult后,咱们必须要将新数据设置给Adapter,然后才能调用DiffResult.dispatchUpdatesTo(Adapter)刷新ui,然而很多人都会忘记这一步。

AsyncListDiff

DiffUtil已经很好用了,但是有上述两个问题,想必Google的工程师也是看不下去的,虽然上述两个问题不难解决,但是很容易遗漏。

因此Google又推出了一个新的类AsyncListDiff

先来看一波AsyncListDiff的使用方式:

public class UserAdapter extends RecyclerView.Adapter<UserAdapter.UserViewHodler> {
    private AsyncListDiffer<User> mDiffer;

    private DiffUtil.ItemCallback<User> diffCallback = new DiffUtil.ItemCallback<User>() {
        @Override
        public boolean areItemsTheSame(User oldItem, User newItem) {
            return TextUtils.equals(oldItem.getId(), newItem.getId());
        }

        @Override
        public boolean areContentsTheSame(User oldItem, User newItem) {
            return oldItem.getAge() == newItem.getAge();
        }
    };

    public UserAdapter() {
        mDiffer = new AsyncListDiffer<>(this, diffCallback);
    }

    @Override
    public int getItemCount() {
        return mDiffer.getCurrentList().size();
    }

    public void submitList(List<User> data) {
        mDiffer.submitList(data);
    }

    public User getItem(int position) {
        return mDiffer.getCurrentList().get(position);
    }

    @NonNull
    @Override
    public UserAdapter.UserViewHodler onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
        View itemView = LayoutInflater.from(parent.getContext()).inflate(R.layout.item_user_list, parent, false);
        return new UserViewHodler(itemView);
    }

    @Override
    public void onBindViewHolder(@NonNull UserAdapter.UserViewHodler holder, int position) {
        holder.setData(getItem(position));
    }

    class UserViewHodler extends RecyclerView.ViewHolder {
        private TextView tvName;
        private TextView tvAge;

        public UserViewHodler(View itemView) {
            super(itemView);
            tvName = itemView.findViewById(R.id.tv_name);
            tvAge = itemView.findViewById(R.id.tv_age);
        }

        public void setData(User data) {
            tvName.setText(data.getName());
            tvAge.setText(String.valueOf(data.getAge()));
        }
    }
}

这里使用了一个简单的Adapter例子,不做封装,是为了更好地说明AsyncListDiffer

不难看出,AsyncListDiffer的使用步骤:

  • 自实现DiffUtil.ItemCallback,给出item差异性计算条件
  • 将所有对数据的操作代理给AsyncListDiffer,可以看到这个Adapter是没有List数据的
  • 使用submitList()更新数据,并刷新ui

ok,咱们看一下效果: 首先我们给Adapter设置数据

List<User> users = new ArrayList<>();
for (int i = 0; i < 10; i++) {
    users.add(new User(String.valueOf(i), "用户" + i, i + 20));
}
mAdapter.submitList(users);

然后修改数据

List<User> users = new ArrayList<>();
for (int i = 0; i < 10; i++) {
    users.add(new User(String.valueOf(i), "用户" + i, i % 3 == 0 ? i + 10: i + 20));
}
mAdapter.submitList(users);

跑起来看一哈

ok,我们看到只有被3整除的position被刷新了,完美的局部刷新。

那么问题来了,AsyncListDiffer是如何解决我们上述的两个问题的呢?

解惑

我们走进AsyncListDiffer的源码看一下:

public class AsyncListDiffer<T> {
    private final ListUpdateCallback mUpdateCallback;
    private final AsyncDifferConfig<T> mConfig;

    public AsyncListDiffer(@NonNull RecyclerView.Adapter adapter,
                @NonNull DiffUtil.ItemCallback<T> diffCallback) {
        mUpdateCallback = new AdapterListUpdateCallback(adapter);
        mConfig = new AsyncDifferConfig.Builder<>(diffCallback).build();
    }

    private List<T> mList;
    private List<T> mReadOnlyList = Collections.emptyList();
    private int mMaxScheduledGeneration;

    public List<T> getCurrentList() {
        return mReadOnlyList;
    }

    public void submitList(final List<T> newList) {
        if (newList == mList) {
            // 如果新旧数据相同,则啥事不做
            return;
        }

        // 用于控制计算线程,防止在上一次submitList未完成时,
        // 又多次调用submitList,这里只返回最后一个计算的DiffResult
        final int runGeneration = ++mMaxScheduledGeneration;

        if (newList == null) {
            // 如果新数据集为空,此种情况不需要计算diff
            // 直接清空数据即可
            // 通知item remove
            mUpdateCallback.onRemoved(0, mList.size());
            mList = null;
            mReadOnlyList = Collections.emptyList();
            return;
        }

        if (mList == null) {
            // 如果旧数据集为空,此种情况不需要计算diff
            // 直接将新数据添加到旧数据集即可
            // 通知item insert
            mUpdateCallback.onInserted(0, newList.size());
            mList = newList;
            mReadOnlyList = Collections.unmodifiableList(newList);
            return;
        }

        final List<T> oldList = mList;
        // 在子线程中计算DiffResult
        mConfig.getBackgroundThreadExecutor().execute(new Runnable() {
            @Override
            public void run() {
                final DiffUtil.DiffResult result = DiffUtil.calculateDiff(new DiffUtil.Callback() {
                    @Override
                    public int getOldListSize() {
                        return oldList.size();
                    }

                    @Override
                    public int getNewListSize() {
                        return newList.size();
                    }

                    @Override
                    public boolean areItemsTheSame(int oldItemPosition, int newItemPosition) {
                        return mConfig.getDiffCallback().areItemsTheSame(
                                oldList.get(oldItemPosition), newList.get(newItemPosition));
                    }

                    @Override
                    public boolean areContentsTheSame(int oldItemPosition, int newItemPosition) {
                        return mConfig.getDiffCallback().areContentsTheSame(
                                oldList.get(oldItemPosition), newList.get(newItemPosition));
                    }
                });
                // 在主线程中更新数据
                mConfig.getMainThreadExecutor().execute(new Runnable() {
                    @Override
                    public void run() {
                        if (mMaxScheduledGeneration == runGeneration) {
                            latchList(newList, result);
                        }
                    }
                });
            }
        });
    }

    private void latchList(@NonNull List<T> newList, @NonNull DiffUtil.DiffResult diffResult) {
        diffResult.dispatchUpdatesTo(mUpdateCallback);
        mList = newList;
        mReadOnlyList = Collections.unmodifiableList(newList);
    }
}

线程部分源码:

private static class MainThreadExecutor implements Executor {
    final Handler mHandler = new Handler(Looper.getMainLooper());
    @Override
    public void execute(@NonNull Runnable command) {
        mHandler.post(command);
    }
}

@NonNull
public AsyncDifferConfig<T> build() {
    if (mMainThreadExecutor == null) {
        mMainThreadExecutor = sMainThreadExecutor;
    }
    if (mBackgroundThreadExecutor == null) {
        synchronized (sExecutorLock) {
            if (sDiffExecutor == null) {
                sDiffExecutor = Executors.newFixedThreadPool(2);
            }
        }
        mBackgroundThreadExecutor = sDiffExecutor;
    }
    return new AsyncDifferConfig<>(
            mMainThreadExecutor,
            mBackgroundThreadExecutor,
            mDiffCallback);
}

ui刷新部分源码:

public final class AdapterListUpdateCallback implements ListUpdateCallback {
    @NonNull
    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);
    }
}

源码实现很简单,总结一下:

  • 首先排除新旧数据为空的情况,这种情况不需要计算diff
  • 在子线程中计算DiffResult,在主线程将DiffResult设置给Adapter,解决主线程阻塞问题
  • 将Adapter的数据代理给AsyncListDiffer,解决Adapter与DiffUtil的数据一致性问题

原文发布于微信公众号 - 程序亦非猿(chengxuyifeiyuan)

原文发表时间:2019-01-22

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

扫码关注云+社区

领取腾讯云代金券