CoR 模式 (一种)

步行者

浏览: 170135 次
性别:
来自: 武汉

最近访客更多访客>>

痞夫balabala

hzldds2000

canicula0811

402230366

博主相关

博客

微博

相册

留言

关于我

文章分类

社区版块

存档分类

博客分类：

设计模式

设计模式企业应用编程 Servlet 框架

CoR(Chain of Responsibility) 即职责链设计模式：使多个对象都有机会处理请求（Request），从而避免请求的发送者和接受者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理他为止。

职责链设计模式大概有三个角色：
（1）请求（Request）：封装请求信息
（2）处理器（Handler）：处理请求（Request），一个具体处理器一般只处理一种请求，如果它不能处理传递过来的请求，那么它就把该请求传递给职责链中的下一个处理器（后继处理器 successor）。
（3）客户端（Client）：发送请求

定义不再多说，直接看实现。下面是一个传统的CoR实现：

1，代表抽象请求的接口(Request)

public interface Request{
    //......
}

2，实现Request接口的实现类，HelpRequest，PrintRequest，SaveRequest
假设有一个文本编辑器，用户界面上有三个按钮 Help，Print 和 Save
HelpRequest 代表当用户点击 Help 按钮时产生的帮助请求，

PrintRequest 代表当用户点击 Print 按钮时产生的打印请求，
SaveRequest 代表当用户点击 Save 按钮时产生的保存请求。

//帮助请求
public class HelpRequest implements Request{
    //......
}
//打印请求
public class PrintRequest implements Request{
    //......
}
//保存请求
public class SaveRequest implements Request{
    //......
}

3，代表抽象处理器的接口Handler：

public interface Handler{
    void handleRequest(Request request);
}

4，实现处理器接口的实现类 HelpHandler，PrintHandler，SaveHandler：
HelpHandler 处理帮助请求（HelpRequest）

public class HelpHandler implements Handler{
    //后继处理器
    private Handler successor;
    public HelpHandler(Handler successor){this.successor = successor;}
    public void handleRequest(Request request) {
        if(request instanceof HelpRequest){
             System.out.println("HelpHandler handle " +request.getClass().getSimpleName());
             // handle request
        }else{
            System.out.println("PrintHandler can't handle "+request.getClass().getSimpleName());
            if(successor != null)
                successor.handleRequest(request);
        }
    }
}

PrintHandler 处理打印请求（PrintRequest）

public class PrintHandler implements Handler{
    //后继处理器
    private Handler successor;
    public PrintHandler(Handler successor){this.successor = successor;}
    public void handleRequest(Request request) {
        if(request instanceof PrintRequest){
            System.out.println("PrintHandler handle "+request.getClass().getSimpleName());
            // handle request
        }else{
            System.out.println("PrintHandler can't handle "+request.getClass().getSimpleName());
           if(successor != null)
                successor.handleRequest(request);
        }
    }
}

SaveHandler处理保存请求（SaveRequest）

public class SaveHandler implements Handler{
    //后继处理器
    private Handler successor;
    public SaveHandler(Handler successor){this.successor = successor;}
    public void handleRequest(Request request) {
        if(request instanceof SaveRequest){
            System.out.println("SaveHandler handle "+request.getClass().getSimpleName());
            // handle request
        }else{
            System.out.println("SaveHandler can't handle "+request.getClass().getSimpleName());
            if(successor != null)
                successor.handleRequest(request);
        }
    }
}

5，客户端 Client 类

public class Client{
    public static void main(String[] args){
        Handler handler1 = new HelpHandler(null);
        Handler handler2 = new PrintHandler(handler1);
        Handler handler3 = new SaveHandler(handler2);

        handler3.handleRequest(new HelpRequest());
        handler3.handleRequest(new PrintRequest());
        handler3.handleRequest(new SaveRequest());
    }
}

运行 Client 类输出如下：

SaveHandler can't handle HelpRequest
PrintHandler can't handle HelpRequest
HelpHandler handle HelpRequest
SaveHandler can't handle PrintRequest
PrintHandler handle PrintRequest
SaveHandler handle SaveRequest

相关链接： http://www.iteye.com/topic/411222 CoR 模式 (另一种)

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

用抽象类也可以，不过要把 handleRequest 中
（1）这个处理器是否能处理这个请求
和
（2）处理相应的请求
这两个功能分离出来，定义成抽象方法供子类（具体处理器）实现

public abstract class AbstractHandler implements Handler {    
    protected Handler successor;    
    public AbstractHandler(Handler successor) {    
        this.successor = successor;    
    }    
    //定义为final,不能被子类继承  
    public final void handleRequest(Request request) {    
        if (canHandleRequest(request)) {    
            handleRequestMyself(request);  
        } else {    
            if (successor != null)    
                successor.handleRequest(request);    
        }    
    }    
    //这个处理器能否处理整个请求  
    protected abstract boolean canHandleRequest(Request request);  
    //处理相应的请求  
    protected abstract void handleRequestMyself(Request request);  
}   

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

PipeLine + Value

lishuaibt 写道

其实纯的责任链模式我的理解是，一种责任推卸的模式，知道有承担责任的模块接收这个请求，并处理这个请求。这样的情况确实不太多吧。（个人觉得哈）。所谓的 pipeline的概念，在以前的turbine框架（一个非常优秀的MVC框架）中就有使用。其大体模式和概念如下：
其实PipeLine类似于Servlet里的FilterChain的概念，而valve类似于Filter。就是一个请求流经这个PipeLine中的每个Valve节点，该节点都对这个请求做一定的处理，而不是纯的责任链模式那样，把责任往下推。是想做了相应的处理后，在把处理后的请求移交给下一个 Valve进行处理。举个例子：在一次请求Servlet的过程中，可能有些处理是所有的请求都需要做的，比如设置CharSet，权限验证，或者URL 的解析等等，这些处理构成了一个请求的Chain，所有的请求都要经过这些处理，才能进行下面的具体的业务处理。这个时候既可以这些共有的处理抽象出来，做成一个pipeline，这个pipeline有过个valve节点组成。。。。

差不多就这个意思吧。。。用文字形容确实不太好说。

分享到：

CoR 模式（另一种） | 关于 Web Service 的一些理解

2009-06-18 22:07
浏览 2193
评论(34)
论坛回复 / 浏览 (34 / 16409)
分类:企业架构
查看更多

34 楼步行者 2009-07-02

艾建锋写道

if(action.equal("help")
{
    HelpClass.fun();
}
else if(..)
{
    ....
}
else
{
   ...
}

是不是这个意思？

你这个是什么意思？？？

33 楼艾建锋 2009-07-02

if(action.equal("help")
{
    HelpClass.fun();
}
else if(..)
{
    ....
}
else
{
   ...
}

是不是这个意思？

32 楼 rain2005 2009-06-30

我一直没有模式的概念，就知道不断的重构，抽象。

31 楼步行者 2009-06-30

xiaohui5850 写道

实际上这个就是一个方法回调
啥时候成模式了

？？？
java 不用方法调用，怎么实现模式啊。。。

30 楼 lishuaibt 2009-06-24

raymond2006k 写道

不必把职责链理解的那么死。
一个Handler 先处理 request 再交给 successor 那不就成了 “不推卸责任”了吗？

而职责链的缺陷是 Handler 与 Successor 耦合了。
而PipeLine(可以算是一种改进的职责链模式)的好处是, Handler 是独立的互不耦合；怎样装配Handler，按什么顺序都有 PipeLine 来进行，一般是xml 配置文件，保持了很好的灵活性。

同意！其实真正GoF里边介绍的纯的责任链模式我个人觉得适用范围很小！反而这种pipeline的思想用的更多一些吧

29 楼步行者 2009-06-24

raymond2006k 写道

主题帖给出的是职责链模式的简单实现方式
简单才能直观嘛

“一个Handler 先处理 request 再交给 successor 那不就成了 “不推卸责任”了吗？”
你这么说证明你没好好看主题帖
handler首先检查自己是否能处理这个request，如果能处理，就处理
不能处理再交给successor

PipeLine和传统职责链的主要区别也不是你所说
主要区别是 PipeLine 中的 Value “可能推卸部分职责”
而传统职责链中的 handler “如果不能处理则推卸全部职责”

28 楼 raymond2006k 2009-06-24

27 楼 pipilu 2009-06-23

这个模式不一定只用于同一进程中，也可以是跨进程的：各个模块都向外暴露同样的服务接口，模块可以灵活装配。方便扩展和订制。

26 楼步行者 2009-06-23

回复上贴： 用抽象类也可以，不过要把 handleRequest 中 （1）这个处理器是否能处理这个请求 和 （2）处理相应的请求 这两个功能分离出来，定义成抽象方法供子类（具体处理器）实现 
<pre name="code" class="java">public abstract class AbstractHandler implements Handler {
 protected Handler successor;
 public AbstractHandler(Handler successor) {
 this.successor = successor;
 }
 //定义为final,不能被子类继承
 public final void handleRequest(Request request) {
 if (canHandleRequest(request)) {
 handleRequestMyself(request);
 } else {
 if (successor != null)
 successor.handleRequest(request);
 }
 }
 //这个处理器能否处理整个请求
 protected abstract boolean canHandleRequest(Request request);
 //处理相应的请求
 protected abstract void handleRequestMyself(Request request);
} </pre>

25 楼 llade 2009-06-23

似乎应该做个抽象父类。然后其他几个handler继承这个抽象父类。

public abstract class AbstractHandler implements Handler {
	
	protected Handler successor;

	public AbstractHandler(Handler successor) {
		this.successor = successor;
	}

	public void handleRequest(Request request) {
		if (this.getClass().isInstance(request)) {
			System.out.println("handle "
					+ request.getClass().getSimpleName());
		} else {
			System.out.println("can't handle "
					+ request.getClass().getSimpleName());
			if (successor != null)
				successor.handleRequest(request);
		}
	}
}

BTW:此类模式应用真的不多见了。链式处理过程，无非两种：有顺序的和无顺序的。而且现代点的代码大多是配置型的，最著名的莫过于Servlet的Filter了。

24 楼步行者 2009-06-22

呵呵极端了
我的意思是不要把所有事想的太极端
我说了现在的 “长” 是为了以后的 ”短”
现在“长”不是错，为了以后能更短
长的东西就一定会重复吗。。
一定要复制粘贴吗。。

23 楼 night_stalker 2009-06-22

我觉得按你的思路，这代码以后也不会变短，用起来也不会更舒服，改起来还得复制粘贴 ……

22 楼 ray_linn 2009-06-22

<div class="quote_title">night_stalker 写道</div>
<div class="quote_div">
譬如楼主那个 main 函数，简直就是一个 handler 的矩阵 …… 唐僧都不带这么说话的。 Handler handler1 = new HelpHandler(null); Handler handler2 = new PrintHandler(handler1); Handler handler3 = new SaveHandler(handler2); handler3.handleRequest(new HelpRequest()); handler3.handleRequest(new PrintRequest()); handler3.handleRequest(new SaveRequest()); 重复性高，大量复制粘贴出来的代码，一改就要改一片，维护起来非常痛苦。
重复性的指标有两个：一个是熵，不过很难算，另一个就是长度，指导实践是最简单容易的了。
 
另外 bla 几句：
软件工程就是让烂程序员不会把项目搞得太糟糕的学问。
企业不关心程序怎么写，写程序是否开心愉快。企业的目的是赚钱，什么"伟大的产品" "代码的质量"都是手段而不是目的。
反正中国人力资源丰富，程序员工资超低，与其提高个体生产效率，不如多招几个烂 coder。
看见你鼓捣新东西，就会劝你收手，劝你回头干苦活去。
 
可能你非常讨厌函式，但是就算 java 消失了，函式编程都依然会存在。
</div>
 
这个远不如delegate方便。。。。。而且不会做无谓的事情。

21 楼步行者 2009-06-22

<div class="quote_title">night_stalker 写道</div>
<div class="quote_div">
譬如楼主那个 main 函数，简直就是一个 handler 的矩阵 …… 唐僧都不带这么说话的。 Handler handler1 = new HelpHandler(null); Handler handler2 = new PrintHandler(handler1); Handler handler3 = new SaveHandler(handler2); handler3.handleRequest(new HelpRequest()); handler3.handleRequest(new PrintRequest()); handler3.handleRequest(new SaveRequest()); 重复性高，大量复制粘贴出来的代码，一改就要改一片，维护起来非常痛苦。
重复性的指标有两个：一个是熵，不过很难算，另一个就是长度，指导实践是最简单容易的了。
 
另外 bla 几句：
软件工程就是让烂程序员不会把项目搞得太糟糕的学问。
企业当然不关心代码怎么写了。企业的目的是赚钱，什么"伟大的产品" "代码的质量"都是手段而不是目的。
反正中国人力资源丰富，程序员工资超低，与其提高个体生产效率，不如多招几个。
 
可能你非常讨厌函式，但是就算 java 消失了，函式编程都依然会存在。
</div>
 
上面的代码只是一个职责链的测试代码，
我不知道重复性的指标有哪几个，那你怎么知道长度决定了重复性呢
现在的 “长” 是为了以后的 ”短”
 
至于软件工程是以工程化方式开发软件的方法，
盖一栋大楼用几个熟练技工就能完成吗。。笑话
我不认为有 "伟大的产品"，但 "代码的质量" 却是必要的
企业的目的是为了长远地赚钱。图眼前小利有何前途
 
“反正中国人力资源丰富，程序员工资超低，与其提高个体生产效率，不如多招几个。”
不重视个体生产效率，多招几个就能提高生产力吗。。

20 楼 night_stalker 2009-06-22

譬如楼主那个 main 函数，简直就是一个 handler 的矩阵 …… 唐僧都不带这么说话的。 Handler handler1 = new HelpHandler(null); Handler handler2 = new PrintHandler(handler1); Handler handler3 = new SaveHandler(handler2); handler3.handleRequest(new HelpRequest()); handler3.handleRequest(new PrintRequest()); handler3.handleRequest(new SaveRequest()); 重复性高，大量复制粘贴出来的代码，一改就要改一片，维护起来非常痛苦。
重复性的指标有两个：一个是熵，不过很难算，另一个就是长度，指导实践是最简单容易的了。
 
另外 bla 几句：
软件工程就是让烂程序员不会把项目搞得太糟糕的学问。
企业不关心程序怎么写，写程序是否开心愉快。企业的目的是赚钱，什么"伟大的产品" "代码的质量"都是手段而不是目的。
反正中国人力资源丰富，程序员工资超低，与其提高个体生产效率，不如多招几个烂 coder。
看见你鼓捣新东西，就会劝你收手，劝你回头干苦活去。
 
可能你非常讨厌函式，但是就算 java 消失了，函式编程都依然会存在。

19 楼 lishuaibt 2009-06-22

说的也有道理啊。。。个人觉得模式这东西有时候是好东西，有时候也不一定的！

做业务的时候，大量的用一些模式，程序看起来确实比较好看，也有一定的扩展性和可性，但是这要求每一个项目的参与人员都要懂得模式吧。但是事实并非如此呀，不是每个程序员都有比较高的水准啊。其实所谓的扩展性，也是建立在一定的技术层面上的，是吧。

但是做框架，做平台可能就不一样了吧。。。

个人见解！

18 楼 hatedance 2009-06-22

步行者写道

functor 函子
A functor is a function that can be manipulated as an object...
看得出来你对函数式编程很感兴趣

设计模式不是追究少的代码量，
而是追求松耦合，提高适应变化的能力

看来不同的人有不同的追求。
有很多人在追求代码少。
我则一直在追求可维护性。也许是因为的工作是维护企业系统为主。
再设想开来，做平台的会追求可扩展性。做关键系统的追求安全性，稳定性。etc...

17 楼步行者 2009-06-22

16 楼 night_stalker 2009-06-22

好复杂 …… 如果用 functor 实现，代码量可以少一半，也容易让人理解和使用。

15 楼步行者 2009-06-22

这是一种传统的实现方式，从书中取经而来
虽然简单，但是直观
Mina 。。能简述一下它的思想吗。。

发表评论

您还没有登录,请您登录后再发表评论

最近访客更多访客>>

博主相关

文章分类

社区版块

存档分类

最新评论