过滤器链及责任链设计模式

Posted hangsingplus

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了过滤器链及责任链设计模式相关的知识，希望对你有一定的参考价值。

过滤器链：

在 Java Web 应用中，多个过滤器的执行顺序是有规定的，称之为过滤器链。按照过滤器链的规定，多个过滤器会按照它们在 web.xml 文件中配置的先后顺序依次执行。

具体来说，假设一个请求需要经过三个过滤器，分别为 Filter1、Filter2 和 Filter3，那么它们的执行顺序为：

  1. 客户端发送请求到服务器端，请求经过 Filter1。
  2. 如果 Filter1 给出了回应，则请求回复给客户端；否则请求经过 Filter2。
  3. 如果 Filter2 给出了回应，则请求回复给客户端；否则请求经过 Filter3。
  4. 如果 Filter3 给出了回应，则请求回复给客户端；否则请求继续向下执行。

因此，如果在 web.xml 文件中将 Filter1 配置在 Filter2 前面，则 Filter1 将先于 Filter2 执行。同样地，如果将 Filter3 配置在 Filter2 后面，则 Filter3 将后于 Filter2 执行。

除了 web.xml 文件中的配置，还可以使用注解来指定过滤器链的执行顺序。例如，在 Spring MVC 中，可以使用 @Order 注解来指定过滤器链中各个过滤器的执行顺序。

责任链：

责任链（Chain of Responsibility）是一种行为型设计模式，它可以将请求的发送者与接收者解耦。责任链中包含多个处理者对象，每个处理者对象都持有对下一个处理者对象的引用，形成一条链式结构。

当一个请求经过责任链时，会沿着链式结构依次传递给每个处理者对象进行处理，直到其中一个处理者对象成功地处理了该请求为止。如果整个责任链中的所有处理者对象都不能处理该请求，则该请求将被丢弃或返回一个默认值。

在实际应用中，责任链常用于以下场景：

  1. 处理请求需要多个对象协作完成，但是每个对象的职责不同。
  2. 需要动态地指定请求处理对象的顺序。
  3. 处理请求的对象集合可以动态生成或修改。
  4. 请求的处理结果不需要返回给发送者。

责任链模式的核心思想是：让请求的发送者和接收者通过一个中间对象来进行解耦。这样，请求发送者只需要向中间对象发送请求，而无需知道请求将由哪个具体对象来进行处理，并且中间对象也不需要知道具体的请求内容，只需要按照预定的规则来选择合适的对象进行处理即可。

总之，责任链模式可以使得不同的处理者对象之间松耦合，提高系统的灵活性和可维护性。同时，责任链模式也可以很好地扩展和修改系统的处理逻辑，因为它允许自由地增加、移除或替换处理者对象。

责任链和过滤器的关系：

 

责任链和过滤器是两种不同的设计模式，但在某些场景下可以相互协作来实现系统的功能。

 

责任链模式通常用于多个处理器对象对同一类型请求进行处理，每个处理器对象都能够完成请求的处理，但是它们的处理方式不尽相同，可能会需要按顺序执行或者需要某一个处理器来处理。责任链模式在该场景下可以非常好地解耦请求处理对象与具体业务处理逻辑。

 

而过滤器模式则通常用于在请求处理前或处理后进行某些额外的操作，例如身份验证、日志记录、字符编码转换等。过滤器可以拦截请求并决定是否向下一个过滤器传递请求，也可以直接处理请求并返回响应结果。

 

在 Java Web 应用中，过滤器通常被用来拦截 HTTP 请求并对其进行处理，例如对请求进行身份验证、字符编码转换或者请求响应的统一处理等。而在实现过滤器时，我们通常会使用责任链模式来组合多个过滤器对象，并将它们按照一定的顺序串联起来形成一个过滤器链。通过过滤器链，请求可以依次经过多个过滤器，并按照一定的规则进行处理，最终得到期望的结果。

 

因此，可以说责任链模式可以用来组织多个过滤器，使得它们按照一定的顺序进行处理，从而实现更灵活的请求处理机制。

 

本文总结自gpt的回复

设计模式----责任链模式

责任链模式

引言

一个事件需要经过多个对象处理是一个挺常见的场景，譬如采购审批流程，请假流程，软件开发中的异常处理流程，web请求处理流程等各种各样的流程，可以考虑使用责任链模式来实现。

以请假流程为例，一般公司普通员工的请假流程简化如下：


普通员工发起一个请假申请，当请假天数小于3天时只需要得到主管批准即可；当请假天数大于3天时，主管批准后还需要提交给经理审批，经理审批通过，若请假天数大于7天还需要进一步提交给总经理审批。

使用 if-else 来实现这个请假流程的简化代码如下：

public class LeaveApproval
{
    public boolean process(String request, int number) {
        boolean result = handleByDirector(request); // 主管处理
        if (result == false) {  // 主管不批准
            return false;
        } else if (number < 3) {    // 主管批准且天数小于 3
            return true;
        }

        result = handleByManager(request); // 准管批准且天数大于等于 3，提交给经理处理
        if (result == false) {   // 经理不批准
            return false;
        } else if (number < 7) { // 经理批准且天数小于 7
            return true;
        }

        result = handleByTopManager(request);   // 经理批准且天数大于等于 7，提交给总经理处理
        if (result == false) { // 总经理不批准
            return false;
        }
        return true;    // 总经理最后批准
    }

    private boolean handleByDirector(String request)
    {
        // 主管处理该请假申请
        if(request.length()>10)
            return false;
        return true;
    }

    private boolean handleByManager(String request) {
        // 经理处理该请假申请
        if(request.length()>5)
        return false;
        return true;
    }

    private boolean handleByTopManager(String request) {
        // 总经理处理该请假申请
        if(request.length()>3)
            return false;
        return true;
    }
}

问题看起来很简单，三下五除二就搞定，但是该方案存在几个问题：

  • LeaveApproval 类比较庞大，各个上级的审批方法都集中在该类中，违反了 “单一职责原则”，测试和维护难度大
  • 当需要修改该请假流程，譬如增加当天数大于30天时还需提交给董事长处理，必须修改该类源代码（并重新进行严格地测试），违反了"开闭原则"
  • 该流程缺乏灵活性，流程确定后不可再修改（除非修改源代码），客户端无法定制流程

使用责任链模式可以解决上述问题。

责任链模式定义

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

责任链可以是一条直线、一个环或者一个树形结构，最常见的职责链是直线型，即沿着一条单向的链来传递请求，如下图所示。链上的每一个对象都是请求处理者，责任链模式可以将请求的处理者组织成一条链，并让请求沿着链传递，由链上的处理者对请求进行相应的处理。在此过程中，客户端实际上无须关心请求的处理细节以及请求的传递，只需将请求发送到链上即可，从而实现请求发送者和请求处理者解耦。


对责任链的理解，关键在于对链的理解，即包含如下两点：

  • 链是一系列节点的集合，在责任链中，节点实质上是指请求的处理者；
  • 链的各节点可灵活拆分再重组，在责任链中，实质上就是请求发送者与请求处理者的解耦。

类图

角色

我们可以从责任链模式的结构图中看到，具体的请求处理者可以有多个，并且所有的请求处理者均具有相同的接口（继承于同一抽象类）。 责任链模式主要包含如下两个角色

  • Handler（抽象处理者）：处理请求的接口，一般设计为具有抽象请求处理方法的抽象类，以便于不同的具体处理者进行继承，从而实现具体的请求处理方法。此外，由于每一个请求处理者的下家还是一个处理者，因此抽象处理者本身还包含了一个本身的引用（ successor）作为其对下家的引用，以便将处理者链成一条链；
  • ConcreteHandler（具体处理者）：它是抽象处理者的子类，可以处理用户请求，在具体处理者类中实现了抽象处理者中定义的抽象请求处理方法，在处理请求之前需要进行判断，看是否有相应的处理权限，如果可以处理请求就处理它，否则将请求转发给后继者；在具体处理者中可以访问链中下一个对象，以便请求的转发。

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

核心

实现责任链模式的关键核心是： 在抽象类 Handler 里面聚合它自己(持有自身类型的引用)，并在 handleRequest 方法里判断其是否能够处理请求。若当前处理者无法处理，则设置其后继者并向下传递，直至请求被处理。

示例代码

1、对请求处理者的抽象

责任链模式的核心在于对 请求处理者的抽象。在实现过程中，抽象处理者一般会被设定为 抽象类，其典型实现代码如下所示：

public abstract class Handler {

    // protected ：维持对下家的引用
    protected Handler successor;

    public void setSuccessor(Handler successor) {
        this.successor=successor;
    }

    public abstract void handleRequest(String request);
}

上述代码中，抽象处理者类定义了对下家的引用 (其一般用 protected 进行修饰)，以便将请求转发给下家，从而形成一条请求处理链。同时，在抽象处理者类中还声明了抽象的请求处理方法，以便由子类进行具体实现。

2、对请求处理者的抽象

具体处理者是抽象处理者的子类，具体处理者类的典型代码如下：

public class ConcreteHandler extends Handler {
    public void handleRequest(String request) {
        if (请求满足条件) {
            //处理请求
        }else {
            this.successor.handleRequest(request);  //转发请求
        }
    }
}

在具体处理类中，通过对请求进行判断以便做出相应的处理，因此，其一般具有两大作用：

  • 处理请求，不同的具体处理者以不同的形式实现抽象请求处理方法 handleRequest()；
  • 转发请求，若该请求超出了当前处理者类的权限，可以将该请求转发给下家；

3、责任链的创建

需要注意的是，责任链模式并不创建职责链，职责链的创建工作必须由系统的其他部分来完成，一般由使用该责任链的客户端创建。职责链模式降低了请求的发送者和请求处理者之间的耦合，从而使得多个请求处理者都有机会处理这个请求。

责任链实现请假案例

请假信息类，包含请假人姓名和请假天数

@Data
@AllArgsConstructor
public class LeaveRequest
{
 String name;//请假人的姓名
 Integer num;//请假天数
}

抽象处理者类 Handler，维护一个 nextHandler 属性，该属性为当前处理者的下一个处理者的引用；声明了抽象方法 process

//抽象处理者
@Data
public abstract class Handler
{
    //维护自身引用
    protected Handler handler;
   //当前处理者的姓名
    protected String name;
    //传入当前处理者的姓名
    public Handler(String name)
    {
        this.name=name;
    }
    //抽象方法，用来处理请假的请求
    public abstract Boolean process(LeaveRequest leaveRequest);
}

三个具体处理类，分别实现了抽象处理类的 process 方法

主管:

public class Director extends Handler{
    public Director(String name) {
        super(name);
    }
    //处理请假的请求
    @Override
    public Boolean process(LeaveRequest leaveRequest) {
       //随机数大于3，就批准请求
        boolean result = (new Random().nextInt(10)) > 3;
        String log = "主管: %s,审批:%s的请假申请,请假天数:%d,审批结果:%s";
        System.out.println(String.format(log,name,leaveRequest.getName(),leaveRequest.getNum(),result==true?"通过":"不通过"));
        if(result)//批准
        {
            //如果请假天数，超过了3天，那么交给上级继续审批
           if(leaveRequest.num>3)
           {
               return nextHandler.process(leaveRequest);
           }
           //请假天数小于3，审批通过
            return true;
        }
        //没有通过审批
        return false;
    }
}

经理

public class Manager extends Handler{
    public Manager(String name) {
        super(name);
    }
    //处理请假的请求
    @Override
    public Boolean process(LeaveRequest leaveRequest) {
        boolean result = (new Random().nextInt(10)) > 3; // 随机数大于3则为批准，否则不批准
        String log = "经理: %s,审批:%s的请假申请,请假天数:%d,审批结果:%s";
        System.out.println(String.format(log,name,leaveRequest.getName(),leaveRequest.getNum(),result==true?"批准":"不通过"));
        if(result)
        {
            //请假天数过多，还是需要提交到更高的一级去审批
            if(leaveRequest.getNum()>7)
            {
                return nextHandler.process(leaveRequest);
            }
            //否则直接通过
            return true;
        }
        return false;
    }
}

总经理

public class TopManager extends Handler{
    public TopManager(String name) {
        super(name);
    }

    @Override
    public Boolean process(LeaveRequest leaveRequest) {
        //随机数大于3，就批准请求
        boolean result = (new Random().nextInt(10)) > 3;
        String log = "总经理: %s,审批:%s的请假申请,请假天数:%d,审批结果:%s";
        System.out.println(String.format(log,name,leaveRequest.getName(),leaveRequest.getNum(),result==true?"通过":"不通过"));
        if(result)//批准
        {
            //默认只有三个处理器，但是如果后续还要加，也需要留个位置
            //如果后续继续添加
            if(nextHandler!=null)
            {
                return nextHandler.process(leaveRequest);
            }
            return true;
        }
        //没有通过审批
        return false;
    }
}

处理器链类:

//处理器链
public class HandlerChain
{
    //维护第一个处理器
    private Handler director=new Director("小忽悠");
    //默认有三个处理器
    public HandlerChain()
    {
        //默认有三个处理器链
        //并且这三个处理器有先后关系
        director.nextHandler=new Manager("小朋友");
        director.nextHandler.nextHandler=new TopManager("超级大忽悠");
    }
    //添加一个处理器进集合
    public void addHandler(Handler handler)
    {
        Handler temp=director;
     while(temp.nextHandler!=null)
     {
         temp=temp.nextHandler;
     }
        temp.nextHandler=handler;
    }
    //执行处理器链
     public void process(LeaveRequest leaveRequest)
    {
        //第一个处理器，如果可以处理器就不需要交给下一个处理器处理了
        //否则，继续交给下一个处理器处理
        director.process(leaveRequest);
    }
}

客户端测试:

public class Client
{
    public static void main(String[] args) {
        LeaveRequest leaveRequest=new LeaveRequest("大忽悠",10);
        HandlerChain handlerChain=new HandlerChain();
        handlerChain.process(leaveRequest);
    }
}

案例类图


与上面所给出的类图不同的是，我通过一个处理器链类，把调用处理器链处理业务逻辑和客户端分离开来，进一步解耦

可扩展性

  • 如果此时审批流程还需要加上一步，就非常方便
  • 例如，我们需要增加一个上帝，来对请假流程做最终的处理，那么我们只需要创建一个上帝处理器实现处理器抽象类，然后添加进处理器链中即可
public class God extends Handler{
    public God(String name) {
        super(name);
    }

    @Override
    public Boolean process(LeaveRequest leaveRequest) {
        System.out.println("上帝保佑你，所以你可以放假了");
        return true;
    }
}

客户端:

public class Client
{
    public static void main(String[] args) {
        LeaveRequest leaveRequest=new LeaveRequest("大忽悠",10);
        HandlerChain handlerChain=new HandlerChain();
        handlerChain.addHandler(new God("上帝"));
        handlerChain.process(leaveRequest);
    }
}


如果还想继续添加处理器，就需要在上帝process方法中预留一个接口

这样很麻烦，我这里没有继续对方法抽取，进行解耦，感兴趣的小伙伴，可以继续尝试解耦

纯与不纯的责任链模式

纯的责任链模式

  • 一个具体处理者对象只能在两个行为中选择一个：要么承担全部责任，要么将责任推给下家，不允许出现某一个具体处理者对象在承担了一部分或全部责任后又将责任向下传递的情况
  • 一个请求必须被某一个处理者对象所接收，不能出现某个请求未被任何一个处理者对象处理的情况

不纯的责任链模式

  • 允许某个请求被一个具体处理者部分处理后再向下传递
  • 或者一个具体处理者处理完某请求后其后继处理者可以继续处理该请求
  • 而且一个请求可以最终不被任何处理者对象所接收

责任链模式主要优点

  • 对象仅需知道该请求会被处理即可，且链中的对象不需要知道链的结构，由客户端负责链的创建，降低了系统的耦合度
  • 请求处理对象仅需维持一个指向其后继者的引用，而不需要维持它对所有的候选处理者的引用，可简化对象的相互连接
  • 在给对象分派职责时，职责链可以给我们更多的灵活性，可以在运行时对该链进行动态的增删改，改变处理一个请求的职责
  • 新增一个新的具体请求处理者时无须修改原有代码，只需要在客户端重新建链即可，符合 “开闭原则”

职责链模式的主要缺点

  • 一个请求可能因职责链没有被正确配置而得不到处理
  • 对于比较长的职责链，请求的处理可能涉及到多个处理对象，系统性能将受到一定影响，且不方便调试
  • 可能因为职责链创建不当，造成循环调用，导致系统陷入死循环

适用场景

  • 有多个对象可以处理同一个请求，具体哪个对象处理该请求待运行时刻再确定，客户端只需将请求提交到链上，而无须关心请求的处理对象是谁以及它是如何处理的
  • 在不明确指定接收者的情况下，向多个对象中的一个提交一个请求
  • 可动态指定一组对象处理请求，客户端可以动态创建职责链来处理请求，还可以改变链中处理者之间的先后次序

模拟实现Tomcat中的过滤器机制

定义封装请求的类Request和封装处理结果响应的类Response

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Reponse
{
    private List<String> data=new ArrayList<>();
    public void addData(String data)
    {
        this.data.add(data);
    }
}

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Request
{
   private Object data;
}

第二步：定义具有过滤功能的接口Filter,具体的过滤规则需要实现该接口

/*
 * 定义接口Filter,具体的过滤规则需要实现这个接口，最后一个参数添加的意义是我们在Main函数中:
 * fc.doFilter(request, response,fc);执行这一步的时候可以按照规则链条一次使用三个过滤规则对字符串进行处理
 */
public interface Filter
{
    void doFilter(Request request,Reponse reponse,FilterChain filterChain);
}

第三步：定义具体的过滤处理规则

public class StuAgeFilter implements Filter
{
    @Override
    public void doFilter(Request request, Reponse reponse, FilterChain filterChain) {
        Stu stu = (Stu) request.getData();
        if(stu.getName().contains("忽悠"))
        {
            //名字不符合要求
            reponse.addData("名字不符合要求");
        }
        //名字符合要求
         reponse.addData("名字符合要求");
        filterChain.doFilter(request,reponse,filterChain);
    }
}


//学生过滤器--过滤出18岁以上的
public class StuFilter implements Filter
{
    @Override
    public void doFilter(Request request, Reponse reponse, FilterChain filterChain) {
        Stu stu = (Stu)request.getData();
        if(stu.getAge()<18)
        {
            //不放行
            reponse.addData("年龄不符合要求");
        }
        //放行
        reponse.addData("年龄满足要求");
        filterChain.doFilter(request,reponse,filterChain);
    }
}
<

以上是关于过滤器链及责任链设计模式的主要内容，如果未能解决你的问题，请参考以下文章

设计模式----责任链模式

责任链模式

浅谈Java五大设计原则之责任链模式

设计模式责任链模式

63 - 责任链模式之过滤器、拦截器

设计模式—责任链模式