设计模式（14）：责任链模式及其在Java中的典型应用示例

最新推荐文章于 2024-02-20 22:22:16 发布

行百里者半九九

最新推荐文章于 2024-02-20 22:22:16 发布

阅读量1.7k

点赞数

分类专栏：设计模式

本文链接：https://blog.csdn.net/qq_41969790/article/details/108098210

版权

设计模式专栏收录该内容

14 篇文章 2 订阅

订阅专栏

责任链模式及其在Java中的典型应用实例

1、什么是责任链模式

责任链模式定义：为请求创建了一个接收者对象的链。这种模式给予请求的类型，对请求的发送者和接收者进行解耦。这种类型的设计模式属于行为型模式。在这种模式中，通常每个接收者都包含对另一个接收者的引用。如果一个对象不能处理请求，那么它会把相同的请求传给下一个接收者，以此类推。

2、责任链模式的特性

（1）意图：

避免请求发送者与接收者耦合在一起，让多个对象都有可能接收请求，将这些对象连接成一条链，并且沿着这条链传递请求，直到有对象处理它为止。

（2）主要解决：

职责链上的处理者负责处理请求，客户只需要将请求发送到职责链上即可，无须关心请求的处理细节和请求的传递，所以职责链将请求的发送者和请求的处理者解耦了。

（3）何时使用：

在处理消息的时候以过滤很多道。

（4）如何解决：

拦截的类都实现统一接口。

（5）关键代码：

Handler 里面聚合它自己，在 HandlerRequest 里判断是否合适，如果没达到条件则向下传递，向谁传递之前 set 进去。

3、责任链模式的优缺点及其应用场景

（1）优点：

1）降低耦合度。它将请求的发送者和接收者解耦。

2）简化了对象。使得对象不需要知道链的结构。

3）增强给对象指派职责的灵活性。通过改变链内的成员或者调动它们的次序，允许动态地新增或者删除责任。

4）增加新的请求处理类很方便。

（2）缺点：

1）不能保证请求一定被接收。

2）系统性能将受到一定影响，而且在进行代码调试时不太方便，可能会造成循环调用。

3）可能不容易观察运行时的特征，有碍于除错。

（3）使用场景：

1）有多个对象可以处理同一个请求，具体哪个对象处理该请求由运行时刻自动确定。

2）在不明确指定接收者的情况下，向多个对象中的一个提交一个请求。

3）可动态指定一组对象处理请求。

（4）注意事项：

在 JAVA WEB 中遇到很多应用。

4、责任链模式的应用示例

（1）示例场景：

服务器后端在对前端发送过来的请求进行处理的时候，一般的一个简单的过滤认证行为为： Request—>请求频率验证—>登录认证—>访问权限—>敏感词过滤—>... 我们可以直接在程序代码中进行顺序流程代码编写，但这样的代码耦合不易于扩展维护和复用，我们可以使用责任链的形式来实现，责任链模式主要可以采用链表的形式进行实现。

（2）代码示例：

定义一个请求包装类，其中该类里面使用建造者模式来创建对象（这里只是实现示例，可不使用建造者模式）：

//定义一个请求包装类
class Request{
    //模拟一些请求验证操作
    private boolean loggedOn;
    private boolean frequentOk;
    private boolean isPermits;
    private boolean containSensitiveWords;
    private String requestBody;

    private Request(boolean loggedOn, boolean frequentOk, boolean isPermits, boolean containSensitiveWords) {
        this.loggedOn = loggedOn;
        this.frequentOk = frequentOk;
        this.isPermits = isPermits;
        this.containSensitiveWords = containSensitiveWords;
    }

    //使用建造者模式创建对象
    static class RequestBuilder{
        private boolean loggedOn;
        private boolean frequentOk;
        private boolean isPermits;
        private boolean containsSensitiveWords;

        RequestBuilder loggedOn(boolean loggedOn){
            this.loggedOn = loggedOn;
            return this;
        }

        RequestBuilder frequentOk(boolean frequentOk){
            this.frequentOk = frequentOk;
            return this;
        }

        RequestBuilder isPermits(boolean isPermits){
            this.isPermits = isPermits;
            return this;
        }
        RequestBuilder containsSensitiveWords(boolean containsSensitiveWords){
            this.containsSensitiveWords = containsSensitiveWords;
            return this;
        }

        public Request build(){
            Request request = new Request(loggedOn,frequentOk,isPermits,containsSensitiveWords);
            return request;
        }
     }

     public boolean isLoggedOn(){
        return loggedOn;
     }
     public boolean isFrequentOk(){
        return frequentOk;
     }
     public boolean isPermits(){
        return isPermits;
     }
     public boolean isContainSensitiveWords(){
        return containSensitiveWords;
     }
}

进行责任链抽象，通过链表形式来实现：

//使用链表形式来实现责任链，责任链抽象
abstract class Handler{
    //责任链的下一个节点
    Handler next;

    public Handler(Handler next) {
        this.next = next;
    }

    public Handler getNext() {
        return next;
    }

    public void setNext(Handler next) {
        this.next = next;
    }
    //每个节点都需要处理请求
    abstract boolean process(Request request);
}

定义责任链的业务主体子类，可以有多个：这里以访问频率验证和登录验证为例：

//责任链的具体子类
class RequestFrequentHandler extends Handler{
    public RequestFrequentHandler(Handler next) {
        super(next);
    }

    @Override
    boolean process(Request request) {
        //业务代码
        System.out.println("访问频率控制.");
        if(request.isFrequentOk()){
            //访问正常，传递给责任链的下一个节点
            Handler next = getNext();
            if(null == next){
                return true;
            }
            if(!next.process(request)){
                return false;
            }else{
                return true;
            }
        }
        return false;
    }
}

//登录的处理器
class LoggingHandler extends Handler{
    public LoggingHandler(Handler next) {
        super(next);
    }

    @Override
    boolean process(Request request) {
        System.out.println("登录验证...");
        if(request.isLoggedOn()){
            Handler next = getNext();
            if(null==next){
                return true;
            }
            if(!next.process(request)){
                return false;
            }else{
                return true;
            }
        }
        return false;
    }
}

使用示例：这里我们通过构造使用责任链来进行，对于一个请求，先进行访问频率验证，再进行登录验证，如果有一个验证不通过，则返回异常。链式执行，依次调用....

public class ChainOfResponsibilityTest {
    public static void main(String[] args) {
        //测试示例
        //构造请求
        Request request = new Request.RequestBuilder().frequentOk(true).loggedOn(true).build();
        //构造责任链
        RequestFrequentHandler requestFrequentHandler = new RequestFrequentHandler(new LoggingHandler(null));
        //测试责任链处理流程、结果
        if(requestFrequentHandler.process(request)){
            System.out.println("正常业务处理...");
        }else{
            System.out.println("访问异常...");
        }
    }
}

测试结果输出示例：

访问频率控制.
登录验证...
正常业务处理...

这里当我们把模拟请求修改为：frequentOk(false)时：

public class ChainOfResponsibilityTest {
    public static void main(String[] args) {
        //测试示例
        //构造请求
        Request request = new Request.RequestBuilder().frequentOk(false).loggedOn(true).build();
        //构造责任链
        RequestFrequentHandler requestFrequentHandler = new RequestFrequentHandler(new LoggingHandler(null));
        //测试责任链处理流程、结果
        if(requestFrequentHandler.process(request)){
            System.out.println("正常业务处理...");
        }else{
            System.out.println("访问异常...");
        }
    }
}

输出结果为：

访问频率控制.
访问异常...

说明程序时链式顺序执行的，当出现出现某个链式节点验证不通过返回false时，后续链上节点将不执行。

5、责任链模式在Java中的典型应用示例

在Java中，Servlet容器是责任链模式的经典应用。如在tomcat的包中，带有Filter、FilterChain结尾的类都是使用的是责任链模式。

（1）javax.servlet.Filter类使用的就是责任链模式来实现对请求的过滤，过滤器是一个对象，执行在任一请求到资源（servlet或静态内容）过滤任务，或者从一个资源，或两者的响应。源码如下：

public interface Filter {

   
    public default void init(FilterConfig filterConfig) throws ServletException {}

    /**
     * The <code>doFilter</code> method of the Filter is called by the container
     * each time a request/response pair is passed through the chain due to a
     * client request for a resource at the end of the chain. The FilterChain
     * passed in to this method allows the Filter to pass on the request and
     * response to the next entity in the chain.
     * <p>
     * A typical implementation of this method would follow the following
     * pattern:- <br>
     * 1. Examine the request<br>
     * 2. Optionally wrap the request object with a custom implementation to
     * filter content or headers for input filtering <br>
     * 3. Optionally wrap the response object with a custom implementation to
     * filter content or headers for output filtering <br>
     * 4. a) <strong>Either</strong> invoke the next entity in the chain using
     * the FilterChain object (<code>chain.doFilter()</code>), <br>
     * 4. b) <strong>or</strong> not pass on the request/response pair to the
     * next entity in the filter chain to block the request processing<br>
     * 5. Directly set headers on the response after invocation of the next
     * entity in the filter chain.
     *
     * @param request  The request to process
     * @param response The response associated with the request
     * @param chain    Provides access to the next filter in the chain for this
     *                 filter to pass the request and response to for further
     *                 processing
     *
     * @throws IOException if an I/O error occurs during this filter's
     *                     processing of the request
     * @throws ServletException if the processing fails for any other reason
     */
    public void doFilter(ServletRequest request, ServletResponse response,
            FilterChain chain) throws IOException, ServletException;

    
    public default void destroy() {}
}

（2）javax.Servlet.FilterChain类也是通过责任链模式来进行过滤链中过滤器的调用

public interface FilterChain {

    /**
     * Causes the next filter in the chain to be invoked, or if the calling
     * filter is the last filter in the chain, causes the resource at the end of
     * the chain to be invoked.
     *
     * @param request
     *            the request to pass along the chain.
     * @param response
     *            the response to pass along the chain.
     *
     * @throws IOException if an I/O error occurs during the processing of the
     *                     request
     * @throws ServletException if the processing fails for any other reason

     * @since 2.3
     */
    public void doFilter(ServletRequest request, ServletResponse response)
            throws IOException, ServletException;

}

FilterChain是Servlet容器提供给开发人员的对象，它提供了对资源的已过滤请求的调用链的视图。过滤器使用FilterChain调用链中的下一个过滤器，或者调用过滤器是链中的最后一个过滤器，用于在链的末端。

本文源代码：

https://github.com/JianfuYang/2020-yjf-review/tree/master/src/designpatterns/responsibility

声明：本文部分内容整理来源于网络，仅做个人学习使用！侵删~

本文部分内容参考链接：

https://www.runoob.com/design-pattern/chain-of-responsibility-pattern.html

行百里者半九九

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
设计模式（14）：责任链模式及其在Java中的典型应用示例

责任链模式及其在Java中的典型应用实例1、什么是责任链模式2、责任链模式的特性3、责任链模式的优缺点及其应用场景4、责任链模式的应用示例5、责任链模式在Java中的典型应用示例1、什么是责任链模式责任链模式定义：为请求创建了一个接收者对象的链。这种模式给予请求的类型，对请求的发送者和接收者进行解耦。这种类型的设计模式属于行为型模式。在这种模式中，通常每个接收者都包含对另一个接收者的引用。如果一个对象不能处理请求，那么它会把相同的请求传给下一个接收者，以此类推。2、责任链模式
复制链接

扫一扫