【设计模式】行为型 - 职责链

【前提 & 场景】

写业务逻辑的时候（和银行交互或者金融相关业务），小编常会遇到这种情况，如图：

流程比较复杂，订单处理节点会很多，按照传统的设计，代码的条理性、可读性都会很差，经常会出现很多if else判断，不去好好设计，很容易被后人视为“坏味道” 。而“职责链模式”恰恰能很好解决这个问题，详情往下看。

【简介】

1.概念

职责链 - 使多个对象（处理者）都有机会处理请求，从而减缓了请求的发送者和（每个）接受者之间的耦合关系。将这个（处理者）对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理他为止。

2.UML

【理解】

1）场景：1.业务流程非常复杂，2.通常一个请求者，多个处理者，处理过程有顺序。

2）通俗来讲，职责链模式，就是把处理者重新做了一层封装，因为处理对象的有序性需求，Handler的实现往往有2个必要的方法，其一是对处理者的节点顺序处理，当前节点处理完成之后使其能够到下一个节点处理。其二是处理当前节点所需要的业务逻辑。

【Demo】

根据现实生活中“考驾照”的需求，写了一个小demo，规则：

1.考驾照只能按照顺序来，考完一门考下一门。

2.没门考试通过生成随机数来判别考试是否通过，大于60分则通过，小于则继续从该节点继续考试。

1）uml展示：

2）代码展示：

1.流程抽象类

package chainFcar;
/**
 * 模拟处理考试流程
 * 规则：
 * 1.考生只有依次考过了：科目一、科目二、科目三、科目四，方可拿到驾照
 * 2.各次考试考过与否成绩均存档
 * 3.中途未通过考试，下次从上次考试节点继续考试
 * 
 * @author zhenhua.zhang
 */
public abstract class AbsExamHandler {
	
	/**
	 * 公共方法，每个节点都会执行，子类不用Override
	 */
	protected void commonMethod(){
		//todo 公共方法：eg ->
		//1.通过id查询考生信息
		//2.核对考生准考证、身份证等信息
		//3.and so on  这块可以拆分多个protected方法
	}
	
	/**
	 * 不同流程的业务起点
	 */
	public abstract void handle(Object o, VincentChain chain);
	
	/**
	 * 不同流程下的业务规则
	 * @return
	 */
	public abstract Boolean businessCheck();
	
	protected void logBeforeExam(Integer type){
		System.out.println("Vincent你的考试科目" + type + "的考试马上开始！");
	}
	
	protected void logDuringExam(Integer type,Double score){
		System.out.println("Vincent你的考试科目" + type + "的成绩是：" + score + "分");
	}
	
	protected void logPassExam(Integer type){
		if(type == 4){
			System.out.println("Vincent，你通过了科目" + type + "的考核，恭喜你拿到了驾驶证！");
			return;
		}
		System.out.println("Vincent，你通过了科目" + type + "的考核，接下来好好准备下一门科目" + (type+1) + "的考核吧！");
	}
	
	protected void logFailExam(Integer type){
		System.out.println("Vincent，你未通过了科目" + type + "的考核，请再接再厉！！！");
	}
	
}

2.科目一~四实现类

package chainFcar;

/**
 * 科目一考试
 * @author zhenhua.zhang
 *
 */
public class ProjectOneExamHandler extends AbsExamHandler{
	
	@Override
	public void handle(Object o, VincentChain chain){
		//todo
		if(businessCheck()){
			chain.doChain(o);
		}
	}
	
	@Override
	public Boolean businessCheck(){
		logBeforeExam(1);
		//生成1~100之间随机数，代表考试成绩，成绩大于60，可以考下一门考试
		Double score = (Double)(Math.random()*100);
		logDuringExam(1,score);
		
		if(score >= 60){
			logPassExam(1);
			return true;
		}
		logFailExam(1);
		return false;
	}
}

package chainFcar;
/**
 * 科目二考试
 * @author zhenhua.zhang
 *
 */
public class ProjectTwoExamHandler extends AbsExamHandler{
	
	@Override
	public void handle(Object o, VincentChain chain){
		//todo
		if(businessCheck()){
			chain.doChain(o);
		}
	}
	
	@Override
	public Boolean businessCheck(){
		logBeforeExam(2);
		//生成1~100之间随机数，代表考试成绩，成绩大于60，可以考下一门考试
		Double score = (Double)(Math.random()*100);
		logDuringExam(2,score);
		
		if(score >= 60){
			logPassExam(2);
			return true;
		}
		
		logFailExam(2);
		return false;
	}
}

package chainFcar;

/*
 * 科目一考试
 * @author zhenhua.zhang
 */
public class ProjectThreeExamHandler extends AbsExamHandler{
	
	@Override
	public void handle(Object o, VincentChain chain){
		//todo
		if(businessCheck()){
			chain.doChain(o);
		}
	}
	
	@Override
	public Boolean businessCheck(){
		logBeforeExam(3);
		//生成1~100之间随机数，代表考试成绩，成绩大于60，可以考下一门考试
		Double score = (Double)(Math.random()*100);
		logDuringExam(3,score);
		
		if(score >= 60){
			logPassExam(3);
			return true;
		}
		
		logFailExam(3);
		return false;
	}
}

package chainFcar;

/**
 * 科目四考试
 * @author zhenhua.zhang
 *
 */
public class ProjectFourExamHandler extends AbsExamHandler{
	@Override
	public void handle(Object o, VincentChain chain){
		//todo other
		if(businessCheck()){
			chain.doChain(o);
		}
	}
	
	@Override
	public Boolean businessCheck(){
		logBeforeExam(4);
		Double score = (Double)(Math.random()*100);
		logDuringExam(4,score);
		
		if(score >= 60){
			logPassExam(4);
			return true;
		}
		
		logFailExam(4);
		return false;
	}
}

3.职责链分发、流程管理类

package chainFcar;

import java.util.ArrayList;
import java.util.List;

/**
 * 职责链分发，流程管理
 * @author zhenhua.zhang
 *
 */
public class VincentChain {
	//处理流程handler集合，利用List有序特性
	List<AbsExamHandler> handler = new ArrayList<AbsExamHandler>();
	
	//index标识位，用于索引handler
	int index = 0;
	
	/**
	 * 按顺序向handler中添加元素
	 * @param absHandler
	 * @return
	 */
	public void addHandler(AbsExamHandler absHandler){
		handler.add(absHandler);
		//return this;
	}
	
	/**
	 * 调用AbsExamHandler流程
	 */
	public void doChain(Object o){
		if(handler.size() == index){
			return;
		}
		AbsExamHandler handlerNew = handler.get(index);
		index++;
		handlerNew.handle(o,this);
	}
}

4.客户端启动访问类

package chainFcar;

/**
 * 
 * @author zhenhua.zhang
 *
 */

public class VincentClient {
	
	public static void main(String[] args){
		VincentChain chain = new VincentChain();
		ProjectOneExamHandler one = new ProjectOneExamHandler();
		ProjectTwoExamHandler two = new ProjectTwoExamHandler();
		ProjectThreeExamHandler three = new ProjectThreeExamHandler();
		ProjectFourExamHandler four = new ProjectFourExamHandler();
		
		chain.addHandler(one);
		chain.addHandler(two);
		chain.addHandler(three);
		chain.addHandler(four);
		
		Object o = new Object();
		chain.doChain(o);
	}
	
}

执行结果：

如图，因为考科目二的时候，随机数生成的成绩只有43.72分，所以到该节点便终止了考试流程。

【小结】

一.上述例子已经展示了职责链模式的使用，关键点在于有序，这里用到了List<AbsExamHandler>的有序性保证顺序执行。

二.优缺点比较：

优点：

1.长流程保证代码整洁、清晰，流程节点的顺序能仍能很好保证。

缺点：

1.（处理者）在实际的处理中，如果跳过了，就并没有发挥任何的作用。那么当这个链结构比较长，比较复杂的话，会产生很多的内存垃圾对象。这也就是职责链的最大缺点之所在。

2.可能不容易观察运行时的特征，有碍于除错。

三、对比链表

1. 链表是一个链状结构，每个节点有一个next属性去指向他的下一节点。
2. 链表有一个Header节点，然后用户每次必须通过头节点，然后去遍历寻找每一个节点。
可见，职责链相比链表，每次走流程，无需从头节点开始。

That's all.

【设计模式】行为型 - 职责链

猜你喜欢