`
lvwenwen
  • 浏览: 958708 次
  • 性别: Icon_minigender_1
  • 来自: 魔都
社区版块
存档分类
最新评论

java设计模式之责任链模式(行为模式 )

阅读更多

 

 

(11).责任链模式:

文章链接:http://haolloyin.blog.51cto.com/1177454/342166

职责链模式(Chain of Responsibility):使多个对象都有机会处理请求,从而避免请求的发送者和接收者之间的耦合关系。将这些对象连成一条链,并沿着这条链传递该请求,直到有一个对象处理它为止。

适用场景:

1、有多个的对象可以处理一个请求,哪个对象处理该请求运行时刻自动确定;

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

3、处理一个请求的对象集合应被动态指定。

 

不足之处:

1、对于每一个请求都需要遍历职责链,性能是个问题;

2、抽象处理者 AbstractHandler 类中的 handleRequest() 方法中使用了递归,栈空间的大小也是个问题。

 个人看法:

职责链模式对于请求的处理是不知道最终处理者是谁,所以是运行动态寻找并指定;而命令模式中对于命令的处理时在创建命令是已经显式或隐式绑定了接收者。

 

 

package com.createtype.desginpatterns.responsibility;
// 测试类  
public class Client {  
    public static void main(String[] args) {  
        // 创建指责链的所有节点  
        AbstractHandler handler01 = new Handler01();  
        AbstractHandler handler02 = new Handler02();  
        AbstractHandler handler03 = new Handler03();  
 
        // 进行链的组装,即头尾相连,一层套一层  
        handler01.setNextHandler(handler02);  
        handler02.setNextHandler(handler03);  
 
        // 创建请求并提交到指责链中进行处理  
        AbstractRequest request01 = new Request01("请求-01");  
        AbstractRequest request02 = new Request02("请求-02");  
        AbstractRequest request03 = new Request03("请求-03");  
          
        // 每次提交都是从链头开始遍历  
        handler01.handleRequest(request01);  
        handler01.handleRequest(request02);  
        handler01.handleRequest(request03);  
    }  
} 
package com.createtype.desginpatterns.responsibility;
// 全局变量,接口类型  
/**  
 * 使用Java中的interface定义全局变量,可根据具体需要在   
 * 具体的包中使用静态导入相关的全局变量,语法如下:   
 *  import static package01.package02.*;  
 */ 
interface Levels {  
    public static final int LEVEL_01 = 1;  
    public static final int LEVEL_02 = 2;  
    public static final int LEVEL_03 = 3;  
} 

//抽象请求类  
abstract class AbstractRequest {  
    private String content = null;  
 
    public AbstractRequest(String content) {  
        this.content = content;  
    }  
 
    public String getContent() {  
        return this.content;  
    }  
 
    // 获得请求的级别  
    public abstract int getRequestLevel();  
} 
 
// 具体请求类01  
class Request01 extends AbstractRequest {  
    public Request01(String content) {  
        super(content);  
    }  
 
    @Override 
    public int getRequestLevel() {  
        return Levels.LEVEL_01;  
    }  
}  
 
// 具体请求类02  
class Request02 extends AbstractRequest {  
    public Request02(String content) {  
        super(content);  
    }  
 
    @Override 
    public int getRequestLevel() {  
        return Levels.LEVEL_02;  
    }  
}  
 
// 具体请求类03  
class Request03 extends AbstractRequest {  
    public Request03(String content) {  
        super(content);  
    }  
 
    @Override 
    public int getRequestLevel() {  
        return Levels.LEVEL_03;  
    }  
} 
 
// 抽象处理者类,  
abstract class AbstractHandler {  
    // 责任链的下一个节点,即处理者  
    private AbstractHandler nextHandler = null;  
 
    // 捕获具体请求并进行处理,或是将请求传递到责任链的下一级别  
    public final void handleRequest(AbstractRequest request) {  
 
        // 若该请求与当前处理者的级别层次相对应,则由自己进行处理  
        if (this.getHandlerLevel() == request.getRequestLevel()) {  
            this.handle(request);  
        } else {  
            // 当前处理者不能胜任,则传递至职责链的下一节点  
            if (this.nextHandler != null) {  
                System.out.println("当前 处理者-0" + this.getHandlerLevel()  
                        + " 不足以处理 请求-0" + request.getRequestLevel());  
                  
                // 这里使用了递归调用  
                this.nextHandler.handleRequest(request);  
            } else {  
                System.out.println("职责链上的所有处理者都不能胜任该请求...");  
            }  
        }  
    }  
 
    // 设置责任链中的下一个处理者  
    public void setNextHandler(AbstractHandler nextHandler) {  
        this.nextHandler = nextHandler;  
    }  
 
    // 获取当前处理者的级别  
    protected abstract int getHandlerLevel();  
 
    // 定义链中每个处理者具体的处理方式  
    protected abstract void handle(AbstractRequest request);  
} 
 
// 具体处理者-01  
class Handler01 extends AbstractHandler {  
    @Override 
    protected int getHandlerLevel() {  
        return Levels.LEVEL_01;  
    }  
 
    @Override 
    protected void handle(AbstractRequest request) {  
        System.out.println("处理者-01 处理 " + request.getContent() + "\n");  
    }  
}  
 
// 具体处理者-02  
class Handler02 extends AbstractHandler {  
    @Override 
    protected int getHandlerLevel() {  
        return Levels.LEVEL_02;  
    }  
 
    @Override 
    protected void handle(AbstractRequest request) {  
        System.out.println("处理者-02 处理 " + request.getContent()+ "\n");  
    }  
}  
 
// 具体处理者-03  
class Handler03 extends AbstractHandler {  
    @Override 
    protected int getHandlerLevel() {  
        return Levels.LEVEL_03;  
    }  
 
    @Override 
    protected void handle(AbstractRequest request) {  
        System.out.println("处理者-03 处理 " + request.getContent()+ "\n");  
    }  
} 
分享到:
评论

相关推荐

    JAVA设计模式之行为模式 责任链模式和状态模式

    【JAVA设计模式】在软件开发中,设计模式是解决常见问题的经验总结,它们提供了一种在特定场景下高效、可扩展的解决方案。本篇将探讨两种重要的行为设计模式:责任链模式(Chain of Responsibility Pattern)和状态...

    java设计模式之责任链模式

    在“java设计模式之责任链模式”的主题中,我们可以深入探讨如何在实际项目中应用责任链模式,包括但不限于以下方面: 1. **代码结构优化**:通过责任链模式,可以使代码结构更加清晰,降低类间的耦合度。 2. **可...

    设计模式之责任链模式Java实现

    责任链模式(Chain of Responsibility)是一种行为设计模式,它允许将请求沿着处理者对象的链进行传递,直到某个对象能够处理这个请求为止。在Java中,我们可以通过接口和类的组合来实现这种模式。让我们深入探讨...

    JAVA 设计模式 工厂模式 代理模式 迭代模式 责任链模式 源码

    以下是关于JAVA设计模式中提及的四种模式——工厂模式、代理模式、迭代器模式以及责任链模式的详细说明。 1. **工厂模式**:工厂模式是一种创建型设计模式,它提供了一种创建对象的最佳方式。在工厂模式中,当创建...

    JAVA设计模式之行为模式

    这是JAVA设计模式中属于行为模式的部分,包括Template(模板模式)、Chain of Responsibility(责任链模式)、Memento(纪念品模式)、Mediator(中介模式)、Strategy(策略模式)、State 、Observer(观察者模式)、Visitor...

    java设计模式之责任链(chain of responsibility)

    责任链(Chain of Responsibility)模式是一种行为设计模式,它允许我们向对象链中传递请求,让每个对象决定是否处理这个请求。在Java中,这种模式常用于事件处理、日志系统或者权限控制等场景,其核心思想是将处理...

    Java模式之责任链

    【Java模式之责任链】 责任链模式是一种行为设计模式,它允许将请求沿着处理者对象的链进行传递,直到某个对象能够处理这个请求。在Java中,这种模式常用于事件处理或者分层处理系统,例如在Spring框架的AOP切面...

    JAVA设计模式(java设计)

    Java设计模式是面向对象编程领域中的重要概念,它是一套被广泛接受并实践的解决软件设计问题的经验总结。设计模式并非具体的代码或库,而是一种在特定情境下为了解决常见问题而制定的通用解决方案的描述。它们描述了...

    java设计模式

    目录: 前 言 第一部分 大旗不挥,谁敢冲锋——热身篇 第1章 单一职责原则 1.1 我是“牛”类,我可以担任多职吗 1.2 绝杀技,打破你的传统思维 1.3 我单纯,所以我快乐 1.4 最佳实践 ...附录:23个设计模式

    JAVA-设计模式-行为型模式-责任链模式

    JAVA-设计模式-行为型模式-责任链模式

    Java设计模式之禅

    《Java设计模式之禅》是一本深入浅出讲解设计模式的书籍,书中不仅包含23种经典设计模式的案例,还详细介绍了设计模式背后的思想和原则,适合初学者以及对设计模式有一定了解的程序员阅读。本书旨在帮助读者理解如何...

    java设计模式ppt

    ### Java设计模式详解 在软件开发领域,设计模式是一种被广泛采用的解决方案,用来解决常见的设计问题。设计模式不仅能够帮助开发者写出可复用、可维护的代码,还能提高团队间的沟通效率。以下是对给定文件中提到的...

    《java设计模式》课后习题模拟试题解答——刘伟.zip

    Java设计模式是软件工程中的一种最佳实践,它总结了在特定场景下解决常见问题的经验,为程序员提供了可重用的解决方案。本资料“《java设计模式》课后习题模拟试题解答——刘伟.zip”主要涵盖了Java设计模式的学习与...

    23种java设计模式.pdf

    JAVA 设计模式可以分为三种:创建模式、结构模式和行为模式。 1. 创建模式 创建模式是指在创建对象时使用的模式,包括 Factory(工厂模式)、Singleton(单例模式)、Builder(建造者模式)、Prototype(原型模式...

    重学java的设计模式

    本文将着重探讨创建型模式、结构型模式和行为模式这三大类设计模式,并结合六项设计原则进行深入解析。 首先,我们来看创建型模式。创建型模式关注于对象的创建,它们提供了创建对象的灵活方式,使得代码更具复用性...

    JAVA设计模式chm文档

    创建模式: ...设计模式之Chain of Responsibility(职责链) 设计模式之Command 设计模式之State 设计模式之Strategy(策略) 设计模式之Mediator(中介者) 设计模式之Interpreter(解释器) 设计模式之Visitor

    《Java设计模式》刘伟 课后习题及模拟试题答案.rar

    行为型模式则包括责任链模式、命令模式、观察者模式等,它们主要用于规定对象之间的交互方式,以及如何在运行时分配职责,提高系统的灵活性和可扩展性。 在解答这些习题的过程中,读者需要深刻理解每种模式的适用...

    【Java设计模式-源码】责任链模式:构建强大的请求处理机制

    在 Java 开发中,责任链模式是一种重要的行为设计模式,它可以解耦请求的发送者和接收者,使多个对象都有机会处理请求。本文将详细介绍责任链模式的意图、解释、编程示例、适用场景、实际应用、优点和权衡。同时,还...

Global site tag (gtag.js) - Google Analytics