设计模式(十二)责任链模式

一、击鼓传花

击鼓传花是一种热闹而又紧张的饮酒游戏。在酒宴上宾客一次坐定位置,由一人击鼓,击鼓的地方与传花的地方是分开的,以示公正。开始击鼓时,花束就开始依次传递,鼓声一落,如果花束在某人手中,则该人就得饮酒。

比如说,贾母、贾赦、贾政、贾宝玉和贾环是五个参加击鼓传花游戏的传花者,他们组成一个环链。击鼓者将花传给贾母,开始传花游戏。花由贾母传给贾赦,贾赦传给贾政,贾政传给贾宝玉,贾宝玉传给贾环,贾环再传给贾母,由此往复,如下图所示。

击鼓传花便是一种典型的责任链模式。

二、什么是责任链模式

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

三、责任链模式的结构

● 抽象处理者(Handler)角色:定义出一个处理请求的接口。如果需要,接口可以定义 出一个方法以设定和返回对下家的引用。这个角色通常由一个Java抽象类或者Java接口实现。上图中Handler类的聚合关系给出了具体子类对下家的引用,抽象方法handleRequest()规范了子类处理请求的操作。

● 具体处理者(ConcreteHandler)角色:具体处理者接到请求后,可以选择将请求处理掉,或者将请求传给下家。由于具体处理者持有对下家的引用,因此,如果需要,具体处理者可以访问下家。

四、责任链模式的实例

我为更清楚的看出责任链模式的结构,我们先来看一看最简答的代码实现。

package com.designpattern.pre1;

/**
 * 抽象处理者,定义处理者的接口
 *
 * @author 98583
 *
 */
public abstract class Handler {
    /**
     * 下一个处理者
     */
    protected Handler successor;

    /**
     * 每个处理者的处理方法
     */
    public abstract void handleRequest();

    /**
     * 设置下一个处理者
     *
     * @param successor
     */
    public void setSuccessor(Handler successor) {
        this.successor = successor;
    }

    /**
     * 获取下一个处理者
     *
     * @return
     */
    public Handler getSuccessor() {
        return successor;
    }
}
package com.designpattern.pre1;

/**
 * 具体处理者
 *
 * @author 98583
 *
 */
public class ConcreteHandler extends Handler {
    /**
     * 处理方法
     */
    public void handleRequest() {
        /**
         * 如果有下一个处理者就交给下一个处理者,但是实际情况中应该判断这个处理者能否处理这个问题,不能处理才传给下一个处理者
         */
        if (getSuccessor() != null) {
            System.out.println("The request is passed to " + getSuccessor());
            getSuccessor().handleRequest();
        }// 在这个处理者中处理
        else {
            System.out.println("The request is handled here.");
        }
    }
}

package com.designpattern.pre1;

public class Client {

    static private Handler handler1, handler2;

    public static void main(String[] args) {
        /**
         * 定义两个处理者
         */
        handler1 = new ConcreteHandler();
        handler2 = new ConcreteHandler();

        handler1.setSuccessor(handler2);
        handler1.handleRequest();
    }
}

现在了解了责任链模式的基本结构,我们可以来实现上边的红楼梦中的击鼓传花的故事了。

package com.designpattern.chainofresp;

/**
 * 相当于抽象的Handler
 * @author 98583
 *
 */
abstract class Player {
    abstract public void handle(int i);

    /**
     * 下一位处理者
     */
    private Player successor;

    public Player() {
        successor = null;
    }

    /**
     * 设置下一个处理者
     * @param aSuccessor
     */
    protected void setSuccessor(Player aSuccessor) {
        successor = aSuccessor;
    }

    /**
     * 传给下一个处理者,这个方法本不应该出现在这,因为每个处理者中都有这个方法,所以就放到父类中来了
     * @param index
     */
    public void next(int index) {
        if (successor != null) {
            successor.handle(index);
        } else {
            System.out.println("Program terminated.");
        }
    }
}
package com.designpattern.chainofresp;

/**
 * 贾母的类相当于ConcreteHandler
 * @author 98583
 *
 */
class JiaMu extends Player {
    public JiaMu(Player aSuccessor) {
        this.setSuccessor(aSuccessor);
    }

    /**
     * 这个处理和的处理方法
     */
    public void handle(int i) {
        if (i == 1) {
            System.out.println("Jia Mu gotta drink!");
        } else {
            System.out.println("Jia Mu passed!");
            /**
             * 传给下一个处理者
             */
            next(i);
        }
    }

}

其他人的类与贾母的类相似,不再贴出,最后附上源码。

package com.designpattern.chainofresp;

/**
 * 击鼓者,相当于客户端
 * @author 98583
 *
 */
public class DrumBeater
{
    private static Player player;

    static public void main(String[] args)
    {
        JiaMu jiaMu = new JiaMu(null);

        jiaMu.setSuccessor( new JiaShe (
            new JiaZheng(
            new JiaBaoYu(
            new JiaHuan( jiaMu ) ) ) ) );

        player = jiaMu;

        player.handle(4);
    }
}

五、责任链模式

优点:

  • 降低耦合度
  • 可简化对象的相互连接
  • 增强给对象指派职责的灵活性
  • 增加新的请求处理类很方便

缺点:

  • 不能保证请求一定被接收
  • 系统性能将受到一定影响,而且在进行代码调试时不太方便;可能会造成循环调用

六、适用环境

1、有多个对象可以处理同一个请求,具体哪个对象处理该请求由运行时刻自动确定。

2、在不明确指定接收者的情况下,向多个对象中的一个提交一个请求。

3、可动态指定一组对象处理请求

http://download.csdn.net/detail/xingjiarong/9329017

时间: 2024-11-05 22:47:32

设计模式(十二)责任链模式的相关文章

设计模式 ( 十二 ) 职责链模式(Chain of Responsibility)(对象行为)

 设计模式(十二)职责链模式(Chain of Responsibility)(对象行为型) 1.概述 你去政府部门求人办事过吗?有时候你会遇到过官员踢球推责,你的问题在我这里能解决就解决.不能解决就推卸给另外个一个部门(对象).至于究竟谁来解决问题呢?政府部门就是为了能够避免屁民的请求与官员之间耦合在一起,让多个(部门)对象都有可能接收请求,将这些(部门)对象连接成一条链,而且沿着这条链传递请求.直到有(部门)对象处理它为止. 样例1:js的事件浮升机制 样例2: 2.问题 假设有多个对象都有

设计模式(十二)职责链模式(Chain of Responsibility)(对象行为型)

1.概述 你去政府部门求人办事过吗?有时候你会遇到过官员踢球推责,你的问题在我这里能解决就解决,不能解决就推卸给另外个一个部门(对象).至于到底谁来解决这个问题呢?政府部门就是为了可以避免屁民的请求与官员之间耦合在一起,让多个(部门)对象都有可能接收请求,将这些(部门)对象连接成一条链,并且沿着这条链传递请求,直到有(部门)对象处理它为止. 例子1:js的事件浮升机制 例子2: 2.问题 如果有多个对象都有可能接受请求,如何避免避免请求发送者与接收者耦合在一起呢? 3.解决方案 职责链模式(Ch

java23种设计模式之十:责任链模式

最近在学习netty中发现其中用到了责任链模式,然后结合自己在写代码中遇到了大量写if...else的情况,决定学习一下责任链模式. 一.什么样的场景下会选择用责任链模式 我们在进行业务逻辑判断时,需要根据传入参数类型的不同做出不同的处理,如果在传入的参数类型相对较少的情况时,可以用if...else来做判断,这样的确是没有什么问题的,但是如果后期由于业务系统的扩展,导致参数类型会随之延伸出很多种不同的处理,这时就需要用责任链模式来抒代码重构,这样会让代码封装的更好.更简洁,阅读性更强,后期如果

[设计模式-行为型]责任链模式(Chain of Responsibility)

概括 名称 Chain of Responsibility 结构 动机 使多个对象都有机会处理请求,从而避免请求的发送者和接收者之间的耦合关系.将这些对象连成一条链,并沿着这条链传递该请求,直到有一个对象处理它为止. 适用性 有多个的对象可以处理一个请求,哪个对象处理该请求运行时刻自动确定. 你想在不明确指定接收者的情况下,向多个对象中的一个提交一个请求. 可处理一个请求的对象集合应被动态指定. 解析 形象比喻: 晚上去上英语课, 为了好开溜坐到了最后一排, 哇, 前面坐了好几个漂亮的MM 哎

设计模式之二十:责任链模式(Chain of Responsibility)

感觉这个设计模式和组合模式一样是一种非常巧妙的设计模式,在须要使用它的地方假设不使用这样的设计模式代码会变的非常复杂,可是这样的设计模式的基本原理又是非常easy的. 责任链模式: 通过使多个对象都有机会来处理请求的方式避免了请求的发送者和接收者之间的耦合.将接收者组织成链式的结构这样能够将请求沿着这条链进行传递,直到有接收者对它进行处理. UML类图: 主要包含: Handler:定义了一个处理请求的接口,实现了定义后继者的方法. ConcreteHandler:处理各自负责的请求,假设不能处

Java设计模式菜鸟系列(十八)责任链模式建模与实现

转载请注明出处:http://blog.csdn.net/lhy_ycu/article/details/40018231 责任链模式(ChainOfResponsibility): 有多个对象,每个对象持有下一个对象的引用,形成一条链,请求在这条链上传递,直到某一对象决定处理该请求,但是发出者并不清楚最终哪个对象会处理该请求. 一.uml建模: 二.代码实现 /** * 责任链模式:有多个对象,每个对象持有下一个对象的引用,形成一条链, * * 请求在这条链上传递,直到某一对象决定处理该请求,

Java设计模式系列之责任链模式

责任链模式 责任链模式是一种对象的行为模式.在责任链模式里,很多对象由每一个对象对其下家的引用而连接起来形成一条链.请求在这个链上传递,直到链上的某一个对象决定处理此请求.发出这个请求的客户端并不知道链上的哪一个对象最终处理这个请求,这使得系统可以在不影响客户端的情况下动态地重新组织和分配责任.Tomcat中的Filter就是使用了责任链模式,创建一个Filter除了要在web.xml文件中做相应配置外,还需要实现javax.servlet.Filter接口. 为了方便理解,责任链模式直接用马士

[设计模式] javascript 之 责任链模式

责任链模式:定义 责任链接模式又称职责链模式,是一种对象的行为模式:它是一种链式结构,每个节点都有可能两种操作,要么处理该请求停止该请求操作,要么把请求转发到下一个节点,让下一个节点来处理请求:该模式定义了一些可能的处理请求的节点对象,请求的起点跟顺序都可能不一样,处理的节点根据请求的不一样而不同:请求者不必知道数据处理完成是由谁来操作的,内部是一个黑箱的操作过程,这是它的一个核心内容: 责任链模式:角色 抽象处理者角色:定义处理方法,以配置是否具有下个节点(Handler)对象; 具体处理者角

设计模式学习-责任链模式

1.定义 避免请求发送者与接收者耦合在一起,让多个对象都有可能接收请求,将这些对象连接成一条链,并且沿着这条链传递请求,直到有对象处理它为止. 2.类图 3.代码示例 1 package com.zhaoyangwoo.chainOfResponsibility; 2 3 /** 4 * Created by john on 16/6/16. 5 * 职责链模式,经费审批场景 6 */ 7 public class Responsibility { 8 9 public static void

《Java设计模式》之责任链模式

责任链模式是一种对象的行为模式.在责任链模式里,很多对象由每一个对象对其下家的引用而连接起来形成一条链.请求在这个链上传递,直到链上的某一个对象决定处理此请求.发出这个请求的客户端并不知道链上的哪一个对象最终处理这个请求,这使得系统可以在不影响客户端的情况下动态地重新组织和分配责任. 从击鼓传花谈起 击鼓传花是一种热闹而又紧张的饮酒游戏.在酒宴上宾客依次坐定位置,由一人击鼓,击鼓的地方与传花的地方是分开的,以示公正.开始击鼓时,花束就开始依次传递,鼓声一落,如果花束在某人手中,则该人就得饮酒.