设计模式学习之责任链模式

定义

责任链（Chain of Responsibility）模式的定义：为了避免请求发送者与多个请求处理者耦合在一起，将所有请求的 处理者 通过前一对象记住其下一个对象的引用而连成一条链；当有请求发生时，可将请求沿着这条链传递，直到有对象处理它为止。也称为职责链模式。

使用场景

1. 多个对象处理同一请求时，但是具体由哪个对象去处理需要运行时做判断。
2. 具体处理者不明确的情况下，向多个处理者提交了一个请求。
3. 可动态指定一组对象处理请求，或添加新的处理者。
4. 责任链一般用于处理流程节点之类的实际业务场景中。

实现所需角色

1. BaseHandler（抽象处理者）：抽象类或者接口,定义处理请求的方法以及持有下一个BaseHandler的引用。
2. FirstHandler、SecondHandler、ThirdHandler和FourthHandler（具体处理者）：继承抽象处理类，对请求进行处理，如果不处理则转发给下一个处理者。
3. Test (客户端)：使用责任链模式的地方。

UML图

具体实现

1.抽象处理者（BaseHandler）

/**
 * 定义处理请求的方法
 */
public abstract class BaseHandler {

    private BaseHandler nextHandler;		//下一个处理者的引用

    public BaseHandler getNextHandler() {
        return nextHandler;
    }

    public void setNextHandler(BaseHandler nextHandler) {
        this.nextHandler = nextHandler;
    }

    public abstract void dealRequest(String req);	//处理请求的方法
}

2.具体处理者1（FirstHandler）

public class FirstHandler extends BaseHandler {

    @Override
    public void dealRequest(String req) {
        if (req.equals("1")) {
            System.out.println("ok, 我是第一个，我处理");
        } else {
            if (getNextHandler() != null) {
                getNextHandler().dealRequest(req);
            } else {
                System.out.println("sorry了，你的请求超出了范围");
            }
        }
    }
}

3.具体处理者2（SecondHandler）

public class SecondHandler extends BaseHandler {

    @Override
    public void dealRequest(String req) {
        if (req.equals("2")) {
            System.out.println("ok, 2是我的，我处理");
        } else {
            if (getNextHandler() != null) {
                getNextHandler().dealRequest(req);
            } else {
                System.out.println("sorry了，你的请求超出了范围");
            }
        }
    }
}

4.具体处理者3（ThirdHandler）

public class ThirdHandler extends BaseHandler {

    @Override
    public void dealRequest(String req) {
        if (req.equals("3")) {
            System.out.println("ok, 第3个就交给我了");
        } else {
            if (getNextHandler() != null) {
                getNextHandler().dealRequest(req);
            } else {
                System.out.println("sorry了，你的请求超出了范围");
            }
        }
    }
}

5.具体处理者4（FourthHandler）

public class FourthHandler extends BaseHandler {

    @Override
    public void dealRequest(String req) {
        if (req.equals("4")) {
            System.out.println("快放手，放开第4个，我来");
        } else {
            if (getNextHandler() != null) {
                getNextHandler().dealRequest(req);
            } else {
                System.out.println("sorry了，你的请求超出了范围");
            }
        }
    }
}

测试责任链模式：

	@Test
    public void testResponsibilityMode() {
        //组装责任链
        BaseHandler firstHandler = new FirstHandler();
        BaseHandler secondHandler = new SecondHandler();
        BaseHandler thirdHandler = new ThirdHandler();
        BaseHandler fourthHandler = new FourthHandler();
        //设置后继责任对象
        firstHandler.setNextHandler(secondHandler);     
        secondHandler.setNextHandler(thirdHandler);
        thirdHandler.setNextHandler(fourthHandler);
        //处理请求
        firstHandler.dealRequest("3");
    }

运行结果如下：

简单的责任链模式案例实现就这样了，复杂的情况也是根据其原理做相应的改变。下面总结一下使用责任链模式有哪些优点和缺点：

优点

1. 降低了对象之间的耦合度。该模式使得一个对象无须知道到底是哪一个对象处理其请求以及链的结构，发送者和接收者也无须拥有对方的明确信息。
2. 增强了系统的可扩展性。可以根据需要增加新的请求处理类，满足开闭原则。
3. 增强了给对象指派职责的灵活性。当工作流程发生变化，可以动态地改变链内的成员或者调动它们的次序，也可动态地新增或者删除责任。
4. 责任链简化了对象之间的连接。每个对象只需保持一个指向其后继者的引用，不需保持其他所有处理者的引用，这避免了使用众多的 if 或者 if···else 语句。
5. 责任分担。每个类只需要处理自己该处理的工作，不该处理的传递给下一个对象完成，明确各类的责任范围，符合类的单一职责原则。

缺点

1. 不能保证每个请求一定被处理。由于一个请求没有明确的接收者，所以不能保证它一定会被处理，该请求可能一直传到链的末端都得不到处理。
2. 降低程序的性能。对于较长的责任链，如果每个请求都是从链头遍历到链尾，那么处理时可能涉及多个处理对象，系统性能将受到一定影响。
3. 职责链建立的合理性要靠客户端来保证，增加了客户端的复杂性，可能会由于职责链的错误设置而导致系统出错，如可能会造成循环调用。
4. 不易于调试。由于该模式采用了类似递归的方式，调试的时候逻辑比较复杂。

参考链接

https://editor.csdn.net/md?articleId=103703760
https://www.cnblogs.com/aeolian/p/8888958.html
https://blog.csdn.net/dingpeiqiang/article/details/91949101