怎么使用ListView实现一个带有网络请求，解析，分页，缓存的公共的List页面来大大的提高工作效率
如何使用ListView实现一个带有网络请求，解析，分页，缓存的公共的List页面来大大的提高工作效率
这个图可能画的有些毛糙，还是再用小文来简述一下，BaseFragment含有一些基本的功能，比如快速弹出一个toast，显示一个等待对话框等待，它还有子类常用的一些属性，activity，LayoutInflater，ImageLoader 等等：
AbstListFragment则是咱们项目的关键部分了，它集成了界面生成、空数据展示界面、网络请求及分页请求，网络请求回调，item点击回调，界面主动刷新广播接收器等功能，
SuperAbstListFragment<T> 是对父类AbstListFragment的进一步抽象，它里面集成了一个适配器与一个万能的ViewHolder，使子类只用
通过以上几个类的不断抽取，当最后在使用的时候，实现类只用简单的几行代码就可以完成很多很多的功能，怎么样，是不是很简单？
就是这个文件，可以通过传入的标题，需要实现的Fragment类，需要请求的地址来生成多种多样的界面，所以在实现子类的时候每个子类都需要重写public static AbstListFragment getInstance(String requestUrl) 方法以供外部可以调用到它。
当然，在该项目中还集成了不少别的基本的东西，比如ImageLoader图片加载，Volley请求工具，json解析工具等，如果是作为一个新项目的话，本项目还是可以作为一个最基本的起始项目来用用。
在平常的开发中经常会有很多列表页面，每做一个列表页就需要创建这个布局文件那个Adapter适配器文件等等一大堆与之相关的附属的不必要的冗余文件。如果版本更新迭代比较频繁，如此以往，就会使项目工程变得无比庞大臃肿。
如果看过这篇文章或者在使用过这种方式之后呢，所有的工作都可以被压缩成只有两个文件，一个JAVA文件一个XML布局文件。而且代码还少少的。
咱们来看看实际情况：
平常的一个列表页面的生成需要以下文件：
- 一个Activity文件，有时候可能还会忘记注册
- 一个包含上下拉刷新控件以及无数据时提示的布局文件
- 一个Listview的item的布局文件
- 一个Adapter适配器文件
- 一个需要被解析的Bean文件
当然在Activity中还需要处理以下功能：
- 数据解析
- 分页加载
- 数据缓存
- 网络请求
当然，以上功能可以通过频繁的复制粘贴来实现，但是这会给以后的维护留下不少不小的坑，比如突然需要更换Listview为Recyclerview，你是不是顿时就想哭了呢？是不是就得一个个文件去改呢？现在不用了，改俩地方就行了。
现在你可能想知道一个公共的List页有什么特点呢？
- 无需再关心网络请求、数据解析、分页、缓存等相同的功能
- 不需要写那么多的相同的布局文件，只用写那些不同的item布局文件就可以，只需要关心你关心的
- 只会有一个Adapter适配器，一个ViewHolder存在，Activity也可以只有一个
- 可复用性超强，无论是Activity中展示，还是在被要求放在ViewPager中显示都没问题
- 大大减小项目的工程文件数量，提高编译速度，不用再把一天的时间都浪费在编译时间上
- 提高你的工作效率，不用再复制粘贴，那个时间没有这个快，只用实现你的getView方法就可以
- 减少维护成本，如果某一天需要在网络请求加上某个参数，以前的方法需要改无数个地方，而现在只用改一个地方就OK，如果如探需要更改上下拉刷新控件，比如需要将XListView改成PullToRefreshListView，你是不是就苦逼了？很多地方都需要跟着改，现在不用了，只用动一个地方全都OK
- 还有很多我一时间想不起来等你去发掘的功能
好，BB了这么多，到底是怎么实现和怎么使用呢？容我慢慢道来：
好，先来看看使用起来有多便捷：
/**
* 示例代码，将关键的部分放在fragment中，无论是viewpager还是Activity，还是其它容器，都可以将fragment嵌入其中显示
*
* @author Sahadev
*
*/
public class ExampleFragment extends SuperAbstListFragment<ExampleBean> {
public static AbstListFragment getInstance(String requestUrl) {
AbstListFragment fragment = new ExampleFragment();
Bundle bundle = new Bundle();
bundle.putString(AbstListFragment.URL, requestUrl);
fragment.setArguments(bundle);
return fragment;
}
@Override
public Type getInstanceType() {
// 返回需要实例化的对象类型
return new TypeToken<List<ExampleBean>>() {
}.getType();
}
/**
* 需要实例化的类,这里仅用一个属性做例子
*
* @author Work
*
*/
public static class ExampleBean implements Serializable {
/**
*
*/
private static final long serialVersionUID = 7624541082621792974L;
@SerializedName("title")
public String title;
}
//在这里完成数据绑定就可以了，支持链式调用
@Override
public void setView(ViewHolder viewHolder, ExampleBean t) {
viewHolder.setText(R.id.title, t.title);
}
@Override
public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
}
}
这是实际运行效果图:仅仅通过短短的几行代码就可以实现强大的功能，是不是很方便？
好，效果先看到了，接下来描述一下是如何完成这么多功能的：
当然，子类写的代码少，那说明父类已经帮它完成了不少功能，所以咱们先看看整体的目录结构：
这个图可能画的有些毛糙，还是再用小文来简述一下，BaseFragment含有一些基本的功能，比如快速弹出一个toast，显示一个等待对话框等待，它还有子类常用的一些属性，activity，LayoutInflater，ImageLoader 等等：
/**
* 基本类，提供一些常用的基本的方法属性供子类使用
*
* @author Sahadev
*
*/
public class BaseFragment extends Fragment {
/**
* 图片加载工具
*/
protected ImageLoader mImageLoader;
/**
* 等待对话框
*/
private LoadingDialog mLoadingDialog;
/**
* 布局填充器
*/
protected LayoutInflater mInflater;
/**
* context
*/
protected Activity mContext;
@Override
public void onAttach(Activity activity) {
super.onAttach(activity);
mContext = activity;
mInflater = (LayoutInflater) mContext.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
}
@Override
public void onActivityCreated(Bundle savedInstanceState) {
super.onActivityCreated(savedInstanceState);
// 在此处初始化mImageLoader，mLoadingDialog等属性
mLoadingDialog = LoadingDialog.getInstance(mContext);
// imageLoader属性可在自定义的Application中设置全局的单例，由自定义Application暴露接口获取单例,比如
// mImageLoader = CustomApplication.getImageLoaderInstance();
}
/**
* 吐司
*
* @param message
*/
protected void toast(String message) {
Toast.makeText(mContext, message, Toast.LENGTH_SHORT).show();
}
/**
* 显示等待对话框，显示默认文本
*/
protected void showLoadingDialog() {
if (mLoadingDialog != null) {
mLoadingDialog.show();
}
}
/**
* 显示等待对话框，显示传入的文本
*
* @param message
*/
public void showLoadingDialog(String message) {
if (mLoadingDialog != null) {
mLoadingDialog.setMessage(message);
mLoadingDialog.show();
}
}
/**
* 关闭等待对话框
*/
protected void dismissLoadingDialog() {
if (mLoadingDialog != null) {
mLoadingDialog.dismiss();
}
}
@Override
public void onDestroy() {
super.onDestroy();
dismissLoadingDialog();
}
}
AbstListFragment则是咱们项目的关键部分了，它集成了界面生成、空数据展示界面、网络请求及分页请求，网络请求回调，item点击回调，界面主动刷新广播接收器等功能，
可以使用户自己定义适配器：
/**
* 含有ListView的Fragment
* 抽取公共的含有ListView的Fragment，此Fragment已经包括基本的下拉刷新，网络加载，分页加载等公共功能，只需要关心实现 推荐使用
* {@link #SuperAbstListFragment}实例化子类方式参见{@link #ExampleFragment}
*
* @author Sahadev
*
*/
public abstract class AbstListFragment extends BaseFragment implements OnItemClickListener, OnClickListener,
Listener<JSONObject>, ErrorListener, OnRefreshListener2<ListView> {
protected PullToRefreshListView mListView;
protected ImageView emptyView;
private AnimationDrawable rocketAnimation;
private View rootView;
protected int page = 0;
public static final String URL = "ABST_LIST_FRAGMENT_URL";
public static final String NEED_REFRESH_BROADCAST_RECEIVER = "NEED_REFRESH_BROADCAST_RECEIVER";
/**
* 请求的链接地址
*/
protected String requestUrl;
/**
* 由子类实现，安全传参
*
* @param requestUrl
* @return
*/
public static AbstListFragment getInstance(String requestUrl) {
return null;
}
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
if (rootView == null) {
rootView = inflater.inflate(R.layout.activity_list_layout, container, false);
emptyView = (ImageView) rootView.findViewById(R.id.empty_view);
mListView = (PullToRefreshListView) rootView.findViewById(R.id.list);
mListView.setEmptyView(emptyView);
mListView.getRefreshableView().setLayoutTransition(new LayoutTransition());
mListView.setOnRefreshListener(this);
mListView.setOnItemClickListener(this);
mListView.getRefreshableView().setOnItemClickListener(this);
emptyView.setOnClickListener(this);
Bundle bundle = getArguments();
if (bundle != null) {
requestUrl = getArguments().getString(AbstListFragment.URL);
}
}
ViewGroup parent = (ViewGroup) rootView.getParent();
if (parent != null) {
parent.removeView(rootView);
}
return rootView;
}
@Override
public void onStart() {
super.onStart();
if (mListView != null) {
mListView.setRefreshing(false);
}
}
@Override
public void onPullDownToRefresh(PullToRefreshBase<ListView> refreshView) {
page = 0;
getData(requestUrl + "&p=" + page);// 这里可以添加分页和其它请求服务器所需要的必要参数，比如token或者其它什么的，所以在传入的地方只用传入必要的参数就OK
}
@Override
public void onPullUpToRefresh(PullToRefreshBase<ListView> refreshView) {
page++;
getData(requestUrl + "&p=" + page);
}
protected void getData(String requestUrl) {
if (isNeedLoadDataFromNet()) {
if (page == 0) {
// 可以在这里设置加载动画
emptyView.setImageResource(R.drawable.loading_animation);// R.drawable.loading_animation代表动画资源
rocketAnimation = (AnimationDrawable) emptyView.getDrawable();
rocketAnimation.start();
}
RequestUtils.requesGet(requestUrl, this, this);
}
}
/**
* 这个方法用于返回是否是从网络加载，有些数据是需要从本地加载的，这个 方法就可以由子类来控制具体是什么
*
* @return
*/
protected boolean isNeedLoadDataFromNet() {
return true;
}
@Override
public void onResponse(JSONObject response) {
// 设置请求完毕之后的状态
rocketAnimation.stop();
emptyView.setImageResource(R.drawable.nocontent);
mListView.onRefreshComplete();
}
@Override
public void onErrorResponse(VolleyError error) {
// 设置请求完毕之后的状态
rocketAnimation.stop();
emptyView.setImageResource(R.drawable.nocontent);
toast("咦?网络状况貌似出了点问题.");
mListView.onRefreshComplete();
}
@Override
public void onClick(View v) {
switch (v.getId()) {
// 当点击无数据提示的时候重新加载
case R.id.empty_view:
mListView.setRefreshing();
break;
default:
break;
}
}
private BroadcastReceiver receiver;
@Override
public void onResume() {
super.onResume();
receiver = new NeedRefreshBroadcastReceiver();
IntentFilter filter = new IntentFilter(NEED_REFRESH_BROADCAST_RECEIVER);
filter.addCategory(Intent.CATEGORY_DEFAULT);
mContext.registerReceiver(receiver, filter);
}
@Override
public void onPause() {
super.onPause();
mContext.unregisterReceiver(receiver);
}
/**
* 主动刷新广播接收器，当数据发生改变的时候(比如添加或者删除)主动刷新
*
* @author Work
*
*/
private class NeedRefreshBroadcastReceiver extends BroadcastReceiver {
@Override
public void onReceive(Context context, Intent intent) {
mListView.setCurrentMode(Mode.PULL_FROM_START);
mListView.setRefreshing(false);
}
}
}
SuperAbstListFragment<T> 是对父类AbstListFragment的进一步抽象，它里面集成了一个适配器与一个万能的ViewHolder，使子类只用
实现几个基本的方法就可以，比如要解析的类型、当item点击之后的处理方式、数据与界面如何绑定等等，来看看这个
类都有什么：
/**
* 抽象的AbstListFragment中间层，具有更强大的功能
*
* @author Work
*
*/
public abstract class SuperAbstListFragment<T> extends AbstListFragment {
protected AbstBaseAdapter<T> adapter;
@Override
public void onActivityCreated(Bundle savedInstanceState) {
super.onActivityCreated(savedInstanceState);
try {
// 如果有些Adapter中不满足实际情况的话，可以使用反射来实例化
// adapter = (AbstBaseAdapter<T>)
// getAdapterClass().getConstructor(Context.class).newInstance(mContext);
adapter = new SuperAdapter(mContext);
mListView.setAdapter(adapter);
} catch (IllegalArgumentException e) {
e.printStackTrace();
}
}
/**
* 万能适配器，它只是个中间件
*
* @author Work
*
*/
public class SuperAdapter extends AbstBaseAdapter<T> {
public SuperAdapter(Context context) {
super(context);
}
@Override
public View getView(int position, View convertView, ViewGroup parent) {
return SuperAbstListFragment.this.getView(position, convertView, parent);
}
}
/**
*
*
* @param position
* @param convertView
* @param parent
* @return
*/
public View getView(int position, View convertView, ViewGroup parent) {
// 这里使用的是万能的ViewHolder
ViewHolder viewHolder = ViewHolder.get(mContext, convertView, parent, R.layout.fragment_list_item, position);// 这一行可以进一步的抽取到父类中
T t = adapter.getData().get(position);
setView(viewHolder, t);
return viewHolder.getConvertView();
}
/**
* 绑定数据，使用户真正关心的只有他们想要关心的
*
* @param viewHolder
* @param t
*/
public abstract void setView(ViewHolder viewHolder, T t);
/**
* 如果单单的getView方法不满足需求的话，可以通过自定义Adapter的方法来实现，该方法用来返回需要实例化的Adapter的类名
*
* @return
*/
public Class<?> getAdapterClass() {
return null;
}
/**
* 需要解析的数据类型是一个对象还是对象的集合，由这个返回
*
* @return
*/
public abstract Type getInstanceType();
/*
* (non-Javadoc)
*
* @see
* com.sahadev.general_assembly.base.AbstListFragment#onResponse(org.json
* .JSONObject) 当网络请求成功之后回调该方法，开始解析数据
*/
@Override
public void onResponse(JSONObject response) {
super.onResponse(response);
if (response != null && response.optBoolean("success")) {
Gson gson = new Gson();
List<T> datas = gson.fromJson(response.optJSONArray("data").toString(), getInstanceType());
initAdapter(datas);
}
}
/**
* 数据解析完毕之后刷新数据
*
* @param list
*/
protected void initAdapter(List<T> list) {
if (page == 0) {
adapter.addFirstPageData(list);
} else {
adapter.addOtherPageData(list);
}
}
}
通过以上几个类的不断抽取，当最后在使用的时候，实现类只用简单的几行代码就可以完成很多很多的功能，怎么样，是不是很简单？
接下来简单介绍一下如何在各种页面只用一个Activity来装载不同页面的Fragment呢：
/**
* 含有ListFragment的Activity
*
* @author 尚斌
*
*/
public class IncludeListFragmentActivity extends FragmentActivity {
private String mFragmentClass = "x.x.x.x.x.x";
private String mRequestUrl = "http://www.baidu.com";
private String title = "标题未定义";
public static final String TITLE = "TITLE";
public static final String CLASS = "CLASS";
public static final String URL = "URL";
/**
* @param context
* @param fragmentClass
* 需要实例化的Fragment的包名
* @param requestUrl
* 该Fragment内部的请求地址
* @return
*/
public static Intent getIntent(Context context, String fragmentClass, String requestUrl, String title) {
Intent intent = new Intent(context, IncludeListFragmentActivity.class);
Bundle bundle = new Bundle();
bundle.putString(TITLE, title);
bundle.putString(CLASS, fragmentClass);
bundle.putString(URL, requestUrl);
intent.putExtras(bundle);
return intent;
}
@SuppressWarnings("unchecked")
@Override
protected void onCreate(Bundle savedInstanceState) {
requestWindowFeature(Window.FEATURE_NO_TITLE);
super.onCreate(savedInstanceState);
Intent intent = getIntent();
Bundle bundle = intent.getExtras();
mFragmentClass = bundle.getString(CLASS);
mRequestUrl = bundle.getString(URL);
title = bundle.getString(TITLE);
// 设置标题
setTitle(title);
// 设置布局文件
setContentView(R.layout.activity_include_list_fragment);
try {
Class<BaseFragment> newInstance = (Class<BaseFragment>) Class.forName(mFragmentClass);
Method method = null;
BaseFragment fragment = null;
method = newInstance.getMethod("getInstance", String.class);
fragment = (BaseFragment) method.invoke(null, mRequestUrl);
if (fragment != null) {
getSupportFragmentManager().beginTransaction().add(R.id.container, fragment).commit();
} else {
throw new Exception("You must be have a named getInstance method!");
}
} catch (Exception e) {
e.printStackTrace();
}
}
就是这个文件，可以通过传入的标题，需要实现的Fragment类，需要请求的地址来生成多种多样的界面，所以在实现子类的时候每个子类都需要重写public static AbstListFragment getInstance(String requestUrl) 方法以供外部可以调用到它。
说了这么多，在这里面其实是没有缓存的，其实这个公共的项目与缓存关系是不大的，既然提到就说一下是怎么实现的，在项目开发的时候很多时候都用到了第三方网络框架，也是有源码的，这里就用Volley举个栗子：
在Volley请求的时候，在请求的基类方法中，根据请求的URL去数据库中寻找，数据库这里推荐使用xUtils提供的数据库存储，如果没找到，则调用网络请求，在网络请求成功回调的部分将请求的数据存入数据库，以便第二次查找，基本思路就是这样：
使用代码举例：
网络请求部分：
public JsonRequest(int method, String url, Map<String, String> body, Listener<T> listener,
ErrorListener errorListener, boolean isNeedCache, Type type) {
super(method, url + "&token=token" + "&vid=vid"), errorListener);
mListener = listener;
mRequestBody = null;
mType = type;
if (isNeedCache && !(检查网络是否可用)) {
url += "&token=token" + "&vid=vid";
try {
//使用自定义的方式去数据库中查找，这里使用的是xUtils举例：
List<Cache> datas = xUtils
.getInstance()
.getDbUtils()
.findAll(
Selector.from(Cache.class).where("requestUrl", "=", url).orderBy("time", false)
.limit(1));
if (!netAccessed && datas != null & listener != null) {
for (Cache cache : datas) {
//如果查找成功就进行回调
listener.onResponse((T) new JSONObject(cache.jsonString));
}
}
} catch (DbException e) {
e.printStackTrace();
} catch (JSONException e) {
e.printStackTrace();
}
}
bodyMap = body;
}网络回调部分，将服务器数据存储：@Override
protected void deliverResponse(final T response) {
if (response != null
&& (response.getClass().equals(String.class) || response.getClass().equals(JSONObject.class))) {
new Thread(new Runnable() {
@Override
public void run() {
Cache cache = new Cache(mUrl, response.toString());
try {
//使用xUtils进行存储
xUtils.getInstance().getDbUtils().save(cache);
} catch (DbException e) {
e.printStackTrace();
}
}
}).start();
}
netAccessed = true;
if (mListener != null && (如果网络可用)) {
if (mType != null) {
try {
String simString1 = response.getClass().getName();
String simString2 = mType.toString();
//有多种类型回调，如果只是回调String类，则调用以下
if (simString2.contains(simString1)) {
mListener.onResponse(response);
} else {
mListener.onResponse(null);
}
} catch (Exception e1) {
}
} else {
//还有一种是JsonObject类型，则调用以下
mListener.onResponse(response);
}
}
}大伙可能实际情况不是这个样子，但是思路可能差不多，仅供参考。当然，在该项目中还集成了不少别的基本的东西，比如ImageLoader图片加载，Volley请求工具，json解析工具等，如果是作为一个新项目的话，本项目还是可以作为一个最基本的起始项目来用用。
项目地址在这里：https://git.oschina.net/sahadev/General-Assembly
项目是一个开源项目，迫切的想要更多的人可以加入进来，将自己工作中可以提高工作效率的知识和成果分享出来，出一份力。如果想加入 请联系我：sahadev@foxmail.com，希望可以一起发展壮大，拥有很多为大家减轻负担的成果。
版权声明：本文为博主原创文章，未经博主允许不得转载。