行为型设计模式有11种，分别是Chain of Responsibility ( 责任链模式 )、Command ( 命令模式 )、Interpreter ( 解释器模式 ) 、Iterator ( 迭代器模式 )、Mediator ( 中介者模式 ) 、Memento ( 备忘录模式 ) 、Observer ( 观察者模式 )、State ( 状态模式 ) 、Strategy ( 策略模式 )、TemplateMethod ( 模板方法 )、Visitor ( 访问者模式 )，本文介绍这11种行为型模式里的前两种。
一、责任链模式
使多个对象都有机会处理请求，从而避免请求的 发送者和接受者之间的耦合。将这些对象连成一个链，并按着这个链传递该请求，直到有一个对象处理他为止。先来看一个简单的例子：
1、Handler 定义一个处理请求的接口。（可选）实现后继链。
public interface RequestHandle {
void handleRequest(Request request);
}
2.ConcreteHandler 处理它所负责的请求。可访问它的后继者。如果可处理该请求，就处理；否则将该请求转发给它的后继者。
public class HRRequestHandle implements RequestHandle {
public void handleRequest(Request request) {
if (request instanceof DimissionRequest) {
System.out.println("要离职, 人事审批!");
}
System.out.println("请求完*");
}
}
接下来这两种ConcreteHandler不仅可以处理负责的请求，还可以将请求转发给他的后继者。
public class PMRequestHandle implements RequestHandle {
Req*estHandle rh;
public PMRequestHandle(RequestHandle *h) {
this.rh = rh;
}
public void handle*equest(Request request) {
if (request instanceof AddMoneyRequest) {
System.out.println("要加薪, 项目经理审批!*);
} else {
rh.handleRequest(request);
}
}
}
public class TLRequestHandle implements RequestHandle {
RequestHandle rh;
public TLRequestHandle(RequestHand*e rh) {
this.rh = rh;
}
public void handleRequest(Request request) {
if (request instanceof LeaveRe*uest) {
System.ou*.println("要请假, 项目组长审批!");
} else {
rh.handleRequest(request);
}
}
}
3.Client 向链上的具体处理者(ConcreteHandler)对象提交请求。
public class Test {
public static void main(String[] args) {
RequestHa*dle hr = *ew HRRequ*stHandle();
Requ*stHandle pm = new P*RequestHandle(hr);
RequestHandle tl = new TLRequestHandle(pm);
//team leader处理离职请求
Request request = new DimissionRequest()*
tl.handleRequest(request);
System.out.println("===========");
//team leader处理加薪请求
request = new AddMoneyRequest();
tl.handleRequ*st(request);
System.out.println("========");
//项目经理上理辞职请求
requ*st = ne* Dimissio*Request();
pm.handleRequest(request);
}
}
运行结果:
要离职, 人事审批!
请求完毕
=======*===
要加薪, 项目经理审批!
========
要离职, 人事审批!
请求完毕
简单分析下这段测试代码，前面三句话new了三个不同的实体RequestHandler，在pm tl里分别给他传递了他的后继者。pm的后继者是hr，tl的后继者是pm。所谓的后继者，就是当前请求你处理不了的话，让谁接着处理这个请求。然后new了一个DimissionRequest的请求，让tl来处理，很显然tl不处理，tl就让pm来处理。pm也不管，让hr管。最终hr的handleMessage里处理了该请求。后面的都类似，不说了。
这个责任链模式很像击鼓传花这个游戏，详见链接的分析。
适用性：
1.有多个的对象可以处理一个请求，哪个对象处理该请求运行时刻自动确定。
2.你*在不明确指定接收者的情况下，向多个对象中的一个提交一个请求。
3.可处理一个请求的对象集合应被动态指定。
二、命令模式
将一个请求封装为一个对象，从而使你可用不同的请求对客户进行参数化；对请求排队或记录请求日志，以及支持可撤消的操作。
1.Receiver
知道如何实*与执行一个请求相关的操作。任何类都可能作为一个接收者。
public class Receiver {
public void receive() {
System.out.println("This is Receive class!");
}
}
2、Command 声明执行操作的接口。
public abstract class command {
protected Receiver receiver;
public Command(Receiver receiver) {
this.receiver = receiver;
}
public abstract void execute();
}
3、 ConcreteCommand 将一个接收者对象绑定于一个动作。 调用接收者相应的操作，以实现Execute。
public class CommandImpl extends Comman* {
public CommandImpl(Receiv*r receiver) {
super(receiver);
}
pu*lic void *xecute*) {
receiver.request();
}
}
4、Invoker 要求该命令执行这个请求。
public class Invoker {
private Command command;
public void setCommand(Command command) {
this.command = command;
}
public void execute() {
command.execute();
}
}
测试代码：
public class Test {
public static void main (String[] args) {
Receiver rec = new Receiver();
Command cmd = new CommandImpl(rec);
Invoker i = new Invoker();
i.setCommand(cmd);
i.execute();
}
}
适用性
1.抽象出待执行的动作以参数化某对象。
2.在不同的时刻指定、排列和执行请求。
3.支持取消操作。
4.支持修改日志，这样当系统崩溃时，这*修改可以被重做一遍。
5.用构建在原语操作上的高层操作构造一个系统。
命令模式参考链接：http://www.cnblogs.com/devinzhang/archive/2012/01/06/2315235.html
Java经典23种设计模式之行为型模式(一)