学以致用--链式结构处理android耗时请求
1：背景
今天遇到了一个情况（首先需要去http请求获取服务器数据，然后将数据存库，其次再将数据的一部分放入share文件，最后更新内存数据.....） 哎，最后一步更新内存还行，非常速度的，前面散步基本是基本包括了android中耗时操作的三个大类吧，哎---是在不想一步一步整
2：知识前提
大概了解程序的设计模式（本文采用责任链模式），有一点点开发经验就ok了哈
3：程序基本模型
一个请求类 Responser, 一个请求执行类ResponserChain,一个 HttpUtils工具类，一个数据库工具类databaseutils，一个share文件工具类shareutils
Responser代码如下：
public abstract class Responser<T> {
public final int CONS_TIME_OUT_ONE_SECOND = 1000;
private final int CONS_TIME_OUT_SIXTEEN_SECOND = 60 * CONS_TIME_OUT_ONE_SECOND; // 10秒
public Responser(int weight) {
this.thisWeight = weight;
this.ResponserKey = String.valueOf(hashCode());
}
public String ResponserKey;<span style="white-space:pre"> </span>//唯一标识一个任务
public int thisWeight = Integer.MAX_VALUE; //该请求的权重
protected T t;
public int timeOut() {
return CONS_TIME_OUT_SIXTEEN_SECOND;
}
/**
* 依次执行任务的时候，如果下一个任务需要上一次执行的返回结果，在这里设置
*
* @param ob
*/
public void doNext(JSONObject ob) {
}
/**
* 依次执行任务的时候，如果下一个任务需要上一次执行的返回结果，在这里获取
*
* @param ob
*/
public T onNext() {
return t;
}
/**
* 执行任务
*
* @return
*/
public abstract String excute();
/**
* 任務類型
*
* @return
*/
public abstract EResponseType resType();
public enum EResponseType {
DATABASE, HTTP, SHARE
}
}
注意以上的一个excute的方法，每个请求类均有该方法执行
下面举例说明以上遇到的情况，先http请求，再入库，然后再share文件，然后内存
<pre name="code" class="java">final Responser<String> http= new Responser<String>(0) {
@Override
public String excute() {
return HttpUtils.get(......);//省略号是请求地址
}
};
<pre name="code" class="java">final Responser<String> db= new Responser<String>(1) {
@Override
public String excute() {
return databaseutils.insert(......);//省略号是插入数据库代码
}
};
<pre name="code" class="java">final Responser<String> unbind = new <span style="font-family: Arial, Helvetica, sans-serif;">Responser</span><span style="font-family: Arial, Helvetica, sans-serif;"><String>(2) {</span>
@Override
public String excute() {
return shareutils.commit(......);//省略号是提交share文件
}
};
然后是执行请求的类ResponserChain：
代码如下
public class ResponserChain {
private Vector<Responser<?>> allResponse = new Vector<Responser<?>>();
private boolean currentChainIsAlive = false;
private responserChainListener _ResChainListener;
private Responser<?> _Responser;
/**
* Constructor one responseChain
*/
public ResponserChain(responserChainListener excuteListener, Responser<?>... responsers) {
if (responsers.length <= 0) {
return;
}
for (Responser<?> responser : responsers) {
allResponse.add(responser);
}
currentChainIsAlive = true;
_ResChainListener = excuteListener;
}
/**
* ready
*/
public boolean ready() {
synchronized (allResponse) {
if (allResponse.isEmpty()) {
return false;
}
for (Responser<?> responser : allResponse) {
if (_Responser == null || responser.thisWeight < _Responser.thisWeight) {
_Responser = responser;
}
}
if (_Responser == null) {
return false;
}
for (Responser<?> responser : allResponse) {
if (responser.ResponserKey.equals(_Responser.ResponserKey)) {
allResponse.remove(responser);
break;
}
}
return _Responser.thisWeight != Integer.MAX_VALUE;
}
}
/**
* go,
*/
public void go() {
HTTPThreadPool.getInstance().submit(new Runnable() {
@Override
public void run() {
/**
* 必须保证以下代码执行的每一句的顺序
*/
final String _task = _Responser.ResponserKey;
final int _timeout = _Responser.timeOut();
new Thread(new Runnable() {
@Override
public void run() {
for (int i = _timeout; i > 0; i -= _Responser.CONS_TIME_OUT_ONE_SECOND) {
// 如果在计算超时的时候，改任务已经执行结束，则結束超時
if (!currentChainIsAlive || !_Responser.ResponserKey.equals(_task)) {
return;
}
try {
Thread.sleep(1050); // 为什么是1050呢--猜
}
catch (Exception e) {
}
}
if (currentChainIsAlive && _Responser.ResponserKey.equals(_task)) {
if (_ResChainListener != null) {
_ResChainListener.onExcuteChainCallBack(HttpConstans.HTTP_TIMEOUT, _Responser, null);
}
release();
}
}
}).start();
String result = _Responser.excute();
// 执行完成，但是职责链已经不存在
if (!currentChainIsAlive) {
return;
}
JSONObject json = null;
try {
if (!TextUtils.isEmpty(result)) {
json = new JSONObject(result);
}
}
catch (JSONException e) {
json = null;
}
if (json == null) {
if (_ResChainListener != null) {
_ResChainListener.onExcuteChainCallBack(HttpConstans.HTTP_FAILED, _Responser, null);
}
release();
return;
}
final int code = json.optInt("code");
if (_ResChainListener != null) {
_ResChainListener.onExcuteChainCallBack(code, _Responser, json);
}
_Responser.thisWeight = Integer.MAX_VALUE;
boolean hasNext = ready();
if (hasNext) {
_Responser.doNext(json);
}
if (code == 0 && hasNext) {
go();
return;
}
release();
}
});
}
/**
* cut current chain
*/
public void cut() {
release();
}
/**
* current chain is alive
*/
public boolean isAlive() {
return currentChainIsAlive;
}
/**
* dynamic add one response, but this response is excute lase
*/
public boolean addResponseToLase(Responser<?>... responsers) {
/** current chain is over, may be this object is destory */
if (!currentChainIsAlive) {
return false;
}
synchronized (allResponse) {
for (Responser<?> responser : responsers) {
allResponse.add(responser);
}
}
return true;
}
/**
* release
*/
public void release() {
currentChainIsAlive = false;
_ResChainListener = null;
allResponse.clear();
}
/**
* one chain excute result
*/
public interface responserChainListener {
public void onExcuteChainCallBack(int result, Responser<?> responser, JSONObject json);
}
}
最后执行你只需要这样.....
ResponserChain c = new ResponserChain(new responserChainListener() {
<span style="white-space:pre"> </span>@Override
<span style="white-space:pre"> </span>public void onExcuteChainCallBack(final int result, final Responser<?> responser, final JSONObject json) {
<span style="white-space:pre"> </span>
<span style="white-space:pre"> </span>postUI(new Runnable() {
<span style="white-space:pre"> </span>@Override
<span style="white-space:pre"> </span>public void run() {
<span style="white-space:pre"> </span>//根据返回的请求的类型，各种结果就出来了，而且是你制定的顺序 http第一执行，db第二执行，share第三执行，
<span style="white-space:pre"> </span>}, http,db,share);
if (c.ready()) {
<span style="white-space:pre"> </span>c.go();
<span style="white-space:pre"> </span>return;
}
好了，这是为了处理开发中遇到的问题，代码不是很高尚，质量也不是很好，只是给各位初学android的码友一种解决问题的方式，写得不好，各位见谅了......
![与专家面对面：Android开发入门问与答[图]](data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACwAAAAAAQABAAACAkQBADs=)