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

来源：互联网发布：网络虚拟信用卡申请编辑：程序博客网时间：2024/06/08 05:38

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可以复用

阅读全文

1 0