大家好，我是小赵，现任藏剑山庄高级铸剑师，山庄的铸剑师团队一共有十多个组，我就是其中的小组长之一，我有七个手下。
今天，小明来找我请假，说他家里出了点状况，需要请一个月的假，可我只是小组长，这么长的假期我是没权利做主的，我签完字，就叫他去找部门经理，然后小明拿着请假条去找部门经理，部门经理签字了，又让小明去找总经理签字，然后小明又拿着请假条去找总经理，最后总经理签字，这个假才算请完。
后来才知道，3天以下的假小组长签字即可，3-7天的假需要小组长和部门经理签字，7以上的假小组长和部门经理签完字后还需要总经理签字。
这个流程在各个企业里面是非常常见的。
咱们就来研究一下这个请假的流程。
角色1：请假条，其实可以理解成请假人，因为请假条上自然有请假人信息。
角色2：领导人，小组长、部门经理、总经理都是审批人。
动作：领导人审批请假条。
那么类图也就可以画出来了：
现在我们把程序写出来，看看请假是怎么请的：
请假条抽象：
我要评论public interface ileave {
string getname();//请假人姓名
int getnum();//请假天数
string getcontent();//请假条内容
}
请假条：
public class leave implements ileave{
private string name;//姓名
private int num;//请假天数
private string content;//请假内容
public leave(string name, int num, string content) {
this.name = name;
this.num = num;
this.content = content;
}
public string getname() {
return name;
}
public int getnum() {
return num;
}
public string getcontent() {
return content;
}
}
处理者抽象：
public interface ihandler {
void handleleave(ileave leave);//处理请假条
}
小组长：
public class groupleader implements ihandler {
@override
public void handleleave(ileave leave) {
system.out.println(leave.getname() + "请假" + leave.getnum() + "天," + leave.getcontent() + "。");
system.out.println("小组长审批：同意。");
}
}
部门经理：
public class manager implements ihandler {
@override
public void handleleave(ileave leave) {
system.out.println(leave.getname() + "请假" + leave.getnum() + "天," + leave.getcontent() + "。");
system.out.println("部门经理审批：同意。");
}
}
总经理：
public class bigmanager implements ihandler {
@override
public void handleleave(ileave leave) {
system.out.println(leave.getname() + "请假" + leave.getnum() + "天," + leave.getcontent() + "。");
system.out.println("总经理审批：同意。");
}
}
客户端：
public static void main(string[] args) {
//请假条来一张
ileave leave = new leave("小花",5,"身体不适");
//小组长第一个审批
ihandler groupleader = new groupleader();
groupleader.handleleave(leave);
if(leave.getnum() >= 3){
ihandler manager = new manager();
manager.handleleave(leave);
}
if(leave.getnum() >= 7){
ihandler bigmanager = new bigmanager();
bigmanager.handleleave(leave);
}
}
输出：
小花请假5天,身体不适。
小组长审批：同意。
小花请假5天,身体不适。
部门经理审批：同意。
这个程序写出来是有问题的。
如果老板还要审批该怎么办？在外面继续加个if判断？一个优秀的程序应该具有高内聚低耦合的特性，这个程序审批规则写在外面是不合理的。
正确的逻辑应该是什么样的呢？ 应该是小花递了请假条之后，就只需要等结果即可，而不是找了这个审批，回来后又跑去找那个审批。
对于请假制度的优化问题，我非常上心，如果我为公司设计了健全的制度，说不定升职加薪就是分分钟的事情。
主要要解决的问题就是职责隔离，小花是申请者，领导是审批者，至于审批规则应该是领导去把控，所以每个领导需要知道自己的上级，也就是下一个审批人是谁。
由此可见，应该把interface改为abstract抽象类增加程序灵活度，使用模板方法模式将领导共同要遵守的规则收集到父类。
类图画出来也差不多，变化的只是处理者抽象：
请假条抽象：
public interface ileave {
string getname();//请假人姓名
int getnum();//请假天数
string getcontent();//请假条内容
}
请假条：
public class leave implements ileave{
private string name;//姓名
private int num;//请假天数
private string content;//请假内容
public leave(string name, int num, string content) {
this.name = name;
this.num = num;
this.content = content;
}
public string getname() {
return name;
}
public int getnum() {
return num;
}
public string getcontent() {
return content;
}
}
处理者抽象：
public abstract class handler {
protected final static int num_one = 1;
protected final static int num_three = 3;
protected final static int num_seven = 7;
//该领导处理的请假天数区间
private int numstart = 0;
private int numend = 0;
//领导上面还有领导
private handler nexthandler;
//设置请假天数范围 上不封顶
public handler(int numstart) {
this.numstart = numstart;
}
//设置请假天数范围
public handler(int numstart, int numend) {
this.numstart = numstart;
this.numend = numend;
}
//设置上级领导
public void setnexthandler(handler nexthandler){
this.nexthandler = nexthandler;
}
//提交请假条
public final void submit(ileave leave){
if(0 == this.numstart){
return;
}
//如果请假天数达到该领导者的处理要求
if(leave.getnum() >= this.numstart){
this.handleleave(leave);
//如果还有上级 并且请假天数超过了当前领导的处理范围
if(null != this.nexthandler && leave.getnum() > numend){
this.nexthandler.submit(leave);//继续提交
}
}
}
//各级领导处理请假条方法
protected abstract void handleleave(ileave leave);
}
小组长：
public class groupleader extends handler {
public groupleader() {
//小组长处理1-3天的请假
super(handler.num_one, handler.num_three);
}
@override
protected void handleleave(ileave leave) {
system.out.println(leave.getname() + "请假" + leave.getnum() + "天," + leave.getcontent() + "。");
system.out.println("小组长审批：同意。");
}
}
部门经理：
public class manager extends handler {
public manager() {
//部门经理处理3-7天的请假
super(handler.num_three, handler.num_seven);
}
@override
protected void handleleave(ileave leave) {
system.out.println(leave.getname() + "请假" + leave.getnum() + "天," + leave.getcontent() + "。");
system.out.println("部门经理审批：同意。");
}
}
总经理：
public class bigmanager extends handler {
public bigmanager() {
//部门经理处理7天以上的请假
super(handler.num_seven);
}
@override
protected void handleleave(ileave leave) {
system.out.println(leave.getname() + "请假" + leave.getnum() + "天," + leave.getcontent() + "。");
system.out.println("总经理审批：同意。");
}
}
客户端：
public static void main(string[] args) {
//请假条来一张
ileave leave = new leave("小花",5,"身体不适");
//各位领导
handler groupleader = new groupleader();
handler manager = new manager();
handler bigmanager = new bigmanager();
groupleader.setnexthandler(manager);//小组长的领导是部门经理
manager.setnexthandler(bigmanager);//部门经理的领导是总经理
//之所以在这里设置上级领导，是因为可以根据实际需求来更改设置，如果实战中上级领导人都是固定的，则可以移到领导实现类中。
//提交申请
groupleader.submit(leave);
}
输出：
小花请假5天,身体不适。
小组长审批：同意。
小花请假5天,身体不适。
部门经理审批：同意。
责任链模式：使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将整个对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它为止。
我们可以把各位领导想象成一条链，从链的开头传递请求到尽头，直到业务逻辑处理完成。
链上的每个节点都可以设置自己处理的指标范围，也可以设置下一任处理者节点。
最显著的好处就是请求者不用知道到底是哪个对象处理的，反正提交请求就对了。
同时链中的处理者并不知道整条链的结构，他们只需要保持一个指向下一任处理者对象的引用，这样非常大的降低了耦合度。
责任链模式的缺点是性能问题，有可能一个请求是从整条链的头部遍历到链尾部，应该尽量避免超长链，并且如果出现问题，调试很不方便。
如对本文有疑问， 点击进行留言回复！！
【面试题】研究过tomcat的NioEndpoint源码吗？请阐述下Reactor多线程模型在tomcat中的实现。
荐 厉害了！阿里P8架构师用4大技术文档带你深入解读爆火的中台战略
网友评论