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的引用，尤其是方法的调用上，层层递进，有点类似递归或者循环的味道。