Java设计模式之责任链模式

上面是的大致的模型图。

message从第一个链开始判断和处理，如果不能处理就传给下一个链，每一个链用handler表示。所有的链继承自同一个父类，Handler，代码如下：

//责任链的基类
public abstract class Handler {

protected Handler nextHandler;

void handle(BaseMessage msg) {
if(msg.getMessageLevel()==this.getHandlerLevel()) {
//如果和当前等级相等就当前处理
handleMessage(msg);
System.out.println("test=处理的chain：handler"+getHandlerLevel()+"||消息内容："+msg.getContent().toString());
}else {
//如果和当前chain等级不等，丢给 下一chain处理
if(nextHandler!=null) {
//有点递归的意思，一个一个的传下去
System.out.println("test=当前handler"+getHandlerLevel()+"处理不力，丢给下一个");
nextHandler.handle(msg);
}else {
//所有的chain都处理不了
System.out.println("没有被处理，因为chain等级不匹配");
}
}
};

//定义抽象方法处理每一个msg，让子类具体实现
abstract void handleMessage(BaseMessage msg);

//返回当前链等级
abstract int getHandlerLevel();
}

//第一个chain和后面所有的chain代码一样的；
public class Handler1 extends Handler {

@Override
void handleMessage(BaseMessage msg) {
// TODO Auto-generated method stub
}

@Override
int getHandlerLevel() {
// TODO Auto-generated method stub
return 1;
}

}

消息的基类和子类如下：

public abstract class BaseMessage {

private Object content;
protected int level;
public int getMessageLevel() {
return level;
}

//设置当前消息等级
public void setLevel(int level) {
this.level = level;
}

public Object getContent() {
return content;
}

//通过构造函数传入内容，灵活处理
protected BaseMessage(Object content) {
this.content=content;
}
}
//下面是消息的子类
public class ThreadMessage extends BaseMessage {
protected ThreadMessage(Object content) {
super(content);
// TODO Auto-generated constructor stub
}
}
//最后是client的调用
public static void main(String[] args) {
//模拟消息
BaseMessage thMsg=new ThreadMessage("子线程发送来 的消息");
//创建chain
Handler1 handler1=new Handler1();
Handler2 handler2=new Handler2();
Handler3 handler3=new Handler3();
//按序编chain
handler1.nextHandler=handler2;
handler2.nextHandler=handler3;
thMsg.setLevel(2);
handler1.handle(thMsg);
}

责任链的关键点就是上一个chain必须持有下一个chain的引用，尤其是方法的调用上，层层递进，有点类似递归或者循环的味道。