定义
责任链模式就是创建多个处理请求的对象，这些对象按照某种顺序组成一条链，（就像链表一样，有个指针可以找到后继）前一个对象保存了下一个对象的实例引用，可以找到下一个对象，请求从头部开始，在这条链上传递，谁能处理就立即处理，请求结束，直到链的结尾。 就像公司审批请假一样，有时候需要部门主管审批完就可以，有时候还需要hr审批通过才行。比如struct框架中的过滤器，也是责任链模式的应用。
ERP系统中不同优先级的订单处理就可以用责任链模式。例如订单分为预售提前单，普通订单以及紧急发货的订单，创建不同的处理器进行不同类型订单的处理，然后按照优先级将这些处理器组成责任链，所有订单都经过这条责任链，根据订单等级的不同，只有对应等级的处理器才能处理对应等级的订单，这就跟有没有权限是一个道理。
UML
责任链模式涉及两个角色：
抽象处理器角色(Handler)：持有下一个处理器的对象引用，定义了处理请求的接口，提供了设置下一个处理器的方法。
具体处理器角色(ConcreteHandler)：实现或者继承抽象处理器角色。
订单的责任链
按照如上所说，对三种优先级不同订单的处理，我们至少需要定义一个抽象处理器，然后定义三个具体处理器，将这三个处理器按优先级组成责任链，然后在业务逻辑中，将订单交给责任链处理。
抽象处理器
/**
* 抽象处理器角色
*/
public abstract class Handler {
private Handler nextHandler;
private Integer priority;
public Handler(Integer priority) {
this.priority = priority;
}
public void setHandler(Handler nextHandler) {
this.nextHandler = nextHandler;
}
/**
* 处理订单请求的传递，如果是当前级别则调用solveOrder()方法处理，否则传递给上一级处理。
* @param order
*/
public final void handleOrder(Order order) {
if (order == null || order.getOrderId() == null) {
throw new RuntimeException("订单信息为空，无法处理");
}
if (order.getPriority() == null) {
throw new IllegalArgumentException("订单"+order.getOrderId()+"没有设置处理级别");
}
if (order.getPriority().equals(this.priority)) {
this.solveOrder(order);
} else {
if (this.nextHandler != null) {
System.out.println(this.getClass().getName()+"无法处理订单"+order.getOrderId()+",传递给高一级的handler处理");
nextHandler.handleOrder(order);
} else {
throw new RuntimeException("没有Handler能够处理当前等级的订单");
}
}
}
/**
* 定义处理订单的方法，由子类实现，处理不同等级的订单
*/
public abstract void solveOrder(Order order);
}
public class Order {
//订单id
private Long orderId;
//订单优先级
private Integer priority;
public Long getOrderId() {
return orderId;
}
public void setOrderId(Long orderId) {
this.orderId = orderId;
}
public Integer getPriority() {
return priority;
}
public void setPriority(Integer priority) {
this.priority = priority;
}
}
假设订单中包含订单id和订单优先级。
在抽象处理器中，我们定义了下一个处理器nextHandler，并定义set方法进行设置，然后定义了一个处理订单的统一方法，子类调用时都是这个入口，对订单信息进行合法性校验，并判断订单的优先级，当前处理器能否处理，如果无法处理就交给下一个处理器，如果没有下一个处理器就抛出异常。
具体处理器
/**
* 定义一个Map容器，保存所有订单处理器
*/
public class OrderHandlerMap {
public static Map<Integer, Handler> map = new HashMap<>();
}
/**
* 预售订单的处理器，预售订单的优先级最低
*/
@Component
public class PreSellOrderHandler extends Handler implements InitializingBean{
/**
* 设置能够处理的订单优先级=1
*/
PreSellOrderHandler() {
super(1);
}
@Override
public void solveOrder(Order order) {
System.out.println(this.getClass().getName()+"开始处理订单"+order.getOrderId());
}
@Override
public void afterPropertiesSet() {
OrderHandlerMap.map.put(1,this);
}
}
/**
* 正常订单的处理器，设置优先级为2
*/
@Component
public class NormalOrderHandler extends Handler implements InitializingBean{
/**
* 设置能够处理的订单优先级=2
*/
NormalOrderHandler() {
super(2);
}
@Override
public void solveOrder(Order order) {
System.out.println(this.getClass().getName()+"开始处理订单"+order.getOrderId());
}
@Override
public void afterPropertiesSet() {
OrderHandlerMap.map.put(2, this);
}
}
/**
* 紧急发货订单的处理器，设置优先级最高=3
*/
@Component
public class UrgentOrderHandler extends Handler implements InitializingBean{
/**
* 设置能够处理的订单优先级=3
*/
UrgentOrderHandler() {
super(3);
}
@Override
public void solveOrder(Order order) {
System.out.println(this.getClass().getName()+"开始处理订单"+order.getOrderId());
}
@Override
public void afterPropertiesSet() {
OrderHandlerMap.map.put(3,this);
}
}
定义了三个优先级不同的订单处理器，并在spring容器启动时实例化一个处理器对象放到Map容器中。
订单处理类
假设现在来了一个订单，责任链要怎么处理呢？
@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes=Application.class)// 指定spring-boot的启动类
public class OrderHandlerTest1 {
@Test
public void test() {
Map<Integer, Handler> handlerMap = OrderHandlerMap.map;
if (handlerMap.isEmpty()) {
throw new RuntimeException("spring中没有注册任何处理器");
}
//获取最低优先级的处理器
Handler handler = null;
for (Map.Entry<Integer,Handler> entry : handlerMap.entrySet()) {
handler = entry.getValue();
if (handler !=null) {
break;
}
}
//测试预售提前单的责任链处理
Order preSellOrder = new Order();
preSellOrder.setOrderId(123L);
preSellOrder.setPriority(1);
handler.handleOrder(preSellOrder);
//测试正常单的责任链处理
Order normalOrder = new Order();
normalOrder.setOrderId(456L);
normalOrder.setPriority(2);
handler.handleOrder(normalOrder);
//测试紧急发货订单的责任链处理
Order urgentOrder = new Order();
urgentOrder.setOrderId(789L);
urgentOrder.setPriority(3);
handler.handleOrder(urgentOrder);
//测试未知等级的订单能否处理
Order unknownOrder = new Order();
unknownOrder.setOrderId(111L);
unknownOrder.setPriority(9);
handler.handleOrder(unknownOrder);
}
@Before
public void before(){
Map<Integer, Handler> handlerMap = OrderHandlerMap.map;
if (handlerMap.isEmpty()) {
throw new RuntimeException("spring中没有注册任何处理器");
}
//先按照优先级排个序
List<Map.Entry<Integer,Handler>> list = new ArrayList<>(handlerMap.entrySet());
Collections.sort(list, new Comparator<Map.Entry<Integer, Handler>>() {
@Override
public int compare(Map.Entry<Integer, Handler> o1, Map.Entry<Integer, Handler> o2) {
return o1.getKey().compareTo(o2.getKey());
}
});
List<Integer> keys = new ArrayList<>(handlerMap.keySet());
Collections.sort(keys);
//设置处理器的更高一级的处理器，keys已经是按照优先级排好序的
for (int i=0; i<keys.size(); i++) {
Integer key = keys.get(i);
Handler handler = handlerMap.get(key);
if (i < keys.size()-1) {
Integer nextKey = keys.get(i + 1);
if (nextKey != null) {
Handler nextHandler = handlerMap.get(nextKey);
handler.setHandler(nextHandler);
}
}
}
}
}
我们在测试之前，先将Map中的处理器组成一个按照优先级排列的处理器责任链，并需要设置当前处理器的下一个处理是谁。然后在测试方法中创建了四种不同优先级的订单，都交给责任链的第一个处理器进行处理，但是真正能够处理该订单的只有对应等级的处理器。运行结果如下，第一个处理器就可以处理订单123，第二个处理器处理订单456，第三个处理器处理订单789，由于订单111等级未知，没有处理器可以处理，就报错。
