看Chain of Responsibility模式后得疑问

public interface Handler{
　　public void handleRequest(Request request);
}
那么Handler实现代码如下：
public class ConcreteHandler implements Handler{
　　private Handler successor;

　　public ConcreteHandler(Handler successor){
　　　　this.successor=successor;
　　}

　　public void handleRequest(Request request){
　　　　if (request instanceof HelpRequest){
　　　　　　//这里是处理Help的具体代码
　　　　}else if (request instanceof PrintRequst){
　　　　　　request.execute();
　　　　}else
　　　　　　//传递到下一个
　　　　　　successor.handle(request);//疑问之处

　　　　}
　　}
}
Handler接口中没有handle（request）这个方法啊，请明示；
ConcreteHandler是Handler接口的实现，它自己有个私有成员，也是Handler的实现：private Handler successor;它也是ConcreteHandler吗？如果是，那么是不是下一个处理request的“节点”呢？请回答，谢谢！

其实这不是个很好的职责链，而是Command模式的变形。

Handler中定义是明显的Command模式，然后在Concrete类中做传递，实际应该在Handler里面做传递，因为这个传递是每个Conncrete都要执行的，当然handler要变成抽象类。

bang.看了你的回答,非常同意
其实这不是个很好的职责链，而是Command模式的变形。
但后面的话恕本人不才,不是很理解,而且我上面的疑问没有解决,请再详细回答,最好直接回答我的问题,以例子解释,帮助我提高,谢谢

successor就是下一个handle，在successor又有一个指向下一个的方法。

那我写一个此模式的应用，看看我理解得对不对，请指点：
public fristHandler implements Handler
{
private Handler successor;

　　public fristHandler (Handler successor){
　　　　this.successor=successor;
　　}

　　public void handleRequest(Request request){
　　　　if (request instanceof HelpRequest){
……help……
　　　　}else if (request instanceof fristRequst){
　　　　　　request.execute();
　　　　}else
　　　　　　//传递到下一个
　　　　　　successor.handle(request);//下一个
　　　　}
　　}

public void handle(Request request){
handleRequest(request);
}
}
////////////////////////////////////
public secondHandler implements Handler
{

private Handler successor;

　　public secondHandler (Handler successor){
　　　　this.successor=successor;
　　}

　　public void handleRequest(Request request){
　　　　if (request instanceof HelpRequest){
……help……
　　　　}else if (request instanceof secondRequst){
　　　　　　request.execute();
　　　　}else
　　　　　　//传递到下一个
　　　　　　successor.handle(request);//下一个
　　　　}
　　}

public void handle(Request request){
handleRequest(request);
}

}
////////////////////////////////////
public thirdHandler implements Handler
{
　　public thirdHandler (){}

　　public void handleRequest(Request request){
　　　　if (request instanceof HelpRequest){
……help……
　　　　}else if (request instanceof thirdRequst){
　　　　　　request.execute();
　　　　}else
　　　　　　return;
　　　　}
　　}

public void handle(Request request){
handleRequest(request);
}

}

public void main(……)
{
thirdHandler third = new thirdHandler();
secondHandler second = new secondHandler( third );
fristHandler frist = new fristHandler ( second );
frist.handle(request);
}

对不对？如果对，请说明不足之处，如果不对，请纠正。请详细点，几句话说不清楚，谢谢了。

不能说是完全正确。在调用时执行递归就不能算是CoR了。


thirdHandler third = new thirdHandler();
secondHandler second = new secondHandler( third );
fristHandler frist = new fristHandler ( second );
frist.handle(request);

上面代码是你在调用模式时实行，逐个检查，但是逐个检查是COR的主要逻辑特征，应该在模式内部完成。

不好意思BANG,我想了一下，还是想不出来,资质太差，请麻烦用代码或者详细说明，

如果不在调用的时候第归的生成HANDLE实例，怎么生成？
successor.handle(request);这个方法到底是怎么把请求传到下一个HANDLE的？？？？

期待

回到我一开始说的将接口变成abstract


public abstract Handler{

    public void handleRequest(Request request){
        
        if(!doMyHandle(request)){
            Handler nextHandler = getNextHandler(); 
            nextHandler.handleRequest(request);
        }
    }

    //负责获得当前Handler的下一个Handler
    public abstract Handler getNextHandler();
    
　　public abstract  boolean doMyHandle(Request request);
        

}

补充，请看我的最新文章 Java事件处理模式
我本人不推荐COF使用在这种处理request的场合，除非你有一些特殊的原因。第一选择应该使用Command模式

你写的这个东西不太好甚至有些错误，方法体有一大堆的if语句

COR的顺序指定是在context中，在client端也可以，运行的时候不用判断是什么类型的

if (request instanceof HelpRequest){

COR有两中形式，一种是纯的COR,一种是不纯的COR,所谓不纯的，就是把责任一部分自己解决，一部分推给别人，呵呵