责任链模式

客官°小女子只卖身不卖艺 2022-05-08 02:04 243阅读 0赞

在公众号的前面我们说策略模式的时候，我们说各种策略的对象和一个行为随着策略对象改变而改变的。换句话说，针对客户端传来不同的参数进行实例不同策略的对象，也就是说保证了客户端和服务端的解耦。

而责任链模式是为客户端的请求创建了一个接收者对象的链，也就是处理这个请求的对象有一串，如果一个对象不能处理，那么串上的其他对象继续处理。

> 责任链模式（Chain of Responsibility Pattern）为请求创建了一个接收者对象的链。这种模式给予请求的类型，对请求的发送者和接收者进行解耦。这种类型的设计模式属于行为型模式。
> 
> 在这种模式中，通常每个接收者都包含对另一个接收者的引用。如果一个对象不能处理该请求，那么它会把相同的请求传给下一个接收者，依此类推。

因为工作中用到那么几次策略模式，在看责任链模式的时候，我觉的策略模式也能解决不明确的请求啊，因为通过反射我能取到所以实现策略接口的类，然后遍历......遍历。想到这里的时候，我就明白了，每次都遍历合适吗？不合适。而责任链就不一样了，对于不明确的请求，传递给下一个，最坏的情况也是遍历一下，但是要比每次都遍历合适。而我又想到什么叫不明确的请求？比如okhttp中的拦截器配置，如果你是okhttp框架的开发人员，你不知道用户会去拦截什么路径，这个时候责任链模式就体现它的作用。

我们要如何实现一个责任链呢？我想它既然是链，那就是链表了，我们来写一个简单的单链表

class Linked<T> {
        public T data;
        public Linked<T> next;
    
        public Linked(T data) {
            this.data = data;
        }
    
        public static void main(String[] args) {
            Linked<Integer> linked = new Linked<>(1);
            linked.next = new Linked<>(2);
            System.out.println(linked.data);
            System.out.println(linked.next.data);
        }
    }

那责任链呢？

abstract class Handler {
    
        protected Handler nextHandler;
    
    
        public Handler getNextHandler() {
            return nextHandler;
        }
    
        public void setNextHandler(Handler nextHandler) {
            this.nextHandler = nextHandler;
        }
    
        //处理请求
        public abstract void handleRequest(int request);
    
    
    }

这个抽象方法你就可以看到一个责任链，其中handleRequest是请求的处理方法，实现这个抽象类必须要实现这个方法，对于不能处理的请求，调用getNextHandler方法返回关联的Handler，然后再执行这个关联Handler的handleRequest方法，如果关联的Handler对象不能处理，那么调用关联的Handler对象关联的Handler的对象，有点绕了，用链表来说就是一个节点不行，就去调用下一个节点，依次往关联的节点调用。既然链子出来了，那么我们写两个实现类，一个处理参数大于0的情况，一个处理小于0的情况。

class HandlerA extends Handler {
        @Override
        public void handleRequest(int request) {
            if (request > 0) {
                System.out.println(">0");
            } else {
                  nextHandler.handleRequest(request);
    //            Ann.invoke(getClass().getClassLoader(), request);
            }
        }
    }
    
    class HandlerB extends Handler {
    
        @Override
        public void handleRequest(int request) {
            if (request < 0) {
                System.out.println("<0");
            } else {
                System.out.println("下一个处理");
                if (nextHandler != null)
                    nextHandler.handleRequest(request);
                else
                    System.out.println("没有下一个处理者了");
            }
        }
    }

HandlerA是处理大于0的情况，HandlerB是处理小于0的情况。这里为什么不考虑0的情况，因为如果你不确定到最后一个处理者能一定处理请求，最好在最后一个请求处理者加一个判断是否还有下一操作者（这里假设0是我们无法处理的，在B的时候做一次判断）那么如何执行呢？

public static void main(String[] args) {
            Handler handlerA = new HandlerA();
            Handler handlerB = new HandlerB();
            handlerA.setNextHandler(handlerB);
            handlerA.handleRequest(-1);
        }

如果你HandlerB关联了A，handlerB.setNextHandler(handlerA);会形成一个环，那么在你使用handleRequest的参数为0的时候，就会无限循环下去，导致stackoverflowerror异常出现。所以要注意死循环调用。

在实际的工作中，如果链过长，七八个也够呛（没遇到过，所以我不确定链会不会过长），因为我们每一个处理者都要setNextHandler。够麻烦的吧。

怎么处理呢？还记得注解吗？我们定义一个注解Level，然后在每一个实现类上面配置级别，我们制定一个规则，如果级别1无法处理，那么就级别2的去处理，级别2无法处理就级别3处理。

@Retention(RetentionPolicy.RUNTIME)
    @Target(ElementType.TYPE)
    @interface Level {
        int level() default 0;
    }

我们在上面的实现类上面写上注解

@Level(level = 1)
    class HandlerA extends Handler {
        @Override
        public void handleRequest(int request) {
            if (request > 0) {
                System.out.println(">0");
            } else {
                Ann.invoke(getClass().getClassLoader(), request);
            }
        }
    }
    
    @Level(level = 2)
    class HandlerB extends Handler {
    
        @Override
        public void handleRequest(int request) {
            if (request < 0) {
                System.out.println("<0");
            } else {
                if (nextHandler != null)
                    nextHandler.handleRequest(request);
                else
                    System.out.println("无法处理");
            }
        }
    }

其中Ann.invoke方法是关键，如果request<0调用这个方法，根据注解的级别去加载相应的下一个处理者

class Ann {
        static void invoke(ClassLoader classLoader, int request) {
            Class<HandlerA> claszz = HandlerA.class;
            Level level = claszz.getAnnotation(Level.class);
            int levelVal = level.level();
            List<Class<? extends Handler>> list = new ArrayList<>();
            try {
                File[] file = new File(classLoader.getResource("").toURI()).listFiles(new FileFilter() {
                    @Override
                    public boolean accept(File pathname) {
                        if (pathname.getName().endsWith(".class")) {//我们只扫描class文件
                            return true;
                        }
                        return false;
                    }
                });
                Class<Handler> clazz2 = (Class<Handler>) classLoader.loadClass(Handler.class.getName());
                for (int i = 0; i < file.length; i++) {
                    //载入包下的类
                    Class<?> clazz = classLoader.loadClass(file[i].getName().replace(".class", ""));
    //                System.out.println(i);
                    //判断是否是Handler的实现类并且不是它本身，满足的话加入到策略列表
                    if (Handler.class.isAssignableFrom(clazz) && clazz != clazz2) {
    //                    System.out.println(i);
                        list.add((Class<? extends Handler>) clazz);
                    }
                }
                for (Class<? extends Handler> classzz : list) {
                    Level level1 = null;
                    Annotation[] annotations = classzz.getAnnotations();
                    if (annotations == null || annotations.length == 0)
                        return;
                    for (int i = 0; i < annotations.length; i++) {
                        if (annotations[i] instanceof Level) {
                            level1 = (Level) annotations[i];
                        }
                    }
                    if (level1.level() == levelVal + 1) {
                        classzz.newInstance().handleRequest(request);
                    }
                }
            } catch (URISyntaxException e) {
                System.out.println("没找到文件");
                e.printStackTrace();
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (InstantiationException e) {
                e.printStackTrace();
            }
        }
    }

其中最最核心的就是下面这个方法

classzz.newInstance().handleRequest(request);

上面一堆代码就是为了找到Level等于2的这个calsszz然后去执行它的方法。而客户端只需要这样做：

public static void main(String[] args) {
            Handler handlerA = new HandlerA();
            handlerA.handleRequest(-1);
        }

也就是说通过注解，我们在只需要传递Level等于1的类的实例，其他的就交给 invoke这个方法处理。

说到这里我想对于责任链模式你已经有了一定的了解，那么接下来我们再说一下概念性的东西：

责任链模式：（）

**意图：**避免请求发送者与接收者耦合在一起，让多个对象都有可能接收请求，将这些对象连接成一条链，并且沿着这条链传递请求，直到有对象处理它为止。

**主要解决：**职责链上的处理者负责处理请求，客户只需要将请求发送到职责链上即可，无须关心请求的处理细节和请求的传递，所以职责链将请求的发送者和请求的处理者解耦了。

**何时使用：**在处理消息的时候以过滤很多道。

**如何解决：**拦截的类都实现统一接口。

**关键代码：**Handler 里面聚合它自己，在 HanleRequest 里判断是否合适，如果没达到条件则向下传递，向谁传递之前 set 进去。