设计模式--责任链(职责链)模式

学校OA系统的采购审批项目，需求是:

1. 采购员采购教学器材。
2. 如果金额小于等于5000，由教学主任审批。
3. 如果金额小于等于10000，由院长审批。
4. 如果金额小于等于30000，由副校长审批。
5. 如果金额超过30000，由校长审批。

请设计程序完成采购审批项目。

传统方案(类图)如下：

传统方案分析以及带来的问题：

1. 传统方案是：接收到一个采购请求后，根据采购金额来调用对应的Approve审批人来完成审批。
2. 传统方案分析：客户端会使用到分支判断(比如switch)来对不同的采购请求处理。这样就存在问题：

• 如果每个审批人的审批金额发生了变化，客户端也需要变化。
• 客户端必须明确的知道有多少个审批级别和访问。

1. 这样，对一个采购请求处理和Approver审批人会存在强烈的耦合关系，不利于代码的维护和扩展。
2. 解决方案：责任链模式。

责任链模式（Chain of Responsibility Pattern）介绍：

1. 责任链模式（Chain of Responsibility Pattern）又叫责任链，为请求创建一个接收者对象的链条（示意图），这种模式对请求的发送者和接受者解耦。
2. 责任链模式通常每个接收者都包含了对另一个接收者的引用。如果该对象不能接收请求，则会把相同的请求传给下一个接收者，以此类推。
3. 责任链模式也是属于行为模式。

责任链模式类图：

对原理类图的说明即责任链模式的角色和职责：

1. 使得多个对象都有机会处理请求，从而避免请求的发送者和接收者之间发生耦合关系，将这个对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它为止。
2. Handler：抽象的处理者，定义了一个处理请求的接口和方法，它是一个接口或者一个抽象类。
3. AbstractHandler：抽象类实现了Handler，同时含有另外一个handler对象。
4. ConcreteHandler：是具体的处理者，它处理它负责的请求，他还可以访问它的后继者(即下一个处理者)。如果可以处理当前请求则自己处理，如果不能则将该请求交给下一个处理者处理，从而形成一个职责链。
5. Request:含有多个属性，表示一个请求。

责任链模式解决学校采购问题：

1. URL类图:

1. 实现代码：

package com.xia.designmode.study.chainofresponsibilitypattern;

/**

* 责任链模式--处理接口(自己加的)

* */

public interface Approver {

/*

* 处理请求方法，得到一个请求，处理是由具体实现类来完成。

* */

public void processRequest(PurchaseRequest purchaseRequest);

}

package com.xia.designmode.study.chainofresponsibilitypattern;

/**

* 责任链模式--抽象处理类角色

* */

public abstract class AbstractApprover implements Approver {

private Approver nextApprover;

private String name;

public AbstractApprover(String name) {

this.name=name;

}

/*

*下一个处理者

* */

public void setNextApprover(Approver nextApprover) {

this.nextApprover = nextApprover;

}

public Approver getNextApprover() {

return nextApprover;

}

public String getName() {

return name;

}

}

package com.xia.designmode.study.chainofresponsibilitypattern;

import java.math.BigDecimal;

/**

* 责任链模式--具体处理类角色

* */

public class CollegeApprover extends AbstractApprover{

public CollegeApprover(String name) {

super(name);

}

@Override

public void processRequest(PurchaseRequest purchaseRequest) {

//处理请求,如果金额小于等于10000，则处理

BigDecimal price=purchaseRequest.getPrice();

if(price.compareTo(new BigDecimal(10000))<=0) {

System.out.println("请求编号number："+purchaseRequest.getNumber()+"由"+this.getName() + "处理");

}else{

this.getNextApprover().processRequest(purchaseRequest);

}

}

}

package com.xia.designmode.study.chainofresponsibilitypattern;

import java.math.BigDecimal;

/**

* 责任链模式--具体处理类角色

* */

public class DepartmentApprover extends AbstractApprover{

public DepartmentApprover(String name) {

super(name);

}

@Override

public void processRequest(PurchaseRequest purchaseRequest) {

//处理请求,如果金额小于等于5000，则处理

BigDecimal price=purchaseRequest.getPrice();

if(price.compareTo(new BigDecimal(5000))<=0) {

System.out.println("请求编号id："+purchaseRequest.getId()+"由"+this.getName() + "处理");

}else{

this.getNextApprover().processRequest(purchaseRequest);

}

}

}

package com.xia.designmode.study.chainofresponsibilitypattern;

import java.math.BigDecimal;

/**

* 责任链模式--具体处理类角色

* */

public class HeadmasterApprover extends AbstractApprover{

public HeadmasterApprover(String name) {

super(name);

}

@Override

public void processRequest(PurchaseRequest purchaseRequest) {

//其他人处理不了的，校长来处理。

System.out.println("请求编号id："+purchaseRequest.getId()+"由"+this.getName() + "处理");

}

}

package com.xia.designmode.study.chainofresponsibilitypattern;

import java.math.BigDecimal;

/**

*责任链模式-Request请求角色

*

* */

public class PurchaseRequest {

private String type; //请求类型

private String number;//请求单号

private BigDecimal price;//价钱

private int id;//id号

public PurchaseRequest(String type, String number, BigDecimal price, int id) {

this.type = type;

this.number = number;

this.price = price;

this.id = id;

}

public PurchaseRequest(String type, String number, BigDecimal price) {

this.type = type;

this.number = number;

this.price = price;

}

public String getType() {

return type;

}

public String getNumber() {

return number;

}

public BigDecimal getPrice() {

return price;

}

public int getId() {

return id;

}

}

package com.xia.designmode.study.chainofresponsibilitypattern;

import java.math.BigDecimal;

/**

* 责任链模式--具体处理类角色

* */

public class VicePresidentApprover extends AbstractApprover{

public VicePresidentApprover(String name) {

super(name);

}

@Override

public void processRequest(PurchaseRequest purchaseRequest) {

//处理请求,如果金额小于等于10000，则处理

BigDecimal price=purchaseRequest.getPrice();

if(price.compareTo(new BigDecimal(30000))<=0) {

System.out.println("请求编号id："+purchaseRequest.getId()+"由"+this.getName() + "处理");

}else{

this.getNextApprover().processRequest(purchaseRequest);

}

}

}

责任链模式在Spring MVC框架中应用的源码分析：

1. SpringMVC中HandlerExceptionChain类就使用到了责任链模式。
2. SpringMVC请求流程简图。

1. 代码分析+Debug源码+说明。

protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {

HandlerExecutionChain mappedHandler = null;

mappedHandler = getHandler(processedRequest);//获取HandlerExecutionChain对象。

//在mappedHandler.applyPreHandle方法内部获得HandlerInterceptor interceptor对象。

//调用了拦截器的interceptor.preHandle方法

if (!mappedHandler.applyPreHandle(processedRequest, response)) {

return;

}

mappedHandler.applyPostHandle(processedRequest, response, mv);

//mappedHandler.applyPostHandle方法中再次获得获取到拦截器对象HandlerInterceptor interceptor，并调用拦截器的interceptor.postHandle方法。

for (int i = interceptors.length - 1; i >= 0; i--) {

HandlerInterceptor interceptor = interceptors[i];

interceptor.postHandle(request, response, this.handler, mv);

}

//在mappedHandler.applyPreHandle方法中还调用了triggerAfterCompletion方法，该方法中还调用了拦截器处理： HandlerInterceptor interceptor = interceptors[i];

try {

interceptor.afterCompletion(request, response, this.handler, ex);

}

catch (Throwable ex2) {

logger.error("HandlerInterceptor.afterCompletion threw exception", ex2);

}

void triggerAfterCompletion(HttpServletRequest request, HttpServletResponse response, @Nullable Exception ex)

throws Exception {

HandlerInterceptor[] interceptors = getInterceptors();

if (!ObjectUtils.isEmpty(interceptors)) {

for (int i = this.interceptorIndex; i >= 0; i--) {

HandlerInterceptor interceptor = interceptors[i];

try {

interceptor.afterCompletion(request, response, this.handler, ex);

}

catch (Throwable ex2) {

logger.error("HandlerInterceptor.afterCompletion threw exception", ex2);

}

}

}

}

说明：

1. Spring MVC请求的流程中，执行了拦截器的相关方法interceptor.postHandle等等。
2. 在处理SpringMVC请求时，使用到了职责链模式以及前面讲到的适配器模式。
3. HandlerExceptionChain主要负责的是请求拦截器的执行和请求处理，但是它本身不处理请求，只是将请求分配给链上注册的处理器执行，这是责任链的执行方式，减少了责任链和处理逻辑之间的耦合，规范了流程。
4. HandlerExceptionChain维护了HandlerInterceptor[](拦截器数组)，可以向其中注册相应的拦截器。

责任链模式注意事项和细节：

1. 将请求和处理分开，实现解耦，提高系统的灵活性。
2. 简化了对象，使得对象不需要知道链的结构。

缺点：

1. 性能受到了影响，特别是在链比较长的时候，因此需要控制链中最大节点数量。通常在Handler中设置一个最大节点数量，在setNext()方法中判断是否已经超过阈值，超过则不允许该链条建立，避免过长的链条无意识的破坏系统性能。
2. 调试不方便，采用了类似递归的方式，调试时逻辑可能比较复杂。

适用场景：

1. 有多个对象可以处理多个请求时，比如多级请求、请假/加薪等审批流程；
2. java web中tomcat的encoding处理、拦截器；