设计模式-责任链模式

来源：互联网发布：小说章节数据库设计编辑：程序博客网时间：2024/06/08 07:58

这里写图片描述

责任链模式定义

责任链模式定义如下：使多个对象都有机会处理请求，从而避免了请求的发送者和接受者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递该请求，直到有对象处理它为止。
责任链模式的重点是在“链”上，由一条链去处理相似的请求，在链中决定谁来处理这个请求，并返回相应的结果。责任链模式的核心在“链”上，“链”是由多个处理者ConcreteHandler组成。
工作流程如下图所示：
这里写图片描述

如果传递一个要求处理者3处理的Request到链中，那么处理者1收到请求后，把请求发送给处理者2；处理者2发现不是自己所处理的，就把请求发送给处理者3；处理者3收到请求后，符合自己能处理的要求，处理后返回结果Response。

这里写图片描述

如果传递一个要求处理者5处理的Request到链中，那么处理者1收到请求后，把请求发送给处理者2；处理者2发现不是自己所处理的，就把请求发送给处理者3；以此类推，处理最后发送到处理者5….处理者5收到请求后，符合自己能处理的要求，处理后返回结果Response。

责任链模式算法框架

如通用类图所示，责任链模式主要由抽象处理者Handler和具体处理者ConcreteHandler构成的。

首先定义两个辅助类，分别是请求类Request和响应类Response。Request类负责封装请求，Response负责封装链中返回的结果。这两个类都需要根据业务产生，可以根据实际应用去完成相关的业务填充。
请求类Resquest的代码如下所示：

public class Request {    private int level;//声明一个level来要求哪个级别可以处理这个请求    public Request(int level){        this.level=level;    }    //请求的等级    public int getRequestLevel(){        return this.level;    }    public void setLevel(int level) {        this.level = level;    }}

响应类的代码如下所示：

public class Response {    private String response;//处理完返回的数据 可以是自定义数据    public Response(String response){        this.response=response;    }    //处理者返回的数据    public String getResponse() {        return response;    }    public void setResponse(String response) {        this.response = response;    }}

然后就是定义抽象处理者角色了。抽象的处理者实现三个职责：一是定义一个请求的处理方法handleMessage，唯一对外开放的方法；二是定义一个链的编排方法setNext，设置下一个处理者；三是定义了具体的请求者必须实现的两个方法：定义自己能够处理的级别getHandlerLevel和具体的处理任务echo。

public abstract class Handler {    private Handler nextHandler;    //每个处理者都必须对请求做出处理    public final Response handleMessage(Request request){        Response response=null;        //判断是否是自己的处理级别        if(this.getHandlerLevel()==request.getRequestLevel()){            response=this.echo(request);        }else{//不属于自己的处理级别            //判断是否有下一个处理者            if(this.nextHandler!=null){                response=this.nextHandler.handleMessage(request);            }else{                //没有适当的处理者，业务自行处理                System.out.println("没有相应的处理者");            }        }        return response;    }    //设置下一个处理者是谁    public void setNext(Handler _handler){        this.nextHandler=_handler;    }    //每个处理者都有一个处理级别    protected abstract int getHandlerLevel();    //每个处理者都必须实现处理任务    protected abstract Response echo(Request request);}

注意：在责任链模式中一个请求发送到链中后，前一节点消费部分消息，然后交由后续节点继续处理。最终可以有处理结果也可以没有处理结果。
接下来就是定义几个具体的处理者来分别进行不同的逻辑处理了。下面定义了三个具体的处理者，以便可以组成一个链。
能够处理Level1级别任务的处理者ConcreteHandler1：

public class ConcreteHandler1 extends Handler{    //设置自己的处理级别    @Override    protected int getHandlerLevel() {        return 1;    }    //定义自己的处理逻辑    @Override    protected Response echo(Request request) {        //完成处理逻辑        System.out.println("Level 1 正在处理中");        //返回一个报告        return new Response("Level 1 已处理");    }}

能够处理Level2级别任务的处理者ConcreteHandler2：

public class ConcreteHandler2 extends Handler{    //设置自己的处理级别    @Override    protected int getHandlerLevel() {        return 2;    }    //定义自己的处理逻辑    @Override    protected Response echo(Request request) {        //完成处理逻辑        System.out.println("Level 2  正在处理中");        //返回一个报告        return new Response("Level 2 已处理");    }}

能够处理Level3级别任务的处理者ConcreteHandler3：

public class ConcreteHandler3 extends Handler{    //设置自己的处理级别    @Override    protected int getHandlerLevel() {        return 3;    }    //定义自己的处理逻辑    @Override    protected Response echo(Request request) {        //完成处理逻辑        System.out.println("Level 3 正在处理中");        //返回一个报告        return new Response("Level 3 已处理");    }}

上面的模式框架代码就搞定了，下面就可以在场景类中测试了，对链进行组装，并传递请求，返回结果。

public class Client {    public static void main(String[] args){        //声明所有的处理节点        Handler handler1=new ConcreteHandler1();        Handler handler2=new ConcreteHandler2();        Handler handler3=new ConcreteHandler3();        //设置链中的阶段顺序1-->2-->3        handler1.setNext(handler2);        handler2.setNext(handler3);        //提交请求，返回结果        Response response=handler1.handleMessage(new Request(2));        if(response!=null){            System.out.println(response.getResponse());        }    }}

上面输出为：
Level 2 正在处理中
Level 2 已处理

在实际应用中，需要自己封装一个类来对责任链模式进行封装，直接返回链中的第一个处理者，具体链的设置不需要高层次模块关系，这样简化了高层次模块的调用，减少模块间的耦合，提高系统的灵活性。

把具体链的设置抽象成单独的一个类ResponChainRoute：

public class ResponChainRoute {    private Handler handler;    public ResponChainRoute() {        // 声明所有的处理节点        Handler handler1 = new ConcreteHandler1();        Handler handler2 = new ConcreteHandler2();        Handler handler3 = new ConcreteHandler3();        // 设置链中的阶段顺序1-->2-->3        handler1.setNext(handler2);        handler2.setNext(handler3);        handler=handler1;    }    public Handler getHandler() {        return handler;    }}

场景类就简化成如下代码了：

public class Client {    public static void main(String[] args){        ResponChainRoute route=new ResponChainRoute();        //提交请求，返回结果        Response response=route.getHandler().handleMessage(new Request(1));        if(response!=null){            System.out.println(response.getResponse());        }    }}

责任链模式的优缺点

优点：责任链模式非常显著的优点是将请求和处理分开。请求者可以不用知道是谁处理的，处理者可以不用知道请求的全貌。（例如在J2EE 项目开发中，可以剥离出无状态Bean由责任链模处理），两者解耦，提高系统的灵活性。

缺点：责任链有两个非常显著的缺点：一是性能问题，每个请求都是从链头遍历到链尾（当请求匹配不到处理者时），特别是链比较长的时候，性能是一个非常大的问题。二是调试不方便，特别是链比较长，环节比较多时，由于采用了类似递归的方式，调试的时候逻辑可能比较复杂。

注意事项：责任链模式中链中节点数量需要控制，避免出现超长链的情况，一般的做法是在Handler中设置一个最大节点数量，在setNext方法中判断是否已经是超过其阈值，超过则不允许该链建立，避免无意识地破坏系统性能。

0 0