Java设计模式--责任链模式

1 定义

有多个对象，每个对象持有下一个对象的引用，这样就形成了一条链，请求在这条链上传递，直到某个对象处理了该请求，但是请求的发出者并不知道是哪个对象处理了该请求，所以，在这里我们可以发现责任链模式可以在隐瞒客户端的情况下对系统的逻辑进行动态调整。

2 类图及实例

2.1 类图

这里我们看一下责任链模式的UML类图。

从上图我们可以看出，处理者持有下一个处理者，并且拥有对请求处理的方法，下面我们来看一看具体的示例。

2.2 实例

（1）休假对象

/**
 * 演示责任链模式
 * 休假对象
 *
 * @author: LIUTAO
 * @Date: Created in 2018/10/29  10:07
 * @Modified By:
 */
public class Leave {
    private String name;
    private String reason;
    private int days;

    public Leave() {
    }

    public Leave(String name, String reason, int days) {
        this.name = name;
        this.reason = reason;
        this.days = days;
    }

    public String getName() {
        return name;
    }

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

    public String getReason() {
        return reason;
    }

    public void setReason(String reason) {
        this.reason = reason;
    }

    public int getDays() {
        return days;
    }

    public void setDays(int days) {
        this.days = days;
    }
}

（2）抽象处理对象

/**
 * 演示责任链模式
 * 抽象处理对象
 *
 * @author: LIUTAO
 * @Date: Created in 2018/10/29  10:04
 * @Modified By:
 */
public abstract class Leader {
    private String name;
    protected Leader leader;

    public String getName() {
        return name;
    }

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

    public void setLeader(Leader leader) {
        this.leader = leader;
    }

    public abstract void handleLeave(Leave leave);
}

（3）具体处理对象1

/**
 * 演示责任链模式
 * 组长对象
 *
 * @author: LIUTAO
 * @Date: Created in 2018/10/29  10:11
 * @Modified By:
 */
public class GroupLeader extends Leader {

    public GroupLeader(String name) {
        super.setName(name);
    }

    @Override
    public void handleLeave(Leave leave) {
        if(leave.getDays() > 3){
            leader.handleLeave(leave);
            return;
        }

        System.out.println(this.getName()+"准许休假");
    }
}

（4）具体处理对象2

/**
 * 演示责任链模式
 * 经理对像
 *
 * @author: LIUTAO
 * @Date: Created in 2018/10/29  10:13
 * @Modified By:
 */
public class Manager extends Leader {
    public Manager(String name) {
        super.setName(name);
    }

    @Override
    public void handleLeave(Leave leave) {
        System.out.println(this.getName() + "准许休假");
    }
}

（5）处理对象容器

/**
 * 演示责任链模式
 * 行政部，这里持有了处理请假的责任链，并对请假进行处理
 *
 * @author: LIUTAO
 * @Date: Created in 2018/10/29  10:17
 * @Modified By:
 */
public class AdministrationSection {
    private GroupLeader groupLeader = new GroupLeader("Mr.Liu");
    private Manager manager = new Manager("Mr.Wang");

    public void handleLeave(Leave leave) {
        groupLeader.setLeader(manager);
        groupLeader.handleLeave(leave);
    }
}

（6）测试类

/**
 * @author: LIUTAO
 * @Date: Created in 2018/10/29  10:14
 * @Modified By:
 */
public class Test {

    public static void main(String[] args) {
        Leave leave = new Leave("ross","have a stomachache",5);
        AdministrationSection administrationSection = new AdministrationSection();
        administrationSection.handleLeave(leave);
    }

}

运行上面的代码，输出如下：

Mr.Wang准许休假

上面我们对责任链进行了封装。针对责任链模式在java中比较明显的一个使用地方就是异常的处理try ... catch。

3 优缺点

责任链模式将请求和处理的逻辑进行了分离，发出请求的客户端并不知道责任链上的哪一个环节会处理请求，这样使得可以在不影响客户端的情况下从新组合服务端的逻辑，提高了系统的灵活性和可扩展性。

至于缺点也很明显，每次处理请求都要从责任链的开头进行。