一、概念以及背景
责任链模式(Chain of Responsibility Pattern):责任链模式是一种创建处理对象序列（比如操作序列）的通用方案。一个处理对象可能需要在完成一些工作之后，将结果传递给另一个对象，这个对象接着做一些工作，再转交给下一个处理对象，以此类推。
简而言之，待处理的对象，需要经过好几个步骤的处理，形成一条链，一个步骤处理完之后，接着往下一个步骤继续处理。
本文涉及的代码在github上，点击 链接 可查看源码。
本文会用两种方式来实现责任链模式，第二种是用lambda表达式的方式来实现，参数行为化的方式实现。
本文所使用的场景如下：处理一封信，首先对会信的头部进行处理，然后会检查这份信的拼写有无错误，有的话把错误的单词修改过来，最后会对信的结尾进行处理。这样一来处理一封信就形成了一条链，先处理……，再处理……，最后处理……。
二、责任链模式
基于上面提到的场景，UML类图如下，责任链模式之所以能形成链，其核心是有一个抽象处理类，该抽象处理类会有一个字段（抽象处理者）被用来记录后续对象，即记录执行处理某个步骤的对象。然后该抽象处理类还有一个抽象方法，即handleWork抽象方法，每个处理步骤（链节点）都会实现该抽象方法，作为该步骤的处理逻辑，当然处理完之后还需要丢给下一个链节点处理。
- Handler抽象类，即抽象处理类，含有一个字段是抽象处理者successor，当然也有setSuccessor方法，用来设置下一个处理者，即本步骤/链节点处理完之后，传递给下一个处理者继续处理。handleWork抽象方法提供了实现不同的处理步骤，有不同的处理逻辑，这里的handle方法也起到了不少的作用，形成链，本链节点handleWork之后，判断自身是否还拥有下一处理者，有的话，下一处理者继续进行handle->handleWork直到处理结束，无处理者。
public abstract class Handler {
protected Handler successor;
public void setSuccessor(Handler successor) {
this.successor = successor;
}
abstract protected String handleWork(String input);
public String handle(String input) {
//本节点处理完之后返回下一节点
String nextNode = handleWork(input);
if (successor != null) {
return successor.handle(nextNode);
}
return nextNode;
}
}
- AddHeaderHandler类，信的头部处理器
public class AddHeaderHandler extends Handler{
@Override
protected String handleWork(String input) {
return "From Raoul, Mario and Alan: " + input;
}
}
- CheckSpellHandler类，检查信的拼写
public class CheckSpellHandler extends Handler{
@Override
protected String handleWork(String input) {
return input.replaceAll("labda", "lambda");
}
}
- AddFooterHandler类，信的结尾处理器
public class AddFooterHandler extends Handler{
@Override
protected String handleWork(String input) {
return input + " Kind regards";
}
}
public class ChainMain {
public static void main(String[] args) {
AddHeaderHandler addHeaderHandler = new AddHeaderHandler();
CheckSpellHandler checkSpellHandler = new CheckSpellHandler();
AddFooterHandler addFooterHandler = new AddFooterHandler();
addHeaderHandler.setSuccessor(checkSpellHandler);
checkSpellHandler.setSuccessor(addFooterHandler);
String test = addHeaderHandler.handle("labda");
System.out.println(test);
}
}
最后控制台输出这封处理过的信：
From Raoul, Mario and Alan: lambda Kind regards
三、责任链模式，行为参数化，lambda方式重构
这里用了Java8的Function
- Function
@FunctionalInterface
public interface Function {
R apply(T t);
}
- LambdaHandler
public class LambdaHandler {
public static Function addHeaderHandler() {
return (input) -> "From Raoul, Mario and Alan: " + input;
}
public static Function checkSpellHandler() {
return (input) -> input.replaceAll("labda", "lambda");
}
public static Function addFooterHandler() {
return (input) -> input + " Kind regards";
}
}
- ChainMain
public class ChainMain {
public static void main(String[] args) {
Function addHeaderHandler = LambdaHandler.addHeaderHandler();
Function checkSpellHandler = LambdaHandler.checkSpellHandler();
Function addFooterHandler = LambdaHandler.addFooterHandler();
String test = addHeaderHandler.andThen(checkSpellHandler).andThen(addFooterHandler).apply("labda");
System.out.println(test);
}
}
- 最后控制台输出这封处理过的信：
From Raoul, Mario and Alan: lambda Kind regards
起核心作用的是Function
我们可以看到，andThen方法的方法参数也是一个跟自身相同的函数式接口Function
Objects.requireNonNull(after);首先判断传入的参数不能为空，毕竟这是下一个处理步骤的实现处理逻辑，关键是(T t) -> after.apply(apply(t));这句代码起了作用，这里分为两步，第一步是先执行自身的apply(t)方法，即在当前步骤，先对节点进行处理，然后返回处理结果，接着是对节点（本步骤的处理结果）进行下一步的处理，即after.apply(apply(t))
@FunctionalInterface
public interface Function {
default Function andThen(Function after) {
Objects.requireNonNull(after);
return (T t) -> after.apply(apply(t));
}
}
当然节点的最后一个处理步骤，我们需要在最后返回的Function
String test = addHeaderHandler.andThen(checkSpellHandler).andThen(addFooterHandler).apply("labda");
本文如有不足之处，请指正或者提出好的建议｡◕‿◕｡谢谢。
参考资料：《Java8实战》