模式20.职责链模式-Java

1.定义

使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将这个对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它为止。

发出请求的客户端并不知道是哪个一个对象处理这个请求，这样系统的更改可以在不影响客户端的情况下动态地重新组织和分配责任。

2.基本代码

**（**1）定义一个处理请示的接口

Handler

package designmode.chainofresponsibility;

public abstract class Handler {
    protected  Handler succesor;  //设置继任者
    public void SetSuccessor(Handler succesor){
        this.succesor=succesor;
    }
    public abstract void HandleRequest(int request);  //处理请求的抽象方法



}

(2)ConcreteHandle类，具体处理类，处理它所负责的请求，可访问它的后继者，如果能处理就处理，不能处理就将该请求转发给它的后继者

package designmode.chainofresponsibility;

public class ConcreteHandler1 extends  Handler{
    @Override
    public String toString() {
        return  "ConcreteHandler1";
    }

    @Override
    public void HandleRequest(int request) {
        if(request>=0 && request< 10){
            System.out.println(this.toString()+"处理请求");
        }else if(succesor!=null){
            succesor.HandleRequest(request);  //转移到下一位
        }
    }
}

package designmode.chainofresponsibility;

public class ConcreteHandler2 extends Handler{
    @Override
    public String toString() {
        return  "ConcreteHandler2";
    }
    @Override
    public void HandleRequest(int request) {
        if(request>=10 && request<20){
            System.out.println(this.toString()+"处理请求");
        }else  if(succesor!=null){
            succesor.HandleRequest(request);  //转移到下一位
        }
    }
}

package designmode.chainofresponsibility;

public class ConcreteHandler3 extends  Handler{
    @Override
    public String toString() {
        return  "ConcreteHandler3";
    }
    @Override
    public void HandleRequest(int request) {
        if(request>=20 && request< 30){
            System.out.println(this.toString()+"处理请求");
        }else if(succesor!=null){
            succesor.HandleRequest(request);  //转移到下一位
        }
    }
}

（3）客户端

package designmode.chainofresponsibility;

public class Client {
    public static void main(String[] args) {
        Handler h1=new ConcreteHandler1();
        Handler h2=new ConcreteHandler2();
        Handler h3=new ConcreteHandler3();

        h1.SetSuccessor(h2);  //设置职责链
        h2.SetSuccessor(h3);

        int [] requests={2,5,14,22,18,3,27,20};
        for (int res: requests){
            h1.HandleRequest(res);  //给最小处理者提交请求
        }}
}

测试结果

ConcreteHandler1处理请求
ConcreteHandler1处理请求
ConcreteHandler2处理请求
ConcreteHandler3处理请求
ConcreteHandler2处理请求
ConcreteHandler1处理请求
ConcreteHandler3处理请求
ConcreteHandler3处理请求

Process finished with exit code 0

3.应用场景

好处

• 客户提交一个请求时，请求沿链传递直至有一个ConcreteHandle对象负责处理它。
• 接收者和发送者都没有双方的明确信息，且链中的对象自己也并不知道链的结构，结果是职责链可简化对象的互相连接，仅需保持一个指向后继者的引用。而不需要保持它所有的候选接收者的引用。从而大大降低了耦合度。
• 由于在客户端定义链结构，可以随时增加或者修改处理一个请求的结构。增强了给对象指派职责的灵活性。
• 要注意，一个请求可能既有可能到了链的末端都得不到处理，或者因为没有正确配置而得不到处理。