移动架构31_责任链和模板模式封装连续请求

Demo地址：

https://gitee.com/YuBaoZi/codes/krbjs78p96fa4cnwyqho176

一、 需求

处理链式请求

需求分析：通常我们会遇到这样的情况，先去判断一个逻辑（有可能是异步的），当结果为一种情况时，继续执行下一步，再去判断；直到最终，如：

获取用户手机号->获取用户资产信息->购买产品

原理：每一步处理，都有请求、处理通过、处理不通过的逻辑，只是具体的内容不同，用抽象方法；

每个处理封装成一个对象，通过java的对象引用产生关联；

每个处理对象依赖上一个处理的结果，因此要将处理结果传递下去；

移动架构16_模板模式

二、代码

1、BaseHandler

/**
* @param <M> 上一个处理环节的结果的类型
* @param <T> 当前处理环节的结果的类型
*            使用示例：
*            Handler<Void,Integer>  handler1 = new Handler1();
*            Handler<Integer, String> handler2 = new Handler2();
*            handler1.nextHandler = handler2;
*            handler1.handle();
* @author baopengjian
*     每一个环节处理的模板 （责任链模式、模板模式 ）
*/
public abstract class BaseHandler<M, T> {
/**
* 下一个处理环节
*/
public BaseHandler<T, ?> nextHandler;
/**
* 当前环节处理的结果
*/
private T result;

/**
* 通过第一个Handler的该方法，启动整个链式处理
*/
public void handle() {
request(null, new CallBack<T>() {
@Override
public void onSuccess(T result) {
BaseHandler.this.result = result;
handleSucess(null,result);
}

@Override
public void onFail(T result) {
BaseHandler.this.result = result;
handleFail(null,result);
}
});
}

/**
* 启动下一环节的处理，并传入当前处理结果
* @param lastResult
*/
protected void handle(final M lastResult) {
request(lastResult, new CallBack<T>() {
@Override
public void onSuccess(T result) {
BaseHandler.this.result = result;
handleSucess(lastResult,result);
}

@Override
public void onFail(T result) {
BaseHandler.this.result = result;
handleFail(lastResult,result);
}
});
}
/**
* 如果需要传递到下一环节，该方法需要在request中当处理结束后被调用
*/
protected void handleNext(){
if(nextHandler != null){
nextHandler.handle(result);
}
}
/**
* 当前环节处理成功
*/
public void handleSucess(M lastResult,T result){
handleNext();
}
/**
* 当前环节处理失败
* @param lastResult
* @param result
*/
public abstract void handleFail(M lastResult,T result);
/**
*  具体处理逻辑的抽象方法
* @param lastResult
* @param callBack 需要在实现中手动调用 callBack.onSucess和 callBack.onFail
* 注意：是callBack 的onSucess不是handleSucess
*/
public abstract void request(M lastResult,CallBack<T> callBack);

/**
* 处理结果的回调
* @param <T> 结果类型
*/
public  interface CallBack<T> {
void onSuccess(T result);

void onFail(T result);
}
}

2、BaseHandler的实现

public class Handler1 extends BaseHandler<Void,Integer> {

@Override
public void handleFail(Void lastResult, Integer result) {
Log.i("Hand",">>> Handler1处理请求失败");
}

@Override
public void request(Void lastResult, CallBack<Integer> callBack) {
Log.i("Hand",">>> Handler1 开始请求request");
Request request = new Request();
request.request1(callBack);
}
}

public class Handler2 extends BaseHandler<Integer,String> {

@Override
public void handleFail(Integer lastResult, String result) {
Log.i("Hand",">>> Handler2处理请求失败");
}

@Override
public void request(Integer lastResult, CallBack<String> callBack) {
Log.i("Hand",">>> Handler2 开始请求request");
Request request = new Request();
request.request2(callBack);
}
}

public class Handler3 extends BaseHandler<String, String> {

@Override
public void handleSucess(String lastResult, String result) {
Log.i("Hand",">>>重写handleSucess Handler3不再向后传递");
}

@Override
public void handleFail(String lastResult, String result) {
Log.i("Hand",">>> Handler3处理请求失败");
}

@Override
public void request(String lastResult, CallBack<String> callBack) {
Log.i("Hand",">>> Handler3 开始请求request");
Request request = new Request();
request.request3(callBack);
}
}

3、模拟请求

public class Request {

Handler handler = new Handler() {
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
if (callBack == null) {
return;
}
switch (msg.what) {
case 1:
int result = (int) msg.obj;
Log.i("Hand",">>> Handle1处理请求完成   当前处理结果："+result);
if (result > 0){
callBack.onSuccess(result);
} else {
callBack.onFail(result);
}
break;
case 2:
Log.i("Hand",">>> Handle2处理请求完成   当前处理结果："+result);
String result2 = (String) msg.obj;
if ("0".equals(result2)) {
callBack.onSuccess(result2);
} else {
callBack.onFail(result2);
}
break;
case 3:
String result3 = (String) msg.obj;
Log.i("Hand",">>> Handle3处理请求完成   当前处理结果："+result3);
if ("结果3".equals(result3)) {
callBack.onSuccess(result3);
} else {
callBack.onFail(result3);
}
break;
default:
break;
}
}
};
BaseHandler.CallBack callBack;

public void request1(BaseHandler.CallBack<Integer> callBack) {
this.callBack = callBack;
handler.postDelayed(new Runnable() {
@Override
public void run() {
Message msg = Message.obtain();
msg.what = 1;
msg.obj = 1;
handler.sendMessage(msg);
}
}, 1000);
}

public void request2(BaseHandler.CallBack<String> callBack) {
this.callBack = callBack;
handler.postDelayed(new Runnable() {
@Override
public void run() {
Message msg = Message.obtain();
msg.what = 2;
msg.obj = "0";
handler.sendMessage(msg);
}
}, 2000);
}

public void request3(BaseHandler.CallBack<String> callBack) {
this.callBack = callBack;
handler.postDelayed(new Runnable() {
@Override
public void run() {
Message msg = Message.obtain();
msg.what = 3;
msg.obj = "结果3";
handler.sendMessage(msg);
}
}, 3000);
}
}

4、调用

BaseHandler<Void, Integer> handler1 = new Handler1();
BaseHandler<Integer, String> handler2 = new Handler2();
BaseHandler<String, String> handler3 = new Handler3();
handler1.nextHandler = handler2;
handler2.nextHandler = handler3;
handler1.handle();

5、运行结果

Handler1 开始请求request

Handle1处理请求完成 当前处理结果：1

Handler2 开始请求request

Handle1处理请求完成 当前处理结果：0

Handler3 开始请求request

Handle3处理请求完成 当前处理结果：结果3

重写handleSucess Handler3不再向后传递

三 要点

1 Handler只要设置了nextHandler对象，默认向下传递

2 整个链式请求：链首以handler方法开始，链尾以重写handlerSuccess方法结束

3 request方法中要调用其参数callBack的onSuccess和onFail方法，注意不是handlerSuccess方法

四 拓展使用

Android中：一般处理结果我们还可以通过接口使其与Activity耦合，刷新界面

1接口：

public interface ICheckDzqmyd {
void sign();
void unSign();
}

2 Handler

public class CheckOtcDzqmydHandler extends BaseHandler<Void, Void> {

private ICheckDzqmyd iCheckDzqmyd;

public CheckOtcDzqmydHandler(ICheckDzqmyd iCheckDzqmyd) {
this.iCheckDzqmyd = iCheckDzqmyd;
}

@Override
public void handleSuccess(Void lastResult, Void result) {
iCheckDzqmyd.sign();
}

@Override
public void handleFail(Void lastResult, Void result) {
iCheckDzqmyd.unSign();
}

@Override
public void request(Void lastResult, final CallBack<Void> callBack) {
if(具体业务逻辑判断){
callBack.onSuccess(null);
}else{
callBack.onFail(null);
}
}
}

3 Activity实现接口(回调刷新UI)

Activity implements ICheckDzqmyd {

@Override
public void sign() {
goBuy();
}

@Override
public void unSign() {
}
}

这种逻辑在Android中是非常常见的

五 优点

1、使用简单，业务逻辑清晰，每个Handler要处理的内容类似；Activity中的判断被抽取出来了

2、接口耦合，拓展性强

3、封装性强，每一个Handler可以复用