责任链模式（Chain of Responsibility）

一、定义

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

责任链模式的角色：

抽象处理者角色（Handler）：定义出一个处理请求的接口。如果需要，接口可以定义出一个方法以设定和返回对下家的引用。这个角色通常由一个Java抽象类或者Java接口实现。

具体处理者角色（ConcreteHandler）：具体处理者接到请求后，可以选择将请求处理掉，或者将请求传给下家。

二、例子

举个简单例子：报销流程，项目经理——部门经理——总经理。其中项目经理报销额度不能超过1000，部门经理报销额度不能超过5000，超过5000的则需要总经理审核。

抽象处理角色ConsumeHandler：

package com.wuychn.chain_of_responsibility;

import java.math.BigDecimal;

public abstract class ConsumeHandler {
    private ConsumeHandler nextHandler;

    public ConsumeHandler getNextHandler() {
        return nextHandler;
    }

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

    public abstract void doHandler(String user, BigDecimal free);
}

具体处理角色：

package com.wuychn.chain_of_responsibility;

import java.math.BigDecimal;

public class DeptHandler extends ConsumeHandler {
    @Override
    public void doHandler(String user, BigDecimal free) {
        if (free.doubleValue() < 5000) {
            if (user.equals("qq"))
                System.out.println(user + "报销不通过");
            else
                System.out.println(user + "给予报销：" + free);
        } else {
            if (getNextHandler() != null) {
                getNextHandler().doHandler(user, free);
            }
        }
    }
}

package com.wuychn.chain_of_responsibility;


import java.math.BigDecimal;

public class GeneralHandler extends ConsumeHandler {
    @Override
    public void doHandler(String user, BigDecimal free) {
        if (free.doubleValue() >= 5000) {
            if (user.equals("zzh"))
                System.out.println(user + "报销不通过");
            else
                System.out.println(user + "给予报销：" + free);
        } else {
            if (getNextHandler() != null) {
                getNextHandler().doHandler(user, free);
            }
        }
    }
}

package com.wuychn.chain_of_responsibility;

import java.math.BigDecimal;

public class ProjectHandler extends ConsumeHandler {
    @Override
    public void doHandler(String user, BigDecimal free) {
        if (free.doubleValue() < 1000) {
            if (user.equals("jj"))
                System.out.println(user + "报销不通过");
            else
                System.out.println(user + "给予报销：" + free);
        } else {
            if (getNextHandler() != null) {
                getNextHandler().doHandler(user, free);
            }
        }
    }
}

测试代码：

package com.wuychn.chain_of_responsibility;

import java.math.BigDecimal;

public class Test {

    public static void main(String[] args) {
        ConsumeHandler project = new ProjectHandler();
        ConsumeHandler dept = new DeptHandler();
        ConsumeHandler general = new GeneralHandler();
        project.setNextHandler(dept);
        dept.setNextHandler(general);
        project.doHandler("jj", new BigDecimal(2000));
        project.doHandler("jj", new BigDecimal(300));
        project.doHandler("qq", new BigDecimal(2000));
        project.doHandler("zzh", new BigDecimal(20000));
        project.doHandler("qq", new BigDecimal(20000));

    }

}

运行结果：

jj给予报销：2000
jj报销不通过
qq报销不通过
zzh报销不通过
qq给予报销：20000

三、优缺点

优点： 

1、降低耦合度。它将请求的发送者和接收者解耦。

2、简化了对象。使得对象不需要知道链的结构。

3、增强给对象指派职责的灵活性。通过改变链内的成员或者调动它们的次序，允许动态地新增或者删除责任。

4、增加新的请求处理类很方便。

缺点： 

1、不能保证请求一定被接收。

2、系统性能将受到一定影响，而且在进行代码调试时不太方便，可能会造成循环调用。

3、可能不容易观察运行时的特征，有碍于除错。

四、使用场景： 

1、有多个对象可以处理同一个请求，具体哪个对象处理该请求由运行时刻自动确定。

2、在不明确指定接收者的情况下，向多个对象中的一个提交一个请求。

3、可动态指定一组对象处理请求。

---

原文：

https://blog.csdn.net/u013256816/article/details/51058075

https://www.runoob.com/design-pattern/chain-of-responsibility-pattern.html