Java设计模式_(行为型)

引用百科

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

责任链模式涉及到的角色：
●　抽象处理者(Handler)角色：定义出一个处理请求的接口。如果需要，接口可以定义出一个方法以设定和返回对下家的引用。这个角色通常由一个Java抽象类或者Java接口实现。抽象方法handleRequest()规范了子类处理请求的操作。
●　具体处理者(RealHandler)角色：具体处理者接到请求后，可以选择将请求处理掉，或者将请求传给下家。由于具体处理者持有对下家的引用，因此，如果需要，具体处理者可以访问下家。

案例：

如：有个请假需求，根据不同的请假天数进行不同的审批

<=2天，只项目经理审批 RealHandlerC

>2,<=5天，需要到部门经理审批 RealHandlerB

>5天，需要总经理审批 RealHandlerA

如下：

具体代码实现如下：

1、抽象处理类角色

//　抽象处理者角色类
public abstract class Handler {
 
    /**
     * @Description: 定义处理方法
     * @param date    请假天数
     */
    public abstract void requestHand(int date);
 
    // 过滤器对象
    private Handler resource;
 
    public Handler getResource() {
        return resource;
    }
 
    public void setResource(Handler resource) {
        this.resource = resource;
    }
 
}

2、具体实现类

//具体处理者角色C(项目经理)
public class RealHandlerC extends Handler {
 
    @Override
    public void requestHand(int date) {
        System.out.println("C 条件过滤...");
        if (date <= 2) {
            System.out.println("C处理请求!");
        } else {
            if (this.getResource() != null) {
                System.out.println("天数为" + date + ",C交给下一级处理!");
                this.getResource().requestHand(date);
            }
        }
    }
}
//具体处理者角色B(部门经理)
public class RealHandlerB extends Handler {
    @Override
    public void requestHand(int date) {
        System.out.println("B 条件过滤...");
        if (date <= 5) {
            System.out.println("B处理请求!");
        } else {
            if (this.getResource() != null) {
                System.out.println("天数为" + date + ",B交给下一级处理!");
                this.getResource().requestHand(date);
            }
        }
    }
}
//具体处理者角色A(总经理)
public class RealHandlerA extends Handler {
    @Override
    public void requestHand(int date) {
        System.out.println("A 条件过滤...");
        if (date > 5) {
            System.out.println("A处理请求!");
        } else {
            if (this.getResource() != null) {
                System.out.println("天数为" + date + ",A交给下一级处理!");
                this.getResource().requestHand(date);
            }
        }
    }
}

3、客户端Client测试

public class Client {
 
    private static void vacation() {
        // 组装责任链
        Handler chainA = new RealHandlerA();
        Handler chainB = new RealHandlerB();
        Handler chainC = new RealHandlerC();
 
        // chainC => chainB =>chainA
        chainC.setResource(chainB);
        chainB.setResource(chainA);
 
        // 测试，模拟请假天数进行审批
        chainC.requestHand(1);
        System.out.println("------------分割线------------");
        chainC.requestHand(4);
        System.out.println("------------分割线------------");
        chainC.requestHand(6);
    }
 
    public static void main(String[] args) {
        vacation();
    }
}

以上用请假案例简单的模拟了责任链模式，输出：
C 条件过滤...
C处理请求!
------------分割线------------
C 条件过滤...
天数为4,C交给下一级处理!
B 条件过滤...
B处理请求!
------------分割线------------
C 条件过滤...
天数为6,C交给下一级处理!
B 条件过滤...
天数为6,B交给下一级处理!
A 条件过滤...
A处理请求!

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