[设计模式]职责链模式

最新推荐文章于 2022-06-21 10:59:03 发布

Ethan__Hu

最新推荐文章于 2022-06-21 10:59:03 发布

阅读量648

点赞数 1

分类专栏：设计模式文章标签：设计模式职责链模式

本文链接：https://blog.csdn.net/daydayplayphone/article/details/78078591

版权

设计模式专栏收录该内容

7 篇文章 0 订阅

订阅专栏

开始写设计模式系列,希望自己可以坚持下来.
第七篇:职责链模式

什么是职责链模式

关于职责链模式GOF是这样定义的：使多个对象都有机会处理请求，从而避免了请求的发送者和接受者之间额耦合关系。将这些对象连成一条链，并沿着这条链传递该请求，直到有对象处理它为止。

简易实现

Talk is cheap,我们来看下最为简易的职责链实现。
抽象的处理者：

package top.huyuxin.ChainofResponsibility;

public abstract class Handler {
    public Handler nextHandler;

    public abstract void handleRequest(String condition);
}

具体的处理者：

package top.huyuxin.ChainofResponsibility;

public class FirstHandler extends Handler {

    @Override
    public void handleRequest(String condition) {
    if("first".equals(condition)){
        System.out.println("firsthandler capture it!");
    }else{
        nextHandler.handleRequest(condition);
    }
    }

}

package top.huyuxin.ChainofResponsibility;

public class SecondHandler extends Handler {

    @Override
    public void handleRequest(String condition) {
    if("second".equals(condition)){
        System.out.println("secondhandler capture it!");
    }else{
        nextHandler.handleRequest(condition);
    }
    }
}

package top.huyuxin.ChainofResponsibility;

public class ThirdHandler extends Handler {

    @Override
    public void handleRequest(String condition) {
    if("third".equals(condition)){
        System.out.println("thirdhandler capture it!");
    }else{
        System.out.println("no one can capture it!");
    }
    }

}

使用：

package top.huyuxin.ChainofResponsibility;

public class Main {

    public static void main(String[] args) {
        Handler firstHandler = new FirstHandler();
        Handler secondHandler = new SecondHandler();
        Handler thirdHandler = new ThirdHandler();
        firstHandler.nextHandler=secondHandler;
        secondHandler.nextHandler=thirdHandler;

        firstHandler.handleRequest("first");
        System.out.println("-----------");
        firstHandler.handleRequest("second");
        System.out.println("-----------");
        firstHandler.handleRequest("third");
        System.out.println("-----------");
        firstHandler.handleRequest("four");

    }

}

输出：

firsthandler capture it!
-----------
secondhandler capture it!
-----------
thirdhandler capture it!
-----------
no one can capture it!

这就是简易的职责链，结构特别的简单，但是问题来了，对于稳定运行的代码他的职责链应该是相对固定的，那么难道我们每次使用都要new出每一个处理者并建立职责链吗？我们可以建立一个管理类将这个过程封装起来

package top.huyuxin.ChainofResponsibility;

public class HandlerManger {

    private HandlerManger() {
        super();
    }

    public static class HandlerManagerInstance{
        private static HandlerManger instance=new HandlerManger();
        public static HandlerManger getInstance() {
            return instance;
        }
    }

    private static Handler firstHandler;
    private static Handler secondHandler;
    private static Handler thirdHandler;

    static{
         firstHandler = new FirstHandler();
         secondHandler = new SecondHandler();
         thirdHandler = new ThirdHandler();
    }

    public void handleRequest(String condition){

        firstHandler.nextHandler=secondHandler;
        secondHandler.nextHandler=thirdHandler;
        firstHandler.handleRequest(condition);
    }

}

调用：

package top.huyuxin.ChainofResponsibility;

public class Main {

    public static void main(String[] args) {

        HandlerManger handlerManger = HandlerManger.HandlerManagerInstance.getInstance();

        handlerManger.handleRequest("first");
        System.out.println("-----------");
        handlerManger.handleRequest("second");
        System.out.println("-----------");
        handlerManger.handleRequest("third");
        System.out.println("-----------");
        handlerManger.handleRequest("four");

    }

结果是一致的，。

实战

在实际的项目中请求条件的匹配简单的字符串判断是远远不够的，
我们需要将请求类也抽象出来。
抽象请求类：

package top.huyuxin.ChainofResponsibility.plus;


public abstract class AbstrastRequest {
    //定义统一的请求级别
    public static final int FIRST_REQUEST=1;    
    public static final int SECOND_REQUEST=2;   
    public static final int THIRD_REQUEST=3;    
    //可有可无，用于开发者创建请求时传入个性化且必要的初始化参数
    private Object object;


    public AbstrastRequest(Object object){
        this.object=object;
    }
    //获取对应的参数
    public Object getContent(){
        return object;
    }

    public abstract int getRequestLevel();

}

具体的请求：

package top.huyuxin.ChainofResponsibility.plus;

import org.omg.CORBA.Request;

public class FirstRequest extends AbstrastRequest {

    public FirstRequest(String name) {
        super(name);
    }

    @Override
    public int getRequestLevel() {
        return FIRST_REQUEST;
    }

    @Override
    public String toString() {
        return "FirstRequest [name=" + getContent() + ", getRequestLevel()=" + getRequestLevel() + "]";
    }
}

package top.huyuxin.ChainofResponsibility.plus;

public class SecondRequest extends AbstrastRequest {


    public SecondRequest(int initflag) {
        super(initflag);
    }

    @Override
    public int getRequestLevel() {
        return SECOND_REQUEST;
    }

    @Override
    public String toString() {
        return "SecondRequest [initflag=" + getContent() + ", getRequestLevel()=" + getRequestLevel() + "]";
    }
}

package top.huyuxin.ChainofResponsibility.plus;

public class ThirdRequest extends AbstrastRequest {

    public ThirdRequest(Boolean flag) {
        super(flag);
    }

    @Override
    public int getRequestLevel() {
        return THIRD_REQUEST;
    }

    @Override
    public String toString() {
        return "ThirdRequest [flag=" + false + ", getRequestLevel()=" + getRequestLevel() + "]";
    }

}

抽象的处理类：

package top.huyuxin.ChainofResponsibility.plus;

public abstract class AbstractHandler {

    protected AbstractHandler nextHandler;

    public final void handlerRequest(AbstrastRequest request){
        if(getHandleLevel()==request.getRequestLevel()){
            handle(request);
        }else {
            if(nextHandler!=null){
                nextHandler.handle(request);
            }else{
                System.out.println("no handler can deal with the request!");
            }
        }
    }

    protected abstract int getHandleLevel();

    protected abstract void handle(AbstrastRequest request);

}

具体的处理类：

package top.huyuxin.ChainofResponsibility.plus;

public class FirstHandler extends AbstractHandler {

    @Override
    protected int getHandleLevel() {
        return AbstrastRequest.FIRST_REQUEST;
    }

    @Override
    protected void handle(AbstrastRequest request) {
        System.out.println("i can deal with the request:"+request.toString());
    }

}

package top.huyuxin.ChainofResponsibility.plus;

public class SecondHandler extends AbstractHandler {

    @Override
    protected int getHandleLevel() {
        return AbstrastRequest.SECOND_REQUEST;
    }

    @Override
    protected void handle(AbstrastRequest request) {
        System.out.println("i can deal with the request:"+request.toString());
    }

}

package top.huyuxin.ChainofResponsibility.plus;

public class ThirdHandler extends AbstractHandler {

    @Override
    protected int getHandleLevel() {
        return AbstrastRequest.THIRD_REQUEST;
    }

    @Override
    protected void handle(AbstrastRequest request) {
        System.out.println("i can deal with the request:"+request.toString());
    }

}

职责链管理器：

package top.huyuxin.ChainofResponsibility.plus;

public class HandlerManger {

    private HandlerManger() {
        super();
    }

    public static class HandlerManagerInstance{
        private static HandlerManger instance=new HandlerManger();
        public static HandlerManger getInstance() {
            return instance;
        }
    }

    private static AbstractHandler firstHandler;
    private static AbstractHandler secondHandler;
    private static AbstractHandler thirdHandler;

    static{
         firstHandler = new FirstHandler();
         secondHandler = new SecondHandler();
         thirdHandler = new ThirdHandler();
    }

    public void handleRequest(AbstrastRequest request){

        firstHandler.nextHandler=secondHandler;
        secondHandler.nextHandler=thirdHandler;
        firstHandler.handlerRequest(request);
    }

}

调用：

package top.huyuxin.ChainofResponsibility.plus;

public class Main {

    public static void main(String[] args) {
        HandlerManger handlerManger=HandlerManger.HandlerManagerInstance.getInstance();

        FirstRequest firstRequest=new FirstRequest("FirstRequest");
        SecondRequest secondRequest=new SecondRequest(2);
        ThirdRequest thirdRequest=new ThirdRequest(true);

        handlerManger.handleRequest(firstRequest);
        handlerManger.handleRequest(secondRequest);
        handlerManger.handleRequest(thirdRequest);


    }

}

结果：

i can deal with the request:FirstRequest [name=FirstRequest, getRequestLevel()=1]
i can deal with the request:SecondRequest [initflag=2, getRequestLevel()=2]
i can deal with the request:ThirdRequest [flag=false, getRequestLevel()=3]

我们将请求分离了出来丰富了请求的内容，使得能够在请求体内携带更多的信息。这些信息能够在请求的初始化以及处理类的处理中提供很大的帮助，并且我们将处理请求方法（handle）与请求分发分离（handlerRequest），使得逻辑更加的清晰。
职责链模式是比较简单的行为模式，他和状态模式比起来相似之处很多，但是又截然不同。

参考《Android源码设计模式解析与实战》中第九章–使编程更有灵活性——职责链模式

Ethan__Hu

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
[设计模式]职责链模式

开始写设计模式系列,希望自己可以坚持下来. 第七篇:职责链模式什么是职责链模式关于职责链模式GOF是这样定义的：使多个对象都有机会处理请求，从而避免了请求的发送者和接受者之间额耦合关系。将这些对象连成一条链，并沿着这条链传递该请求，直到有对象处理它为止。简易实现Talk is cheap,我们来看下最为简易的职责链实现。抽象的处理者：package top.huyuxin.Chainof
复制链接

扫一扫