Java设计模式(十七)：责任链设计模式

向右看齐 2022-03-29 10:06 219阅读 0赞

# 1. 应用场景 #

*  一场足球赛，A队的2个组成队a、b。a队踢上半场，踢完后交给b队踢下半场，一起完成这场球赛。
 *  吃一条鱼：妈妈吃鱼头，吃完让儿子吃鱼身体，吃完给爸爸吃鱼尾巴。
 *  Servlet容器的过滤器

责任链就是这样有一条执行链来完成一件事。

# 2. 概念 #

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

# 3. Class Diagram #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzIxMTI1MTgz_size_16_color_FFFFFF_t_70]

*  Handler：定义处理请求的接口，并且实现后继链（successor）
 *  concreteHandler：具体的处理类

# 4. Implementation #

public class Request { 
    
        private RequestType type;
        private String name;
    
    
        public Request(RequestType type, String name) { 
            this.type = type;
            this.name = name;
        }
    
    
        public RequestType getType() { 
            return type;
        }
    
    
        public String getName() { 
            return name;
        }
    }
    
    public enum RequestType { 
        TYPE1, TYPE2
    }
    
    public abstract class Handler { 
        protected Handler successor;
    
        public Handler(Handler successor) { 
            this.successor = successor;
        }
    
        protected abstract void handlerRequest(Request request);
    }
    
    public class ConcreteHandler1 extends Handler { 
    
        public ConcreteHandler1(Handler successor) { 
            super(successor);
        }
    
        @Override
        protected void handlerRequest(Request request) { 
            if (request.getType() == RequestType.TYPE1) { 
                System.out.println(request.getName() + " is handle by ConcreteHandler1");
                return;
            }
            if (successor != null) { 
                successor.handlerRequest(request);
            }
        }
    }
    
    public class ConcreteHandler2 extends Handler { 
    
        public ConcreteHandler2(Handler successor) { 
            super(successor);
        }
    
        @Override
        protected void handlerRequest(Request request) { 
            if (request.getType() == RequestType.TYPE2) { 
                System.out.println(request.getName() + " is handle by ConcreteHandler2");
                return;
            }
            if (successor != null) { 
                successor.handlerRequest(request);
            }
        }
    }
    
    public class Client { 
        public static void main(String[] args) { 
            Handler handler1 = new ConcreteHandler1(null);
            Handler handler2 = new ConcreteHandler2(handler1);
    
            Request request1 = new Request(RequestType.TYPE1, "request1");
            handler2.handlerRequest(request1);
    
            Request request2 = new Request(RequestType.TYPE2, "request2");
            handler2.handlerRequest(request2);
        }
    }

# 5. 优点和缺点 #

## 5.1 ##

*  将请求的发送者和接受者解耦
 *  可以简化你的对象，因为你不需要知道链的结构
 *  通过改变链内的成员或调用它们的次序，允许你动态的增加或者删除责任。

## 5.2 用途或者缺点 ##

*  经常被使用在窗口系统中，处理鼠标和键盘之类的事件。
 *  并不保证请求一定会被执行，如果没有任何对象处理它的话，它可能会落到链表尾端。
 *  可能不容易观察运行时的特征，有碍于出错。

# 6. JDK #

*  [java.util.logging.Logger\#log()][java.util.logging.Logger_log]
 *  [Apache Commons Chain][]
 *  [javax.servlet.Filter\#doFilter()][javax.servlet.Filter_doFilter]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzIxMTI1MTgz_size_16_color_FFFFFF_t_70]: /images/20220329/74b5beec4a854d6d98425bbb9806f144.png
[java.util.logging.Logger_log]: http://docs.oracle.com/javase/8/docs/api/java/util/logging/Logger.html#log%28java.util.logging.Level,%20java.lang.String%29
[Apache Commons Chain]: https://commons.apache.org/proper/commons-chain/index.html
[javax.servlet.Filter_doFilter]: http://docs.oracle.com/javaee/7/api/javax/servlet/Filter.html#doFilter-javax.servlet.ServletRequest-javax.servlet.ServletResponse-javax.servlet.FilterChain-