学校OA系统的采购审批项目，需求是:
1) 采购员采购教学器材。
2) 如果金额小于等于5000，由教学主任审批。
3) 如果金额小于等于10000，由院长审批。
4) 如果金额小于等于30000，由副校长审批。
5) 如果金额超过30000，由校长审批。
请设计程序完成采购审批项目。
传统方案(类图)如下：
传统方案分析以及带来的问题：
1） 传统方案是：接收到一个采购请求后，根据采购金额来调用对应的Approve审批人来完成审批。
2） 传统方案分析：客户端会使用到分支判断(比如switch)来对不同的采购请求处理。这样就存在问题：
一、 如果每个审批人的审批金额发生了变化，客户端也需要变化。
二、 客户端必须明确的知道有多少个审批级别和访问。
3） 这样，对一个采购请求处理和Approver审批人会存在强烈的耦合关系，不利于代码的维护和扩展。
4） 解决方案：责任链模式。
责任链模式（Chain of Responsibility Pattern）介绍：
1. 责任链模式（Chain of Responsibility Pattern）又叫责任链，为请求创建一个接收者对象的链条（示意图），这种模式对请求的发送者和接受者解耦。
2. 责任链模式通常每个接收者都包含了对另一个接收者的引用。如果该对象不能接收请求，则会把相同的请求传给下一个接收者，以此类推。
3. 责任链模式也是属于行为模式。
责任链模式类图：
对原理类图的说明即责任链模式的角色和职责：
1） 使得多个对象都有机会处理请求，从而避免请求的发送者和接收者之间发生耦合关系，将这个对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它为止。
2） Handler：抽象的处理者，定义了一个处理请求的接口和方法，它是一个接口或者一个抽象类。
3） AbstractHandler：抽象类实现了Handler，同时含有另外一个handler对象。
4） ConcreteHandler：是具体的处理者，它处理它负责的请求，他还可以访问它的后继者(即下一个处理者)。如果可以处理当前请求则自己处理，如果不能则将该请求交给下一个处理者处理，从而形成一个职责链。
5） Request:含有多个属性，表示一个请求。
责任链模式解决学校采购问题：
1. URL类图:
2. 实现代码：
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请求流程简图。
3) 代码分析+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处理、拦截器；
