设计模式——责任链模式

#　责任链模式

@author lisiwen

@createTime 2020/01/07

​ **职责链模式(Chain of Responsibility)：**使多个对象都有机会处理请求，这样避免请求的发送者和接受者之间的耦合关系。将这个 对象连胜一条链，并沿着这条链传递该请求，直到有一个对象处理它为止.

代码示例：

Handler.java

/**
 * @ProjectName: designpattern
 * @ClassName: Handler
 * @Description: 定义一个处理请示的接口，继承该类的是具体的处理者类，处理他所负责的请求，可以访问它的后继者，如果可处理该请求，就处理之，否则就将该请求转发给它的后继者。
 * @Author: lisiwen
 * @Date: 2020/1/7 8:53
 **/
abstract class Handler {
    protected Handler successor;

    /**
     * @param successor
     * @Description 设置继承者
     * @Date 2020/1/7 8:54
     * @Return void
     **/
    public void setSuccessor(Handler successor) {
        this.successor = successor;
    }

    /**
     * @param request
     * @Description 处理请求的抽象方法
     * @Date 2020/1/7 8:55
     * @Return void
     **/
    abstract void handlRequest(int request);
}

ConcreteHandler1.java

/**
 * @ProjectName: designpattern
 * @ClassName: ConcreteHandler1
 * @Description: 当前请求数在0到10之间则有权处理，否则转到下一位
 * @Author: lisiwen
 * @Date: 2020/1/7 8:55
 **/
public class ConcreteHandler1 extends Handler {
    @Override
    void handlRequest(int request) {
        //0-10 才处理次请求
        if (request >= 0 && request < 10) {
            System.out.println(this.getClass().getName() + "处理请求" + request);
        } else if (successor != null) {
            //转移到下一位
            successor.handlRequest(request);
        }
    }
}

ConcreteHandler2.java

/**
 * @ProjectName: designpattern
 * @ClassName: ConCreteHandler2
 * @Description: 当前请求数在10到20之间则有权处理，否则转到下一位
 * @Author: lisiwen
 * @Date: 2020/1/7 8:58
 **/
public class ConcreteHandler2 extends Handler {
    @Override
    void handlRequest(int request) {
        //0-10 才处理次请求
        if (request >= 10 && request < 20) {
            System.out.println(this.getClass().getName() + "处理请求" + request);
        } else if (successor != null) {
            //转移到下一位
            successor.handlRequest(request);
        }
    }
}

ConcreteHandler3.java

/**
 * @ProjectName: designpattern
 * @ClassName: ConcreteHandler3
 * @Description: 当前请求数在20到30之间则有权处理，否则转到下一位
 * @Author: lisiwen
 * @Date: 2020/1/7 8:59
 **/
public class ConcreteHandler3 extends Handler {
    @Override
    void handlRequest(int request) {
        //0-10 才处理次请求
        if (request >= 20 && request < 30) {
            System.out.println(this.getClass().getName() + "处理请求" + request);
        } else if (successor != null) {
            //转移到下一位
            successor.handlRequest(request);
        }
    }
}

Main.java

/**
 * @ProjectName: designpattern
 * @ClassName: Main
 * @Description: 客户端
 * @Author: lisiwen
 * @Date: 2020/1/7 8:52
 **/
public class Main {
    public static void main(String[] args) {
        Handler h1 = new ConcreteHandler1();
        Handler h2 = new ConcreteHandler2();
        Handler h3 = new ConcreteHandler3();
        // 设置责任链
        h1.setSuccessor(h2);
        h2.setSuccessor(h3);
        int[] request = {2, 6, 12, 15, 19, 20, 32, 23, 2, 10};
        // 循环给最小楚离着提交请求，不同的数额，由不同权限处理者处理
        for (int i : request) {
            h1.handlRequest(i);
        }
    }
}
// 控制台输出
chainofresponsibility.ConcreteHandler1处理请求2
chainofresponsibility.ConcreteHandler1处理请求6
chainofresponsibility.ConcreteHandler2处理请求12
chainofresponsibility.ConcreteHandler2处理请求15
chainofresponsibility.ConcreteHandler2处理请求19
chainofresponsibility.ConcreteHandler3处理请求20
chainofresponsibility.ConcreteHandler3处理请求23
chainofresponsibility.ConcreteHandler1处理请求2
chainofresponsibility.ConcreteHandler2处理请求10

优点

1. 当客户提交一个请求时，请求时沿链传递直至有一个ConcreteHandler对象负责处理他，使得接受和发送者都没有对方的明确信息，且链中的对象自己也并不知道链的结构。结果是职责链可简化对象的相互连接，他们仅需保持一个纸箱其后继者的引用，而不需要保持它所有候选接受者的引用。大大的降低了耦合度。
2. 随时的增加或修改处理一个请求的结构，增强了给对象指派职责的灵活性。
3. 一个请求有可能到了链的末端都得不到处理，或者因为没有正确配置而不得不处理，这样很糟糕，需要考虑全面。