资讯专栏INFORMATION COLUMN

上云采购季！| 2核2G4M爆款云服务器低至59元/年，更有多台、长期优惠，快来选购！

立即前往
首页/文章专栏/Android AsyncListDiffer-RecyclerView最好的伙伴

Android AsyncListDiffer-RecyclerView最好的伙伴

617035918 / 1298人阅读

摘要：本文到此结束不不不，还早着呢，咱们理智分析一下首先这个方法是执行在主线程的，如果新旧数据比较大，那么这个方法铁定是会阻塞主线程的计算出后，咱们必须要将新数据设置给，然后才能调用刷新，然而很多人都会忘记这一步。

</>复制代码 
  1. 版权声明：本文已授权微信公众号：Android必修课，转载请申明出处
    自Android5.0以来，RecyclerView渐渐取代ListView成为Android开发中使用最多的列表控件，对于RecyclerView的使用相信大家都不陌生，但对于RecyclerView的高效刷新，却是很多人不知道的。
简单粗暴的刷新方式 
</>复制代码 
  1. Adapter.notifyDataSetChanged();

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

无脑刷新整个RecyclerView可视区域，每个item重绘，如果你的onBindViewHolder逻辑处理稍微复杂一些，则容易造成卡顿

无法触发RecyclerView的item动画，用户体验极差。

局部刷新方式

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

</>复制代码 
  1. Adapter.notifyItemChanged(int)
  2. Adapter.notifyItemInserted(int)
  3. Adapter.notifyItemRangeChanged(int, int)
  4. Adapter.notifyItemRangeInserted(int, int)
  5. Adapter.notifyItemRangeRemoved(int, int)

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

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

DiffUtil

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

使用DiffUtil，有3个步骤

1.自实现DiffUtil.callback 
</>复制代码 
  1. private DiffUtil.Callback diffCallback = new DiffUtil.Callback() {
  2.     @Override
  3.     public int getOldListSize() {
  4.         // 返回旧数据的长度
  5.         return oldList == null ? 0 : oldList.size();
  6.     }
  7.     @Override
  8.     public int getNewListSize() {
  9.         // 返回新数据的长度
  10.         return newList == null ? 0 : newList.size();
  11.     }
  12.     @Override
  13.     public boolean areItemsTheSame(int oldItemPosition, int newItemPosition) {
  14.         // 返回两个item是否相同
  15.         // 例如：此处两个item的数据实体是User类，所以以id作为两个item是否相同的依据
  16.         // 即此处返回两个user的id是否相同
  17.         return TextUtils.equals(oldList.get(oldItemPosition).getId(), newList.get(oldItemPosition).getId());
  18.     }
  19.     @Override
  20.     public boolean areContentsTheSame(int oldItemPosition, int newItemPosition) {
  21.         // 当areItemsTheSame返回true时，我们还需要判断两个item的内容是否相同
  22.         // 此处以User的age作为两个item内容是否相同的依据
  23.         // 即返回两个user的age是否相同
  24.         return oldList.get(oldItemPosition).getAge() == newList.get(newItemPosition).getAge();
  25.     }
  26. };
2.计算得到DiffResult 
</>复制代码 
  1.  DiffUtil.DiffResult diffResult = DiffUtil.calculateDiff(diffCallback);
3.将DiffResult设置给Adapter 
</>复制代码 
  1.  // 注意此处一定要将新数据设置给Adapter
  2.  // 否则会造成ui刷新了但数据未更新的bug
  3.  mAdapter.setData(newList);
  4.  diffResult.dispatchUpdatesTo(mAdapter);

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

本文到此结束？

不不不，还早着呢，咱们理智分析一下：

首先DiffUtil.calculateDiff()这个方法是执行在主线程的，如果新旧数据List比较大，那么这个方法铁定是会阻塞主线程的

计算出DiffResult后，咱们必须要将新数据设置给Adapter，然后才能调用DiffResult.dispatchUpdatesTo(Adapter)刷新ui，然而很多人都会忘记这一步。

AsyncListDiff

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

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

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

</>复制代码 
  1. public class UserAdapter extends RecyclerView.Adapter {
  2.     private AsyncListDiffer mDiffer;
  3.     private DiffUtil.ItemCallback diffCallback = new DiffUtil.ItemCallback() {
  4.         @Override
  5.         public boolean areItemsTheSame(User oldItem, User newItem) {
  6.             return TextUtils.equals(oldItem.getId(), newItem.getId());
  7.         }
  8.         @Override
  9.         public boolean areContentsTheSame(User oldItem, User newItem) {
  10.             return oldItem.getAge() == newItem.getAge();
  11.         }
  12.     };
  13.     public UserAdapter() {
  14.         mDiffer = new AsyncListDiffer<>(this, diffCallback);
  15.     }
  16.     @Override
  17.     public int getItemCount() {
  18.         return mDiffer.getCurrentList().size();
  19.     }
  20.     public void submitList(List data) {
  21.         mDiffer.submitList(data);
  22.     }
  23.     public User getItem(int position) {
  24.         return mDiffer.getCurrentList().get(position);
  25.     }
  26.     @NonNull
  27.     @Override
  28.     public UserAdapter.UserViewHodler onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
  29.         View itemView = LayoutInflater.from(parent.getContext()).inflate(R.layout.item_user_list, parent, false);
  30.         return new UserViewHodler(itemView);
  31.     }
  32.     @Override
  33.     public void onBindViewHolder(@NonNull UserAdapter.UserViewHodler holder, int position) {
  34.         holder.setData(getItem(position));
  35.     }
  36.     class UserViewHodler extends RecyclerView.ViewHolder {
  37.         private TextView tvName;
  38.         private TextView tvAge;
  39.         public UserViewHodler(View itemView) {
  40.             super(itemView);
  41.             tvName = itemView.findViewById(R.id.tv_name);
  42.             tvAge = itemView.findViewById(R.id.tv_age);
  43.         }
  44.         public void setData(User data) {
  45.             tvName.setText(data.getName());
  46.             tvAge.setText(String.valueOf(data.getAge()));
  47.         }
  48.     }
  49. }

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

不难看出，AsyncListDiffer的使用步骤：

自实现DiffUtil.ItemCallback，给出item差异性计算条件

将所有对数据的操作代理给AsyncListDiffer，可以看到这个Adapter是没有List数据的

使用submitList()更新数据，并刷新ui

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

</>复制代码 
  1. List users = new ArrayList<>();
  2. for (int i = 0; i < 10; i++) {
  3.     users.add(new User(String.valueOf(i), "用户" + i, i + 20));
  4. }
  5. mAdapter.submitList(users);

然后修改数据

</>复制代码 
  1. List users = new ArrayList<>();
  2. for (int i = 0; i < 10; i++) {
  3.     users.add(new User(String.valueOf(i), "用户" + i, i % 3 == 0 ? i + 10: i + 20));
  4. }
  5. mAdapter.submitList(users);

跑起来看一哈

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

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

解惑

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

</>复制代码 
  1. public class AsyncListDiffer {
  2.     private final ListUpdateCallback mUpdateCallback;
  3.     private final AsyncDifferConfig mConfig;
  4.     public AsyncListDiffer(@NonNull RecyclerView.Adapter adapter,
  5.                 @NonNull DiffUtil.ItemCallback diffCallback) {
  6.         mUpdateCallback = new AdapterListUpdateCallback(adapter);
  7.         mConfig = new AsyncDifferConfig.Builder<>(diffCallback).build();
  8.     }
  9.     private List mList;
  10.     private List mReadOnlyList = Collections.emptyList();
  11.     private int mMaxScheduledGeneration;
  12.     public List getCurrentList() {
  13.         return mReadOnlyList;
  14.     }
  15.     public void submitList(final List newList) {
  16.         if (newList == mList) {
  17.             // 如果新旧数据相同，则啥事不做
  18.             return;
  19.         }
  20.         // 用于控制计算线程，防止在上一次submitList未完成时，
  21.         // 又多次调用submitList，这里只返回最后一个计算的DiffResult
  22.         final int runGeneration = ++mMaxScheduledGeneration;
  23.         if (newList == null) {
  24.             // 如果新数据集为空，此种情况不需要计算diff
  25.             // 直接清空数据即可
  26.             // 通知item remove
  27.             mUpdateCallback.onRemoved(0, mList.size());
  28.             mList = null;
  29.             mReadOnlyList = Collections.emptyList();
  30.             return;
  31.         }
  32.         if (mList == null) {
  33.             // 如果旧数据集为空，此种情况不需要计算diff
  34.             // 直接将新数据添加到旧数据集即可
  35.             // 通知item insert
  36.             mUpdateCallback.onInserted(0, newList.size());
  37.             mList = newList;
  38.             mReadOnlyList = Collections.unmodifiableList(newList);
  39.             return;
  40.         }
  41.         final List oldList = mList;
  42.         // 在子线程中计算DiffResult
  43.         mConfig.getBackgroundThreadExecutor().execute(new Runnable() {
  44.             @Override
  45.             public void run() {
  46.                 final DiffUtil.DiffResult result = DiffUtil.calculateDiff(new DiffUtil.Callback() {
  47.                     @Override
  48.                     public int getOldListSize() {
  49.                         return oldList.size();
  50.                     }
  51.                     @Override
  52.                     public int getNewListSize() {
  53.                         return newList.size();
  54.                     }
  55.                     @Override
  56.                     public boolean areItemsTheSame(int oldItemPosition, int newItemPosition) {
  57.                         return mConfig.getDiffCallback().areItemsTheSame(
  58.                                 oldList.get(oldItemPosition), newList.get(newItemPosition));
  59.                     }
  60.                     @Override
  61.                     public boolean areContentsTheSame(int oldItemPosition, int newItemPosition) {
  62.                         return mConfig.getDiffCallback().areContentsTheSame(
  63.                                 oldList.get(oldItemPosition), newList.get(newItemPosition));
  64.                     }
  65.                 });
  66.                 // 在主线程中更新数据
  67.                 mConfig.getMainThreadExecutor().execute(new Runnable() {
  68.                     @Override
  69.                     public void run() {
  70.                         if (mMaxScheduledGeneration == runGeneration) {
  71.                             latchList(newList, result);
  72.                         }
  73.                     }
  74.                 });
  75.             }
  76.         });
  77.     }
  78.     private void latchList(@NonNull List newList, @NonNull DiffUtil.DiffResult diffResult) {
  79.         diffResult.dispatchUpdatesTo(mUpdateCallback);
  80.         mList = newList;
  81.         mReadOnlyList = Collections.unmodifiableList(newList);
  82.     }
  83. }

线程部分源码：

</>复制代码 
  1. private static class MainThreadExecutor implements Executor {
  2.     final Handler mHandler = new Handler(Looper.getMainLooper());
  3.     @Override
  4.     public void execute(@NonNull Runnable command) {
  5.         mHandler.post(command);
  6.     }
  7. }
  8. @NonNull
  9. public AsyncDifferConfig build() {
  10.     if (mMainThreadExecutor == null) {
  11.         mMainThreadExecutor = sMainThreadExecutor;
  12.     }
  13.     if (mBackgroundThreadExecutor == null) {
  14.         synchronized (sExecutorLock) {
  15.             if (sDiffExecutor == null) {
  16.                 sDiffExecutor = Executors.newFixedThreadPool(2);
  17.             }
  18.         }
  19.         mBackgroundThreadExecutor = sDiffExecutor;
  20.     }
  21.     return new AsyncDifferConfig<>(
  22.             mMainThreadExecutor,
  23.             mBackgroundThreadExecutor,
  24.             mDiffCallback);
  25. }

ui刷新部分源码：

</>复制代码 
  1. public final class AdapterListUpdateCallback implements ListUpdateCallback {
  2.     @NonNull
  3.     private final RecyclerView.Adapter mAdapter;
  4.     public AdapterListUpdateCallback(@NonNull RecyclerView.Adapter adapter) {
  5.         mAdapter = adapter;
  6.     }
  7.     @Override
  8.     public void onInserted(int position, int count) {
  9.         mAdapter.notifyItemRangeInserted(position, count);
  10.     }
  11.     @Override
  12.     public void onRemoved(int position, int count) {
  13.         mAdapter.notifyItemRangeRemoved(position, count);
  14.     }
  15.     @Override
  16.     public void onMoved(int fromPosition, int toPosition) {
  17.         mAdapter.notifyItemMoved(fromPosition, toPosition);
  18.     }
  19.     @Override
  20.     public void onChanged(int position, int count, Object payload) {
  21.         mAdapter.notifyItemRangeChanged(position, count, payload);
  22.     }
  23. }

源码实现很简单，总结一下：

首先排除新旧数据为空的情况，这种情况不需要计算diff

在子线程中计算DiffResult，在主线程将DiffResult设置给Adapter，解决主线程阻塞问题

将Adapter的数据代理给AsyncListDiffer，解决Adapter与DiffUtil的数据一致性问题

完结，撒花
喜欢这篇文章记得给我一个小心心哦

GPU云服务器 云服务器 最好的android 最好的android开发公司 服务器的合作伙伴 伙伴关系

文章版权归作者所有，未经允许请勿转载,若此文章存在违规行为，您可以联系管理员删除。

转载请注明本文地址：https://www.ucloud.cn/yun/77164.html

相关文章

  • 六大布局之RelativeLayout

    摘要：前言上一期我们给大家讲解了的使用，这一期我们为大家讲解一下相对布局的使用，是的六大布局之一，也是我们常用的布局之一，下面我们一起开始学习吧简介相对布局允许子元素指定它们相对于其父元素或兄弟元素的位置，这是实际布局中最常用的布局方式之一。 前言 上一期我们给大家讲解了FrameLayout的使用，这一期我们为大家讲解一下RelativeLayout（相对布局）的使用，RelativeLa...

    chenjiang3 评论0 收藏0

  • 关于MVC/P 的简单介绍

    摘要：模式的核心是为了将模型从视图控制器中分离出来，从而使得模型独立于它们，因此模型不包含对视图和控制的引用。 写在最前面的那些话 相信对于大多数小白来说,关于MVP、MVC设计模式肯定是听过也看到过很多次了,也许也有过一些简单了解,但关于TA的具体概念,如何使用以及具体应用等都毫无所知,所以本着许多小伙伴一看到mvp、mvc就一脸懵逼的表情(当然也包括本人了⊙▽⊙)#),最近上手一个基于m...

    snowLu 评论0 收藏0

发表评论

登陆后可评论

0条评论

617035918

男|高级讲师
我要私信

TA的文章

阅读更多
最新活动
阅读需要支付1元查看
<