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

Android移动架构汇总​​​​​​​
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可以复用