您可以扩展Loader类，以执行其他异步工作，例如直接从数据库中加载。
这是一个例子
编辑： 添加了一个更好的Loader使用示例。
最终设法找到了真正帮助我了解事情原理的教程。
通过扩展加载程序类，您可以避免与内容观察者打交道，并且它相当容易实现（最后），需要在代码中进行的修改是
- 添加的实现
LoaderManager.LoaderCallbacks<D>
，D
您的数据列表在哪里（代码段1） - 创建您的加载程序类，复制代码段2，并添加来自数据库的数据加载
- 最后，调用加载程序1进行初始化，然后刷新重启调用。（摘要2和3）
片段1： 如何将加载程序与片段“链接”：
public static class AppListFragment extends ListFragment implements LoaderManager.LoaderCallbacks<List<SampleItem>> { public Loader<List<SampleItem>> onCreateLoader(int id, Bundle args) { //... return new SampleLoader (getActivity()); } public void onLoadFinished(Loader<List<SampleItem>> loader, List<SampleItem> data) { // ... mAdapter.setData(data); if (isResumed()) { setListShown(true); } else { setListShownNoAnimation(true); } // ... } public void onLoaderReset(Loader<List<SampleItem>> loader) { // ... mAdapter.setData(null); // ... } }片段2：
您的自定义加载程序的架构：（我对观察者的观点进行了两次评论，因为我认为从一开始就很难实现它，您可以简单地调用加载程序而不会弄乱自动刷新）
public class SampleLoader extends AsyncTaskLoader<List<SampleItem>> { // We hold a reference to the Loader’s data here. private List<SampleItem> mData; public SampleLoader(Context ctx) { // Loaders may be used across multiple Activitys (assuming they aren't // bound to the LoaderManager), so NEVER hold a reference to the context // directly. Doing so will cause you to leak an entire Activity's context. // The superclass constructor will store a reference to the Application // Context instead, and can be retrieved with a call to getContext(). super(ctx); } @Override public List<SampleItem> loadInBackground() { // This method is called on a background thread and should generate a // new set of data to be delivered back to the client. List<SampleItem> data = new ArrayList<SampleItem>(); // TODO: Perform the query here and add the results to 'data'. return data; } @Override public void deliverResult(List<SampleItem> data) { if (isReset()) { // The Loader has been reset; ignore the result and invalidate the data. releaseResources(data); return; } // Hold a reference to the old data so it doesn't get garbage collected. // We must protect it until the new data has been delivered. List<SampleItem> oldData = mData; mData = data; if (isStarted()) { // If the Loader is in a started state, deliver the results to the // client. The superclass method does this for us. super.deliverResult(data); } // Invalidate the old data as we don't need it any more. if (oldData != null && oldData != data) { releaseResources(oldData); } } @Override protected void onStartLoading() { if (mData != null) { // Deliver any previously loaded data immediately. deliverResult(mData); } // Begin monitoring the underlying data source. ////if (mObserver == null) { ////mObserver = new SampleObserver(); // TODO: register the observer ////} //// takeContentChanged() can still be implemented if you want //// to mix your refreshing in that mechanism if (takeContentChanged() || mData == null) { // When the observer detects a change, it should call onContentChanged() // on the Loader, which will cause the next call to takeContentChanged() // to return true. If this is ever the case (or if the current data is // null), we force a new load. forceLoad(); } } @Override protected void onStopLoading() { // The Loader is in a stopped state, so we should attempt to cancel the // current load (if there is one). cancelLoad(); // Note that we leave the observer as is. Loaders in a stopped state // should still monitor the data source for changes so that the Loader // will know to force a new load if it is ever started again. } @Override protected void onReset() { // Ensure the loader has been stopped. onStopLoading(); // At this point we can release the resources associated with 'mData'. if (mData != null) { releaseResources(mData); mData = null; } // The Loader is being reset, so we should stop monitoring for changes. ////if (mObserver != null) { // TODO: unregister the observer //// mObserver = null; ////} } @Override public void onCanceled(List<SampleItem> data) { // Attempt to cancel the current asynchronous load. super.onCanceled(data); // The load has been canceled, so we should release the resources // associated with 'data'. releaseResources(data); } private void releaseResources(List<SampleItem> data) { // For a simple List, there is nothing to do. For something like a Cursor, we // would close it in this method. All resources associated with the Loader // should be released here. } // NOTE: Implementing an observer is outside the scope of this post (this example // uses a made-up "SampleObserver" to illustrate when/where the observer should // be initialized). // The observer could be anything so long as it is able to detect content changes // and report them to the loader with a call to onContentChanged(). For example, // if you were writing a Loader which loads a list of all installed applications // on the device, the observer could be a BroadcastReceiver that listens for the // ACTION_PACKAGE_ADDED intent, and calls onContentChanged() on the particular // Loader whenever the receiver detects that a new application has been installed. // Please don’t hesitate to leave a comment if you still find this confusing! :) ////private SampleObserver mObserver;}片段3： 如何首次调用加载程序（仅）
// Initialize a Loader with an id. If the Loader with this id is not // initialized before getLoaderManager().initLoader(LOADER_ID, null, this);
片段4： 用于刷新数据（调用查询）
// Check if the loader exists and then restart it. if (getLoaderManager().getLoader(LOADER_ID) != null) getLoaderManager().restartLoader(LOADER_ID, null, this);
参考：
- 片段1：从此处提取的加载程序的用法
- 片段2：此处提供更多信息和逻辑，贯穿整篇文章
- 片段3和4：只是装载程序的用法。
创建者还将这些的完整代码上传到github
