一、定义

责任链模式：通过对前一个对象记住下一个对象的引用形成的链路，沿着链路，直到找到对象处理请求。

二、示例：

模拟场景：
1、程序员需要请假，无论请多少天的假，开发领导都需要审批。请假的天数大于3天，小于等于10，开发经理需要审批。请假天数10天以上的，公司老板需要审批。

传统编码

if 语句全写在一个方法里面，随着审批角色的新增，if语句也变多。代码冗余，难维护

package com.qf.design.behavior.responsibilitychain.design;

import com.qf.design.behavior.responsibilitychain.tradition.HolidayController;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class ApproveController {
    private Logger logger= LoggerFactory.getLogger(HolidayController.class);
    @Override
    public void process(Integer day) {
        //开发领导审批
        logger.info("开发领导审批");
        
        //开发经理审批
        if (day>3){
            logger.info("开发经理审批");
        }

        //老板审批
        if (day>10){
            logger.info("老板审批");
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

责任链模式设计

每个对象只需要关注自己和下一个对象请求触发的条件
定义抽象类，等待被实现，子类可以定义下一个对象，设计具体触发条件

package com.qf.design.behavior.responsibilitychain.design;

public abstract class HolidayHandler {

    protected HolidayHandler next;

    public void setNext(HolidayHandler next){
        this.next=next;
    }

    public HolidayHandler getNext(){
        return next;
    }
    public abstract void process(Integer day);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

开发领导只关心，下一个审批角色：开发经理的触发条件

package com.qf.design.behavior.responsibilitychain.design;

import com.qf.design.behavior.responsibilitychain.tradition.HolidayController;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class Leader extends HolidayHandler{

    private Logger logger= LoggerFactory.getLogger(HolidayController.class);
    @Override
    public void process(Integer day) {
        //开发领导审批
        logger.info("开发领导审批");

       if (day>3){
           next.process(day);
       }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

开发经理只关心，下一个审批角色：老板的触发条件

package com.qf.design.behavior.responsibilitychain.design;

import com.qf.design.behavior.responsibilitychain.tradition.HolidayController;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class Manager extends HolidayHandler{

    private Logger logger= LoggerFactory.getLogger(HolidayController.class);
    @Override
    public void process(Integer day) {
        //开发经理审批
        logger.info("开发经理审批");

        //老板审批
        if (day>10){
            next.process(day);
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

老板无需关注其他的触发条件

package com.qf.design.behavior.responsibilitychain.design;

import com.qf.design.behavior.responsibilitychain.tradition.HolidayController;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class Boss extends HolidayHandler{
    private Logger logger= LoggerFactory.getLogger(HolidayController.class);
    @Override
    public void process(Integer day) {
        //开发领导审批
        logger.info("开发领导审批");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

测试：ApiTest

package com.qf.design.behavior.responsibilitychain.design;

public class ApiTest {
    public static void main(String[] args) {
        HolidayHandler leader = new Leader();
        HolidayHandler manager = new Manager();
        HolidayHandler boss = new Boss();
        leader.setNext(manager);
        manager.setNext(boss);
        leader.process(1);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13

UML关系图

总结：
从上⾯代码从if语句重构到使⽤责任链模式开发可以看到，我们的代码结构变得清晰⼲净了，也解决了⼤量if语句的使⽤。并不是if语句不好，只不过if语句并不适合做系统流程设计，但是在做判断和⾏为逻辑处理中还是⾮常可以使⽤的。

在我们前⾯学习结构性模式中讲到过组合模式，它像是⼀颗组合树⼀样，我们搭建出⼀个流程决策树。其实这样的模式也是可以和责任链模型进⾏组合扩展使⽤，⽽这部分的重点在于如何关联链路的关联，最终的执⾏都是在执⾏在中间的关系链。

责任链模式很好的处理单⼀职责和开闭原则，简单了耦合也使对象关系更加清晰，⽽且外部的调⽤⽅并不需要关⼼责任链是如何进⾏处理的(以上程序中可以把责任链的组合进⾏包装，在提供给外部使⽤)。但除了这些优点外也需要是适当的场景才进⾏使⽤，避免造成性能以及编排混乱调试测试疏漏问题。