还在担心代码越写越乱？试试责任链模式

Myth丶恋晨 2023-10-11 20:33 40阅读 0赞

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

*  1.什么是责任链
 *  2.使用场景
 *   *  2.1 反例
     *  2.2 责任链改造
     *  2.3 责任链工厂改造

责任链是一种设计模式，也是一种设计的思想，在学习这个设计模式之前，我们先来看看什么是责任链？

## 1.什么是责任链 ##

责任链模式是一种行为设计模式， 允许你将请求沿着处理者链进行发送。收到请求后， 每个处理者均可对请求进行处理， 或将其传递给链上的下个处理者。

> 责任链（Chain of Responsibility）模式的定义：为了避免请求发送者与多个请求处理者耦合在一起，于是将所有请求的处理者通过前一对象记住其下一个对象的引用而连成一条链；当有请求发生时，可将请求沿着这条链传递，直到有对象处理它为止

在责任链模式中，客户只需要将请求发送到责任链上即可，无须关心请求的处理细节和请求的传递过程，请求会自动进行传递。所以责任链将请求的发送者和请求的处理者解耦了。

**目的：将请求方与处理方解耦，链式调用，可以灵活改变处理顺序，符合开闭原则，可扩展性强。**

![在这里插入图片描述][1bf93cfb7a0445b494d8ec3baece6639.png_pic_center]

## 2.使用场景 ##

责任链的使用场景还是比较多的：

*  多条件流程判断：权限控制
 *  ERP 系统流程审批：总经理、人事经理、项目经理
 *  Java 过滤器的底层实现 Filter

如果不使用该设计模式，那么当需求有所改变时，就会使得代码臃肿或者难以维护，例如下面的例子。

### 2.1 反例 ###

假设现在有一个闯关游戏，进入下一关的条件是上一关的分数要高于 xx：

*  游戏一共 3 个关卡
 *  进入第二关需要第一关的游戏得分大于等于 80
 *  进入第三关需要第二关的游戏得分大于等于 90

那么代码可以这样写：

//第一关
    public class FirstPassHandler {
        
        public int handler(){
        
            System.out.println("第一关-->FirstPassHandler");
            return 80;
        }
    }
    
    //第二关
    public class SecondPassHandler {
        
        public int handler(){
        
            System.out.println("第二关-->SecondPassHandler");
            return 90;
        }
    }
    
    
    //第三关
    public class ThirdPassHandler {
        
        public int handler(){
        
            System.out.println("第三关-->ThirdPassHandler，这是最后一关啦");
            return 95;
        }
    }
    
    
    //客户端
    public class HandlerClient {
        
        public static void main(String[] args) {
        
    
            FirstPassHandler firstPassHandler = new FirstPassHandler();//第一关
            SecondPassHandler secondPassHandler = new SecondPassHandler();//第二关
            ThirdPassHandler thirdPassHandler = new ThirdPassHandler();//第三关
    
            int firstScore = firstPassHandler.handler();
            //第一关的分数大于等于80则进入第二关
            if(firstScore >= 80){
        
                int secondScore = secondPassHandler.handler();
                //第二关的分数大于等于90则进入第二关
                if(secondScore >= 90){
        
                    thirdPassHandler.handler();
                }
            }
        }
    }

那么如果这个游戏有 100 关，我们的代码很可能就会写成这个样子：

if(第1关通过){
        
        // 第2关 游戏
        if(第2关通过){
        
            // 第3关 游戏
            if(第3关通过){
        
               // 第4关 游戏
                if(第4关通过){
        
                    // 第5关 游戏
                    if(第5关通过){
        
                        // 第6关 游戏
                        if(第6关通过){
        
                            //...
                        }
                    }
                } 
            }
        }
    }

这种代码不仅冗余，并且当我们要将某两关进行调整时会对代码非常大的改动，这种操作的风险是很高的，因此，该写法非常糟糕。

下面我们对其进行初步改造

如何解决这个问题，我们可以通过链表将每一关连接起来，形成责任链的方式，第一关通过后是第二关，第二关通过后是第三关…

**这样客户端就不需要进行多重 if 的判断了：**

public class FirstPassHandler {
        
        /**
         * 第一关的下一关是 第二关
         */
        private SecondPassHandler secondPassHandler;
    
        public void setSecondPassHandler(SecondPassHandler secondPassHandler) {
        
            this.secondPassHandler = secondPassHandler;
        }
    
        //本关卡游戏得分
        private int play(){
        
            return 80;
        }
    
        public int handler(){
        
            System.out.println("第一关-->FirstPassHandler");
            if(play() >= 80){
        
                //分数>=80 并且存在下一关才进入下一关
                if(this.secondPassHandler != null){
        
                    return this.secondPassHandler.handler();
                }
            }
    
            return 80;
        }
    }
    
    public class SecondPassHandler {
        
    
        /**
         * 第二关的下一关是 第三关
         */
        private ThirdPassHandler thirdPassHandler;
    
        public void setThirdPassHandler(ThirdPassHandler thirdPassHandler) {
        
            this.thirdPassHandler = thirdPassHandler;
        }
    
        //本关卡游戏得分
        private int play(){
        
            return 90;
        }
    
        public int handler(){
        
            System.out.println("第二关-->SecondPassHandler");
    
            if(play() >= 90){
        
                //分数>=90 并且存在下一关才进入下一关
                if(this.thirdPassHandler != null){
        
                    return this.thirdPassHandler.handler();
                }
            }
    
            return 90;
        }
    }
    
    public class ThirdPassHandler {
        
    
        //本关卡游戏得分
        private int play(){
        
            return 95;
        }
    
        /**
         * 这是最后一关，因此没有下一关
         */
        public int handler(){
        
            System.out.println("第三关-->ThirdPassHandler，这是最后一关啦");
            return play();
        }
    }
    
    public class HandlerClient {
        
        public static void main(String[] args) {
        
    
            FirstPassHandler firstPassHandler = new FirstPassHandler();//第一关
            SecondPassHandler secondPassHandler = new SecondPassHandler();//第二关
            ThirdPassHandler thirdPassHandler = new ThirdPassHandler();//第三关
    
            firstPassHandler.setSecondPassHandler(secondPassHandler);//第一关的下一关是第二关
            secondPassHandler.setThirdPassHandler(thirdPassHandler);//第二关的下一关是第三关
    
            //说明：因为第三关是最后一关，因此没有下一关
            //开始调用第一关 每一个关卡是否进入下一关卡 在每个关卡中判断
            firstPassHandler.handler();
    
        }
    }

**缺点**

**现有模式的缺点：**

> 每个关卡中都有下一关的成员变量并且是不一样的，形成链很不方便  
> 代码的扩展性非常不好

### 2.2 责任链改造 ###

既然每个关卡中都有下一关的成员变量并且是不一样的，那么我们可以在关卡上抽象出一个父类或者接口，然后每个具体的关卡去继承或者实现。

有了思路，我们先来简单介绍一下责任链设计模式的基本组成：

*  **抽象处理者**（Handler）角色：定义一个处理请求的接口，包含抽象处理方法和一个后继连接。
 *  **具体处理者**（Concrete Handler）角色：实现抽象处理者的处理方法，判断能否处理本次请求，如果可以处理请求则处理，否则将该请求转给它的后继者。
 *  **客户类**（Client）角色：创建处理链，并向链头的具体处理者对象提交请求，它不关心处理细节和请求的传递过程。

![在这里插入图片描述][5cfed77d6b474c1d8630a12be0693daf.png_pic_center]

public abstract class AbstractHandler {
        
    
        /**
         * 下一关用当前抽象类来接收
         */
        protected AbstractHandler next;
    
        public void setNext(AbstractHandler next) {
        
            this.next = next;
        }
    
        public abstract int handler();
    }

public class FirstPassHandler extends AbstractHandler{
        
    
        private int play(){
        
            return 80;
        }
    
        @Override
        public int handler(){
        
            System.out.println("第一关-->FirstPassHandler");
            int score = play();
            if(score >= 80){
        
                //分数>=80 并且存在下一关才进入下一关
                if(this.next != null){
        
                    return this.next.handler();
                }
            }
            return score;
        }
    }

public class SecondPassHandler extends AbstractHandler{
        
    
        private int play(){
        
            return 90;
        }
    
        public int handler(){
        
            System.out.println("第二关-->SecondPassHandler");
    
            int score = play();
            if(score >= 90){
        
                //分数>=90 并且存在下一关才进入下一关
                if(this.next != null){
        
                    return this.next.handler();
                }
            }
    
            return score;
        }
    }

public class ThirdPassHandler extends AbstractHandler{
        
    
        private int play(){
        
            return 95;
        }
    
        public int handler(){
        
            System.out.println("第三关-->ThirdPassHandler");
            int score = play();
            if(score >= 95){
        
                //分数>=95 并且存在下一关才进入下一关
                if(this.next != null){
        
                    return this.next.handler();
                }
            }
            return score;
        }
    }

public class HandlerClient {
        
        public static void main(String[] args) {
        
    
            AbstractHandler firstPassHandler = new FirstPassHandler();//第一关
            AbstractHandler secondPassHandler = new SecondPassHandler();//第二关
            AbstractHandler thirdPassHandler = new ThirdPassHandler();//第三关
    
            // 和上面没有更改的客户端代码相比，只有这里的set方法发生变化，其他都是一样的
            firstPassHandler.setNext(secondPassHandler);//第一关的下一关是第二关
            secondPassHandler.setNext(thirdPassHandler);//第二关的下一关是第三关
    
            //说明：因为第三关是最后一关，因此没有下一关
    
            //从第一个关卡开始
            firstPassHandler.handler();
    
        }
    }

**可以发现, 其上重写的方法均为父类中规定的方法,即职责**

### 2.3 责任链工厂改造 ###

配置工厂,在工厂中完成责任链的层级关系和相关流程

大致过程如下：

public class HandlerFactory {
        
    
        public static AbstractHandler createHandler(){
        
            /**
             * 静态的方法,工厂会初始化好整条职责连的成员
             */
            AbstractHandler  one = new FirstPassHandler ();
            AbstractHandler  two = new SecondPassHandler ();
            AbstractHandler  third = new ThirdPassHandler ();
    
            /**
             * 将责任链连起来
             */
            one.setNext(two);
            two.setNext(third);
            return one;
        }
    }

组装整个职责连

public class ReqCient {
        
    
        /**
         * 消息发送给的目标,这里选用抽象,提高扩展性
         */
        private AbstractHandler handler;
    
        /**
         * 配置客户的处理器
         *
         * @param handler
         */
        public void setHandler(AbstractHandler handler) {
        
            this.handler = handler;
        }
    
        public void reqExecute() {
        
            handler.handler();
        }
    }

测试

public class Test {
        
        public static void main(String[] args) {
        
            //构建请求
            ReqCient client = new ReqCient();
            //配置处理中心
            client.setHandler(HandlerFactory.createHandler());
            //发出请求....
            client.reqExecute();
        }
    }

无论前端还是后端,都和责任链接触良多

*  jdk的异常处理
 *  过滤器链
 *  目前火热的框架 Spring,doubbo,早起的java团队开发的AWT(被观察者模式取代)
 *  前端的js事件模型等等

[1bf93cfb7a0445b494d8ec3baece6639.png_pic_center]: https://img-blog.csdnimg.cn/1bf93cfb7a0445b494d8ec3baece6639.png#pic_center
[5cfed77d6b474c1d8630a12be0693daf.png_pic_center]: https://img-blog.csdnimg.cn/5cfed77d6b474c1d8630a12be0693daf.png#pic_center