责任链模式

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

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

责任链模式（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 进去。

优点： 1、降低耦合度。它将请求的发送者和接收者解耦。 2、简化了对象。使得对象不需要知道链的结构。 3、增强给对象指派职责的灵活性。通过改变链内的成员或者调动它们的次序，允许动态地新增或者删除责任。 4、增加新的请求处理类很方便。

缺点： 1、不能保证请求一定被接收。 2、系统性能将受到一定影响，而且在进行代码调试时不太方便，可能会造成循环调用。 3、可能不容易观察运行时的特征，有碍于除错。

使用场景： 1、有多个对象可以处理同一个请求，具体哪个对象处理该请求由运行时刻自动确定。 2、在不明确指定接收者的情况下，向多个对象中的一个提交一个请求。 3、可动态指定一组对象处理请求。