ItemKeyedDataSource 使用注意事项

最新推荐文章于 2023-07-21 10:42:56 发布
最新推荐文章于 2023-07-21 10:42:56 发布
阅读量1.2k 收藏
点赞数
分类专栏： paging 文章标签： android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cxmfzu/article/details/105660776
版权

Paging简介

Paging主要由三个部分组成：DataSource PageList PageListAdapter。
DataSource<Key, Value>从字面意思理解是一个数据源，其中key对应加载数据的条件信息，Value对应加载数据的实体类。
DataSource是一个抽象类，但是我们不能直接继承它实现它的子类。但是Paging库里提供了它的三个子类供我们继承用于不同场景的实现。

  • PageKeyedDataSource<Key, Value> ：适用于目标数据根据页信息请求数据的场景，即Key 字段是页相关的信息。比如请求的数据的参数中包含类似next/previous页数的信息。
  • ItemKeyedDataSource<Key, Value> ：适用于目标数据的加载依赖特定item的信息， 即Key字段包含的是Item中的信息，比如需要根据第N项的信息加载第N+1项的数据，传参中需要传入第N项的ID时，该场景多出现于论坛类应用评论信息的请求。
  • PositionalDataSource：适用于目标数据总数固定，通过特定的位置加载数据，这里Key是Integer类型的位置信息，T即Value。 比如从数据库中的1200条开始加在20条数据。

测试例子

PagedList配置如下

 private PagedList.Config config = new PagedList.Config.Builder()
            .setInitialLoadSizeHint(10) // 配置 初始化 加载条数
            .setPageSize(10) // 设置 每页 加载条数
            .setPrefetchDistance(2)
            .setMaxSize(20)
            .setEnablePlaceholders(false)
            .build();
            
   private LiveData<PagedList<Cheese>> livePagedList = new LivePagedListBuilder<Integer,Cheese>(factory,config)
            .setInitialLoadKey(0)//  指定初始化加载的key
            // .setFetchExecutor()// 指定线程执行异步操作
            .setBoundaryCallback(new CheeseBoundaryCallback())
            .build();

场景描述：
数据库默认有100条数据。初始化加载0~10条数据，PagedList最多存储20条数据。在滑动在距离上边缘2条和下边缘2条的时候加载更多数据。
运行现象：
滑动过程中容易出现只能加载20条数据，超过20条的数据无法加载。

解决方案

 private PagedList.Config config = new PagedList.Config.Builder()
            .setInitialLoadSizeHint(10) // 配置 初始化 加载条数
            .setPageSize(10) // 设置 每页 加载条数
            .setPrefetchDistance(2)
            .setMaxSize(10 *3) // 配置pagedList最大加载条数为3倍的PageSize 
            .setEnablePlaceholders(false)
            .build();

关于解决方案的思路是：思路是保证loadBefore，loadInitial，loadAfter三个回调获取到的数据都可以完整的保存在PageList里面。

初始化流程简介

由于遇到了以上的问题，因此，对Paging如果更新RecyclerView，已经实现加载更多的流程有了兴趣，因此，对代码分析如下。
使用PagedList一般是将PagedList存储在ViewHolder中，因此ViewHolder的代码一般如下

public class CheeseViewModel extends ViewModel{
	private LiveData<PagedList<Cheese>> livePagedList = new LivePagedListBuilder<Integer,Cheese>(factory,config)
            .setInitialLoadKey(0)//  指定初始化加载的key
            // .setFetchExecutor()// 指定线程执行异步操作
            .setBoundaryCallback(new CheeseBoundaryCallback())
            .build();
}

根据源码可以得知，最终调用的代码是

static <K, T> PagedList<T> create(@NonNull DataSource<K, T> dataSource,
            @NonNull Executor notifyExecutor,
            @NonNull Executor fetchExecutor,
            @Nullable BoundaryCallback<T> boundaryCallback,
            @NonNull Config config,
            @Nullable K key){
            	...
            	if (dataSource.isContiguous() || !config.enablePlaceholders){
            		return new ContiguousPagedList<>(contigDataSource,
                    notifyExecutor,
                    fetchExecutor,
                    boundaryCallback,
                    config,
                    key,
                    lastLoad);
            	}
            }

在ContiguousPagedList构造函数中调用dispatchLoadInitial方法。
dispatchLoadInitial 即回调到ItemKeyedDataSource的 dispatchLoadInitial 函数中

public abstract class ItemKeyedDataSource<Key, Value> extends ContiguousDataSource<Key, Value>{
	@Override
    final void dispatchLoadInitial(@Nullable Key key, int initialLoadSize, int pageSize,
            boolean enablePlaceholders, @NonNull Executor mainThreadExecutor,
            @NonNull PageResult.Receiver<Value> receiver) {
        LoadInitialCallbackImpl<Value> callback =
                new LoadInitialCallbackImpl<>(this, enablePlaceholders, receiver);
                // 注意 loadInitial 是抽象方法，需要在子类实现
        loadInitial(new LoadInitialParams<>(key, initialLoadSize, enablePlaceholders), callback);
        callback.mCallbackHelper.setPostExecutor(mainThreadExecutor);
    }
}

抽象方法在继承ItemKeyedDataSource的子类实现，源码如下

public class MyItemKeyedDataSource extends ItemKeyedDataSource<Integer,Cheese>{
	    @Override
    public void loadInitial(@NonNull LoadInitialParams params, @NonNull LoadInitialCallback callback) {
		...
		// 获取cheeseList，通过回调传递给ItemKeyedDataSource
        callback.onResult(cheeseList);
    }
}

LoadInitialCallback 在ItemKeyedDataSource的实现如下

public abstract class ItemKeyedDataSource<Key, Value> extends ContiguousDataSource<Key, Value>{
	static class LoadInitialCallbackImpl<Value> extends LoadInitialCallback<Value> {
		public void onResult(@NonNull List<Value> data){
		if (!mCallbackHelper.dispatchInvalidResultIfInvalid()) {
				// 调用核心的Receiver
                mCallbackHelper.dispatchResultToReceiver(new PageResult<>(data, 0, 0, 0));
            }
		}
	}
}

核心的ContiguousPagedList#mReceiver如下，PageResult.Receiver实现RecyclerView item的初始化已经加载更新。

class ContiguousPagedList<K, V> extends PagedList<V> implements Callback{
	    PageResult.Receiver<V> mReceiver = new PageResult.Receiver<V>() {
        // Creation thread for initial synchronous load, otherwise main thread
        // Safe to access main thread only state - no other thread has reference during construction
        @AnyThread
        @Override
        public void onPageResult(@PageResult.ResultType int resultType,
                @NonNull PageResult<V> pageResult) {
            if (pageResult.isInvalid()) {
                detach();
                return;
            }

            if (isDetached()) {
                // No op, have detached
                return;
            }

            List<V> page = pageResult.page;
            if (resultType == PageResult.INIT) {
                mStorage.init(pageResult.leadingNulls, page, pageResult.trailingNulls,
                        pageResult.positionOffset, ContiguousPagedList.this);
                if (mLastLoad == LAST_LOAD_UNSPECIFIED) {
                    // Because the ContiguousPagedList wasn't initialized with a last load position,
                    // initialize it to the middle of the initial load
                    mLastLoad =
                            pageResult.leadingNulls + pageResult.positionOffset + page.size() / 2;
                }
            } else {
                // if we end up trimming, we trim from side that's furthest from most recent access
                boolean trimFromFront = mLastLoad > mStorage.getMiddleOfLoadedRange();

                // is the new page big enough to warrant pre-trimming (i.e. dropping) it?
                boolean skipNewPage = mShouldTrim
                        && mStorage.shouldPreTrimNewPage(
                                mConfig.maxSize, mRequiredRemainder, page.size());

                if (resultType == PageResult.APPEND) {
                    if (skipNewPage && !trimFromFront) {
                        // don't append this data, drop it
                        mAppendItemsRequested = 0;
                        mAppendWorkerState = READY_TO_FETCH;
                    } else {
                        mStorage.appendPage(page, ContiguousPagedList.this);
                    }
                } else if (resultType == PageResult.PREPEND) {
                    if (skipNewPage && trimFromFront) {
                        // don't append this data, drop it
                        mPrependItemsRequested = 0;
                        mPrependWorkerState = READY_TO_FETCH;
                    } else {
                        mStorage.prependPage(page, ContiguousPagedList.this);
                    }
                } else {
                    throw new IllegalArgumentException("unexpected resultType " + resultType);
                }

                if (mShouldTrim) {
                    if (trimFromFront) {
                        if (mPrependWorkerState != FETCHING) {
                            if (mStorage.trimFromFront(
                                    mReplacePagesWithNulls,
                                    mConfig.maxSize,
                                    mRequiredRemainder,
                                    ContiguousPagedList.this)) {
                                // trimmed from front, ensure we can fetch in that dir
                                mPrependWorkerState = READY_TO_FETCH;
                            }
                        }
                    } else {
                        if (mAppendWorkerState != FETCHING) {
                            if (mStorage.trimFromEnd(
                                    mReplacePagesWithNulls,
                                    mConfig.maxSize,
                                    mRequiredRemainder,
                                    ContiguousPagedList.this)) {
                                mAppendWorkerState = READY_TO_FETCH;
                            }
                        }
                    }
                }
            }

            if (mBoundaryCallback != null) {
                boolean deferEmpty = mStorage.size() == 0;
                boolean deferBegin = !deferEmpty
                        && resultType == PageResult.PREPEND
                        && pageResult.page.size() == 0;
                boolean deferEnd = !deferEmpty
                        && resultType == PageResult.APPEND
                        && pageResult.page.size() == 0;
                deferBoundaryCallbacks(deferEmpty, deferBegin, deferEnd);
            }
        }
    };
}

由于是初始化，因此resultType == PageResult.INIT
执行的分支并未调用postValue接口，更新数据，只是将数据保存在agedStorage mStorage 中。

if (resultType == PageResult.INIT) {
                mStorage.init(pageResult.leadingNulls, page, pageResult.trailingNulls,
                        pageResult.positionOffset, ContiguousPagedList.this);
                if (mLastLoad == LAST_LOAD_UNSPECIFIED) {
                    // Because the ContiguousPagedList wasn't initialized with a last load position,
                    // initialize it to the middle of the initial load
                    mLastLoad =
                            pageResult.leadingNulls + pageResult.positionOffset + page.size() / 2;
                }
            }

这时候需要查看源码LivePagedListBuilder，ViewHolder持有的LiveData本质是ComputableLiveData，在第一次订阅观察者是，会调用onActive

public ComputableLiveData(@NonNull Executor executor) {
        mExecutor = executor;
        mLiveData = new LiveData<T>() {
            @Override
            protected void onActive() {
                mExecutor.execute(mRefreshRunnable);
            }
        };
    }

onActive执行mRefreshRunnable线程，

    final Runnable mRefreshRunnable = new Runnable() {
        @WorkerThread
        @Override
        public void run() {
            boolean computed;
            do {
                computed = false;
                // compute can happen only in 1 thread but no reason to lock others.
                if (mComputing.compareAndSet(false, true)) {
                    // as long as it is invalid, keep computing.
                    try {
                        T value = null;
                        while (mInvalid.compareAndSet(true, false)) {
                            computed = true;
                            value = compute();
                        }
                        if (computed) {
                        	// 这里调用postValue接口，这时候在生命周期允许的条件下回调更新UI
                            mLiveData.postValue(value);
                        }
                    } finally {
                        mComputing.set(false);
                    }
                }
scenario.

            } while (computed && mInvalid.get());
        }
    };

Activity或者Fragment中注册PagedList的观察者代码如下

 viewModel.getLivePagedList().observe(getViewLifecycleOwner(),
                cheeses ->{
                    Log.d(TAG,"===submitList==="+cheeses.size());
                    // 这里最终调用adapter的更新接口，更新UI
                    adapter.submitList(cheeses);
            }
        );

以上即为使用PagedListAdapter初始化RecyclerView的流程。

滑动更新

RecyclerView在创建Item过程中，会调用onCreateViewHolder和onBindViewHolder等接口，在onBindViewHolder接口中，需要获取Adapter的Item列表，用于与item界面元素绑定。

public class CheeseAdapter extends PagedListAdapter<Cheese,CheeseViewHolder> {
	    @Override
    public void onBindViewHolder(@NonNull CheeseViewHolder holder, int position) {
        holder.bindTo(getItem(position));
    }
}

getItem最终调用到
public class AsyncPagedListDiffer{
public T getItem(int index) {
…
// 这个方法实现了滑动刷新
mPagedList.loadAround(index);
return mPagedList.get(index);
}
}

    protected void loadAroundInternal(int index) {
        int prependItems = getPrependItemsRequested(mConfig.prefetchDistance, index,
                mStorage.getLeadingNullCount());
        int appendItems = getAppendItemsRequested(mConfig.prefetchDistance, index,
                mStorage.getLeadingNullCount() + mStorage.getStorageCount());

        mPrependItemsRequested = Math.max(prependItems, mPrependItemsRequested);
        if (mPrependItemsRequested > 0) {
        	// 调用 loadBefore
            schedulePrepend();
        }

        mAppendItemsRequested = Math.max(appendItems, mAppendItemsRequested);
        if (mAppendItemsRequested > 0) {
        	// loadAfter
            scheduleAppend();
        }
    }
cxmfzu
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Ant 表格组件 dataSource不带key 引发的报错
weixin_43990297的博客
03-19 1100
按照 React 的规范，所有的数组组件必须绑定 key。在 Table 中，dataSource 和 columns 里的数据值都需要指定 key 值。对于 dataSource 默认将每列数据的 key 属性作为唯一的标识。 如果 dataSource[i].key 没有提供，使用 rowKey 来指定 dataSource 的主键，如下所示。若没有指定，控制台会出现以上的提示，表格组件也会出现各类奇怪的错误。 // 比如你的数据主键是 uid return <Table rowKey="u.
WPF学习笔记——DataContext 与 ItemSource
weixin_34197488的博客
05-19 497
作为一个WPF新手，在ListBox控件里，我分不清 DataContext 与 ItemSource的区别。在实践中，似乎：<ListBox x:Name="Lst" DataContext="{Binding model.UserList}" ItemsSource="{Binding}">与<ListBox x:Name="Lst" ItemsSource="{Bind...
Android Paging library详解（二）
虎哥LoveDroid
08-27 1484
重要API及源码分析 1.重要API介绍 1.1 DataSource 1.2 PageList 1.3 PagedListAdapter 2.源码解析 1.重要API介绍 Paging主要由三个部分组成：DataSource PageList PageListAdapter 1.1 DataSource DataSource&amp;lt;Key, Value&amp;gt;从字面意...
DataSource数据源
一个很懒的人
06-07 9242
本文详细的介绍了 JAVA中的数据源，认真看下来 你一定会收获满满！！！
Sharding-JDBC——数据分片——分表（最全demo）
最新发布
cxclll的博客
07-21 676
标准分片策略适用于单分片键，此策略支持和两个分片算法。其中是必选的，用于处理和IN的分片。是可选的，用于处理BETWEEN==、AND>=
Paging3Sample:一个简单的示例显示了如何使用分页3库
05-11
Paging 3提供了两种类型的DataSource：`PageKeyedDataSource`和`ItemKeyedDataSource`。前者基于页面编号加载数据，后者则基于每个项目的唯一标识加载数据。 #### 2.2 PagingSource Paging 3引入了`PagingSource`...
第七讲 快速入门jetpack（终）- 课件.pdf
12-06
根据数据来源的不同，可以使用`PositionalDataSource`、`PageKeyedDataSource`或`ItemKeyedDataSource`。例如，从网络获取数据通常使用`PageKeyedDataSource`，因为它支持按页加载。 在实际项目中，Paging库与...
android-pagination-example:Android Jetpack的分页库的示例项目
05-08
带Firebase的Android Jetpack分页这是一个使用Android Jetpack分页库的小示例项目。... 其中使用了PagedListAdapter和ItemKeyedDataSource，并将数据存储在Firebase中。 在下面您可以看到最终结果：
Android架构之Paging组件(一)
qq_43404873的博客
11-15 3152
Paging组件的意义 分页加载是在应用程序开发过程中十分常见的需求。我们经常需要以列表的形式加载大量的数据，一次性加载所有的数据，必然会消耗大量的时间和数据流量。然而用户只需要部分数据。这时候就有了分页加载。分页加载是对数据进行按需加载。 分页加载有两种模式: 传统的上拉加载更多 无限滚动分页效果 Paging组件就是基于无限滚动模式而设计的。 比如说:京东的App就是就是基于无限滚动模式进行分页加载的。当我们滑动到一定量的数据的时候，会自动请求加载下一页的数据。这让用户会感觉到，所有的数据都是一次
ItemSource与DataContext的区别
tasty
09-27 1899
DataContext用于绑定单行，ItemSource用于多行绑定。 Those two properties do not serve the same purpose. DataContext is a general (dependency) property of all descendants of FrameworkElement. Is is inherited throu
JetPack--Paging2
aruba的博客
09-18 304
Paging是一个用于分页加载的组件，对于一些列表数据，以前大家都使用过的一种方式是定义一个page，当达到加载更多条件时，page加一再去请求数据，为此我们要写很多重复的代码，Paging就对分页进行了一个封装 Paging由分为三个模块 1.DataSource：数据从该模块中获取，数据可以来源于网络、本地数据库等 2.PagedList：负责具体获取数据的逻辑，何时获取、加载下一页、预加载等...
JetPack ：Paging、WorkManager、Slices介绍和使用方式
Mr.SSY的博客
06-09 3288
本文由玉刚说写作平台提供写作赞助，版权归玉刚说微信公众号所有 原作者：Mr.s（猪_队友） 版权声明：未经玉刚说许可，不得以任何形式转载 今年谷歌I/O大会，谷歌发布了 Android Jetpack.这是新一代组件、工具和架构指导，用谷歌官方的话就是旨在加快开发者的 Android 应用开发速度。Android Jetpack 组件将现有的支持库与架...
Android_Jetpack:Paging组件之PageKeyedDataSource的MVVM使用
nanquan11的博客
11-27 1328
PageKeyedDataSource是比较常见的一种DataSource，适用于数据源以“页”的方式进行请求的情况。例如，请求参数为page=2&pagesize=10，则表示数据源以10条数据为一页，当前返回第二页的5条数据。 接下来首先来按照MVVM架构跑通一个笑话大全数据接口，这里使用的是最新笑话接口，key是我自己注册的。 接口：http://v.juhe.cn/joke/content/text.php?key=您申请的KEY&page=1&pagesize=10 接口返
手把手教你使用Android Paging Library
御风而行
10-13 2758
当我们用RecyclerView来展示服务器返回的大量数据时，通常我们都需要实现分页的效果。以前我们都是通过监听RecyclerView的滚动事件，当RecyclerView滑动到底部的时候再次请求网络，把数据展示到RecyclerView上。现在Google提供了一个分页库来帮助开发者更轻松的实现在RecyclerView中逐步而且优雅地加载数据 本文我将以Google官方提供的PagingWi...
Jetpack插件化学习之AndroidX Paging 大数据列表加载库一
边城晨的专栏
10-25 1198
Jetpack插件化学习之AndroidX Paging 大数据列表加载库一 本文根据以下思路进行Paging的学习: Paging介绍 Paing核心组件 总结梳理 Paging介绍 分页库使您可以更轻松地在应用程序中逐步和优雅地加载数据 RecyclerView。 许多应用程序使用包含大量项目的数据源中的数据，但一次只显示一小部分。 分页库可帮助您的应用观察并显示此数据的合理子集。此功能有...
Android Jetpack架构组件之 Paging（使用、源码篇）
浅谈Android
10-22 7876
1、前言 最近简单看了下google推出的框架Jetpack，感觉此框架的内容可以对平时的开发有很大的帮助，也可以解决很多开发中的问题，对代码的逻辑和UI界面实现深层解耦，打造数据驱动型UI界面。 Android Architecture组件是Android Jetpack的一部分，它们是一组库，旨在帮助开发者设计健壮、可测试和可维护的应用程序，包含一下组件： 带你领略Android Je...
Android 架构组件 - 让天下没有难做的 App
程序亦非猿——一个能帮你进大厂的男人
03-12 211
本文转载自我的好基友老梁老司机，一文带你领略AAC的魅力。Google 为了帮助 Android 开发者更快更好地开发 App，推出了一系列组件，这些组件被打包成了一个整...
Android查找问题的网站,Paging 使用及遇到的问题
weixin_34036423的博客
05-29 227
Paging概述Jetpack 的一个分页库，帮助开发者更好的分离ui和数据获取的逻辑，降低项目的耦合。本文主要描述从服务器直接获取数据项目地址：github.com/Tkorn/kotli…库架构DataSource.Factory,顾名思义，就是数据源工厂。抽象类，需要我们实现create() 方法，返回DataSource 对象。**注意：create() 每次被调用都应该返回新对象，**...
Jetpack Navigation入门与实践：简化Fragment管理与高效数据传递
Navigation的诞生是为了提供一个直观的可视化页面导航图，使得开发者可以通过`destination`和`action`轻松实现页面之间的导航，从而简化了Fragment的切换操作，不再需要频繁地使用FragmentManager和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值