23种设计模式 第三部分 关系模式(5)责任链模式
来源:互联网 发布:macrar解压软件下载 编辑:程序博客网 时间:2024/06/05 16:49
理解
实现
public interface Handler { public void operator(); }
public abstract class AbstractHandler { private Handler handler; public Handler getHandler() { return handler; } public void setHandler(Handler handler) { this.handler = handler; } }
public class MyHandler extends AbstractHandler implements Handler { private String name; public MyHandler(String name) { this.name = name; } @Override public void operator() { System.out.println(name+"deal!"); if(getHandler()!=null){ getHandler().operator(); } } }test:
public class Test { public static void main(String[] args) { MyHandler h1 = new MyHandler("h1"); MyHandler h2 = new MyHandler("h2"); MyHandler h3 = new MyHandler("h3"); h1.setHandler(h2); h2.setHandler(h3); h1.operator(); } }输出:
h1deal!h2deal!h3deal!
此处强调一点就是,链接上的请求可以是一条链,可以是一个树,还可以是一个环,模式本身不约束这个,需要我们自己去实现,同时,在一个时刻,命令只允许由一个对象传给另一个对象,而不允许传给多个对象。
其他实现
Intent
- Avoid coupling the sender of a request to its receiver by giving more than one object a chance to handle the request. Chain the receiving objects and pass the request along the chain until an object handles it.
- Launch-and-leave requests with a single processing pipeline that contains many possible handlers.
- An object-oriented linked list with recursive traversal.
Problem
There is a potentially variable number of "handler" or "processing element" or "node" objects, and a stream of requests that must be handled. Need to efficiently process the requests without hard-wiring handler relationships and precedence, or request-to-handler mappings.
Discussion
Encapsulate the processing elements inside a "pipeline" abstraction; and have clients "launch and leave" their requests at the entrance to the pipeline.
The pattern chains the receiving objects together, and then passes any request messages from object to object until it reaches an object capable of handling the message. The number and type of handler objects isn't known a priori, they can be configured dynamically. The chaining mechanism uses recursive composition to allow an unlimited number of handlers to be linked.
Chain of Responsibility simplifies object interconnections. Instead of senders and receivers maintaining references to all candidate receivers, each sender keeps a single reference to the head of the chain, and each receiver keeps a single reference to its immediate successor in the chain.
Make sure there exists a "safety net" to "catch" any requests which go unhandled.
Do not use Chain of Responsibility when each request is only handled by one handler, or, when the client object knows which service object should handle the request.
Structure
The derived classes know how to satisfy Client requests. If the "current" object is not available or sufficient, then it delegates to the base class, which delegates to the "next" object, and the circle of life continues.
Example
The Chain of Responsibility pattern avoids coupling the sender of a request to the receiver by giving more than one object a chance to handle the request. ATM use the Chain of Responsibility in money giving mechanism.
Check list
- The base class maintains a "next" pointer.
- Each derived class implements its contribution for handling the request.
- If the request needs to be "passed on", then the derived class "calls back" to the base class, which delegates to the "next" pointer.
- The client (or some third party) creates and links the chain (which may include a link from the last node to the root node).
- The client "launches and leaves" each request with the root of the chain.
- Recursive delegation produces the illusion of magic.
Rules of thumb
- Chain of Responsibility, Command, Mediator, and Observer, address how you can decouple senders and receivers, but with different trade-offs. Chain of Responsibility passes a sender request along a chain of potential receivers.
- Chain of Responsibility can use Command to represent requests as objects.
- Chain of Responsibility is often applied in conjunction with Composite. There, a component's parent can act as its successor.
public class ChainBefore { interface Image { String process(); } static class IR implements Image { public String process() { return "IR"; } } static class LS implements Image { public String process() { return "LS"; } } static class Processor { private static java.util.Random rn = new java.util.Random(); private static int nextId = 1; private int id = nextId++; public boolean handle( Image img ) { if (rn.nextInt(2) != 0) { System.out.println( " Processor " + id + " is busy" ); return false; } System.out.println( "Processor " + id + " - " + img.process() ); return true; } } public static void main( String[] args ) { Image[] input = { new IR(), new IR(), new LS(), new IR(), new LS(), new LS() }; Processor[] procs = { new Processor(), new Processor(), new Processor() }; for (int i=0, j; i < input.length; i++) { j = 0; while ( ! procs[j].handle( input[i] )) j = (j+1) % procs.length; } }}
输出:
Processor 1 - IR Processor 1 is busy Processor 2 is busy Processor 3 is busy Processor 1 is busy Processor 2 is busyProcessor 3 - IR Processor 1 is busyProcessor 2 - LSProcessor 1 - IRProcessor 1 - LS Processor 1 is busy Processor 2 is busy Processor 3 is busyProcessor 1 - LS
- 23种设计模式 第三部分 关系模式(5)责任链模式
- 23种设计模式 第三部分 关系模式(1)策略模式
- 23种设计模式 第三部分 关系模式(2)模板方法模式
- 23种设计模式 第三部分 关系模式(3)观察者模式
- 23种设计模式 第三部分 关系模式(4)迭代子模式
- 23种设计模式 第三部分 关系模式(6)命令模式
- 23种设计模式-责任链模式
- 23种设计模式(10):责任链模式
- 23种设计模式(11):责任链模式
- 23种设计模式(19)-责任链模式
- 【23种设计模式】行为型模式 > 责任链模式
- 设计模式23篇:责任链模式
- 设计模式--责任链模式(COR)
- 设计模式十五(责任链模式)
- 设计模式之(责任链模式)
- 责任链模式(JAVA设计模式)
- c++设计模式(责任链模式)
- (1)设计模式:责任链模式
- 基于cocos2d-x引擎3.9版本分析之CCAutoreleasePool篇
- 计算机网络的五层协议体系
- python中nltk的下载安装方式
- 搭建android开发环境
- LoraWAN中文翻译
- 23种设计模式 第三部分 关系模式(5)责任链模式
- 自己用到的TensorFlow的几种输入
- java开发教程
- 如何阅读一本书
- Android布局管理之TableLayout
- java对redis的基本操作
- 随笔 2016/9/17 == 和 equals方法 的区别
- Mvp模式的进一步探索
- 118. Pascal's Triangle