概述
在实际项目，一般很少直接在主线程中进行数据库操作。为解决该问题可以使用AsyncQueryHandler，该类中有一系列的startXXX方法，可以在子线程对数据库进行CRUD操作。但如果我们加载的数据不在数据库中时，AsyncQueryHandler就显得无能为力了。此时可以使用Loader。
Loader设计用于从数据源加载某类数据（如对象）。数据源可以是磁盘、数据库、ContentProvider、网络或者另一个进程。loader可以在不阻塞主线程的情况下获取并发送数据给接收者。android提供了Loader，AsyncTaskLoader与CursorLoader三种内置类型。
作为基类，Loader本身没有多大用处，它定义了供LoaderManager与loader通讯的api。
AsyncTaskLoader是一个抽象的Loader。它使用AsyncTask将数据加载任务转移到其他线程上。我们用的大部分都是它的子类。
CursorLoader，它是AsyncTaskLoader的子类，它借助ContentResolver从ContentProvider中加载数据。
以上内容摘自王明发译的《Android编程权威指南》
Loader
整个Loader类中没有进行任何关于加载数据的处理逻辑，它只是定义了Loader的三个状态——start,abandon,reset——以及两个监听器(OnLoadCompleteListener,OnLoadCanceledListener)和一个ContentObserver。
ContentObserver在Loader中只是定义，在CursorLoader中才使用。CursorLoader#loadInBackground中有：
cursor.registerContentObserver(mObserver);
因此，到cursor发生变化时，会执行ForceLoadContentObserver#onChange()，它又会调用onContentChanged()方法：
public void onContentChanged() {
if (mStarted) {//内容发生变化， 并且loader已经start过，所以直接强制重新加载一次
forceLoad();
} else {
// loader已经停止了, 所以不需要立即加载新数据。<span style="font-family: Arial, Helvetica, sans-serif;">但记录下数据变化的标识，在重新启动时去刷新.</span>
mContentChanged = true;
}
}对于commitContentChanged()，注释上有一句话：Call this when you have completely processed a load without it being cancelled。这就是说：当你完全处理了一个没有被取消的loader时调用该方法。因此，mProcessingChange表示是否正在处理changed
public void commitContentChanged() {
mProcessingChange = false;
} public boolean takeContentChanged() {
boolean res = mContentChanged;
mContentChanged = false;
mProcessingChange |= res;//如果有变化，那就表示正在处理变化。
return res;
}Loader为三种状态提供了一系列的方法：如获取方法isStarted(),isAbandoned(),isReset()。修改方法如下：
public final void startLoading() {//禁止私自调用
//修改三个状态，略
onStartLoading();
}
protected void onStartLoading() {
}
public boolean cancelLoad() {
return onCancelLoad();
}
protected boolean onCancelLoad() {
return false;
}
/**
* 强制重新加载数据。无论是否已经加载过数据
* 必须在主线程中调用。
*/
public void forceLoad() {
onForceLoad();
}
protected void onForceLoad() {
}
/**
* 由LoaderManager调用，禁止自己调用。
* 停止向客户端反应最新的数据变化，但依旧能监听到。
*/
public void stopLoading() {
mStarted = false;
onStopLoading();
}
/**
* 自己处理stop loading的逻辑的地方
*/
protected void onStopLoading() {
}
/**
* 由LoaderManager调用，禁止私自调用。
* 保留现有数据，但不会通知新数据变化
*/
public void abandon() {
mAbandoned = true;
onAbandon();
}
protected void onAbandon() {
}
/**
* 同上面stop一样
*/
public void reset() {
onReset();
//修改状态，略
}
protected void onReset() {
}
从上面可以看出，Loader只是定义了一些操作自身的函数，方便LoaderManager使用。它并没有真正加载数据，一般加载数据都是通过继承AsyncTaskLoader实现的。
LoaderManager
LoaderManager主要用来管理loader。可以在activity/fragment中调用getLoaderManager()获取LoaderManager的实例。LoaderManager只是一个接口，它的真正实现是其内部类<LoaderManagerImpl。
initLoader()
通过该方法可以完成loader的初始化。LoaderManager会根据loader的状态自动调用第三个参数(以下称回调)中的方法。这也是回调的作用：根据loader的状态，执行不同的操作。
第一个参数是指定当前loader的id，这是该loader的唯一标识。当id相同时，loader就相同。
第二个参数是方便在初始化loader时传递参数。它最终会传递到回调中onCreateLoader()中成为第二个参数。
initLoader()的部分代码如下：
public <D> Loader<D> initLoader(int id, Bundle args, LoaderManager.LoaderCallbacks<D> callback) {
……
LoaderInfo info = mLoaders.get(id);//mLoaders是SparseArray对象，所以key值可以为int类型的
……
if (info == null) {
// Loader doesn't already exist; create.
info = createAndInstallLoader(id, args, (LoaderManager.LoaderCallbacks<Object>)callback);
} else {
info.mCallbacks = (LoaderManager.LoaderCallbacks<Object>)callback;
}
if (info.mHaveData && mStarted) {
// If the loader has already generated its data, report it now.
info.callOnLoadFinished(info.mLoader, info.mData);
}
return (Loader<D>)info.mLoader;
}最后一个判断表明：如果当前的loader有数据，并且已经启动，就会直接调用LoadInfo.callOnLoadFinished()，而在该方法中会调用到LoaderCallbacks.onLoadFinished()。
当info为null时调用createAndInstallLoader()，同时将initLoader()中的所有参数传递进去。createAndInstallLoader()主要代码如下：
LoaderInfo info = createLoader(id, args, callback);
installLoader(info); private LoaderInfo createLoader(int id, Bundle args,
LoaderManager.LoaderCallbacks<Object> callback) {
LoaderInfo info = new LoaderInfo(id, args, (LoaderManager.LoaderCallbacks<Object>)callback);//分别为LoaderInfo中的mId,mArgs,mCallbacks赋值
Loader<Object> loader = callback.onCreateLoader(id, args);//调用onCreateLoader生成Loader实例
info.mLoader = (Loader<Object>)loader;//将生成的实例赋值到LoaderInfo#mLoader
return info;
}在installLoader()中，会调用mLoaders.put(info.mId, info)，这里的info.mId就是initLoader()中的第一个参数。这样就将新建的loader存储到了mLoaders中。
同时installLoader()还会调用info.start()。这是一个很重要的方法 ，因为它会调用Loader.startLoading()。代码为：
void start() {
……
mStarted = true;
……
if (mLoader == null && mCallbacks != null) {//再一次判断，防止mLoader为null
mLoader = mCallbacks.onCreateLoader(mId, mArgs);
}
if (mLoader != null) {
……
if (!mListenerRegistered) {
mLoader.registerListener(mId, this);
mLoader.registerOnLoadCanceledListener(this);
mListenerRegistered = true;
}
mLoader.startLoading();
}
}从这里开始已经由LoaderManager进入到了Loader中。
restartLoader
AsyncTaskLoader
protected void onStartLoading() {//CursorLoader.java
if (mCursor != null) {
deliverResult(mCursor);
}
if (takeContentChanged() || mCursor == null) {
forceLoad();//调用forceLoad()，并在loadInBackground()进行查询操作。
}
}onForceLoad
@Override
protected void onForceLoad() {//调用forceLoad会执行到该方法
super.onForceLoad();//方法空实现
cancelLoad();
mTask = new LoadTask();
executePendingTask();
} void executePendingTask() {
if (mCancellingTask == null && mTask != null) {
……
mTask.executeOnExecutor(mExecutor, (Void[]) null);//启动AsyncTask进行异步执行
}
}在mTask的doInBackground中会调用onLoadInBackground()，它又调用loadInBackground()，这才是异步执行的地方。
mTask为AsyncTask，故加载完毕后会走onPostExecute中，又会调用dispatchOnLoadComplete()，其作用主要是对加载结果进行分发。如下：
void dispatchOnLoadComplete(LoadTask task, D data) {
if (mTask != task) {
//Load complete of old task, trying to cancel.mTask只有在onForceLoad()中被赋值，所以这里的操作就是旧有的loader加载完数据
dispatchOnCancelled(task, data);
} else {
if (isAbandoned()) {
// loader被废弃，所以给个回调，让子类有机会处理data的回收。参考CursorLoader.
onCanceled(data);
} else {//通知数据变化，以及分发数据
commitContentChanged();//将Loader中的mProcessingChange设置为false
mLastLoadCompleteTime = SystemClock.uptimeMillis();
mTask = null;//关闭当前的loader
deliverResult(data);//很简单，只是调用Loader中关联的OnLoadCompleteListener回调
}
}
}if (mData != data || !mHaveData) {
mData = data;
mHaveData = true;
if (mStarted) {
callOnLoadFinished(loader, data);//这里最终会调用到Callback中的onLoadFinished
}
}至此，Loader的加载过程结束。这中间唯一需要自己操作的就是继承AsyncTaskLoader时，必须重写onStartLoad()并在其中调用forceLoad()，不然整个加载过程不完整。
总结
LoaderManager通过id区分它所管理的loader。当两个loader的id相同时，便会被认为是同一个loader。
如果当前id的loader已经存在，那么不会创建新的loader，只是更新initLoader()中的回调。
如果当前id的loader已经存在，并且已经有数据，那么不会再次查询数据，而是直接将数据传递到回调中的onLoadFinished()中。
示例
一个完整的对AsyncTaskLoader的实现，有些东西基本上是固定的，而且与CursorLoader类似。例子来源于google的TODO-MVP-Loaders。如下：
public class TasksLoader extends AsyncTaskLoader<List<Task>>
implements TasksRepository.TasksRepositoryObserver{
private TasksRepository mRepository;
public TasksLoader(Context context, @NonNull TasksRepository repository) {
super(context);
checkNotNull(repository);//如果repository为null，此句话抛异常
mRepository = repository;//为加载数据的数据源。根据实际逻辑换。
}
@Override
public List<Task> loadInBackground() {//异步加载数据
return mRepository.getTasks();
}
@Override
public void deliverResult(List<Task> data) {
if (isReset()) {//重置过，加载的数据就不需要。这里还需要对数据进行回收处理。CursorLoader中这里会关闭cursor
return;
}
if (isStarted()) {//start了，将新加载的数据传递给loader。最终会走到LoaderCallbacks#onLoadFinished
super.deliverResult(data);
}
//这里一般需要对旧数据进行一些回收处理。
}
@Override
protected void onStartLoading() {
if (mRepository.cachedTasksAvailable()) {//有缓存，就先把缓存给返回
deliverResult(mRepository.getCachedTasks());
}
mRepository.addContentObserver(this);
//takeContentChanged()的判断是一定有的
if (takeContentChanged() || !mRepository.cachedTasksAvailable()) {
//该loader停止后有数据变化，或者别的什么原因必须进行更新(本例中是缓存不可用)，就强制更新数据。
forceLoad();//它会调用到loadInBackground()。
}
}
@Override
protected void onStopLoading() {//CursorLoader也这么调，没考虑为啥。
cancelLoad();
}
@Override
protected void onReset() {
onStopLoading();//
//进行一些清尾工作
mRepository.removeContentObserver(this);
}
//TasksRepository.TasksRepositoryObserver中的回调，跟Loader无关
@Override
public void onTasksChanged() {
if (isStarted()) {
forceLoad();
}
}
}
9573
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
