【Java设计模式】责任链模式

✍ 责任链模式是我们介绍的第一个行为型模式，这里有必要把行为型模式好好介绍一下：

行为型模式(Behavioral Pattern) 是对 在不同的对象之间划分责任和算法的抽象化 。行为型模式不仅仅关注类和对象的结构，而
且 重点关注它们之间的相互作用 。通过行为型模式，可以更加清晰地 划分类与对象的职责 ，并 研究系统在运行时实例对象之间的交互 。在系统运行时，对象并不是孤立的，它们可以通过相互通信与协作完成某些复杂功能，一个对象在运行时也将影响到其他对象的运行。

行为型模式分为 类行为型模式 和 对象行为型模式 两种：

• 类行为型模式：类的行为型模式使用继承关系在几个类之间分配行为，类行为型模式主要通过多态等方式来分配父类与子类的职责。
• 对象行为型模式：对象的行为型模式则使用对象的聚合关联关系来分配行为，对象行为型模式主要是通过对象关联等方式来分配两个或多个类的职责。根据“合成复用原则”，系统中要尽量使用关联关系来取代继承关系，因此大部分行为型设计模式都属于对象行为型设计模式。

✍ 模式动机

职责链可以是 一条直线 、 一个环或者一个树形结构 ， 最常见的职责链是 直线型 ， 即沿着 一条单向的链 来传递请求 。 链上的每一个对象都是请求处理者 ， 职责链模式可以 将请求的处理者组织成一条链 ， 并使请求沿着链传递 ， 由链上的处理者对请求进行相应的处理 ， 客户端无须关心请求的处理细节以及请求的传递 ， 只需将请求发送到链上即可 ， 将请求的发送者和请求的处理者解耦 。 这就是职责链模式的模式动机 。

职责链模式(Chain of Responsibility Pattern) 的定义如下：避免请求发送者与接收者耦合在一起， 让多个对象都有可能接收请求 ， 将这些对象连接成一条链 ，并且 沿着这条链传递请求 ，直到有对象处理它为止。由于英文翻译的不同，职责链模式又称为责任链模式。

职责链模式包含如下角色：

• Handler: 抽象处理者 ：定义一个处理请求的接口，包含抽象处理方法和一个后继连接。
• ConcreteHandler: 具体处理者：实现抽象处理者的处理方法，判断能否处理本次请求，如果可以处理请求则处理，否则将该请求转给它的后继者。
• Client: 客户类：创建处理链，并向链头的具体处理者对象提交请求，它不关心处理细节和请求的传递过程。

✍ 演示一下：
课程类

public class Course {
    private String name;
    private String article;
    private String video;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getArticle() {
        return article;
    }

    public void setArticle(String article) {
        this.article = article;
    }

    public String getVideo() {
        return video;
    }

    public void setVideo(String video) {
        this.video = video;
    }

    @Override
    public String toString() {
        return "Course{" +
                "name='" + name + '\'' +
                ", article='" + article + '\'' +
                ", video='" + video + '\'' +
                '}';
    }
}

责任者的抽象类 （Handler: 抽象处理者）

public abstract class Approver {
    protected Approver approver;

    public void setNextApprover(Approver approver){
        this.approver = approver;
    }
    public abstract void deploy(Course course);
}

审核笔记的责任者(笔记审核员) （ConcreteHandler: 具体处理者）

需要导入jar包 下载地址

import org.apache.commons.lang3.StringUtils;

public class ArticleApprover extends Approver {
    @Override
    public void deploy(Course course) {
        if(StringUtils.isNotEmpty(course.getArticle())){
            System.out.println(course.getName()+"含有配套文档,批准");
            if(approver != null){
                approver.deploy(course);
            }
        }else{
            System.out.println(course.getName()+"不含有配套文档,不批准,流程结束");
            return;
        }
    }
}

审核视频的责任者（视频审核员） （ConcreteHandler: 具体处理者）

import org.apache.commons.lang3.StringUtils;

public class VideoApprover extends Approver{
    @Override
    public void deploy(Course course) {
        if(StringUtils.isNotEmpty(course.getVideo())){
            System.out.println(course.getName()+"含有视频,批准");
            if(approver != null){
                approver.deploy(course);
            }
        }else{
            System.out.println(course.getName()+"不含有视频,不批准,流程结束");
            return;
        }
    }
}

类图：

审核视频的 和 审核笔记的 很明显是一条责任链

测试类（Client: 客户类）

public class Test {
    public static void main(String[] args) {
        Approver articleApprover = new ArticleApprover(); //笔记审核员
        Approver videoApprover = new VideoApprover(); //视频审核员

        Course course = new Course();
        course.setName("Java设计模式");
        course.setArticle("Java设计模式的配套笔记");
        course.setVideo("Java设计模式的视频");

        articleApprover.setNextApprover(videoApprover); //审核视频

        articleApprover.deploy(course);  //审核视频
    }
}

结果：

这个设计模式还是比较简单的

✍ 模式分析

在职责链模式里 ， 很多对象由每一个对象对其下家的引用而连接起来形成一条链 。请求在这条链上传递 ， 直到链上的某一个对象处理此请求为止 。发出这个请求的客户端并不知道链上的哪一个对象最终处理这个请求 ， 这使得系统可以在不影响客户端的情况下动态地重新组织链和分配责任

✍ 说一下它的优缺点

职责链模式的优点

• 降低耦合度
• 可简化对象的相互连接
• 增强给对象指派职责的灵活性
• 增加新的请求处理类很方便

职责链模式的缺点

• 不能保证请求一定被接收。
• 系统性能将受到一定影响，而且在进行代码调试时不太方便；可能会造成循环调用。

✍ 模式适用环境

在以下情况下可以使用职责链模式：

• 有多个对象可以处理同一个请求，具体哪个对象处理该请求由运行时刻自动确定。
• 在不明确指定接收者的情况下，向多个对象中的一个提交一个请求。
• 可动态指定一组对象处理请求。

✍模式扩展

纯与不纯的职责链模式

• 一个纯的职责链模式要求一个具体处理者对象只能在两个行为中选择一个：一个是承担责任，另一个是把责任推给下家。不允许出现某一个具体处理者对象在承担了一部分责任后又将责任向下传的情况。
• 在一个纯的职责链模式里面，一个请求必须被某一个处理者对象所接收；在一个不纯的职责链模式里面，一个请求可以最终不被任何接收端对象所接收。