- 浏览: 167609 次
- 性别:
- 来自: 武汉
文章分类
最新评论
-
cmm13655612162:
zhai4902176 写道 写的真不错,作为基础很薄弱的我理 ...
SAX解析XML 详解 -
kisso143:
写的很详细,不错,收藏一下
SAX解析XML 详解 -
zhai4902176:
写的真不错,作为基础很薄弱的我理解的还是挺浅的。请问楼主 “ ...
SAX解析XML 详解 -
ahzdc:
讲的很好啊
JAVA 注解示例 详解 -
elisonwell:
不错,我喜欢
JAVA 注解示例 详解
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
其实PipeLine类似于Servlet里的FilterChain的概念,而valve类似于Filter。就是一个请求流经这个PipeLine中 的每个Valve节点,该节点都对这个请求做一定的处理,而不是纯的责任链模式那样,把责任往下推。是想做了相应的处理后,在把处理后的请求移交给下一个 Valve进行处理。举个例子:在一次请求Servlet的过程中,可能有些处理是所有的请求都需要做的,比如设置CharSet,权限验证,或者URL 的解析等等,这些处理构成了一个请求的Chain,所有的请求都要经过这些处理,才能进行下面的具体的业务处理。这个时候既可以这些共有的处理抽象出来, 做成一个pipeline,这个pipeline有过个valve节点组成。。。。
差不多就这个意思吧。。。用文字形容确实不太好说。
评论
{
HelpClass.fun();
}
else if(..)
{
....
}
else
{
...
}
是不是这个意思?
你这个是什么意思???
{
HelpClass.fun();
}
else if(..)
{
....
}
else
{
...
}
是不是这个意思?
啥时候成模式了
???
java 不用方法调用,怎么实现模式啊。。。
一个Handler 先处理 request 再交给 successor 那不就成了 “不推卸责任”了吗?
而职责链的缺陷是 Handler 与 Successor 耦合了。
而PipeLine(可以算是一种改进的 职责链模式)的好处是, Handler 是独立的互不耦合;怎样装配Handler,按什么顺序都有 PipeLine 来进行,一般是xml 配置文件,保持了很好的灵活性。
同意!其实真正GoF里边介绍的纯的责任链模式我个人觉得适用范围很小!反而这种pipeline的思想用的更多一些吧
一个Handler 先处理 request 再交给 successor 那不就成了 “不推卸责任”了吗?
而职责链的缺陷是 Handler 与 Successor 耦合了。
而PipeLine(可以算是一种改进的 职责链模式)的好处是, Handler 是独立的互不耦合;怎样装配Handler,按什么顺序都有 PipeLine 来进行,一般是xml 配置文件,保持了很好的灵活性。
主题帖给出的是 职责链模式 的简单实现方式
简单才能直观嘛
“一个Handler 先处理 request 再交给 successor 那不就成了 “不推卸责任”了吗?”
你这么说证明你没好好看主题帖
handler首先检查自己是否能处理这个request,如果能处理,就处理
不能处理再交给successor
PipeLine和传统职责链 的主要区别 也不是你所说
主要区别 是 PipeLine 中的 Value “可能推卸部分职责”
而 传统职责链 中的 handler “如果不能处理则推卸全部职责”
一个Handler 先处理 request 再交给 successor 那不就成了 “不推卸责任”了吗?
而职责链的缺陷是 Handler 与 Successor 耦合了。
而PipeLine(可以算是一种改进的 职责链模式)的好处是, Handler 是独立的互不耦合;怎样装配Handler,按什么顺序都有 PipeLine 来进行,一般是xml 配置文件,保持了很好的灵活性。
<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>
<p> </p>
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了。
我的意思是不要把所有事想的太极端
我说了 现在的 “长” 是为了以后的 ”短”
现在“长”不是错,为了以后能更短
长的东西就一定会重复吗。。
一定要复制粘贴吗。。
<div class="quote_div">
<p>譬如楼主那个 main 函数, 简直就是一个 handler 的矩阵 …… 唐僧都不带这么说话的。<br><br><span style="color: #333399;">Handler handler</span>1 = new Help<span style="color: #333399;">Handler</span>(null); <br><span style="color: #333399;">Handler handler</span>2 = new Print<span style="color: #333399;">Handler</span>(<span style="color: #333399;">handler</span>1); <br><span style="color: #333399;">Handler handler</span>3 = new Save<span style="color: #333399;">Handler</span>(<span style="color: #333399;">handler</span>2); <br><span style="color: #333399;">handler</span>3.<span style="color: #333399;">handle</span>Request(new HelpRequest()); <br><span style="color: #333399;">handler</span>3.<span style="color: #333399;">handle</span>Request(new PrintRequest()); <br><span style="color: #333399;">handler</span>3.<span style="color: #333399;">handle</span>Request(new SaveRequest());<br><br>重复性高,大量复制粘贴出来的代码,一改就要改一片,维护起来非常痛苦。</p>
<p>重复性的指标有两个: 一个是熵,不过很难算,另一个就是长度,指导实践是最简单容易的了。</p>
<p> </p>
<p>另外 bla 几句:</p>
<p>软件工程就是让烂程序员不会把项目搞得太糟糕的学问。</p>
<p>企业不关心程序怎么写,写程序是否开心愉快。企业的目的是赚钱,什么"伟大的产品" "代码的质量"都是手段而不是目的。</p>
<p>反正中国人力资源丰富,程序员工资超低,与其提高个体生产效率,不如多招几个烂 coder。</p>
<p>看见你鼓捣新东西,就会劝你收手,劝你回头干苦活去。</p>
<p> </p>
<p><span style="color: #efefef;">可能你非常讨厌函式,但是就算 java 消失了,函式编程都依然会存在。</span></p>
</div>
<p> </p>
<p>这个远不如delegate方便。。。。。而且不会做无谓的事情。</p>
<div class="quote_div">
<p>譬如楼主那个 main 函数, 简直就是一个 handler 的矩阵 …… 唐僧都不带这么说话的。<br><br><span style="color: #333399;">Handler handler</span>1 = new Help<span style="color: #333399;">Handler</span>(null); <br><span style="color: #333399;">Handler handler</span>2 = new Print<span style="color: #333399;">Handler</span>(<span style="color: #333399;">handler</span>1); <br><span style="color: #333399;">Handler handler</span>3 = new Save<span style="color: #333399;">Handler</span>(<span style="color: #333399;">handler</span>2); <br><span style="color: #333399;">handler</span>3.<span style="color: #333399;">handle</span>Request(new HelpRequest()); <br><span style="color: #333399;">handler</span>3.<span style="color: #333399;">handle</span>Request(new PrintRequest()); <br><span style="color: #333399;">handler</span>3.<span style="color: #333399;">handle</span>Request(new SaveRequest());<br><br>重复性高,大量复制粘贴出来的代码,一改就要改一片,维护起来非常痛苦。</p>
<p>重复性的指标有两个: 一个是熵,不过很难算,另一个就是长度,指导实践是最简单容易的了。</p>
<p> </p>
<p>另外 bla 几句:</p>
<p>软件工程就是让烂程序员不会把项目搞得太糟糕的学问。</p>
<p>企业当然不关心代码怎么写了。企业的目的是赚钱,什么"伟大的产品" "代码的质量"都是手段而不是目的。</p>
<p>反正中国人力资源丰富,程序员工资超低,与其提高个体生产效率,不如多招几个。</p>
<p> </p>
<p><span style="color: #efefef;">可能你非常讨厌函式,但是就算 java 消失了,函式编程都依然会存在。</span></p>
</div>
<p> </p>
<p>上面的代码只是一个 职责链的测试代码,</p>
<p>我不知道重复性的指标有哪几个,那你怎么知道长度决定了 重复性呢</p>
<p>现在的 “长” 是为了以后的 ”短”</p>
<p> </p>
<p>至于 软件工程 是以工程化方式开发软件的方法,</p>
<p>盖一栋大楼 用几个熟练技工就能完成吗。。笑话</p>
<p>我不认为有 "伟大的产品",但 "代码的质量" 却是必要的</p>
<p>企业的目的是为了长远地赚钱。图眼前小利 有何前途</p>
<p> </p>
<p>“反正中国人力资源丰富,程序员工资超低,与其提高个体生产效率,不如多招几个。”</p>
<p>不重视个体生产效率,多招几个就能 提高 生产力吗。。</p>
<p> </p>
<p> </p>
<p>重复性的指标有两个: 一个是熵,不过很难算,另一个就是长度,指导实践是最简单容易的了。</p>
<p> </p>
<p>另外 bla 几句:</p>
<p>软件工程就是让烂程序员不会把项目搞得太糟糕的学问。</p>
<p>企业不关心程序怎么写,写程序是否开心愉快。企业的目的是赚钱,什么"伟大的产品" "代码的质量"都是手段而不是目的。</p>
<p>反正中国人力资源丰富,程序员工资超低,与其提高个体生产效率,不如多招几个烂 coder。</p>
<p>看见你鼓捣新东西,就会劝你收手,劝你回头干苦活去。</p>
<p> </p>
<p><span style="color: #efefef;">可能你非常讨厌函式,但是就算 java 消失了,函式编程都依然会存在。</span></p>
做业务的时候,大量的用一些模式,程序看起来确实比较好看,也有一定的扩展性和可性,但是这要求每一个项目的参与人员都要懂得模式吧。但是事实并非如此呀,不是每个程序员都有比较高的水准啊。其实所谓的扩展性,也是建立在一定的技术层面上的,是吧。
但是做框架,做平台可能就不一样了吧。。。
个人见解!
A functor is a function that can be manipulated as an object...
看得出来 你对 函数式编程 很感兴趣
设计模式 不是追究 少的代码量,
而是追求松耦合,提高适应变化的能力
看来不同的人有不同的追求。
有很多人在追求代码少。
我则一直在追求可维护性。也许是因为的工作是维护企业系统为主。
再设想开来,做平台的会追求可扩展性。做关键系统的追求安全性,稳定性。etc...
A functor is a function that can be manipulated as an object...
看得出来 你对 函数式编程 很感兴趣
设计模式 不是追究 少的代码量,
而是追求松耦合,提高适应变化的能力
虽然简单,但是直观
Mina 。。能简述一下 它的思想吗。。
相关推荐
在v4T架构的基础上,A RM又推出了 T humb指令集架构(I S A),这是一个16 位的I S A,可以改进代码密度(一般约为 ...便可始终以一种模式(Thumb-2)执行, 而不像ARM7那样需要在ARM/Thumb这 两种模式下切换。
根据模式耦合理论, 设计了一种基于三芯光纤并支持LP01、LP11a、LP11b三种空间模式传输的三模复用/解复用器。该三芯光纤由一个位于中央的三模纤芯和两个外部的单模纤芯构成。选择三模纤芯的结构参数, 根据模式有效...
报道了一种双包层七芯光子晶体光纤,其零色散点在1036 nm,在波长1060 nm处非线性系数为2.43 W-1·km-1。采用中心波长为1060 nm、脉冲宽度为160 ps、重复频率为1 MHz、光束质量M2<1.3、最大输出功率为4.5 W的增益...
所以需要选用一种能够克服离群点 影响的模型来对wine数据集进行预测,因此我们选用了class包中的1- 近邻模型来进行分类预测,结果如表3所示,可以看出分类效果有提高。 表3 直接分类预测结果 "模型 "训练集 "测试集 ...
背景与目的:由于亚洲地区涉及不同的养分管理方案和耕作制度,长期的生育能力研究是监测产量变化的重要因素之一。 对集约灌溉稻作模式进行了许多短期和长期的肥料试验,主要是为了提供肥料用量,但并未考虑对土壤...
源组(resource groups)采用预先缓存和特殊的清除处理(这是一种通过控制对象分配 和释放来提高效率的方法) <5> GUI:强大而灵活的GUI 管理,支持动画式的GUI <6> 矢量(Vectors),对于2D 矢量的完全支持 3)...
这两款芯片采取电流模式控制,并提供10焊球micro SMD及小型16引脚LLP两种封装选择,可驱动双显示屏幕或单一大显示屏幕的串行白光LED背光系统。 LM3502及LM3503转换器可为便携式电子产品双显示屏幕或单一大显示...
这两款芯片采取电流模式控制,并提供10焊球micro SMD及小型16引脚LLP两种封装选择,可驱动双显示屏幕或单一大显示屏幕的串行白光LED背光系统。 LM3502及LM3503转换器可为便携式电子产品双显示屏幕或单一大显示屏幕...
这两款芯片采取电流模式控制,并提供10焊球micro SMD及小型16引脚LLP两种封装选择,可驱动双显示屏幕或单一大显示屏幕的串行白光LED背光系统。 LM3502及LM3503转换器可为便携式电子产品双显示屏幕或单一大显示...
这两款芯片采取电流模式控制,并提供10焊球micro SMD及小型16引脚LLP两种封装选择,可驱动双显示屏幕或单一大显示屏幕的串行白光LED背光系统。 LM3502及LM3503转换器可为便携式电子产品双显示屏幕或单一大显示屏幕...
提出了一种利用互相关性测量空间横向流速的方法。通过设定谱域光学相干层析术系统的扫描模式X 和Y,利用同一深度位置的相邻A 扫信号间的互相关性与空间横向速度分量之间的数学关系,求得空间横向流速的绝对大小。...
设计了一种三芯光子晶体光纤(PCFs)偏振分束器。利用光纤的谐振现象,实现了偏振状态的分离。当三芯光子晶体光纤中三个超模式的模式折射率满足一定条件时,将产生谐振现象。通过选择合适的光纤结构参数,可使某一偏振...
由于光纤纤芯可承受功率和光纤纤芯大小有关,而加大纤芯直径会降低光束质量,为了进一步提高光纤激光输出功率而不降低光束质量,一种方法是设计超大模场双包层光纤,加大光纤中低阶模的直径;另一种方法是加大光纤的纤芯...
边界元方法是一种数值求解偏微分方程的高效算法,在微纳光学求解电磁场问题中有广泛的应用。在实际计算中,边界元数目的选择直接关系着数值模拟的精度。研究不同边界元数目下微腔谐振频率的计算误差,发现主要误差可...
介绍了一种基于纤芯失配与错位熔接的光纤Mach-Zehnder干涉仪,实现了折射率-温度双参量传感。将带有凸锥结构的多模光纤段与错位熔接接头作为两个耦合单元,其中凸锥结构增加了包层模式能量,提高了传感器透射谱对比度。...
利用光纤在不同弯曲曲率下的不同形变,提出并验证了一种基于七芯光纤和少模光纤的新型光纤曲率传感器。分别制作了三种不同结构的传感器,利用快速傅里叶变换分析了它们的干涉模式,获得波长的传感灵敏度分别为6.33,...
其中 <符号模式列表> 是一个用逗号分隔的表 [ugoa]{+|-|=}[rwxXlstugo] chmod u+rw 给用户加权限。同理,u-rw也可以减权限。 chmod u=rw 给用户赋权限。与加权限不一样,赋权限有覆盖的效果。 主要形式有如下几...