Android责任链模式

责任链模式介绍

责任链模式指的是，当一个请求可能会经过各个对象的处理，并且每一个对象都可能终止该请求或者将该请求继续往下一个对象传递。这些对象形成了一条链，并且每个对象都有机会去处理该请求，直至该请求被处理掉。

责任链的使用场景

责任链有很多使用场景，例如Android中的OKHttp框架，又或者举个例子，当我们拿着一张报销单请求报销时，我们的请求过程是：

1.直属领导审批，如果报销金额小于1000，报销通过，若大于1000，将请求转给上层领导继续审批；

2.部门领导审批，如果报销金额小于10000，报销通过，若大于10000，将请求转给老板继续审批；

3.老板审批，如果报销金额小于100000，报销通过，若大于100000，报销金额太高，驳回。

在代码中使用具体的责任链模式

1.首先定义请求以及响应

/**
 * 报销请求
 **/
public final class Request {

    private int account;
    private String msg;

    public int getAccount() {
        return account;
    }

    public void setAccount(int account) {
        this.account = account;
    }

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }
}

/**
 * 请求响应
 **/
public final class Response {
    private boolean transit;
    private String responseMsg;

    public boolean isTransit() {
        return transit;
    }

    public void setTransit(boolean transit) {
        this.transit = transit;
    }

    public String getResponseMsg() {
        return responseMsg;
    }

    public void setResponseMsg(String responseMsg) {
        this.responseMsg = responseMsg;
    }
}

2.接下来定义我们的请求处理对象，即是我们的直属领导、经理、boss,他们实现同一个接口

public interface Interceptor {

    Response intercept(Chain chain);

  /**
   * 由于我们的请求是以链式的方式进行的，这里定义了一个链用于传递请求
   **/
    interface Chain{
        Request request();
        //传递请求
        Response proceed(Request request);
    }
}

分别定义请求处理者，LeaderInterceptor、ManagerInterceptor、BossInterceptor（请求必须有人来终结）

//请求一级处理者
public class LeaderInterceptor implements Interceptor {

    @Override
    public Response intercept(Chain chain) {
        Request request = chain.request();
        Response response = new Response();
        if (request.getAccount() < 1000) {
            response.setResponseMsg("pass by leader");
            response.setTransit(true);
            return response;
        }
        return chain.proceed(request);
    }
}

//二级处理者
public class ManagerInterceptor implements Interceptor {
    @Override
    public Response intercept(Chain chain) {
        Request request = chain.request();
        Response response = new Response();
        if (request.getAccount() < 10000) {
            response.setResponseMsg("pass by manager");
            response.setTransit(true);
            return response;
        }
        return chain.proceed(request);
    }
}

//请求终结者
public class BossInterceptor implements Interceptor {

    @Override
    public Response intercept(Chain chain) {
        Request request = chain.request();
        Response response = new Response();
        if (request.getAccount() < 100000) {
            response.setResponseMsg("pass by boss");
            response.setTransit(true);
            return response;
        }
        response.setResponseMsg("refuse by boss");
        response.setTransit(false);
        return response;
    }
}

3.接下来实现责任链来处理这个请求，基本思想就是，从链中一个个的取出处理者，如被该处理者处理了，就返回结果，否则再传递给下一个处理者，直至请求被处理完毕

public class RealInterceptorChain implements Interceptor.Chain {
    private static final String TAG = "RealInterceptorChain";
    private List<Interceptor> interceptors;
    private Request request;
    private int index;


    public RealInterceptorChain(List<Interceptor> interceptors, Request request, int index) {
        this.interceptors = interceptors;
        this.request = request;
        this.index = index;
    }

    @Override
    public Request request() {
        return request;
    }

    @Override
    public Response proceed(Request request) {
        Response response = new Response();
        if (index >= interceptors.size()) {
            Log.e(TAG, "out of size");
            return null;
        }
        if (interceptors.get(index) == null) {
            Log.e(TAG, "interceptor " + interceptors.get(index) + "is null");
            return response;
        }
        Interceptor interceptor = interceptors.get(index); //取出当前处理者
        RealInterceptorChain next = new RealInterceptorChain(interceptors, request, index + 1); //获取下一个对象者
        response = interceptor.intercept(next);
        if (response == null) {
            Log.e(TAG, "interceptor " + interceptor + " return null");
        }

        return response;
    }
}

4.最后来看看如何使用这个链呢,使用很简单，实例化责任链以及请求，给责任链添加处理对象，然后再调用责任链的处理方法即可。

public class ApplyAccountUtil {
   /**
     * 给责任链添加处理者以及请求，处理者的顺序可以打乱，但是打乱之后处理的结果就不同
     * 了，从第一个处理者开始处理。
     **/
    private static Response addInterceptorChain(Request request) {
        List<Interceptor> interceptors = new ArrayList<>();
        interceptors.add(new LeaderInterceptor());
        interceptors.add(new ManagerInterceptor());
        interceptors.add(new BossInterceptor());
        Interceptor.Chain chain = new RealInterceptorChain(interceptors, request, 0);
        return chain.proceed(request);  
    }
    public static void main(String[] args) {
        Request request = new Request();
        request.setAccount(100000);
        Response response = addInterceptorChain(request);
    }

}

如上，一个报销请求就从直属领导之手经经理、boss处理，直至请求被通过或者被驳回，在实际生产环境下有很多类似的场景，都可以借鉴责任链模式。

扫描二维码关注公众号，回复： 5796462 查看本文章