责任链模式

作者: 涛涛123759 | 来源:发表于2021-08-20 15:06 被阅读0次

Android知识总结

1、定义

一个请求沿着一条“链”传递，直到该“链”上的某个处理者处理它为止。实际上就是一个递归。

2、介绍

责任链模式属于行为型模式。
多个对象中，每个对象都持有下一个对象的引用，这就构成了链这种结构。
一个请求通过链的头部，一直往下传递到链上的每一个结点，直到有某个结点对这个请求做出处理为止，这就是责任链模式。
责任链模式一般分为处理者与请求者。具体的处理者分别处理请求者的行为。

3、UML类图

角色说明：

Handler（抽象处理者）：抽象类或者接口,定义处理请求的方法以及持有下一个Handler的引用.
ConcreteHandler1,ConcreteHandler2（具体处理者）：实现抽象处理类,对请求进行处理,如果不处理则转发给下一个处理者.
Client (客户端):即要使用责任链模式的地方。

4、实现

抽象类

public abstract class AbstractHandler {
    /**
     * 下一个节点
     */
    protected AbstractHandler nextHandler;

    /**
     * 处理时间
     *
     * @param request 条件
     * @return
     */
    public abstract String handlerRequest(String request);

}

实现类

public class Handler1 extends AbstractHandler{

    @Override
    public String handlerRequest(String request) {
        if (request.equals("handler1")){
            return "handler1";
        } else {
            return "handler1 + " + nextHandler.handlerRequest(request);
        }
    }
}

public class Handler2 extends AbstractHandler{

    @Override
    public String handlerRequest(String request) {
        if (request.equals("handler2")){
            return "handler2";
        } else {
            return "handler2 + " + nextHandler.handlerRequest(request);
        }
    }
}

执行类

public class MainTest {
    public static void main(String[] args) {
        AbstractHandler handler1 = new Handler1();
        AbstractHandler handler2 = new Handler2();

        handler1.nextHandler = handler2;

        System.out.println(handler1.handlerRequest("handler2"));
    }
}

5、另一种实现方式

以送快递为例，单个快递员只负责某个片区的快递，若某个快递目的地不属于当前的片区，则交给下一个快递员来处理，直到有人处理为止。

创建抽象处理者

public abstract class AbstractHandler {
    /**
     * 下一节点上的处理者对象
     */
    protected AbstractHandler nextHandler;


    /**
     * 处理请求
     *
     * @param request
     */
    public void handleRequest(AbstractRequest request) {
        if (getHandlerLevel() == request.getRequestLevel()) {
            handle(request);
        } else {
            if (nextHandler != null) {
                nextHandler.handleRequest(request);
            } else {
                System.out.println("所有对象都不能处理该请求");
            }
        }
    }

    /**
     * 处理请求
     *
     * @param request 请求对象
     */
    public abstract void handle(AbstractRequest request);

    /**
     * 每个处理者具体处理请求对象的实现
     *
     * @return 处理级别
     */
    public abstract int getHandlerLevel();


    /**
     * 设置下一个处理者
     *
     * @param nextHandler
     */
    public void setNextHandler(AbstractHandler nextHandler) {
        this.nextHandler = nextHandler;
    }

}



public abstract class AbstractRequest {
    /**
     * 要处理的内容对象
     */
    private Object object;

    /**
     * 通过构造函数注入要处理的内容对象
     * @param object 要处理的内容对象
     */
    public AbstractRequest(Object object) {
        this.object = object;
    }
    /**
     * 获取要处理的内容对象
     * @return 要处理的内容对象
     */
    public Object getObject() {
        return object;
    }

    /**
     * 获取请求级别
     * @return 请求级别
     */
    public abstract int getRequestLevel();
}

创建具体处理者类

public class ConductHandler1 extends AbstractHandler {

    @Override
    public void handle(AbstractRequest request) {
        System.out.println("Handler1 handler request :"+request.getRequestLevel());
    }

    @Override
    public int getHandlerLevel() {
        return 1;
    }
}


public class ConductHandler2 extends AbstractHandler {

    @Override
    public void handle(AbstractRequest request) {
        System.out.println("Handler2 handler request :"+request.getRequestLevel());
    }

    @Override
    public int getHandlerLevel() {
        return 2;
    }
}

public class ConductRequest1 extends AbstractRequest {
    /**
     * 通过构造函数注入要处理的内容对象
     *
     * @param object 要处理的内容对象
     */
    public ConductRequest1(Object object) {
        super(object);
    }

    @Override
    public int getRequestLevel() {
        return 1;
    }
}


public class ConductRequest2 extends AbstractRequest{
    /**
     * 通过构造函数注入要处理的内容对象
     *
     * @param object 要处理的内容对象
     */
    public ConductRequest2(Object object) {
        super(object);
    }

    @Override
    public int getRequestLevel() {
        return 2;
    }
}

客户端测试

public class TextMan {

    public static void main(String[] argc){
        //不同级别的请求
        AbstractRequest request1 = new ConductRequest1("request 1");
        AbstractRequest  request2 = new ConductRequest2("request 2");

        //不同级别的处理者
        AbstractHandler handler1 = new ConductHandler1();
        AbstractHandler handler2 = new ConductHandler2();

        // 设置处理者的链式关系
        handler1.setNextHandler(handler2);

        // 总是从链子的首端发起请求
        handler1.handleRequest(request1);
        handler1.handleRequest(request2);
    }
}

6、应用场景

多个对象处理同一请求时，但是具体由哪个对象去处理需要运行时做判断。
具体处理者不明确的情况下，向这组对象提交了一个请求。

7. 优点

代码的解耦，请求者与处理者的隔离分开。
易于扩展，新增处理者往链上加结点即可。

8、缺点

责任链过长的话，或者链上的结点判断处理时间太长的话会影响性能，特别是递归循环的时候。
请求有可能遍历完链都得不到处理。

9. Android中的源码分析

Android中的事件分发机制就是类似于责任链模式，关于事件分发机制，这里先不详述了，先占个坑，后面另起文章说明。
另外，OKhttp中对请求的处理也是用到了责任链模式，有兴趣的可以去看下OKhttp的源码。后面有时间也会对OKhttp的源码进行分析。

9.1、模仿OkHttp实现一个拦截器

接口类

public interface Interceptor {
    String intercept(Chain chain);

    interface Chain {
        String request();
        String proceed(String request);
    }
}

工具类

public class RealInterceptorChain implements Interceptor.Chain {
    private List<Interceptor> interceptors;
    private String request;
    private int index;

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


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

    @Override
    public String proceed(String request) {
        RealInterceptorChain next = new RealInterceptorChain(interceptors, request, index + 1);
        Interceptor interceptor = interceptors.get(index);
        String response = interceptor.intercept(next);
        return response;
    }
}

实现接口类

public class HandlerInterceptor1 implements Interceptor {
    @Override
    public String intercept(Chain chain) {
        String request = chain.request();
        request = request + " ==> HandlerInterceptor1";
        String response = chain.proceed(request);
        response = response + "HandlerInterceptor1  ==> ";
        return response;
    }
}

public class HandlerInterceptor2 implements Interceptor{
    @Override
    public String intercept(Chain chain) {
        String request = chain.request();
        request = request + " ==> HandlerInterceptor2";
        String response = chain.proceed(request);
        response = response + "HandlerInterceptor2 ==> ";
        return response;
    }
}

public class HandlerInterceptor3 implements Interceptor {
    @Override
    public String intercept(Chain chain) {
        String request = chain.request();
        System.out.println(request + " ==> HandlerInterceptor3");
        return " HandlerInterceptor3 ==> ";
    }
}

执行

public class MainTest {
    public static void main(String[] args) {
        List<Interceptor> interceptors = new ArrayList<>();
        interceptors.add(new HandlerInterceptor1());
        interceptors.add(new HandlerInterceptor2());
        interceptors.add(new HandlerInterceptor3());
        RealInterceptorChain chain = new RealInterceptorChain(interceptors,
                "开始 ==> ", 0);
        String response = chain.proceed("请求 ==> ");
        System.out.println(response + "结束");
    }
}