Java设计模式（四）责任链模式
在公众号的前面我们说策略模式的时候，我们说各种策略的对象和一个行为随着策略对象改变而改变的。换句话说，针对客户端传来不同的参数进行实例不同策略的对象，也就是说保证了客户端和服务端的解耦。
而责任链模式是为客户端的请求创建了一个接收者对象的链，也就是处理这个请求的对象有一串，如果一个对象不能处理，那么串上的其他对象继续处理。
责任链模式（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、可动态指定一组对象处理请求。
小程序更新题库：进入小程序
1.知道jdk1.7中try-with-resources语法糖？
2.notify()与notifyAll()的区别？
3.常用的RPC框架？
4.TCP如何保证安全性？
5.CSRF是什么