【设计模式】第十五章：责任链模式详解及应用案例

小咪咪 2024-03-17 14:37 88阅读 0赞

## 系列文章 ##

[【设计模式】七大设计原则][Link 1]  
[【设计模式】第一章：单例模式][Link 2]  
[【设计模式】第二章：工厂模式][Link 3]  
[【设计模式】第三章：建造者模式][Link 4]  
[【设计模式】第四章：原型模式][Link 5]  
[【设计模式】第五章：适配器模式][Link 6]  
[【设计模式】第六章：装饰器模式][Link 7]  
[【设计模式】第七章：代理模式][Link 8]  
[【设计模式】第八章：桥接模式][Link 9]  
[【设计模式】第九章：外观模式 / 门面模式][Link 10]  
[【设计模式】第十章：组合模式][Link 11]  
[【设计模式】第十一章：享元模式][Link 12]  
[【设计模式】第十二章：观察者模式][Link 13]  
[【设计模式】第十三章：模板方法模式][Link 14]  
[【设计模式】第十四章：策略模式][Link 15]  
[【设计模式】第十五章：责任链模式][Link 16]  
[【设计模式】第十六章：迭代器模式][Link 17]  
[【设计模式】第十七章：状态模式][Link 18]  
[【设计模式】第十八章：备忘录模式][Link 19]  
[【设计模式】第十九章：访问者模式][Link 20]  
[【设计模式】第二十章：解释器模式][Link 21]  
[【设计模式】第二十一章：命令模式][Link 22]  
[【设计模式】第二十二章：中介者模式][Link 23]

--------------------

#### 文章目录 ####

*  系列文章
 *  一、定义
 *  二、角色分类
 *  三、实现方式
 *   *  UML图
     *  具体实现
 *  四、应用场景
 *  五、优缺点
 *   *  优点
     *  缺点
 *  推荐

--------------------

## 一、定义 ##

> **摘自百度百科：** 在责任链模式里，很多对象由每一个对象对其下家的引用而连接起来形成一条链。请求在这个链上传递，直到链上的某一个对象决定处理此请求。发出这个请求的客户端并不知道链上的哪一个对象最终处理这个请求，这使得系统可以在不影响客户端的情况下动态地重新组织和分配责任。

--------------------

## 二、角色分类 ##

**抽象处理者（Handler）**

定义了处理请求的接口或者抽象类，并提供了处理请求的的方法和设置下一个处理者的方法

**具体处理者（Concrete Handler）**

它是抽象处理者的子类，可以处理用户请求，在具体处理者类中实现了抽象处理者中定义的抽象请求处理方法，在处理请求之前需要进行判断，看是否有相应的处理权限，如果可以处理请求就处理它，否则将请求转发给后继者；在具体处理者中可以访问链中下一个对象，以便请求的转发

**客户角色（Client）**

具体调用方法的角色

--------------------

## 三、实现方式 ##

### UML图 ###

![Image.png][]

### 具体实现 ###

假如我们想用责任链模式实现一个请假流程，可以这么来实现

**抽象处理者（Handler）**

@Data
    public abstract class Handler {
        
      // 处理者姓名
      protected String processorName;
      // 下一个处理者
      protected Handler nextHandler
    
      public Handler (String processorName) {
        
        this.processorName = processorName;
      }
    
      /**
       * 处理请假抽象方法
       * @param name 请假人姓名
       * @param numOfDays 请假天数
       */
      public abstract boolean process(String name, int numOfDays);
    }

**具体处理者（Concrete Handler）**

/**
     * 组长
     */
    @Slf4j
    public class TeamLeaderHandler extends Handler {
        
      public TeamLeaderHandler(String processorName) {
        
        this.processorName = processorName;
      }
    
      @Override
      public boolean process(String name, int numOfDays) {
        
        // 创建随机数，值大于3则为通过，否则为不通过
        boolean res = (new Random().nextInt(10)) > 3;
        String result = res ? "通过" : "驳回";
        log.info("组长<{}>审批<{}>的请假申请，请假天数为：<{}>天，审批结果为：<{}>", processorName, name, numOfDays, result);
    
        if(Boolean.FALSE.equals(res)) {
        
          // 审批驳回
          return false;
        } else if (numOfDays < 3){
        
          // 请假通过且请假天数小于3天时直接通过
          return true;
        }
        // 若审批通过且请假天数大于等于3天时提交给下一个审批人
        return nextHandler.process(name, numOfDays);
      }
    }
    
    /**
     * 部门经理
     */
    @Slf4j
    public class DepartmentManagerHandler extends Handler {
        
      public DepartmentManagerHandler(String processorName) {
        
        super(name);
      }
    
      @Override
      public boolean process(String name, int numOfDays) {
        
        // 创建一个随机数 当随机数大于3时为通过，否则为不通过
        boolean res = (new Random().nextInt(10)) > 3;
        String result = result ? "通过" : "驳回";
        log.info("部门经理<{}>审批<{}>的请假申请，请假天数为：<{}>天，审批结果为：<{}>", processorName, name, numOfDays, result);
    
        if(Boolean.FALSE.equals(res)) {
        
          // 审批驳回
          return false;
        } else if (numOfDays <7) {
        
          // 审批通过且审批天数小于7天时直接通过
          return true;
        }
        // 批准天数大于等于7天时提交给下一个审批人
        return nextHandler.process(name, numOfDays);
      }
    
      /**
       * CEO
       */
      @Slf4j
      public class CEOHandler extends Handler {
        
        public CEOHandler(String processorName) {
        
          super(name);
        }
    
        public boolean process(String name, int numOfDays) {
        
          // 创建一个随机数，大于3则为通过，否则为驳回
          boolean res = (new Random().nextInt(10)) > 3;
          String result = res ? "通过" : "驳回";
          log.info("CEO<{}>审批<{}>的请假申请，请假天数为：<{}>天，审批结果为：<{}>", processorName, name, numOfDays, result);
    
          if(Boolean.FALSE.equals(res)) {
        
            //驳回
            return false;
          }
          return true;
        } 
      } 
    }

**客户角色（Client）**

public class Client {
        
      public static void main(String[] args) {
        
        Handler zhangsan = new TeamLeaderHandler("张三");
        Handler lisi = new DepartmentManagerHandler("李四");
        Handler wangwu = new CEOHandler("王五");
    
        // 创建责任链
        zhangsan.setNextHandler(lisi);
        lisi.setNextHandler(wangwu);
    
        // 发起请假申请
        boolean res1 = zhangsan.process("小A", 2);
        System.out.println("最终结果：" + res);
    
        boolean res1 = zhangsan.process("小B", 5);
        System.out.println("最终结果：" + res);
        
        boolean res1 = zhangsan.process("小C", 10);
        System.out.println("最终结果：" + res);
      }
    }

**运行结果**

组长<张三>审批<小A>的请假申请，请假天数为：<2>天，审批结果为：<通过>
    最终结果：true
    
    部门经理<李四> 审批 <小B> 的请假申请，请假天数： <5>天 ，审批结果：<不通过> 
    最终结果：false
    
    组长<张三> 审批 <小C> 的请假申请，请假天数： <10> 天，审批结果：<通过> 
    部门经理<李四> 审批 <小C> 的请假申请，请假天数： <10> 天，审批结果：<通过> 
    CEO<王五> 审批 <小C> 的请假申请，请假天数： <10> 天，审批结果：<通过> 
    最终结果：true

--------------------

## 四、应用场景 ##

> 以下部分内容摘自**菜鸟教程**

**意图：** 避免请求发送者与接收者耦合在一起，让多个对象都有可能接收请求，将这些对象连接成一条链，并且沿着这条链传递请求，直到有对象处理它为止。

**主要解决：** 职责链上的处理者负责处理请求，客户只需要将请求发送到职责链上即可，无须关心请求的处理细节和请求的传递，所以职责链将请求的发送者和请求的处理者解耦了。

**何时使用：** 在处理消息的时候以过滤很多道。

**如何解决：** 拦截的类都实现统一接口。

**关键代码：** Handler 里面聚合它自己，在 HandlerRequest 里判断是否合适，如果没达到条件则向下传递，向谁传递之前 set 进去。

**应用实例：**

1.  红楼梦中的"击鼓传花"。
2.  JS 中的事件冒泡。
3.  JAVA WEB 中 Apache Tomcat 对 Encoding 的处理，Struts2 的拦截器，jsp servlet 的 Filter。

**使用场景：**

1.  有多个对象可以处理同一个请求，具体哪个对象处理该请求由运行时刻自动确定。
2.  在不明确指定接收者的情况下，向多个对象中的一个提交一个请求。
3.  可动态指定一组对象处理请求。

**注意事项：** 在 JAVA WEB 中遇到很多应用。

--------------------

## 五、优缺点 ##

### 优点 ###

1.  降低耦合度。它将请求的发送者和接收者解耦。
2.  简化了对象。使得对象不需要知道链的结构。
3.  增强给对象指派职责的灵活性。通过改变链内的成员或者调动它们的次序，允许动态地新增或者删除责任。
4.  增加新的请求处理类很方便。

### 缺点 ###

1.  不能保证请求一定被接收。
2.  系统性能将受到一定影响，而且在进行代码调试时不太方便，可能会造成循环调用。
3.  可能不容易观察运行时的特征，有碍于除错。

--------------------

## 推荐 ##

关注博客和公众号获取最新文章

[Bummon’s Blog][Bummon_s Blog] ｜ [Bummon’s Home][Bummon_s Home] ｜ [公众号][Link 24]

[Link 1]: https://blog.csdn.net/HackAzrael/article/details/127247474
[Link 2]: https://blog.csdn.net/HackAzrael/article/details/127257678
[Link 3]: https://blog.csdn.net/HackAzrael/article/details/127263017
[Link 4]: https://blog.csdn.net/HackAzrael/article/details/127281056
[Link 5]: https://blog.csdn.net/HackAzrael/article/details/131191740
[Link 6]: https://blog.csdn.net/HackAzrael/article/details/130830533
[Link 7]: https://blog.csdn.net/HackAzrael/article/details/131527873
[Link 8]: https://blog.csdn.net/HackAzrael/article/details/131527943
[Link 9]: https://blog.csdn.net/HackAzrael/article/details/131528074
[Link 10]: https://blog.csdn.net/HackAzrael/article/details/131528365
[Link 11]: https://blog.csdn.net/HackAzrael/article/details/131528404
[Link 12]: https://blog.csdn.net/HackAzrael/article/details/131528468
[Link 13]: https://blog.csdn.net/HackAzrael/article/details/131528589
[Link 14]: https://blog.csdn.net/HackAzrael/article/details/131529402
[Link 15]: https://blog.csdn.net/HackAzrael/article/details/131529479
[Link 16]: https://blog.csdn.net/HackAzrael/article/details/131529548
[Link 17]: https://blog.csdn.net/HackAzrael/article/details/131529642
[Link 18]: https://blog.csdn.net/HackAzrael/article/details/131554457
[Link 19]: https://blog.csdn.net/HackAzrael/article/details/131554575
[Link 20]: https://blog.csdn.net/HackAzrael/article/details/131554702
[Link 21]: https://blog.csdn.net/HackAzrael/article/details/131554803
[Link 22]: https://blog.csdn.net/HackAzrael/article/details/131554865
[Link 23]: https://blog.csdn.net/HackAzrael/article/details/131554931
[Image.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/272182a7e1f045f98dd72119c15a8cd8.png
[Bummon_s Blog]: https://blog.bummon.com/
[Bummon_s Home]: https://www.bummon.com/
[Link 24]: https://www.bummon.com/wechat/