走穿java23种设计模式-15责任链模式详解

你的名字 2022-05-31 09:22 221阅读 0赞

# 走穿java23种设计模式-15责任链模式详解 #

责任链模式是一种常见的行为模式。

## 一.责任链模式的现实场景 ##

习伟过生日邀请了很多朋友到KTV一起庆祝，为了增加欢乐的气氛，习伟建议大家一起玩击鼓传花的游戏。由习伟击鼓，大家依次往下传花，鼓声停下来时，花在谁手上就要喝酒并且还要唱一首歌。  
大家都很踊跃地参加这个游戏，聚会的气氛很快热闹起来，习伟也度过了一个很快乐的生日聚会。

在上面的这个场景中，击鼓传花的这个游戏过程类似于设计模式中的责任链模式，就是要事件不断的进行传递，直到事件被执行为止。

## 二.责任链模式（Chain of Respinsibility Pattern）的定义 ##

使多个对象都有处理请求的机会，从而避免了请求的发送者和接收者之间的耦合关系。将这些对象串成一条链，并沿着这条链依次传递请求，直到有对象处理它为止。

## 三.责任链模式的类图 ##

![1][]  
这里类图中看起来是抽象类直接调用自己，但是实际是他的子类具体处理者调用下一个具体具体处理者。

## 四.责任链模式的两个角色 ##

### 1.抽象处理者（Handler）角色 ###

该角色对请求进行抽象，并定义一个方法来设定和返回对下一个处理者的引用。

### 2.具体处理者（Concrte Handler）角色 ###

该角色接到请求后，可以选择将请求处理掉，或者将请求传递给下一个处理者。  
由于具体处理者持有对下一个处理者的引用，因此，如果需要，具体处理者可以访问下一个处理者，把问题給下一个处理者，并以此类推。

## 五.责任链模式的优缺点 ##

### 责任链模式中的优点 ###

#### 1. 责任链模式将请求和处理分开，请求者不知道是谁处理，处理者可以不用知道请求者全貌。 ####

#### 2. 提高系统的灵活性 ####

### 命令模式的缺点 ###

#### 1.降低程序的性能。每个请求都是从链头遍历到链尾，当遇到链比较长的时候，性能就会大幅下降。 ####

#### 2.不易于调试，由于该模式采用了类似递归的方式，调试的时候逻辑比较复杂。 ####

责任链中的节点数量需要控制，避免出现超长链的情况，这就需要设置一个最大的节点数量，一旦超过则不允许增加节点，避免责任链无意识地破化系统性能。

## 六.责任链模式的使用场景 ##

责任链模式是一种常见的模式，Struts2的核心控件FilterDispatcher是一个Servlet过滤器，该控件就是采用责任链模式，可以对用户请求进行层层过滤处理。责任链模式在实际项目中的使用也是有的，其典型的应用场景如下：

### 1.一个请求需要一系列的处理工作。 ###

### 2.业务流的处理，例如文件审批。 ###

### 3.对系统进行扩展。 ###

## 七.责任链模式的示例 ##

这里使用上面的现实常见做代码示例。

## 示例的类图 ##

![2][]  
方法的作用看代码。。。

## 示例的代码 ##

### 抽象处理类Player ###

package p15_ChainOfRespinsibility;
    
    /**
     * 抽象处理者
     */
    public abstract class Player {
        
    
        //具体的传花人
        private  Player successor;
    
        //传入下一个具体的传花人
        protected void setSuccessor(Player successor){
            this.successor=successor;
        }
    
        //传递的过程
        public abstract  void handle(int i);
    
        //传递給下一个
        public void next(int index){
            if (successor!=null) {
                successor.handle(index);
            }else {
                System.out.println("游戏结束！");
            }
        }
    
    }

### 具体处理类PlayerA ###

package p15_ChainOfRespinsibility;
    
    /**
     * 具体处理者，传花人
     */
    public class PlayerA extends Player {
        
    
        //构造方法,传入下一个传花人
        public PlayerA(Player successor) {
            this.setSuccessor(successor);
        }
    
    
        //传花的过程
        @Override
        public void handle(int i) {
            if (i==1){
                System.out.println("PlayerA 喝酒！");
            }else {
                System.out.println("PlayerA 向下传花！");
                next(i);
            }
    
        }
    }

### 具体处理类PlayerB ###

package p15_ChainOfRespinsibility;
    
    /**
     * 具体处理者，传花人
     */
    public class PlayerB extends Player {
        
    
        //构造方法,传入下一个传花人
        public PlayerB(Player successor) {
            this.setSuccessor(successor);
        }
    
    
        //传花的过程
        @Override
        public void handle(int i) {
            if (i==2){
                System.out.println("PlayerB 喝酒！");
            }else {
                System.out.println("PlayerB 向下传花！");
                next(i);
            }
    
        }
    }

### 具体处理类PlayerC ###

package p15_ChainOfRespinsibility;
    
    /**
     * 具体处理者，传花人
     */
    public class PlayerC extends Player {
        
    
        //构造方法,传入下一个传花人
        public PlayerC(Player successor) {
            this.setSuccessor(successor);
        }
    
    
        //传花的过程
        @Override
        public void handle(int i) {
            if (i==3){
                System.out.println("PlayerC 喝酒！");
            }else {
                System.out.println("PlayerC 向下传花！");
                next(i);
            }
    
        }
    }

### 具体处理类PlayerD ###

package p15_ChainOfRespinsibility;
    
    /**
     * 具体处理者，传花人
     */
    public class PlayerD extends Player {
        
    
        //构造方法,传入下一个传花人
        public PlayerD(Player successor) {
            this.setSuccessor(successor);
        }
    
    
        //传花的过程
        @Override
        public void handle(int i) {
            if (i==4){
                System.out.println("PlayerD 喝酒！");
            }else {
                System.out.println("PlayerD 向下传花！");
                next(i);
            }
    
        }
    }

上面PlayerABCD类都是类似的，只是传花过程，对自己的判断不一样。

### 事件类，测试类DrumBeater ###

package p15_ChainOfRespinsibility;
    
    /**
     * 击鼓者
     *测试类
     */
    public class DrumBeater {
        
    
        public static void main(String args[]){
            //创建一个链
            PlayerD playerD=new PlayerD(null);
            PlayerC playerC=new PlayerC(playerD);
            PlayerB playerB=new PlayerB(playerC);
            PlayerA playerA=new PlayerA(playerB);
    
            //击鼓三次下停下来
            playerA.handle(3);
    
        }
    }

## 程序运行结果； ##

![3][]  
这里击鼓3下就是C喝酒，如果击鼓4下就是D喝酒，如果击鼓五下，没有人要喝酒，游戏结束。

但是实际生活的传花游戏，一般会循环开始，也就是D会继续传给A，这里把把i==换成i%4==就可以了。  
但是责任链模式基本是没有把事件再重新让所有处理者再处理的。。。

命令模式模式就为大家介绍到这里。

大家如果对其他设计模式有兴趣可以看看我之前的博客：

14命令模式：[http://blog.csdn.net/wenzhi20102321/article/details/79323404][http_blog.csdn.net_wenzhi20102321_article_details_79323404]

13模板方法模式：[http://blog.csdn.net/wenzhi20102321/article/details/79284870][http_blog.csdn.net_wenzhi20102321_article_details_79284870]

12享元模式：[http://blog.csdn.net/wenzhi20102321/article/details/78724677][http_blog.csdn.net_wenzhi20102321_article_details_78724677]

11外观模式：[http://blog.csdn.net/wenzhi20102321/article/details/78639087][http_blog.csdn.net_wenzhi20102321_article_details_78639087]

10桥梁模式：[http://blog.csdn.net/wenzhi20102321/article/details/78566532][http_blog.csdn.net_wenzhi20102321_article_details_78566532]

9组合模式：[http://blog.csdn.net/wenzhi20102321/article/details/78463190][http_blog.csdn.net_wenzhi20102321_article_details_78463190]

8适配器模式：[http://blog.csdn.net/wenzhi20102321/article/details/78389326][http_blog.csdn.net_wenzhi20102321_article_details_78389326]

7装饰模式：[http://blog.csdn.net/wenzhi20102321/article/details/78336273][http_blog.csdn.net_wenzhi20102321_article_details_78336273]

6代理模式：[http://blog.csdn.net/wenzhi20102321/article/details/78209493][http_blog.csdn.net_wenzhi20102321_article_details_78209493]

创建型模式详解：[http://blog.csdn.net/wenzhi20102321/article/details/78175558][http_blog.csdn.net_wenzhi20102321_article_details_78175558]

5原型模式：[http://blog.csdn.net/wenzhi20102321/article/details/78167984][http_blog.csdn.net_wenzhi20102321_article_details_78167984]

4建造者模式：[http://blog.csdn.net/wenzhi20102321/article/details/78163855][http_blog.csdn.net_wenzhi20102321_article_details_78163855]

3抽象工厂模式：[http://blog.csdn.net/wenzhi20102321/article/details/78153437][http_blog.csdn.net_wenzhi20102321_article_details_78153437]  
2工厂方法模式：[http://blog.csdn.net/wenzhi20102321/article/details/78129065][http_blog.csdn.net_wenzhi20102321_article_details_78129065]  
可以仔细对比一下工厂方法模式和抽象工厂模式，看看概念，看看类图，看看代码，就会明白了。

1单例模式：[http://blog.csdn.net/wenzhi20102321/article/details/77882203][http_blog.csdn.net_wenzhi20102321_article_details_77882203]

java 23种设计模式介绍：[http://blog.csdn.net/wenzhi20102321/article/details/54601909][http_blog.csdn.net_wenzhi20102321_article_details_54601909]

在这新春佳节之际，祝大家，新年愉快，新年新气象，在新的一年里能实现更多的人生价值。

# 共勉；当我们发现自己老了，其实并不是年纪大了，而是心不在年轻。 #

[1]: https://i.imgur.com/MpbBj1d.png
[2]: https://i.imgur.com/c0wYlcn.png
[3]: https://i.imgur.com/qIX4xRY.png
[http_blog.csdn.net_wenzhi20102321_article_details_79323404]: http://blog.csdn.net/wenzhi20102321/article/details/79323404
[http_blog.csdn.net_wenzhi20102321_article_details_79284870]: http://blog.csdn.net/wenzhi20102321/article/details/79284870
[http_blog.csdn.net_wenzhi20102321_article_details_78724677]: http://blog.csdn.net/wenzhi20102321/article/details/78724677
[http_blog.csdn.net_wenzhi20102321_article_details_78639087]: http://blog.csdn.net/wenzhi20102321/article/details/78639087
[http_blog.csdn.net_wenzhi20102321_article_details_78566532]: http://blog.csdn.net/wenzhi20102321/article/details/78566532
[http_blog.csdn.net_wenzhi20102321_article_details_78463190]: http://blog.csdn.net/wenzhi20102321/article/details/78463190
[http_blog.csdn.net_wenzhi20102321_article_details_78389326]: http://blog.csdn.net/wenzhi20102321/article/details/78389326
[http_blog.csdn.net_wenzhi20102321_article_details_78336273]: http://blog.csdn.net/wenzhi20102321/article/details/78336273
[http_blog.csdn.net_wenzhi20102321_article_details_78209493]: http://blog.csdn.net/wenzhi20102321/article/details/78209493
[http_blog.csdn.net_wenzhi20102321_article_details_78175558]: http://blog.csdn.net/wenzhi20102321/article/details/78175558
[http_blog.csdn.net_wenzhi20102321_article_details_78167984]: http://blog.csdn.net/wenzhi20102321/article/details/78167984
[http_blog.csdn.net_wenzhi20102321_article_details_78163855]: http://blog.csdn.net/wenzhi20102321/article/details/78163855
[http_blog.csdn.net_wenzhi20102321_article_details_78153437]: http://blog.csdn.net/wenzhi20102321/article/details/78153437
[http_blog.csdn.net_wenzhi20102321_article_details_78129065]: http://blog.csdn.net/wenzhi20102321/article/details/78129065
[http_blog.csdn.net_wenzhi20102321_article_details_77882203]: http://blog.csdn.net/wenzhi20102321/article/details/77882203
[http_blog.csdn.net_wenzhi20102321_article_details_54601909]: http://blog.csdn.net/wenzhi20102321/article/details/54601909