[设计模式Java实现附plantuml源码~行为型]请求的链式处理——职责链模式

本文介绍: 职责链模式通过建立一条链来组织请求的处理者。请求将沿着链进行传递，请求发送者无须知道请求在何时、何处以及如何被处理，实现了请求发送者与处理者的解耦。在软件开发中，如果遇到有多个对象可以处理同一请求时可以应用职责链模式。例如，在Web应用开发中创建一个过滤器（Filter）链来对请求数据进行过滤，在工作流系统中实现公文的分级审批等，使用职责链模式可以较好地解决此类问题。

🔥[设计模式Java实现附plantuml源码]专链

很多情况下，在一个软件系统中可以处理某个请求的对象不止一个。例如SCM系统中的采购单审批，主任、副董事长、董事长和董事会都可以处理采购单，他们可以构成一条处理采购单的链式结构。采购单沿着这条链进行传递，这条链就称为职责链。职责链可以是一条直线、一个环或者一个树形结构，最常见的职责链是直线型，即沿着一条单向的链来传递请求。链上的每一个对象都是请求处理者，职责链模式可以将请求的处理者组织成一条链，并让请求沿着链传递，由链上的处理者对请求进行相应的处理，客户端无须关心请求的处理细节以及请求的传递，只需将请求发送到链上即可，实现请求发送者和请求处理者解耦。

@startuml

abstract class Handler {
# successor: Handler
+ handlerRequest()
} 

Handler *--> Handler: successor

class ConcreteHandlerA extends Handler {
+ handlerRequest()
}
class ConcreteHandlerB extends Handler {
+ handlerRequest()
}

class Client{}
Client --> Handler: 在client 组建责任链

@enduml

由图可以看出，在职责链模式结构图中包含以下两个角色。
（1）Handler（抽象处理者）：它定义了一个处理请求的接口，一般设计为抽象类。由于不同的具体处理者处理请求的方式不同，因此在其中定义了抽象请求处理方法。因为每个处理者的下家还是一个处理者，因此在抽象处理者中定义了一个抽象处理者类型的对象（结构图中的successor），作为其对下家的引用。通过该引用，处理者可以连成一条链。
（2）ConcreteHandler（具体处理者)：它是抽象处理者的子类，可以处理用户请求。在具体处理者类中实现了抽象处理者中定义的抽象请求处理方法，在处理请求之前需要进行判断，看是否有相应的处理权限，如果可以处理请求就处理它，否则将请求转发给后继者。在具体处理者中可以访问链中下一个对象，以便请求的转发。

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

package havior;

public class ChainDemo {

    public static class Request {
        private final Integer money;
        private final String purpose;

        private final String number;

        public Request(Integer money, String purpose, String number) {
            this.money = money;
            this.purpose = purpose;
            this.number = number;
        }

        public Integer getMoney() {
            return money;
        }

        public String toString(String handlerName) {
            return handlerName+" 审批通过: Request{" +
                "money=" + money +
                ", purpose='" + purpose + ''' +
                ", number='" + number + ''' +
                '}';
        }
    }

    public abstract static class Handler {
        protected final Handler successor;

        protected final String name;

        public Handler(Handler handler, String name) {
            this.successor = handler;
            this.name = name;
        }

        public abstract void handlerRequest(Request request);
    }

    public static class ConcreteHandlerA extends Handler {

        public ConcreteHandlerA(Handler handler) {
            super(handler, ConcreteHandlerA.class.getSimpleName());
        }

        @Override
        public void handlerRequest(Request request) {
            System.out.println(request.toString(this.name));
            if(request.getMoney() < 100) {
                return;
            }
            this.successor.handlerRequest(request);
        }
    }

    public static class ConcreteHandlerB extends Handler {

        public ConcreteHandlerB(Handler handler) {
            super(handler, ConcreteHandlerB.class.getSimpleName());
        }

        @Override
        public void handlerRequest(Request request) {
            System.out.println(request.toString(this.name));
            if(request.getMoney() < 1000) {
                return;
            }
            this.successor.handlerRequest(request);
        }
    }



    public static void main(String[] args) {
        Handler chain = new ConcreteHandlerA(new ConcreteHandlerB(null));
        Request request = new Request(10, "买根辣条", "001");
        chain.handlerRequest(request);
        Request request1 = new Request(200, "买个游戏手柄", "002");
        chain.handlerRequest(request1);
        Request request3 = new Request(20000, "幻想时刻", "003");
        chain.handlerRequest(request3); // 这里抛出异常，因为责任链没有包括>=1000的审批
    }
}

结果

ConcreteHandlerA 审批通过: Request{money=10, purpose='买根辣条', number='001'}
ConcreteHandlerA 审批通过: Request{money=200, purpose='买个游戏手柄', number='002'}
ConcreteHandlerB 审批通过: Request{money=200, purpose='买个游戏手柄', number='002'}
ConcreteHandlerA 审批通过: Request{money=20000, purpose='幻想时刻', number='003'}
ConcreteHandlerB 审批通过: Request{money=20000, purpose='幻想时刻', number='003'}
Exception in thread "main" java.lang.NullPointerException: Cannot invoke "havior.ChainDemo$Handler.handlerRequest(havior.ChainDemo$Request)" because "this.successor" is null
	at havior.ChainDemo$ConcreteHandlerB.handlerRequest(ChainDemo.java:71)
	at havior.ChainDemo$ConcreteHandlerA.handlerRequest(ChainDemo.java:55)
	at havior.ChainDemo.main(ChainDemo.java:84)

一个纯的职责链模式要求一个具体处理者对象只能在两个行为中选择一个：要么承担全部责任，要么将责任推给下家。不允许出现某一个具体处理者对象在承担了一部分或全部责任后又将责任向下传递的情况。而且在纯的职责链模式中，要求一个请求必须被某一个处理者对象所接收，不能出现某个请求未被任何一个处理者对象处理的情况。在前面的采购单审批实例中应用的是纯的职责链模式。