设计模式之责任链模式

╰+哭是因爲堅強的太久メ 2022-10-22 02:46 177阅读 0赞

# 一：责任链模式的定义 #

**使多个对象都有机会处理请求，从而避免了请求的发送者和接受者之间的耦合关系。将这些对象连城一条链，并沿着这条链传递该请求，直到有对象处理它为止。**

# 二：责任链模式的优点 #

责任链模式非常显著的优点是将请求和处理分开，请求者可以不用知道是谁处理的，处理者可以不用知道请求的全貌，两者解耦，提高系统的灵活性。

# 三：责任链模式的缺点 #

*  责任链存在性能问题，每个请求都是从链头遍历到链尾，特别是在链比较长的时候，性能是一个非常大的问题。
 *  调试不是很方便，特别是链条比较长，环节比较多的时候，由于采用了类似递归的方式，调用的时候逻辑可能比较复杂。

# 四：UML #

![Center][]

五：代码实现

Request实体类：

package chain;
    
    /**
     * @author lizhangyu
     * @date 2021/4/26 17:05
     */
    public class Request {
    
        private int level;
    
        public Request(int level) {
            this.level = level;
        }
    
        public int getHandlerLevel() {
            return level;
        }
    }

Handler实体类：

package chain;
    
    /**
     * @author lizhangyu
     * @date 2021/4/26 16:38
     */
    public abstract class Handler {
    
        private Handler nextHandler;
    
        /**
         * 每个处理者都必须对请求做出处理
         * @param request
         */
        public final void handlerMessage(Request request) {
            if (getHandlerLevel() == request.getHandlerLevel()) {
                response(request);
            }else if (nextHandler != null) {
                nextHandler.handlerMessage(request);
            }
        }
    
        /**
         * 设置下一个处理者是谁
         * @param _handler
         */
        public void setNextHandler(Handler _handler) {
            this.nextHandler = _handler;
        }
    
        /**
         * 每个处理者都有一个处理级别
         * @return
         */
        protected abstract int getHandlerLevel();
    
        /**
         * 每个处理者都必须实现处理任务
         * @param request
         * @return
         */
        protected abstract void response(Request request);
    }

ConcreteHandler1实体类：

package chain;
    
    /**
     * @author lizhangyu
     * @date 2021/4/26 17:00
     */
    public class ConcreteHandler1 extends Handler {
    
        /**
         * 设置自己的处理级别
         * @return
         */
        @Override
        protected int getHandlerLevel() {
            return 1;
        }
    
        /**
         * 定义自己的处理逻辑
         * @param request
         */
        @Override
        protected void response(chain.Request request) {
            System.out.println("这是具体请求1");
        }
    }

ConcreteHandler2实体类：

package chain;
    
    /**
     * @author lizhangyu
     * @date 2021/4/26 17:16
     */
    public class ConcreteHandler2 extends Handler {
    
        /**
         * 设置自己的处理级别
         * @return
         */
        @Override
        protected int getHandlerLevel() {
            return 2;
        }
    
        /**
         * 定义自己的处理逻辑
         * @param request
         */
        @Override
        protected void response(Request request) {
            System.out.println("这是具体请求2");
        }
    }

ConcreteHandler3实体类：

package chain;
    
    /**
     * @author lizhangyu
     * @date 2021/4/26 17:39
     */
    public class ConcreteHandler3 extends Handler {
    
        /**
         * 设置自己的处理级别
         * @return
         */
        @Override
        protected int getHandlerLevel() {
            return 3;
        }
    
        /**
         * 定义自己的处理逻辑
         * @param request
         */
        @Override
        protected void response(Request request) {
            System.out.println("这是具体请求3");
        }
    }

Client实体类：

package chain;
    
    /**
     * @author lizhangyu
     * @date 2021/4/26 17:17
     */
    public class Client {
    
        public static void main(String[] args) {
            Handler handler1 = new ConcreteHandler1();
            Handler handler2 = new ConcreteHandler2();
            Handler handler3 = new ConcreteHandler3();
            handler1.setNextHandler(handler2);
            handler2.setNextHandler(handler3);
            handler1.handlerMessage(new Request(3));
        }
    
    }

运行结果：

这是具体请求3
    
    Process finished with exit code 0

总结：运用责任链模式可以在不改具体实现类的方法的前提下，对处理问题的解决方式可以很好的进行动态扩展。

[Center]: /images/20221022/968f50d68ff044f58c0ec0806fbe14bd.png