1 背景

在Android中任何耗时的操作都不能放在UI主线程中，所以耗时的操作都需要使用异步实现。同样的，在ContentProvider中也可能存在耗时操作，这时也该使用异步操作，而3.0之后最推荐的异步操作就是Loader。它可以方便我们在Activity和Fragment中异步加载数据，而不是用线程或AsyncTask，他的优点如下：

• 提供异步加载数据机制；
• 对数据源变化进行监听，实时更新数据；
• 在Activity配置发生变化（如横竖屏切换）时不用重复加载数据；
• 适用于任何Activity和Fragment；

PS：由于在我们现在的多个项目中都大量的使用了Loader来处理数据加载（而且由于粗心跳过几个坑，譬如Loader ID重复导致数据逻辑异常、多线程中restartLoader导致Loader抛出异常（最后保证都在UI线程中执行即可）等），所以接下来我们进行下使用及源码浅析。

【工匠若水 http://blog.csdn.net/yanbober 转载请注明出处。点我开始Android技术交流】

PPPS：前方高能，文章巨长，请做好心理准备（您可以选择通过左上角目录点击索引到感兴趣的章节直接查看，或者，或者，或者直接高能往下看）。

2 基础使用实例

该基础实例讲解完全来自于官方文档，详细可以点击我查看英文原文。

既然接下来准备要说说他的使用强大之处了，那不妨我们先来一张图直观的感性认识下不用Loader（左）与用Loader（右）对我们开发者及代码复杂度和框架的影响吧，如下：

2-1 Loader API概述说明

如下是我们开发中常用的一些Loader相关接口：

Class/Interface	Description
LoaderManager	一个与Activity、Fragment关联的抽象类，用于管理一个或多个Loader实例。每个Activity或Fragment只能有一个LoaderManager，而一个LoaderManager可以有多个Loader。
LoaderManager.LoaderCallbacks	用于和LoaderManager交互的回调接口。譬如，可以使用onCreateLoader()创建一个新的Loader。
AsyncTaskLoader	抽象的Loader，提供一个AsyncTask继承实现。
CursorLoader	AsyncTaskLoader的子类，用于向ContentResover请求返回一个Cursor。该类以标准游标查询实现了Loader协议，使用后台线程进行查询，使用这个Loader是从ContentProvider加载异步数据最好的方式。

2-2 在应用中使用Loader

在我们开发的一个App里，使用Loader时常规的步骤包含如下一些操作需求：

• 一个Activity或Fragment；
• 一个LoaderManager实例；
• 一个CursorLoader，从ContentProvider加载数据；
• 一个LoaderManager.LoaderCallbacks实现，创建新Loader及管理已存在Loader；
• 一个组织Loader数据的Adapter，如SimpleCursorAdapter；

下面我们看下具体流程。

2-2-1 启动一个Loader（initLoader）

一个Activity或Fragment中LoaderManager管理一个或多个Loader实例，每个Activity或Fragment只有一个LoaderManager，我们可以在Activity的onCreate()或Fragment的onActivityCreated()里初始化一个Loader。例如：

// Prepare the loader. Either re-connect with an existing one,  // or start a new one.  getLoaderManager().initLoader(0, null, this);

可以看见上面的initLoader()方法有三个参数：

• 第一个参数代表当前Loader的ID；
• 第二个参数代表提供给Loader构造函数的参数，可选；
• 第三个参数代表LoaderManager.LoaderCallbacks的回调实现；

上面initLoader()方法的调用确保了一个Loader被初始化和激活的状态，该方法的调运有如下两种结果：

• 如果代表该Loader的ID已经存在，则后面创建的Loader将直接复用已经存在的；
• 如果代表该Loader的ID不存在，initLoader()会触发LoaderManager.LoaderCallbacks回调的onCreateLoader()方法创建一个Loader；

可以看见通过initLoader()方法可以将LoaderManager.LoaderCallbacks实例与Loader进行关联，且当Loader的状态变化时就被回调。所以说，如果调用者正处于其开始状态并且被请求的Loader已经存在，且已产生了数据，那么系统会立即调用onLoadFinished()（在initLoader()调用期间），所以你必须考虑到这种情况的发生。

当然了，intiLoader()会返回一个创建的Loader，但是你不用获取它的引用，因为LoadeManager会自动管理该Loader的生命周期，你只用在它回调提供的生命周期方法中做自己数据逻辑的处理即可。

2-2-2 重启一个Loader（restartLoader）

通过上面initLoader()方法介绍我们可以知道initLoader调运后要么得到一个ID已存在的Loader，要么创建一个新的Loader；但是有时我们想丢弃旧数据然后重新开始创建一个新Loader，这可怎么办呢？别担心，要丢弃旧数据调用restartLoader()即可。例如，SearchView.OnQueryTextListener的实现重启了Loader，当用户查询发生变化时Loader需要重启，如下：

public boolean onQueryTextChanged(String newText) {      // Called when the action bar search text has changed. Update      // the search filter, and restart the loader to do a new query      // with this filter.      mCurFilter = !TextUtils.isEmpty(newText) ? newText : null;      getLoaderManager().restartLoader(0, null, this);      return true;  }

上面方法的参数啥的和再上面的init方法类似，就不再罗嗦了。

2-2-3 使用LoaderManager Callbacks

LoaderManager.LoaderCallbacks是LoaderManager的回调交互接口。LoaderManager.LoaderCallbacks包含如下三个方法：

• onCreateLoader()
  实例化并返回一个新创建给定ID的Loader对象；
• onLoadFinished()
  当创建好的Loader完成了数据的load之后回调此方法；
• onLoaderReset()
  当创建好的Loader被reset时调用此方法，这样保证它的数据无效；

2-2-3-1 onCreateLoader说明

当你尝试使用一个Loader（譬如通过initLoader()方法），它会检查给定Loader的ID是否存在，如果不存在就触发LoaderManager.LoaderCallbacks里的onCreateLoader()方法创建一个新Loader。创建新Loader实例典型的做法就是通过CursorLoader类创建，不过你也可以自定义一个继承自Loader的子类来实现自己的Loader。

下面的例子中我们通过onCreateLoader()回调创建一个CursorLoader实例，使用CursorLoader的构造方法创建实例时需要一些参数去查询一个ContentProvider。具体参数如下：

• uri
  准备获取内容的URI。
• projection
  要返回的列key list，null表示返回所有列，但是返回所有列很多时候会降低性能；
• selection
  要返回的行过滤，也就是SQL中的WHERE语句，null代表返回uri指定的所有行；
• selectionArgs
  用来替换上面selection中包含的“？”；
• sortOrder
  结果的行排序，也就是SQL中的ORDER BY，传递null则无序；

 // If non-null, this is the current filter the user has provided.  String mCurFilter;  ...  public Loader<Cursor> onCreateLoader(int id, Bundle args) {      // This is called when a new Loader needs to be created. This      // sample only has one Loader, so we don't care about the ID.      // First, pick the base URI to use depending on whether we are      // currently filtering.      Uri baseUri;      if (mCurFilter != null) {          baseUri = Uri.withAppendedPath(Contacts.CONTENT_FILTER_URI,                    Uri.encode(mCurFilter));      } else {          baseUri = Contacts.CONTENT_URI;      }        // Now create and return a CursorLoader that will take care of      // creating a Cursor for the data being displayed.      String select = "((" + Contacts.DISPLAY_NAME + " NOTNULL) AND ("              + Contacts.HAS_PHONE_NUMBER + "=1) AND ("              + Contacts.DISPLAY_NAME + " != '' ))";      return new CursorLoader(getActivity(), baseUri,              CONTACTS_SUMMARY_PROJECTION, select, null,              Contacts.DISPLAY_NAME + " COLLATE LOCALIZED ASC");  }

2-2-3-2 onLoadFinished说明

当创建好的Loader完成数据加载时回调此方法，我们要确保该方法在Loader释放现有维持的数据之前被调用。在这里我们应该移除所有对旧数据的使用（因为旧数据不久就会被释放），但是不用释放旧数据，因为Loader会帮我们完成旧数据的释放。

Loader一旦知道App不再使用旧数据就会释放掉。例如，如果数据来自CursorLoader里的一个Cursor，我们不应该自己在代码中调用close()方法；如果一个Cursor正在被放置到一个CursorAdapter时我们应当使用swapCursor()进行新数据交换，这样正在被放置的旧的Cursor就不会被关掉，也就不会导致Adapter的加载异常。

// This is the Adapter being used to display the list's data.  SimpleCursorAdapter mAdapter;  ...    public void onLoadFinished(Loader<Cursor> loader, Cursor data) {      // Swap the new cursor in. (The framework will take care of closing the      // old cursor once we return.)      mAdapter.swapCursor(data);  }

2-2-3-3 onLoaderReset说明

当实例化好的Loader被重启时该方法被回调，这里会让Loader的数据置于无效状态。这个回调方法其实就是为了告诉我们啥时候数据要被释放掉，所以我们应该在这个时候移除对它的引用。如下移除实例：

// This is the Adapter being used to display the list's data.  SimpleCursorAdapter mAdapter;  ...    public void onLoaderReset(Loader<Cursor> loader) {      // This is called when the last Cursor provided to onLoadFinished()      // above is about to be closed. We need to make sure we are no      // longer using it.      mAdapter.swapCursor(null);  }

2-2-4 Loader使用实例实战

下面这个实例是一个Fragment，模拟的是用ListView显示通讯录的实时匹配查询结果，使用CursorLoader管理通讯录Provider查询。如下源码，比较简单，注释也很丰富了，所以不过多解释：

public static class CursorLoaderListFragment extends ListFragment implements OnQueryTextListener, LoaderManager.LoaderCallbacks<Cursor> {        // This is the Adapter being used to display the list's data.      SimpleCursorAdapter mAdapter;        // If non-null, this is the current filter the user has provided.      String mCurFilter;        @Override public void onActivityCreated(Bundle savedInstanceState) {          super.onActivityCreated(savedInstanceState);            // Give some text to display if there is no data. In a real          // application this would come from a resource.          setEmptyText("No phone numbers");            // We have a menu item to show in action bar.          setHasOptionsMenu(true);            // Create an empty adapter we will use to display the loaded data.          mAdapter = new SimpleCursorAdapter(getActivity(),                  android.R.layout.simple_list_item_2, null,                  new String[] { Contacts.DISPLAY_NAME, Contacts.CONTACT_STATUS },                  new int[] { android.R.id.text1, android.R.id.text2 }, 0);          setListAdapter(mAdapter);            // Prepare the loader. Either re-connect with an existing one,          // or start a new one.          getLoaderManager().initLoader(0, null, this);      }        @Override public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) {          // Place an action bar item for searching.          MenuItem item = menu.add("Search");          item.setIcon(android.R.drawable.ic_menu_search);          item.setShowAsAction(MenuItem.SHOW_AS_ACTION_IF_ROOM);          SearchView sv = new SearchView(getActivity());          sv.setOnQueryTextListener(this);          item.setActionView(sv);      }        public boolean onQueryTextChange(String newText) {          // Called when the action bar search text has changed. Update          // the search filter, and restart the loader to do a new query          // with this filter.          mCurFilter = !TextUtils.isEmpty(newText) ? newText : null;          getLoaderManager().restartLoader(0, null, this);          return true;      }        @Override public boolean onQueryTextSubmit(String query) {          // Don't care about this.          return true;      }        @Override public void onListItemClick(ListView l, View v, int position, long id) {          // Insert desired behavior here.          Log.i("FragmentComplexList", "Item clicked: " + id);      }        // These are the Contacts rows that we will retrieve.      static final String[] CONTACTS_SUMMARY_PROJECTION = new String[] {          Contacts._ID,          Contacts.DISPLAY_NAME,          Contacts.CONTACT_STATUS,          Contacts.CONTACT_PRESENCE,          Contacts.PHOTO_ID,          Contacts.LOOKUP_KEY,      };      public Loader<Cursor> onCreateLoader(int id, Bundle args) {          // This is called when a new Loader needs to be created. This          // sample only has one Loader, so we don't care about the ID.          // First, pick the base URI to use depending on whether we are          // currently filtering.          Uri baseUri;          if (mCurFilter != null) {              baseUri = Uri.withAppendedPath(Contacts.CONTENT_FILTER_URI,                      Uri.encode(mCurFilter));          } else {              baseUri = Contacts.CONTENT_URI;          }            // Now create and return a CursorLoader that will take care of          // creating a Cursor for the data being displayed.          String select = "((" + Contacts.DISPLAY_NAME + " NOTNULL) AND ("                  + Contacts.HAS_PHONE_NUMBER + "=1) AND ("                  + Contacts.DISPLAY_NAME + " != '' ))";          return new CursorLoader(getActivity(), baseUri,                  CONTACTS_SUMMARY_PROJECTION, select, null,                  Contacts.DISPLAY_NAME + " COLLATE LOCALIZED ASC");      }        public void onLoadFinished(Loader<Cursor> loader, Cursor data) {          // Swap the new cursor in. (The framework will take care of closing the          // old cursor once we return.)          mAdapter.swapCursor(data);      }        public void onLoaderReset(Loader<Cursor> loader) {          // This is called when the last Cursor provided to onLoadFinished()          // above is about to be closed. We need to make sure we are no          // longer using it.          mAdapter.swapCursor(null);      }  }

到此整个Loader基础使用就介绍完了，关于Loader的高级功能，譬如自定义Loader等内容这里先不贴代码说明，因为在这里一下子说完都会觉得蒙圈，而且接受难度也比较大，所以我们在上面这些基础铺垫之后乘热先来源码浅析，有了源码浅析把持住全局结构后再去用Loader的高级用法就会觉得得心应手许多。

【工匠若水 http://blog.csdn.net/yanbober 转载请注明出处。点我开始Android技术交流】

3 源码浅析

和上面的基本使用介绍一样，关于Loader的源码浅析过程会涉及到Activity、Fragment、LoaderManager、Loader、AsyncLoader、CursorLoader等类。所以我们分析的过程还是和以前一样，依据使用顺序进行分析。

我们在分析之前先来看一个Loader框架概要图,如下：

通过上面图和前面的基础实例你会发现Loader的框架和各个类的职责都很明确。Activity和Fragment管理LoaderManager，LoaderManager管理Loader，Loader得到数据后触发在LoaderManager中实现的Loader的callback接口，LoaderManager在接收到Loader的callback回传调运时触发我们Activity或Fragment中实现的LoaderManager回调callback接口，就这样就实现了Loader的所有功能，而我们平时写代码一般只用关心LoaderManager的callback实现即可；对于自定义Loader可能还需要关心AsyncTaskLoader子类的实现。

3-1 Activity及Fragment中LoadManager的管理浅析

首先我们都知道，在使用Loader的第一步就是在Activity或者Fragment中获取LoaderManager实例，所以我们先来看下Activity和Fragment是如何管理这些LoaderManager的。

先来看看Fragment中的LoaderManager，如下：

final class FragmentState implements Parcelable {      ......      LoaderManagerImpl mLoaderManager;      boolean mLoadersStarted;      boolean mCheckedForLoaderManager;      ......      //fragment中获取LoaderManager办法      public LoaderManager getLoaderManager() {          //可以看见，一个Fragment只有一个LoaderManager          if (mLoaderManager != null) {              return mLoaderManager;          }          if (mActivity == null) {              throw new IllegalStateException("Fragment " + this + " not attached to Activity");          }          mCheckedForLoaderManager = true;          //从Activity中获取LoaderManager，传入的mWho为当前Fragment的识别key，然后create传入true表示创建！！！！！！          mLoaderManager = mActivity.getLoaderManager(mWho, mLoadersStarted, true);          return mLoaderManager;      }        public void onStart() {          mCalled = true;            if (!mLoadersStarted) {              mLoadersStarted = true;              if (!mCheckedForLoaderManager) {                  mCheckedForLoaderManager = true;                  //如果还没调运过getLoaderManager，那就尝试获取LoaderManager，传入的create为false！！！！！                  mLoaderManager = mActivity.getLoaderManager(mWho, mLoadersStarted, false);              }              //生命周期依附上LoaderManager              if (mLoaderManager != null) {                  mLoaderManager.doStart();              }          }      }        public void onDestroy() {          mCalled = true;          if (!mCheckedForLoaderManager) {              mCheckedForLoaderManager = true;              //如果还没调运过getLoaderManager，那就尝试获取LoaderManager，传入的create为false！！！！！              mLoaderManager = mActivity.getLoaderManager(mWho, mLoadersStarted, false);          }          //生命周期依附上LoaderManager          if (mLoaderManager != null) {              mLoaderManager.doDestroy();          }      }        void performStart() {          ......          mCalled = false;          onStart();          ......          //生命周期依附上LoaderManager          if (mLoaderManager != null) {              mLoaderManager.doReportStart();          }      }        void performStop() {          ......          mCalled = false;          onStop();          ......          if (mLoadersStarted) {              mLoadersStarted = false;              if (!mCheckedForLoaderManager) {                  mCheckedForLoaderManager = true;                  //如果还没调运过getLoaderManager，那就尝试获取LoaderManager，传入的create为false！！！！！                  mLoaderManager = mActivity.getLoaderManager(mWho, mLoadersStarted, false);              }              if (mLoaderManager != null) {                  //生命周期依附上LoaderManager                  if (mActivity == null || !mActivity.mChangingConfigurations) {                      mLoaderManager.doStop();                  } else {                      mLoaderManager.doRetain();                  }              }          }      }        void performDestroyView() {          ......          mCalled = false;          onDestroyView();          ......          //生命周期依附上LoaderManager          if (mLoaderManager != null) {              mLoaderManager.doReportNextStart();          }      }  }

从上面可以看出，Fragment在其生命周期内会控制LoaderManager（LoaderManager其实控制了Loader）的doStart、doDestroy等方法，也就是说我们在Fragment中只管通过getLoaderManager方法来获取LoaderManager实例，然后使用就行，别的Fragment都会帮我们处理OK的。

接下来看看Activity中的LoaderManager，如下：

public class Activity extends ContextThemeWrapper implements ... {          //mAllLoaderManagers保存了Activity与Fragment的所有LoaderManager      ArrayMap<String, LoaderManagerImpl> mAllLoaderManagers;      LoaderManagerImpl mLoaderManager;      ......      //Activity中获取LoaderManager实例的方法      public LoaderManager getLoaderManager() {          //可以看见，一个Activity只有一个LoaderManager          if (mLoaderManager != null) {              return mLoaderManager;          }          mCheckedForLoaderManager = true;          //咦？这不就是上面Fragment的getLoaderManager中调运的那个activity中的getLoaderManager吗，只是和这里的参数不一样而已          mLoaderManager = getLoaderManager("(root)", mLoadersStarted, true);          return mLoaderManager;      }      //Activity与Fragment获取LoaderManager实例的真正方法！！      LoaderManagerImpl getLoaderManager(String who, boolean started, boolean create) {          //可见一个Activity维护一个mAllLoaderManagers的MAP          if (mAllLoaderManagers == null) {              mAllLoaderManagers = new ArrayMap<String, LoaderManagerImpl>();          }          //尝试从缓存mAllLoaderManagers的MAP中获取已经实例化的LoaderManager实例          LoaderManagerImpl lm = mAllLoaderManagers.get(who);          if (lm == null) {              if (create) {                  //如果没有找到并且需要实例化create（切记这个create参数是很重要的），就调运LoaderManagerImpl构造方法实例化一个LoaderManager对象，然后存入缓存mAllLoaderManagers的MAP中                  lm = new LoaderManagerImpl(who, this, started);                  mAllLoaderManagers.put(who, lm);              }          } else {              lm.updateActivity(this);          }          return lm;      }        void invalidateFragment(String who) {          if (mAllLoaderManagers != null) {              LoaderManagerImpl lm = mAllLoaderManagers.get(who);              if (lm != null && !lm.mRetaining) {                  //生命周期依附上LoaderManager                  lm.doDestroy();                  mAllLoaderManagers.remove(who);              }          }      }        final void performStop() {          if (mLoadersStarted) {              mLoadersStarted = false;              //生命周期依附上LoaderManager              if (mLoaderManager != null) {                  //mChangingConfigurations表示如果当前发生了配置变化则为true，否则为false！！！！！！！重点，Loader特性之一                  if (!mChangingConfigurations) {                      //当前Activity的stop不是由配置变化引起则直接调用LoaderManager的doStop()方法！！！！！！                      mLoaderManager.doStop();                  } else {                      //当前Activity配置变化，所以需要保存当前的loaderManager，在Activity恢复时恢复这个LoaderManager！！！！！！                      mLoaderManager.doRetain();                  }              }          }      ......      }        final void performDestroy() {          ......          onDestroy();          //生命周期依附上LoaderManager          if (mLoaderManager != null) {              mLoaderManager.doDestroy();          }          ......      }        protected void onCreate(@Nullable Bundle savedInstanceState) {          if (mLastNonConfigurationInstances != null) {              //从mLastNonConfigurationInstances中恢复mAllLoaderManagers（mLastNonConfigurationInstances是从onAttach中恢复的），Activity配置变化时会走这里！！！！              mAllLoaderManagers = mLastNonConfigurationInstances.loaders;          }          ......          mCalled = true;      }        final void performStart() {      ......          if (mAllLoaderManagers != null) {              final int N = mAllLoaderManagers.size();              LoaderManagerImpl loaders[] = new LoaderManagerImpl[N];              for (int i=N-1; i>=0; i--) {                  loaders[i] = mAllLoaderManagers.valueAt(i);              }              //生命周期依附上LoaderManager              for (int i=0; i<N; i++) {                  LoaderManagerImpl lm = loaders[i];                  //调用LoaderManager.finishRetain()以及doReportStart()方法来恢复LoaderManager的状态！！！！！                  lm.finishRetain();                  lm.doReportStart();              }          }          mActivityTransitionState.enterReady(this);      }      //该方法会被ActivityThread类调用，且调运时机早于performDestroy()方法！！！！！！      NonConfigurationInstances retainNonConfigurationInstances() {          ......          NonConfigurationInstances nci = new NonConfigurationInstances();          ......          //配置变化时保存mAllLoaderManagers！！！！！！          nci.loaders = mAllLoaderManagers;          return nci;      }  }

通过上面的分析可以发现，Activity其实真正的管理了Activity及Fragment的LoaderManager（Fragment也会管理一部分自己LoaderManager的周期），而LoaderManager又管理了Loader，可以发现他们各自的管理范围都是十分的清晰明了的。

3-2 LoadManager及其实现类LoadManagerImpl的浅析

上面分析Activity及Fragment中获取LoaderManager实例时已经知道，我们获取的LoaderManager实例其实就是LoaderManagerImpl对象，而LoaderManagerImpl又是LoaderManager类的子类，所以接下来我们来分析这两个父子类。

先看下抽象父类LoaderManager，如下：

public abstract class LoaderManager {      //LoaderManager的回调接口定义      public interface LoaderCallbacks<D> {          public Loader<D> onCreateLoader(int id, Bundle args);          public void onLoadFinished(Loader<D> loader, D data);          public void onLoaderReset(Loader<D> loader);      }      //下面这些方法没必要再细说了，上面介绍过的      public abstract <D> Loader<D> initLoader(int id, Bundle args,              LoaderManager.LoaderCallbacks<D> callback);        public abstract <D> Loader<D> restartLoader(int id, Bundle args,              LoaderManager.LoaderCallbacks<D> callback);      //会触发回调的onLoaderReset方法      public abstract void destroyLoader(int id);        public abstract <D> Loader<D> getLoader(int id);        public abstract void dump(String prefix, FileDescriptor fd, PrintWriter writer, String[] args);        public static void enableDebugLogging(boolean enabled) {          LoaderManagerImpl.DEBUG = enabled;      }  }

可以看见LoaderManager抽象类只是定义了一些规范接口而已，那么接着我们看下抽象类LoaderManager的实现类LoaderManagerImpl，如下：

class LoaderManagerImpl extends LoaderManager {      static final String TAG = "LoaderManager";      static boolean DEBUG = false;        //保存当前存活的Loader      final SparseArray<LoaderInfo> mLoaders = new SparseArray<LoaderInfo>(0);      //保存已经运行完的Loader      final SparseArray<LoaderInfo> mInactiveLoaders = new SparseArray<LoaderInfo>(0);        final String mWho;        Activity mActivity;      boolean mStarted;      boolean mRetaining;      boolean mRetainingStarted;      //是否正在创建Loader，多线程中同时调运创建会导致异常      boolean mCreatingLoader;      //Loader的封装类      final class LoaderInfo implements Loader.OnLoadCompleteListener<Object>,              Loader.OnLoadCanceledListener<Object> {          final int mId;          final Bundle mArgs;          LoaderManager.LoaderCallbacks<Object> mCallbacks;          Loader<Object> mLoader;          boolean mHaveData;          boolean mDeliveredData;          Object mData;          boolean mStarted;          //mRetaining标记Activity配置变化时保持当前Loader，不用销毁；和上面分析Activity的LoaderManager的retainNonConfigurationInstances方法关联！！！！！！          boolean mRetaining;          boolean mRetainingStarted;          boolean mReportNextStart;          boolean mDestroyed;          boolean mListenerRegistered;            LoaderInfo mPendingLoader;          //LoaderInfo构造方法          public LoaderInfo(int id, Bundle args, LoaderManager.LoaderCallbacks<Object> callbacks) {              mId = id;              mArgs = args;              mCallbacks = callbacks;          }          //启动一个Loader          void start() {              //配置改变恢复则不用启动，用原来的              if (mRetaining && mRetainingStarted) {                  mStarted = true;                  return;              }              //如果已经启动，则不用再restart了              if (mStarted) {                  return;              }                mStarted = true;                //如果当前封装中mLoader为空并且通过构造方法的mCallbacks不为空则回调onCreateLoader方法创建Loader              if (mLoader == null && mCallbacks != null) {                 mLoader = mCallbacks.onCreateLoader(mId, mArgs);              }              if (mLoader != null) {                  if (mLoader.getClass().isMemberClass()                          && !Modifier.isStatic(mLoader.getClass().getModifiers())) {                          //如果当前创建的Loader对象是一个非静态内部类则抛异常！！！！！！                      throw new IllegalArgumentException(                              "Object returned from onCreateLoader must not be a non-static inner member class: "                              + mLoader);                  }                  if (!mListenerRegistered) {                      //注册Loader的监听方法                      mLoader.registerListener(mId, this);                      mLoader.registerOnLoadCanceledListener(this);                      mListenerRegistered = true;                  }                  //调运Loader的startLoading方法                  mLoader.startLoading();              }          }          //Activity的配置改变时进行标志位的设置，以便可以保存，配合上面Activity的分析！！！！！！          void retain() {              mRetaining = true;              ......          }          //Activity配置变化后重启后如果有数据则通知回调方法，配合上面Activity的分析！！！！！！          void finishRetain() {              ......              if (mStarted && mHaveData && !mReportNextStart) {                  callOnLoadFinished(mLoader, mData);              }          }          //配合上面Activity的分析！！！！！！          void reportStart() {              ......          }          //停止Loader          void stop() {              mStarted = false;              if (!mRetaining) {                  //如果不是Activity配置变化，即不用保存则注销掉这些回调                  if (mLoader != null && mListenerRegistered) {                      ......                  }              }          }          //取消掉Loader          void cancel() {              ......          }          //销毁掉Loader          void destroy() {              ......              if (mCallbacks != null && mLoader != null && mHaveData && needReset) {                  ......                  try {                      //在destroy时如果有数据存在则调用callback的onLoaderReset方法！！！！！！                      mCallbacks.onLoaderReset(mLoader);                  } finally {                      ......                  }              }              ......              if (mLoader != null) {                  //注销监听方法                  if (mListenerRegistered) {                      ......                  }                  //close Cursor等重置操作                  mLoader.reset();              }              if (mPendingLoader != null) {                  mPendingLoader.destroy();              }          }      //Loader被取消时回调该方法          @Override          public void onLoadCanceled(Loader<Object> loader) {              ......              LoaderInfo pending = mPendingLoader;              //执行最新的Loader              if (pending != null) {                  mPendingLoader = null;                  mLoaders.put(mId, null);                  destroy();                  installLoader(pending);              }          }          //加载完成时回调          @Override          public void onLoadComplete(Loader<Object> loader, Object data) {              ......              //执行最新的Loader              if (pending != null) {                  mPendingLoader = null;                  mLoaders.put(mId, null);                  destroy();                  installLoader(pending);                  return;              }                if (mData != data || !mHaveData) {                  mData = data;                  mHaveData = true;                  if (mStarted) {                      callOnLoadFinished(loader, data);                  }              }              ......          }          //调用onLoadFinished          void callOnLoadFinished(Loader<Object> loader, Object data) {              if (mCallbacks != null) {                  ......                  try {                      //回调onLoadFinished方法                      mCallbacks.onLoadFinished(loader, data);                  } finally {                      ......                  }                  mDeliveredData = true;              }          }      }        //！！！！！！真正LoaderManagerImpl的构造方法      LoaderManagerImpl(String who, Activity activity, boolean started) {          mWho = who;          mActivity = activity;          mStarted = started;      }        //更新当前Activity引用      void updateActivity(Activity activity) {          mActivity = activity;      }        //私有的创建Loader方法      private LoaderInfo createLoader(int id, Bundle args,              LoaderManager.LoaderCallbacks<Object> callback) {          LoaderInfo info = new LoaderInfo(id, args,  (LoaderManager.LoaderCallbacks<Object>)callback);          //回调callback的onCreateLoader方法得到Loader对象          Loader<Object> loader = callback.onCreateLoader(id, args);          //把得到的Loader对象包装成LoaderInfo对象          info.mLoader = (Loader<Object>)loader;          return info;      }        //包装了创建Loader与install方法，并将mCreatingLoader标记置位      private LoaderInfo createAndInstallLoader(int id, Bundle args,              LoaderManager.LoaderCallbacks<Object> callback) {          try {              mCreatingLoader = true;              //调运上面的私有创建方法创建LoaderInfo对象              LoaderInfo info = createLoader(id, args, callback);              //把创建的LoaderInfo对象传入installLoader方法              installLoader(info);              return info;          } finally {              mCreatingLoader = false;          }      }        void installLoader(LoaderInfo info) {          //将创建的LoaderInfo对象存入mLoaders的Map中          mLoaders.put(info.mId, info);          if (mStarted) {              //如果Activity已经started，则启动LoaderInfo的start方法              info.start();          }      }        //public的方法，创建一个Loader，前面介绍过的      @SuppressWarnings("unchecked")      public <D> Loader<D> initLoader(int id, Bundle args, LoaderManager.LoaderCallbacks<D> callback) {          //如果多线程中正在有创建的则抛出异常（写代码要注意这种情况，尤其是跑Monkey容易抛出，解决办法就是保证都在统一线程中执行！！！！！！）          if (mCreatingLoader) {              throw new IllegalStateException("Called while creating a loader");          }          //从现有的Map中尝试获取指定ID的LoaderInfo对象          LoaderInfo info = mLoaders.get(id);          if (info == null) {              //发现不存在就调运上面的createAndInstallLoader创建一个              info = createAndInstallLoader(id, args,  (LoaderManager.LoaderCallbacks<Object>)callback);          } else {              //否则还用当前的Loader，只是重新赋值了callBack而已              info.mCallbacks = (LoaderManager.LoaderCallbacks<Object>)callback;          }            if (info.mHaveData && mStarted) {              //已经有数据，直接调运LoaderInfo的callOnLoadFinished              info.callOnLoadFinished(info.mLoader, info.mData);          }          //返回Loader对象          return (Loader<D>)info.mLoader;      }        //重新创造Loader，前面介绍过的      @SuppressWarnings("unchecked")      public <D> Loader<D> restartLoader(int id, Bundle args, LoaderManager.LoaderCallbacks<D> callback) {          if (mCreatingLoader) {              //如果多线程中正在有创建的则抛出异常（写代码要注意这种情况，尤其是跑Monkey容易抛出，解决办法就是保证都在统一线程中执行！！！！！！）              throw new IllegalStateException("Called while creating a loader");          }            LoaderInfo info = mLoaders.get(id);          if (info != null) {              LoaderInfo inactive = mInactiveLoaders.get(id);              if (inactive != null) {                  if (info.mHaveData) {                      //发现是已经运行完的Loader且已经存在的Loader有数据则destroy掉运行完的Loader                      inactive.mDeliveredData = false;                      inactive.destroy();                      info.mLoader.abandon();                      mInactiveLoaders.put(id, info);                  } else {                      if (!info.mStarted) {                          //有相同id的Loader还没start则destory掉                          mLoaders.put(id, null);                          info.destroy();                      } else {                          //有一个相同id的Loader正在加载数据，但是还没加载完，调用它的cancel()方法通知取消加载                          info.cancel();                          if (info.mPendingLoader != null) {                              info.mPendingLoader.destroy();                              info.mPendingLoader = null;                          }                          //创建一个指定id的Loader同时赋给mPendingLoader，因为这个时候已经有一个Loader正在加载数据，而且我们已经调用了其cancel()方法来通知取消加载                          info.mPendingLoader = createLoader(id, args,                                   (LoaderManager.LoaderCallbacks<Object>)callback);                          //返回创建的Loader                          return (Loader<D>)info.mPendingLoader.mLoader;                      }                  }              } else {                  //终止已存在的Loader                  info.mLoader.abandon();                  mInactiveLoaders.put(id, info);              }          }          //重新创建Loader返回          info = createAndInstallLoader(id, args,  (LoaderManager.LoaderCallbacks<Object>)callback);          return (Loader<D>)info.mLoader;      }        //销毁指定id的Loader      public void destroyLoader(int id) {          if (mCreatingLoader) {              throw new IllegalStateException("Called while creating a loader");          }          //不解释，单纯的destory          int idx = mLoaders.indexOfKey(id);          if (idx >= 0) {              LoaderInfo info = mLoaders.valueAt(idx);              mLoaders.removeAt(idx);              info.destroy();          }          idx = mInactiveLoaders.indexOfKey(id);          if (idx >= 0) {              LoaderInfo info = mInactiveLoaders.valueAt(idx);              mInactiveLoaders.removeAt(idx);              info.destroy();          }          ......      }        //获取指定id的Loader对象      @SuppressWarnings("unchecked")      public <D> Loader<D> getLoader(int id) {          if (mCreatingLoader) {              throw new IllegalStateException("Called while creating a loader");          }          //优先获取LoaderInfo中的mPendingLoader          LoaderInfo loaderInfo = mLoaders.get(id);          if (loaderInfo != null) {              if (loaderInfo.mPendingLoader != null) {                  return (Loader<D>)loaderInfo.mPendingLoader.mLoader;              }              return (Loader<D>)loaderInfo.mLoader;          }          return null;      }      ......  }

我勒个去！好长，好累！通过上面粗略的分析你会发现和我们上面基础实例介绍LoaderManager的方法时描述的一样，每个方法都有自己的特点，发挥着各自的作用，LoaderManager的实质是将Loader对象转换为LoaderInfo来进行管理，也就是管理了所有的Loader对象。

3-3 Loader及其实现类的浅析

上面分析了Activity及Fragment管理了LoaderManager的相关方法，LoaderManager管理了Loader的相关方法，那么接下来我们就来看看这个被管理的终极目标Loader是咋回事，还有他的子类咋回事。

先来看看我画的一张关系图，如下：

我去，这图现在看可能有些吓人，我们还是先来慢慢分析一下再说吧。

3-3-1 Loader基类源码浅析

我们先来看看这个Loader基类吧，该类核心方法及内部类结构图如下：

代码分析如下：

public class Loader<D> {      int mId;      OnLoadCompleteListener<D> mListener;      OnLoadCanceledListener<D> mOnLoadCanceledListener;      Context mContext;      boolean mStarted = false;      boolean mAbandoned = false;      boolean mReset = true;      boolean mContentChanged = false;      boolean mProcessingChange = false;      //数据源变化监听器（观察者模式），实现了ContentObserver类      public final class ForceLoadContentObserver extends ContentObserver {          public ForceLoadContentObserver() {              super(new Handler());          }            @Override          public boolean deliverSelfNotifications() {              return true;          }            @Override          public void onChange(boolean selfChange) {              //实质是调运Loader的forceLoad方法              onContentChanged();          }      }        //Loader加载完成接口，当加载完成时Loader通知loaderManager,loaderManager再回调我们initLoader方法的callback      public interface OnLoadCompleteListener<D> {          public void onLoadComplete(Loader<D> loader, D data);      }      //LoaderManager中监听cancel，同上类似      public interface OnLoadCanceledListener<D> {          public void onLoadCanceled(Loader<D> loader);      }        //构造方法      public Loader(Context context) {          //mContext持有Application的Context，防止泄露内存等          mContext = context.getApplicationContext();      }        //加载完成时回调传递加载数据结果，实质是对OnLoadCompleteListener接口方法的封装      public void deliverResult(D data) {          if (mListener != null) {              mListener.onLoadComplete(this, data);          }      }      //类似同上，对OnLoadCanceledListener的方法的封装      public void deliverCancellation() {          if (mOnLoadCanceledListener != null) {              mOnLoadCanceledListener.onLoadCanceled(this);          }      }        public Context getContext() {          return mContext;      }      public int getId() {          return mId;      }      public void registerListener(int id, OnLoadCompleteListener<D> listener) {          mListener = listener;          mId = id;      }      public void unregisterListener(OnLoadCompleteListener<D> listener) {          mListener = null;      }      public void registerOnLoadCanceledListener(OnLoadCanceledListener<D> listener) {          mOnLoadCanceledListener = listener;      }      public void unregisterOnLoadCanceledListener(OnLoadCanceledListener<D> listener) {          mOnLoadCanceledListener = null;      }      public boolean isStarted() {          return mStarted;      }      public boolean isAbandoned() {          return mAbandoned;      }      public boolean isReset() {          return mReset;      }        //开始加载数据时LoaderManager会调用该方法      public final void startLoading() {          //设置标记          mStarted = true;          mReset = false;          mAbandoned = false;          onStartLoading();      }        //真正开始加载数据的地方******空方法，子类实现！！！！！！      protected void onStartLoading() {      }        //取消Loader的方法      public boolean cancelLoad() {          return onCancelLoad();      }        //真正取消的地方******，子类实现！！！！！！return false表示取消失败（因为已完成或未开始）      protected boolean onCancelLoad() {          return false;      }        //强制重新Loader，放弃旧数据      public void forceLoad() {          onForceLoad();      }        //真正重新Loader的地方******空方法，子类实现！！！！！！      protected void onForceLoad() {      }        //同上      public void stopLoading() {          mStarted = false;          onStopLoading();      }      protected void onStopLoading() {      }        //同上      public void abandon() {          mAbandoned = true;          onAbandon();      }      protected void onAbandon() {      }        //同上      public void reset() {          onReset();          mReset = true;          mStarted = false;          mAbandoned = false;          mContentChanged = false;          mProcessingChange = false;      }      protected void onReset() {      }        //Loader数据变化的一些标记处理      public boolean takeContentChanged() {          boolean res = mContentChanged;          mContentChanged = false;          mProcessingChange |= res;          return res;      }      public void commitContentChanged() {          mProcessingChange = false;      }      public void rollbackContentChanged() {          if (mProcessingChange) {              mContentChanged = true;          }      }        //上面ForceLoadContentObserver内部类的onChange方法调运      public void onContentChanged() {          if (mStarted) {              forceLoad();          } else {              mContentChanged = true;          }      }        //一些方便调试的方法      public String dataToString(D data)      public String toString()      public void dump(String prefix, FileDescriptor fd, PrintWriter writer, String[] args)  }

通过上面粗略的分析可以发现，Loader基类无非也就是一个方法接口的定义类，组织预留了一些方法供LoaderManager去调运处理，同时需要子类实现其提供的一些onXXX方法，以便LoaderManager调运Loader的方法时可以触发Loader子类的实现逻辑。

3-3-2 AsyncTaskLoader抽象子类源码浅析

上面既然说了Loader类的作用主要是规定接口，同时供LoaderManager管理，那LoaderManager管理的Loader自然需要做一些事情，也就是说我们需要继承Loader实现一些逻辑操作。然而好在系统API已经帮我们实现了一些简单的封装实现，我们这里就先来看下Loader的直接子类AsyncTaskLoader吧，先来看下该抽象子类的方法及内部类粗略图，如下：

代码分析如下：

public abstract class AsyncTaskLoader<D> extends Loader<D> {      static final String TAG = "AsyncTaskLoader";      static final boolean DEBUG = false;      //LoadTask内部类是对AsyncTask的封装，实现了Runnable接口      final class LoadTask extends AsyncTask<Void, Void, D> implements Runnable {          ......          @Override          protected D doInBackground(Void... params) {              try {                  //AsyncTask的子线程中执行AsyncTaskLoader的onLoadInBackground方法！！！！重点                  D data = AsyncTaskLoader.this.onLoadInBackground();                  //把执行结果数据D返回到UI线程                  return data;              } catch (OperationCanceledException ex) {                  if (!isCancelled()) {                      throw ex;                  }                  return null;              }          }            /* Runs on the UI thread */          @Override          protected void onPostExecute(D data) {              //AsyncTask子线程执行完毕后回调AsyncTaskLoader的dispatchOnLoadComplete方法              AsyncTaskLoader.this.dispatchOnLoadComplete(this, data);          }            /* Runs on the UI thread */          @Override          protected void onCancelled(D data) {              //取消AsyncTask时调运              AsyncTaskLoader.this.dispatchOnCancelled(this, data);          }            //Runnable的实现方法          @Override          public void run() {              waiting = false;              AsyncTaskLoader.this.executePendingTask();          }      ......      }        private final Executor mExecutor;        volatile LoadTask mTask;      volatile LoadTask mCancellingTask;        long mUpdateThrottle;      long mLastLoadCompleteTime = -10000;      Handler mHandler;      //public构造方法      public AsyncTaskLoader(Context context) {          this(context, AsyncTask.THREAD_POOL_EXECUTOR);      }        /** {@hide} 无法被外部调运的构造方法 */      public AsyncTaskLoader(Context context, Executor executor) {          super(context);          mExecutor = executor;      }        public void setUpdateThrottle(long delayMS) {          mUpdateThrottle = delayMS;          if (delayMS != 0) {              mHandler = new Handler();          }      }        @Override      protected void onForceLoad() {          super.onForceLoad();          //取消当前的Loader          cancelLoad();          //新建task并执行          mTask = new LoadTask();          executePendingTask();      }        @Override      protected boolean onCancelLoad() {          ......      }        public void onCanceled(D data) {      }        //LoadTask的Runnable方法run中执行      void executePendingTask() {          if (mCancellingTask == null && mTask != null) {              if (mTask.waiting) {                  mTask.waiting = false;                  mHandler.removeCallbacks(mTask);              }              if (mUpdateThrottle > 0) {                  long now = SystemClock.uptimeMillis();                  if (now < (mLastLoadCompleteTime+mUpdateThrottle)) {                      // Not yet time to do another load.                      mTask.waiting = true;                      mHandler.postAtTime(mTask, mLastLoadCompleteTime+mUpdateThrottle);                      return;                  }              }              //真正的触发执行AsyncTask方法              mTask.executeOnExecutor(mExecutor, (Void[]) null);          }      }        void dispatchOnCancelled(LoadTask task, D data) {          onCanceled(data);          if (mCancellingTask == task) {              rollbackContentChanged();              mLastLoadCompleteTime = SystemClock.uptimeMillis();              mCancellingTask = null;              //触发Loader的接口方法onLoadCanceled，在LoaderManager中实现              deliverCancellation();              executePendingTask();          }      }        void dispatchOnLoadComplete(LoadTask task, D data) {          if (mTask != task) {              dispatchOnCancelled(task, data);          } else {              if (isAbandoned()) {                  // This cursor has been abandoned; just cancel the new data.                  onCanceled(data);              } else {                  commitContentChanged();                  mLastLoadCompleteTime = SystemClock.uptimeMillis();                  mTask = null;                  //触发Loader的接口方法onLoadComplete，在LoaderManager中实现                  deliverResult(data);              }          }      }      //需要子类实现！！！！！在子线程中执行      public abstract D loadInBackground();        //LoadTask（AsyncTask的子线程中回调）中调运      protected D onLoadInBackground() {          return loadInBackground();      }        //LoadTask（AsyncTask的onCancelLoad中回调）调运      public void cancelLoadInBackground() {      }        public boolean isLoadInBackgroundCanceled() {          return mCancellingTask != null;      }      //锁标记处理      public void waitForLoader() {          LoadTask task = mTask;          if (task != null) {              task.waitForLoader();          }      }  }

可以看见上面继承Loader的AsyncTaskLoader其实质是提供了一个基于AsyncTask工作机制的Loader（子类LoadTask继承AsyncTask<Void, Void, D>，并且实现了Runable接口，功能十分强大。），但是不可直接用，因为其为abstract抽象类，所以我们需要继承实现它才可以使用，然而好在系统API已经帮我们提供了他现成的子类CursorLoader，但CursorLoader同时也限制了Loader的泛型数据为Cursor类型。当然了，我们如果想要Loader自己的类型数据那也很简单—继承实现AsyncTaskLoader即可，后面会给出例子的。

3-3-3 CursorLoader子类源码浅析

有了上面继承自Loader的抽象AsyncTaskLoader，接下来我们就来看看SDK为我们提供的抽象AsyncTaskLoader实现类CursorLoader，我们先来粗略看看该类的方法图，如下：

具体代码分析如下：

//继承自AsyncTaskLoader，数据类型为Cursor的Loader异步加载实现类  public class CursorLoader extends AsyncTaskLoader<Cursor> {      //Cursor的子类ForceLoadContentObserver      final ForceLoadContentObserver mObserver;        Uri mUri;      String[] mProjection;      String mSelection;      String[] mSelectionArgs;      String mSortOrder;        Cursor mCursor;      CancellationSignal mCancellationSignal;        /* Runs on a worker thread 最核心的实现方法，在这里查询获取数据 */      @Override      public Cursor loadInBackground() {          synchronized (this) {              if (isLoadInBackgroundCanceled()) {                  throw new OperationCanceledException();              }              mCancellationSignal = new CancellationSignal();          }          try {              //不过多解释，耗时的查询操作              Cursor cursor = getContext().getContentResolver().query(mUri, mProjection, mSelection,                      mSelectionArgs, mSortOrder, mCancellationSignal);              if (cursor != null) {                  try {                      // Ensure the cursor window is filled.                      cursor.getCount();                      //给Cursor设置观察者；ContentProvider通知Cursor的观察者数据发生了改变，Cursor通知CursorLoader的观察者数据发生了改变，CursorLoader通过ContentProvider重新加载新的数据                      cursor.registerContentObserver(mObserver);                  } catch (RuntimeException ex) {                      cursor.close();                      throw ex;                  }              }              return cursor;          } finally {              synchronized (this) {                  mCancellationSignal = null;              }          }      }        @Override      public void cancelLoadInBackground() {          super.cancelLoadInBackground();            synchronized (this) {              if (mCancellationSignal != null) {                  mCancellationSignal.cancel();              }          }      }        /* Runs on the UI thread */      @Override      public void deliverResult(Cursor cursor) {          if (isReset()) {              // An async query came in while the loader is stopped              if (cursor != null) {                  cursor.close();              }              return;          }          Cursor oldCursor = mCursor;          mCursor = cursor;            if (isStarted()) {              super.deliverResult(cursor);          }            if (oldCursor != null && oldCursor != cursor && !oldCursor.isClosed()) {              oldCursor.close();          }      }        public CursorLoader(Context context) {          super(context);          mObserver = new ForceLoadContentObserver();      }        public CursorLoader(Context context, Uri uri, String[] projection, String selection,              String[] selectionArgs, String sortOrder) {          super(context);          //新建一个当前类（Loader）的内部类对象，数据库变化时调运ForceLoadContentObserver的onChange方法，onChange调运Loader的onContentChanged方法，onContentChanged调运Loader的forceLoad方法          mObserver = new ForceLoadContentObserver();          mUri = uri;          mProjection = projection;          mSelection = selection;          mSelectionArgs = selectionArgs;          mSortOrder = sortOrder;      }        @Override      protected void onStartLoading() {          if (mCursor != null) {              deliverResult(mCursor);          }          if (takeContentChanged() || mCursor == null) {              forceLoad();          }      }        @Override      protected void onStopLoading() {          // Attempt to cancel the current load task if possible.          cancelLoad();      }        @Override      public void onCanceled(Cursor cursor) {          if (cursor != null && !cursor.isClosed()) {              cursor.close();          }      }        @Override      protected void onReset() {          super.onReset();            // Ensure the loader is stopped          onStopLoading();            if (mCursor != null && !mCursor.isClosed()) {              mCursor.close();          }          mCursor = null;      }        public Uri getUri() {          return mUri;      }        public void setUri(Uri uri) {          mUri = uri;      }        public String[] getProjection() {          return mProjection;      }        public void setProjection(String[] projection) {          mProjection = projection;      }        public String getSelection() {          return mSelection;      }        public void setSelection(String selection) {          mSelection = selection;      }        public String[] getSelectionArgs() {          return mSelectionArgs;      }        public void setSelectionArgs(String[] selectionArgs) {          mSelectionArgs = selectionArgs;      }        public String getSortOrder() {          return mSortOrder;      }        public void setSortOrder(String sortOrder) {          mSortOrder = sortOrder;      }  }

可以发现，CursorLoader的封装大大简化了应用开发者代码的复杂度；它完全就是一个异步的数据库查询瑞士军刀，没有啥特别需要分析的地方，所以不再过多说明。

3-4 Loaders相关源码浅析总结

通过上面我们的源码分析和分析前那副图可以总结如下结论：

• 一次完整的数据加载流程为Activity调用LoaderManager的doStart()方法，然后LoaderManager调用Loader的startLoading()方法，然后Loader调运AsyncTaskLoader的doingBackground()方法进行耗时数据加载，然后AsyncTaskLoader回调LoaderManager的complete数据加载完成方法，接着LoaderManager回调我们在Activity中实现的callback中的onLoadFinish()方法。

• Acivity和Fragment的生命周期主动管理了LoaderManager，每个Activity用一个ArrayMap的mAllLoaderManager来保存当前Activity及其附属Frament的唯一LoaderManager；在Activity配置发生变化时，Activity在destory前会保存mAllLoaderManager，当Activity再重新创建时，会在Activity的onAttcach()、onCreate()、performStart()方法中恢复mAllLoaderManager。

• LoaderManager给Activity提供了管理自己的一些方法；同时主动管理了对应的Loader，它把每一个Loader封装为LoadInfo对象，同时它负责主动调运管理Loader的startLoading()、stopLoading()、,forceLoad()等方法。

• 由于整个Activity和Fragment主动管理了Loader，所以关于Loader的释放（譬如CursorLoader的Cursor关闭等）不需要我们人为处理，Loader框架会帮我们很好的处理的；同时特别注意，对于CursorLoader，当我们数据源发生变化时Loader框架会通过ContentObserver调用onContentChanged的forceLoad方法重新请求数据进行回调刷新。

好了，至此你会发现Loader真的很牛叉，No！应该是Google的工程师真的很牛叉，架构真的很赞，值得推荐。

【工匠若水 http://blog.csdn.net/yanbober 转载请注明出处。点我开始Android技术交流】

4 应用层开发之Loader进阶实战

上面对于Loader的基础使用及源码框架都进行了简单分析，有了上面的铺垫我们再回过头来看看我们开发中的一些高级技巧，通过这些高级技巧不仅是对前面源码分析的实例验证，也是对自己知识的积累。

4-1 ContentPorvider情况下的CurSorLoader自动刷新

在我们使用CurSorLoader时大家都会考虑一种情况的处理—–当数据库发生变化时如何自动刷新当前UI。呵呵，我们先来说说这个原理，数据库在数据改变时通过ContentPorvider和ContentResolver发出通知，接着ContentProvider通知Cursor的观察者数据发生了变化，然后Cursor通知CursorLoader的观察者数据发生了变化，接着CursorLoader通过ContentProvider加载新数据，完事调用CursorAdapter的changeCursor()用新数据替换旧数据显示。

这个过程具体的实现步骤如下：

1. 对获取的Cursor数据设置需要监听的URI（即，在ContentProvider的query()方法或者Loader的loadingBackground()方法中调用Cursor的setNotificationUri()方法）；

2. 在ContentProvider的insert()、update()、delete()等方法中调用ContentResolver的notifyChange()方法；

通过上面两步我们就能享受CurSorLoader的自动数据刷新功能了；可以发现，所谓的CurSorLoader自动刷新无非就是观察者模式的框架而已，所以不再过多说明。

特别注意：

有些人觉得为了方便可能会将上面第一步对于Cursor设置监听直接写在了ContentProvider的query()方法中，如下：

@Override  public Cursor query(Uri uri, String[] projection, String selection, String[]   selectionArgs,String sortOrder) {      SQLiteDatabase database = sqLiteOpenHelper.getReadableDatabase();      Cursor cursor = database.query(EmailContent.CONTACT_TABLE, projection,      selection,selectionArgs, null, null, sortOrder);      //设置NotificationUri监听      cursor.setNotificationUri(contentResolver, EmailContent.MESSAGE);      return cursor;  }

这里要提醒的是，这种写法在某些场合下是不值得推荐的（譬如大规模上千次并发平凡的调运query操作场合），因为效率极低，他会频繁的通过Binder进行通信，导致system_server不停的调运GC操作，以至于会使系统卡顿。

PS：因为我以前跳过一次这个坑，平时使用应用没啥问题，但是当进行压力测试时却发现LogCat一直在不停的打印GC，同时导致当前系统卡顿，杀掉应用后系统就不卡了，所以基本怀疑问题就出在了应用中，于是通过很多办法去查找（譬如dempsys content去查看个数），最终发现罪魁祸首是这个监听频繁调运导致的，随将其挪到loadingBackground中不再卡顿。

4-2 不使用ContentPorvider且自定义Loader的情况下自动刷新

我们目前的项目其实都使用了ContentPorvider实现，所以就是上面讲的那些情况。但是你一定会问，如果我们应用的数据不用于应用间共享，使用ContentProvider那得多麻烦啊？我先告诉你，是很麻烦，但是Android提供的CursorLoader的API必须使用ContentProvider才能实现数据加载和自动刷新。

这时候你指定会说，那还说个屁！哎，别急，你看看下面这段代码是否会有所感触呢，如下：

public NoProviderLoader extends AsyncTaskLoader {      ......      ForceLoadContentObserver mObserver = new ForceLoadContentObserver();      ......      @Override      public Cursor loadInBackground() {          SQLiteDatabase database = sqLiteOpenHelper.getReadableDatabase();          Cursor cursor = database.query(table, columns, selection, selectionArgs, groupBy, having, orderBy);          if (cursor != null) {              //最重要的两行代码！！！！！！              cursor.registerContentObserver(mObserver);//给Cursor设置观察者              cursor.setNotificationUri(getContext().getContentResolver(), otificationUri);//给Cursor设置要观察的URI          }            return cursor;      }      ......  }

咦？是不是上面代码很奇怪，异步操作的方法中没有使用ContentProvider，而是直接读取了数据库。握草！这不就是我们刚刚想要的需求么，它没有使用ContentProvider提供Cursor数据，同时实现了数据变化自动更新功能。

简单解释下上面代码的原理吧，我们自定义的NoProviderLoader中定义的ForceLoadContentObserver是Loader的一个内部类，上面源码分析已经解释过了，当数据变化时会调运该类的onChange()方法，实质是调运了Loader的forceLoad()方法，所以能够自动刷新，不多解释了。

4-3 Loader自定义之AsyncTaskLoader衍生

可能看到这里你更加会举一反三的反驳一句了，上面搞了半天都是和数据库Cursor相关的东东，难道Loader就不能异步处理别的数据结构么？答案是能，因为你可能已经注意到了Loader和AsyncTaskLoader都是泛型类；既然这样，那我们找猫画虎一把呗，仿照CursorLoader自定义一个自己的异步加载试试，具体实现如下（哈哈，想了又想，这里还是直接给出官方的自定义AsyncTaskLoader好点，毕竟权威些，详细点我查看官方自定义实现Demo）：

官方对于查询已安装App列表的Loader实现，支持新App安装后自动刷新的功能，实现如下：

/** * This class holds the per-item data in our Loader. */  public static class AppEntry {      public AppEntry(AppListLoader loader, ApplicationInfo info) {          mLoader = loader;          mInfo = info;          mApkFile = new File(info.sourceDir);      }        public ApplicationInfo getApplicationInfo() {          return mInfo;      }        public String getLabel() {          return mLabel;      }        public Drawable getIcon() {          if (mIcon == null) {              if (mApkFile.exists()) {                  mIcon = mInfo.loadIcon(mLoader.mPm);                  return mIcon;              } else {                  mMounted = false;              }          } else if (!mMounted) {              // If the app wasn't mounted but is now mounted, reload              // its icon.              if (mApkFile.exists()) {                  mMounted = true;                  mIcon = mInfo.loadIcon(mLoader.mPm);                  return mIcon;              }          } else {              return mIcon;          }            return mLoader.getContext().getResources().getDrawable(                  android.R.drawable.sym_def_app_icon);      }        @Override public String toString() {          return mLabel;      }        void loadLabel(Context context) {          if (mLabel == null || !mMounted) {              if (!mApkFile.exists()) {                  mMounted = false;                  mLabel = mInfo.packageName;              } else {                  mMounted = true;                  CharSequence label = mInfo.loadLabel(context.getPackageManager());                  mLabel = label != null ? label.toString() : mInfo.packageName;              }          }      }        private final AppListLoader mLoader;      private final ApplicationInfo mInfo;      private final File mApkFile;      private String mLabel;      private Drawable mIcon;      private boolean mMounted;  }    /** * Perform alphabetical comparison of application entry objects. */  public static final Comparator<AppEntry> ALPHA_COMPARATOR = new Comparator<AppEntry>() {      private final Collator sCollator = Collator.getInstance();      @Override      public int compare(AppEntry object1, AppEntry object2) {          return sCollator.compare(object1.getLabel(), object2.getLabel());      }  };    /** * Helper for determining if the configuration has changed in an interesting * way so we need to rebuild the app list. */  public static class InterestingConfigChanges {      final Configuration mLastConfiguration = new Configuration();      int mLastDensity;        boolean applyNewConfig(Resources res) {          int configChanges = mLastConfiguration.updateFrom(res.getConfiguration());          boolean densityChanged = mLastDensity != res.getDisplayMetrics().densityDpi;          if (densityChanged || (configChanges&(ActivityInfo.CONFIG_LOCALE                  |ActivityInfo.CONFIG_UI_MODE|ActivityInfo.CONFIG_SCREEN_LAYOUT)) != 0) {              mLastDensity = res.getDisplayMetrics().densityDpi;              return true;          }          return false;      }  }    /** * Helper class to look for interesting changes to the installed apps * so that the loader can be updated. */  public static class PackageIntentReceiver extends BroadcastReceiver {      final AppListLoader mLoader;        public PackageIntentReceiver(AppListLoader loader) {          mLoader = loader;          IntentFilter filter = new IntentFilter(Intent.ACTION_PACKAGE_ADDED);          filter.addAction(Intent.ACTION_PACKAGE_REMOVED);          filter.addAction(Intent.ACTION_PACKAGE_CHANGED);          filter.addDataScheme("package");          mLoader.getContext().registerReceiver(this, filter);          // Register for events related to sdcard installation.          IntentFilter sdFilter = new IntentFilter();          sdFilter.addAction(Intent.ACTION_EXTERNAL_APPLICATIONS_AVAILABLE);          sdFilter.addAction(Intent.ACTION_EXTERNAL_APPLICATIONS_UNAVAILABLE);          mLoader.getContext().registerReceiver(this, sdFilter);      }        @Override public void onReceive(Context context, Intent intent) {          // Tell the loader about the change.          mLoader.onContentChanged();      }  }    /** * A custom Loader that loads all of the installed applications. */  public static class AppListLoader extends AsyncTaskLoader<List<AppEntry>> {      final InterestingConfigChanges mLastConfig = new InterestingConfigChanges();      final PackageManager mPm;        List<AppEntry> mApps;      PackageIntentReceiver mPackageObserver;        public AppListLoader(Context context) {          super(context);            // Retrieve the package manager for later use; note we don't          // use 'context' directly but instead the save global application          // context returned by getContext().          mPm = getContext().getPackageManager();      }        /** * This is where the bulk of our work is done. This function is * called in a background thread and should generate a new set of * data to be published by the loader. */      @Override public List<AppEntry> loadInBackground() {          // Retrieve all known applications.          List<ApplicationInfo> apps = mPm.getInstalledApplications(                  PackageManager.GET_UNINSTALLED_PACKAGES |                  PackageManager.GET_DISABLED_COMPONENTS);          if (apps == null) {              apps = new ArrayList<ApplicationInfo>();          }            final Context context = getContext();            // Create corresponding array of entries and load their labels.          List<AppEntry> entries = new ArrayList<AppEntry>(apps.size());          for (int i=0; i<apps.size(); i++) {              AppEntry entry = new AppEntry(this, apps.get(i));              entry.loadLabel(context);              entries.add(entry);          }            // Sort the list.          Collections.sort(entries, ALPHA_COMPARATOR);            // Done!          return entries;      }        /** * Called when there is new data to deliver to the client. The * super class will take care of delivering it; the implementation * here just adds a little more logic. */      @Override public void deliverResult(List<AppEntry> apps) {          if (isReset()) {              // An async query came in while the loader is stopped. We              // don't need the result.              if (apps != null) {                  onReleaseResources(apps);              }          }          List<AppEntry> oldApps = mApps;          mApps = apps;            if (isStarted()) {              // If the Loader is currently started, we can immediately              // deliver its results.              super.deliverResult(apps);          }            // At this point we can release the resources associated with          // 'oldApps' if needed; now that the new result is delivered we          // know that it is no longer in use.          if (oldApps != null) {              onReleaseResources(oldApps);          }      }        /** * Handles a request to start the Loader. */      @Override protected void onStartLoading() {          if (mApps != null) {              // If we currently have a result available, deliver it              // immediately.              deliverResult(mApps);          }            // Start watching for changes in the app data.          if (mPackageObserver == null) {              mPackageObserver = new PackageIntentReceiver(this);          }            // Has something interesting in the configuration changed since we          // last built the app list?          boolean configChange = mLastConfig.applyNewConfig(getContext().getResources());            if (takeContentChanged() || mApps == null || configChange) {              // If the data has changed since the last time it was loaded              // or is not currently available, start a load.              forceLoad();          }      }        /** * Handles a request to stop the Loader. */      @Override protected void onStopLoading() {          // Attempt to cancel the current load task if possible.          cancelLoad();      }        /** * Handles a request to cancel a load. */      @Override public void onCanceled(List<AppEntry> apps) {          super.onCanceled(apps);            // At this point we can release the resources associated with 'apps'          // if needed.          onReleaseResources(apps);      }        /** * Handles a request to completely reset the Loader. */      @Override protected void onReset() {          super.onReset();            // Ensure the loader is stopped          onStopLoading();            // At this point we can release the resources associated with 'apps'          // if needed.          if (mApps != null) {              onReleaseResources(mApps);              mApps = null;          }            // Stop monitoring for changes.          if (mPackageObserver != null) {              getContext().unregisterReceiver(mPackageObserver);              mPackageObserver = null;          }      }        /** * Helper function to take care of releasing resources associated * with an actively loaded data set. */      protected void onReleaseResources(List<AppEntry> apps) {          // For a simple List<> there is nothing to do. For something          // like a Cursor, we would close it here.      }  }

不用多说，上面Loader为Google出品，强大的不得了，我们完全可以仿写这个例子实现自己的请求。

如下为官方对该自定义Loader调运的Demo代码：

public static class AppListAdapter extends ArrayAdapter<AppEntry> {      private final LayoutInflater mInflater;        public AppListAdapter(Context context) {          super(context, android.R.layout.simple_list_item_2);          mInflater = (LayoutInflater)context.getSystemService(Context.LAYOUT_INFLATER_SERVICE);      }        public void setData(List<AppEntry> data) {          clear();          if (data != null) {              addAll(data);          }      }        /** * Populate new items in the list. */      @Override public View getView(int position, View convertView, ViewGroup parent) {          View view;            if (convertView == null) {              view = mInflater.inflate(R.layout.list_item_icon_text, parent, false);          } else {              view = convertView;          }            AppEntry item = getItem(position);          ((ImageView)view.findViewById(R.id.icon)).setImageDrawable(item.getIcon());          ((TextView)view.findViewById(R.id.text)).setText(item.getLabel());            return view;      }  }    public static class AppListFragment extends ListFragment implements OnQueryTextListener, OnCloseListener, LoaderManager.LoaderCallbacks<List<AppEntry>> {        // This is the Adapter being used to display the list's data.      AppListAdapter mAdapter;        // The SearchView for doing filtering.      SearchView mSearchView;        // If non-null, this is the current filter the user has provided.      String mCurFilter;        @Override public void onActivityCreated(Bundle savedInstanceState) {          super.onActivityCreated(savedInstanceState);            // Give some text to display if there is no data. In a real          // application this would come from a resource.          setEmptyText("No applications");            // We have a menu item to show in action bar.          setHasOptionsMenu(true);            // Create an empty adapter we will use to display the loaded data.          mAdapter = new AppListAdapter(getActivity());          setListAdapter(mAdapter);            // Start out with a progress indicator.          setListShown(false);            // Prepare the loader. Either re-connect with an existing one,          // or start a new one.          getLoaderManager().initLoader(0, null, this);      }        public static class MySearchView extends SearchView {          public MySearchView(Context context) {              super(context);          }            // The normal SearchView doesn't clear its search text when          // collapsed, so we will do this for it.          @Override          public void onActionViewCollapsed() {              setQuery("", false);              super.onActionViewCollapsed();          }      }        @Override public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) {          // Place an action bar item for searching.          MenuItem item = menu.add("Search");          item.setIcon(android.R.drawable.ic_menu_search);          item.setShowAsAction(MenuItem.SHOW_AS_ACTION_IF_ROOM                  | MenuItem.SHOW_AS_ACTION_COLLAPSE_ACTION_VIEW);          mSearchView = new MySearchView(getActivity());          mSearchView.setOnQueryTextListener(this);          mSearchView.setOnCloseListener(this);          mSearchView.setIconifiedByDefault(true);          item.setActionView(mSearchView);      }        @Override public boolean onQueryTextChange(String newText) {          // Called when the action bar search text has changed. Since this          // is a simple array adapter, we can just have it do the filtering.          mCurFilter = !TextUtils.isEmpty(newText) ? newText : null;          mAdapter.getFilter().filter(mCurFilter);          return true;      }        @Override public boolean onQueryTextSubmit(String query) {          // Don't care about this.          return true;      }        @Override      public boolean onClose() {          if (!TextUtils.isEmpty(mSearchView.getQuery())) {              mSearchView.setQuery(null, true);          }          return true;      }        @Override public void onListItemClick(ListView l, View v, int position, long id) {          // Insert desired behavior here.          Log.i("LoaderCustom", "Item clicked: " + id);      }        @Override public Loader<List<AppEntry>> onCreateLoader(int id, Bundle args) {          // This is called when a new Loader needs to be created. This          // sample only has one Loader with no arguments, so it is simple.          return new AppListLoader(getActivity());      }        @Override public void onLoadFinished(Loader<List<AppEntry>> loader, List<AppEntry> data) {          // Set the new data in the adapter.          mAdapter.setData(data);            // The list should now be shown.          if (isResumed()) {              setListShown(true);          } else {              setListShownNoAnimation(true);          }      }        @Override public void onLoaderReset(Loader<List<AppEntry>> loader) {          // Clear the data in the adapter.          mAdapter.setData(null);      }  }

强大的一逼！这下满技能，不解释，自己看。

4-4 进阶总结

通过前面基础实例、源码分析、进阶演示你会发现Loader的真的非常好用，非常牛逼，牛逼的我不想再解释啥了，自己体会吧。

PS：之前看见微博上有人讨论AsyncTaskLoader与AsyncTask的区别，这下彻底明朗了，看完源码我们再回过头来总结性的说说他们二者区别，如下：

class	优势	劣势
AsyncTaskLoader	会自动刷新数据变化；会自动处理Activiy配置变化造成的影响；适合处理纯数据加载；	不能实时通知UI刷新；不能在onLoadFinished时主动切换生命周期（譬如replace Fragment）；
AsyncTask	可以与UI实时交互及replace操作；	不会自动处理Activiy配置变化造成的影响；

好了，该撕逼的也撕了，该装逼的也装了，该分析的也分析了，该学习的也学到了，接下来就是看自己如何带着Loader去叱诧风云了。

【工匠若水 http://blog.csdn.net/yanbober 转载请注明出处。点我开始Android技术交流】