三国演义：责任链模式

大家好，我是老田，今天我给大家分享设计模式中的责任链模式。用贴切的生活故事，以及真实项目场景来讲设计模式，最后用一句话来总结这个设计模式。

专注于为中小企业提供网站设计制作、成都网站设计服务,电脑端+手机端+微信端的三站合一,更高效的管理,为中小企业依安免费做网站提供优质的服务。我们立足成都，凝聚了一批互联网行业人才，有力地推动了1000+企业的稳健成长，帮助中小企业通过网站建设实现规模扩充和转变。

关于设计模式系列，前面我们已经分享过：

故事

前两天，没事又刷了一遍三国演义，看到关羽身在曹营心在汉，听说刘备在袁绍那里，然后就上演了“过五关，斩六将”。

关羽过五关斩六将主要内容：

  • 第一关，东岭关，斩守将孔秀。

东岭关，守关将名叫孔秀，本是黄巾余党，归降曹操之后，带着五百人奉命防守东岭关。关羽车队从关前通过时，孔秀索要通关文牒，与关羽发生冲突，只一个回合，就被关羽斩杀。

  • 第二关，洛阳关，孟坦和韩福。

关羽过了东岭关，在要过洛阳时，韩福、孟坦用鹿角拦住道路。先是孟坦挑战，与关羽说翻，交手不敌，孟坦拨马回跑，引关公来追，这样韩福就可以在后面射箭擒拿关公，可谁想到关公赤兔马快，从后面赶上孟坦，一刀就把孟坦给劈了。韩福慌得射了一箭，中关公左臂，关公忍住箭伤，也冲过鹿角，一刀斩杀韩福，于是过洛阳。

  • 第三关，汜水关，卞喜。

在得知关羽过关斩将，东岭关孔秀、洛阳韩福、孟坦都被杀害，卞喜自思难以抵挡关公。于是就假意迎接关公，在镇国寺安排下刀斧手，准备伺机杀死关公。幸亏有镇国寺老方丈普净给警示，关公这才察觉出阴谋，与卞喜闹翻，一刀斩杀卞喜，于是关公过汜水关。

  • 第四关，王植。

这王植是韩福的亲家，听说韩福被关公杀死，十分愤怒，于是就要为韩福报仇。在关公到达荥阳时，王植在馆驿设宴，宴请关公和二位皇嫂。却是暗中派从事胡班放火，想要烧死关公。但胡班因关公给父亲胡华带信的缘故，向关羽告了密。关羽和二位皇嫂得以提前逃离馆驿，胡班却假意放火，迷惑王植。不过王植后来察觉，杀了胡班，来追关羽时，被关羽斩杀，于是关公过荥阳。

  • 第五关，黄河渡口，秦琪。

这秦琪不仅是夏侯惇的爱将，更是老将军蔡阳的外甥，奉命守卫黄河渡口，盘查过往船只。关公到黄河渡口时，要找船只渡河，被秦琪拦住，秦琪不仅不放关公等人渡河，反而口出狂言，终于激怒关公，被关公斩杀

这就是关羽过五关斩六将的全部过程。

这个故事情节让我想起了一个设计模式：责任链模式。

其实，我们生活中也有着非常多的责任链模式。比如：基本上每个公司都有自己的OA系统，主要是员工基本信息、请假、调休、报销等功能。如果，我有事需要请假两天，于是登录OA系统，发起请假审批。

由于，对于请假时间的长短公司有如下规定：

小于等于半天，审批环节：项目负责人

大于半天，小于等于1天的，审批环节：项目负责人+技术总监

超过1天，审批环节：项目负责人+技术总监+Boss

可以看得出来，我请假审批流程为项目负责人+技术总监+Boss。

到底什么是责任链设计模式?

什么是责任链模式呢

责任链模式英文解释为：

Avoid coupling the sender of a request to its receiver bygiving more than one object a chance to handle the request.Chainthe receiving objects and pass the request along the chain until anobject handles it.

责任链模式(Chain of Responsibility Pattern)将链中每一个节点都看作一个对象，每个节点处理的请求均不同，且内部自动维护下一个节点对象。当一个请求从链式的首端发出时，会沿着责任链预设的路径依次传递到每一个节点对象，直至被链中的某个对象处理为止，属于行为型设计模式。

责任链模式通用代码

Java实现责任链设计模式如下：

 
 
 
 
    
  
  
  
  
  1. public abstract class Handler { 
    2. 
  
  
  
  
  2.         protected Handler nextHandler = null; 
    3. 
  
  
  
  
  3.         public abstract void handle(); 
    4. 
  
  
  
  
  4.         public Handler getNextHandler() { 
    5. 
  
  
  
  
  5.             return nextHandler; 
    6. 
  
  
  
  
  6.         } 
    7. 
  
  
  
  
  7.         public void setNextHandler(Handler nextHandler) { 
    8. 
  
  
  
  
  8.             this.nextHandler = nextHandler; 
    9. 
  
  
  
  
  9.         } 
    10. 
  
  
  
  
  10. } 
    11. 
  
  
  
  
  11.  
    12. 
  
  
  
  
  12. public class HandlerA extends Handler{ 
    13. 
  
  
  
  
  13.         @Override 
    14. 
  
  
  
  
  14.         public void handle() { 
    15. 
  
  
  
  
  15.             if(nextHandler == null){ 
    16. 
  
  
  
  
  16.                 System.out.println("HandlerA handle ..."); 
    17. 
  
  
  
  
  17.             }else{ 
    18. 
  
  
  
  
  18.                 nextHandler.handle(); 
    19. 
  
  
  
  
  19.             } 
    20. 
  
  
  
  
  20.         } 
    21. 
  
  
  
  
  21. } 
    22. 
  
  
  
  
  22.  
    23. 
  
  
  
  
  23. public class HandlerB extends Handler{ 
    24. 
  
  
  
  
  24.         @Override 
    25. 
  
  
  
  
  25.         public void handle() { 
    26. 
  
  
  
  
  26.             if(nextHandler == null){ 
    27. 
  
  
  
  
  27.                 System.out.println("HandlerB handle ..."); 
    28. 
  
  
  
  
  28.             }else{ 
    29. 
  
  
  
  
  29.                 nextHandler.handle(); 
    30. 
  
  
  
  
  30.             } 
    31. 
  
  
  
  
  31.         } 
    32. 
  
  
  
  
  32. } 
    33. 
  
  
  
  
  33.  
    34. 
  
  
  
  
  34. public class HandlerC extends Handler{ 
    35. 
  
  
  
  
  35.     @Override 
    36. 
  
  
  
  
  36.     public void handle() { 
    37. 
  
  
  
  
  37.         if(getNextHandler() == null){ 
    38. 
  
  
  
  
  38.             System.out.println("HandlerC handle ..."); 
    39. 
  
  
  
  
  39.         }else{ 
    40. 
  
  
  
  
  40.             getNextHandler().handle(); 
    41. 
  
  
  
  
  41.         } 
    42. 
  
  
  
  
  42.     } 
    43. 
  
  
  
  
  43. } 
    44. 
  
  
  
  
  44. //测试 
    45. 
  
  
  
  
  45. public class  Client{ 
    46. 
  
  
  
  
  46.     public static void main(String[] args) { 
    47. 
  
  
  
  
  47.         Handler handlerA = new HandlerA(); 
    48. 
  
  
  
  
  48.         Handler handlerB = new HandlerB(); 
    49. 
  
  
  
  
  49.         handlerA.setNextHandler(handlerB); 
    50. 
  
  
  
  
  50.         handlerA.handle(); 
    51. 
  
  
  
  
  51.     } 
    52. 
  
  
  
  
  52. } 
    53.

运行结果：

 
 
 
 
    
  
  
  
  
  1. HandlerC handle ... 
    2.

从上面代码，我们可以画出UML图：

从UML图中，我们又可以看出，责任链模式中有两个非常重要的角色：

(1)、抽象处理者角色(Handler)

定义处理请求的接口。接口可以也可以给出一个方法以设定和返回对下个对象引用。这个角色通常由一个Java抽象类或者Java接口实现。

(2)、具体处理者角色(HandlerA、HandlerB、HandlerC)

具体处理者接到请求后，可以选择将请求处理掉，或者将请求传给下个对象。由于具体处理者持有对下家的引用。

责任链模式的优缺点

  • 优点：请求和处理分开，两者解耦，提供系统的灵活性。
  • 缺点：性能能问，一个链非常长的时候，非常耗时。因为我们避免建立很长的链。

生活中的案例

在日常生活中，责任链模式是比较常见的。我们平时处理工作中的一些事务，往往是各部门协同合作来完成某一个任务的。而每个部门都有各自的职责，因此，很多时候事情完成一半，便会转交到下一个部门，直到所有部门都审批通过，事情才能完成。

责任链模式主要解耦了请求与处理，客户只需将请求发送到链上即可，不需要关心请求的具体内容和处理细节，请求会自动进行传递，直至有节点对象进行处理。

责任链模式主要适用于以下应用场景:

  • 多个对象可以处理同一请求，但具体由哪个对象处理则在运行时动态决定。
  • 在不明确指定接收者的情况下，向多个对象中的一个提交请求。
  • 可动态指定一组对象处理请求。

请假流程的代码实现

下面我们来对，前面的案例：OA上请假流程做一个Java代码的实现。

抽象处理者：领导类

 
 
 
 
    
  
  
  
  
  1. public abstract class Leader { 
    2. 
  
  
  
  
  2.     private Leader next; 
    3. 
  
  
  
  
  3.     public void setNext(Leader next) { 
    4. 
  
  
  
  
  4.         this.next = next; 
    5. 
  
  
  
  
  5.     } 
    6. 
  
  
  
  
  6.     public Leader getNext() { 
    7. 
  
  
  
  
  7.         return next; 
    8. 
  
  
  
  
  8.     } 
    9. 
  
  
  
  
  9.     //处理请求的方法 
    10. 
  
  
  
  
  10.     public abstract void handleRequest(double LeaveDays); 
    11. 
  
  
  
  
  11. } 
    12.

项目负责人

 
 
 
 
    
  
  
  
  
  1. public class ProjectLeader extends Leader { 
    2. 
  
  
  
  
  2.     @Override 
    3. 
  
  
  
  
  3.     public void handleRequest(double LeaveDays) { 
    4. 
  
  
  
  
  4.         if (LeaveDays <= 0.5) { 
    5. 
  
  
  
  
  5.             System.out.println("项目负责人批准您请假" + LeaveDays + "天。"); 
    6. 
  
  
  
  
  6.         } else { 
    7. 
  
  
  
  
  7.             if (getNext() != null) { 
    8. 
  
  
  
  
  8.                 getNext().handleRequest(LeaveDays); 
    9. 
  
  
  
  
  9.             } else { 
    10. 
  
  
  
  
  10.                 System.out.println("请假天数太多，没有人批准该假条！"); 
    11. 
  
  
  
  
  11.             } 
    12. 
  
  
  
  
  12.         } 
    13. 
  
  
  
  
  13.     } 
    14. 
  
  
  
  
  14. } 
    15.

技术总监

 
 
 
 
    
  
  
  
  
  1. public class TechnicalDirectorLeader extends Leader { 
    2. 
  
  
  
  
  2.  
    3. 
  
  
  
  
  3.     @Override 
    4. 
  
  
  
  
  4.     public void handleRequest(double LeaveDays) { 
    5. 
  
  
  
  
  5.         if (LeaveDays <= 1) { 
    6. 
  
  
  
  
  6.             System.out.println("技术总监批准您请假" + LeaveDays + "天。"); 
    7. 
  
  
  
  
  7.         } else { 
    8. 
  
  
  
  
  8.             if (getNext() != null) { 
    9. 
  
  
  
  
  9.                 getNext().handleRequest(LeaveDays); 
    10. 
  
  
  
  
  10.             } else { 
    11. 
  
  
  
  
  11.                 System.out.println("请假天数太多，没有人批准该假条！"); 
    12. 
  
  
  
  
  12.             } 
    13. 
  
  
  
  
  13.         } 
    14. 
  
  
  
  
  14.     } 
    15. 
  
  
  
  
  15. } 
    16.

Boss

 
 
 
 
    
  
  
  
  
  1. public class BossLeader extends Leader { 
    2. 
  
  
  
  
  2.     @Override 
    3. 
  
  
  
  
  3.     public void handleRequest(double LeaveDays) { 
    4. 
  
  
  
  
  4.         if (LeaveDays >= 2 && LeaveDays <= 30) { 
    5. 
  
  
  
  
  5.             System.out.println("Boss批准您请假" + LeaveDays + "天。"); 
    6. 
  
  
  
  
  6.         } else { 
    7. 
  
  
  
  
  7.             if (getNext() != null) { 
    8. 
  
  
  
  
  8.                 getNext().handleRequest(LeaveDays); 
    9. 
  
  
  
  
  9.             } else { 
    10. 
  
  
  
  
  10.                 System.out.println("请假天数太多，没有人批准该假条！"); 
    11. 
  
  
  
  
  11.             } 
    12. 
  
  
  
  
  12.         } 
    13. 
  
  
  
  
  13.     } 
    14. 
  
  
  
  
  14. } 
    15.

发起审批

 
 
 
 
    
  
  
  
  
  1. public class LeaveApproval { 
    2. 
  
  
  
  
  2.     public static void main(String[] args) { 
    3. 
  
  
  
  
  3.         //组装责任链 
    4. 
  
  
  
  
  4.         Leader projectLeader = new ProjectLeader(); 
    5. 
  
  
  
  
  5.         Leader technicalDirectorLeader = new TechnicalDirectorLeader(); 
    6. 
  
  
  
  
  6.         Leader bossLeader = new BossLeader(); 
    7. 
  
  
  
  
  7.  
    8. 
  
  
  
  
  8.         projectLeader.setNext(technicalDirectorLeader); 
    9. 
  
  
  
  
  9.         technicalDirectorLeader.setNext(bossLeader); 
    10. 
  
  
  
  
  10.  
    11. 
  
  
  
  
  11.         //请假两天，提交请假流程，开启审批环节, 
    12. 
  
  
  
  
  12.         projectLeader.handleRequest(2); 
    13. 
  
  
  
  
  13.     } 
    14. 
  
  
  
  
  14. } 
    15.

审批结果

 
 
 
 
    
  
  
  
  
  1. Boss批准您请假2.0天。 
    2.

如果请假天数是31天，审批结果

 
 
 
 
    
  
  
  
  
  1. 请假天数太多，没有人批准该假条! 
    2.

整个请假流程为：

把这张流程图改成纵向：

就这么一环套一环的，使用上面两个例子和两张图来理解责任链模式是不是就更轻松了?

自己吹牛逼，没什么用，下面来看看大神们是怎么使用责任链模式的。

大佬们是如何使用的

在Spring、Mybatis等框架中，都用使用到责任链模式，下面先来看在Spring中是如何使用的。

在Spring MVC中的org.springframework.web.servlet.DispatcherServlet类中：

getHandler 方法的处理使用到了责任链模式，handlerMappings是之前 Spring 容器初始化好的，通过遍历 handlerMappings查找与request匹配的 Handler, 这里返回 HandlerExecutionChain 对象。这个 HandlerExecutionChain对象到后面执行的时候再分析为什么返回的是这样一个对象。

 
 
 
 
    
  
  
  
  
  1. @Nullable 
    2. 
  
  
  
  
  2. protected HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception { 
    3. 
  
  
  
  
  3.  if (this.handlerMappings != null) { 
    4. 
  
  
  
  
  4.   for (HandlerMapping mapping : this.handlerMappings) { 
    5. 
  
  
  
  
  5.    HandlerExecutionChain handler = mapping.getHandler(request); 
    6. 
  
  
  
  
  6.    if (handler != null) { 
    7. 
  
  
  
  
  7.     return handler; 
    8. 
  
  
  
  
  8.    } 
    9. 
  
  
  
  
  9.   } 
    10. 
  
  
  
  
  10.  } 
    11. 
  
  
  
  
  11.  return null; 
    12. 
  
  
  
  
  12. } 
    13.

以上便是责任链模式在Spring的具体使用，关于Mybatis中责任链模式的使用，请看这篇文章：

总结

本文通过关二爷的过五关斩六将和OA系统中的请假审批流程，完美的解释了责任链设计模式。

最后用一句话来总结责任链模式：

各人自扫门前雪，莫管他人瓦上霜。

本文转载自微信公众号「Java后端技术全栈」，可以通过以下二维码关注。转载本文请联系Java后端技术全栈公众号。

文章名称：三国演义：责任链模式
转载注明：http://www.shufengxianlan.com/qtweb/news30/113780.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

网站内链知识

分类信息网

小程序　　 　自贡电信机房　　 　网站设计　　 　犀浦封阳台　　 　贵阳托管服务器　　 　眉山网站建设　　 　泸州叙永网站建设　　 　成都网站推广　　 　手机微信网站　　 　内江做网站　　 　达州网站建设　　 　腾讯云香港空间　　 　正泰动物制药　　 　成都ssl证书认证　　 　H5网站制作　　 　高端定制网站设计　　 　成都封阳台　　 　消防维保　　 　外贸网站设计方案　　 　重庆联通机房托管