设计模式-责任链模式（Chain of Responsibility Pattern）

推荐：Java设计模式汇总

责任链模式

定义
为请求创建一个接收者对象的链。这种模式给予请求的类型，对请求的发送者和接收者进行解耦。

类型
行为型。

UML类图

角色

• 抽象处理者（BaseHandler）角色：定义处理请求的接口，并且有接下来要处理请求的处理者的引用。
• 具体处理者（ConcreteHandler）角色：实现抽象处理者角色中处理请求的接口。

例子
慕课网讲师上线新课程时，慕课网工作人员需要检查资料是否齐全，将检查的过程当作是链式的，比如先检查是否有课程手记，当有课程手记时，再检查是否有课程视频。

Course类，课程类。

package com.kaven.design.pattern.behavioral.chainofresponsibility;

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 + '\'' +
                '}';
    }
}

Approver类（抽象处理者角色），deploy()方法是抽象处理者角色定义的处理请求的接口，approver属性是接下来要处理请求的处理者的引用，不要纠结类名。

package com.kaven.design.pattern.behavioral.chainofresponsibility;

public abstract class Approver {
    protected Approver approver;

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

ArticleApprover类（ 具体处理者角色），继承了Approver类，实现了deploy()方法，检查是否有手记，有手记就将课程给下一个检查的处理者检查。

package com.kaven.design.pattern.behavioral.chainofresponsibility;


import org.springframework.util.StringUtils;

public class ArticleApprover extends Approver {
    public void deploy(Course course) {
        if(!StringUtils.isEmpty(course.getArticle())) {
            System.out.println(course.getName() + "含有手记，批准");
            if (approver != null) {
                approver.deploy(course);
            }
        }
        else{
                System.out.println(course.getName()+"不包含手记，不批准");
                return ;
        }
    }
}

VideoApprover类（ 具体处理者角色），继承了Approver类，实现了deploy()方法，检查是否有视频，有视频就将课程给下一个检查的处理者检查。

package com.kaven.design.pattern.behavioral.chainofresponsibility;

import org.springframework.util.StringUtils;

public class VideoApprover extends Approver {
    public void deploy(Course course) {
        if(!StringUtils.isEmpty(course.getVideo())){
            System.out.println(course.getName()+"含有视频，批准");
            if(approver != null){
                approver.deploy(course);
            }
        }
        else{
            System.out.println(course.getName()+"不包含视频，不批准");
            return ;
        }
    }
}

应用层代码1：

package com.kaven.design.pattern.behavioral.chainofresponsibility;

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);
    }
}

输出：

Java设计模式含有手记，批准
Java设计模式含有视频，批准

应用层代码2：

package com.kaven.design.pattern.behavioral.chainofresponsibility;

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);
    }
}

输出：

Java设计模式不包含手记，不批准

应用层代码3：

package com.kaven.design.pattern.behavioral.chainofresponsibility;

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);
    }
}

输出：

Java设计模式含有手记，批准
Java设计模式不包含视频，不批准

这里便完成了一个简单的责任链模式。

适用场景

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

优点

• 请求者不需要知道处理者，也不需要知道如何处理。每个责任对象只负责自己的责任范围，其他的交给后继者。各个组件间完全解耦。
• 责任链模式会把功能分散到单独的责任对象中，然后在使用时动态的组合形成链，从而可以灵活的分配责任对象，也可以灵活的添加责任对象。

缺点

• 因为功能处理都分散到了单独的责任对象中，每个责任对象功能单一，要把整个流程处理完，需要很多的责任对象，会产生大量的细粒度责任对象。
• 每个责任对象都只负责自己的部分，这样就可能出现某个请求，即使把整个链走完，都没有责任对象处理它。这就需要提供默认处理，并且注意构造链的有效性。

如果有说错的地方，请大家不吝赐教（记得留言哦~~~~）。