描述：某个请求可以在多个串联的处理者链上传递，直到它被一个处理者处理。

场景：团队leader要申请500元公费吃饭，有3个上司能批准，他们是：项目经理批准200以内，产品经理批准800以内，总经理任意，那么公费请求就能在这些上司中的一个被批准，如果属于自己的批准范围，则可以直接批准，否则传给下一个处理者。

实现：

抽象处理者：

abstract class Handler {
    public abstract void dealIt(int fee);

    Handler nextHandler;

    public void setHandler(Handler nextHandler) {
        this.nextHandler = nextHandler;
    }

    public Handler getHandler() {
        return this.nextHandler;
    }
}

具体的处理者1：

class FirstHandler extends Handler {

    @Override
    public void dealIt(int fee) {
        if(fee < 200) {
            System.out.println("I am first handler, I deal less than 200 yuan");
        }else {
            nextHandler = getHandler();
            if(null != nextHandler) {
                nextHandler.dealIt(fee);
            }
        }
    }
}

具体的处理者2：

class SecondHandler extends Handler {

    @Override
    public void dealIt(int fee) {
        if(fee < 500) {
            System.out.println("I am second handler, I deal less than 500 yuan");
        }else {
            nextHandler = getHandler();
            if(null != nextHandler) {
                nextHandler.dealIt(fee);
            }
        }
    }
}

客户端调用：

    public static void main(String[] args) {
        Handler firstHandler = new FirstHandler();
        Handler secondHandler = new SecondHandler();
        firstHandler.setHandler(secondHandler);
        secondHandler.setHandler(null);
        firstHandler.dealIt(400);
    }

ok，100的费用由处理者1处理，400的费用由处理者2处理，如果700则没人处理。