概念

  • 为了避免请求发送者与多个请求处理者耦合在一起，于是将所有请求的处理者通过前一对象记住其下一个对象的引用而连成一条链；当有请求发生时，可将请求沿着这条链传递，直到有对象处理它为止。属于对象行为型模式
  • image.png

主要角色

  • 抽象处理者（Handler）角色：
    • 定义一个处理请求的接口，包含抽象处理方法和一个后继连接。
  • 具体处理者（Concrete Handler）角色：
    • 实现抽象处理者的处理方法，判断能否处理本次请求，如果可以处理请求则处理，否则将该请求转给它的后继者。

  • 客户类（Client）角色：

    • 创建处理链，并向链头的具体处理者对象提交请求，它不关心处理细节和请求的传递过程 ```java /**

      • 抽象处理者（Handler）角色 */ public interface Filter {

      void doFilter(Request request,Response response,FilterChain chain); }

  1. ```java
  2. /**
  3.  * 具体处理者（Concrete Handler）角色
  4.  */
  5. public class CharacterFilter implements Filter{
  6.     @Override
  7.     public void doFilter(Request request, Response response, FilterChain chain) {
  8.         //功能
  9.         request.msg +=" ====";
  11.         System.out.println("CharacterFilter...doFilter之前");
  13.         //放行
  14.         chain.doFilter(request,response,chain);
  17.         System.out.println("CharacterFilter...doFilter之后");
  18.     }
  19. }
  1. /**
  2.  * 具体处理者（Concrete Handler）角色
  3.  */
  4. public class EncodingFilter  implements Filter{
  5.     @Override
  6.     public void doFilter(Request request, Response response, FilterChain chain) {
  7.         request.msg+=" oooo";
  8.         System.out.println("EncodingFilter...doFilter之前");
  10.         //放行
  11.         chain.doFilter(request,response,chain);
  14.         System.out.println("EncodingFilter...doFilter之后");
  15.     }
  16. }
  1. /**
  2.  * 具体处理者（Concrete Handler）角色
  3.  */
  4. public class HttpFilter implements Filter{
  5.     @Override
  6.     public void doFilter(Request request, Response response, FilterChain chain) {
  7.         //第一个filter的功能
  8.         request.msg+=">>>";
  10.         System.out.println("HttpFilter...doFilter之前");
  12.         //放行
  13.         chain.doFilter(request,response,chain);
  16.         System.out.println("HttpFilter...doFilter之后");
  17.     }
  18. }
  1. /**
  2.  * 靠他维护链条
  3.  *
  4.  * HandlerExecutionChain
  5.  *
  6.  */
  7. public class FilterChain implements Filter {
  10.     //记录当前执行的步骤
  11.     int cursor = 0;
  12.     //filter的链
  13.     List<Filter> filtersChain = new ArrayList<>();
  15.     //最终要执行的目标方法
  16.     My target;
  18.     public void setTarget(My target) {
  19.         this.target = target;
  20.     }
  22.     public My getTarget() {
  23.         return target;
  24.     }
  27.     //添加filter
  28.     void addFilter(Filter filter){
  29.         filtersChain.add(filter);
  30.     }
  32.     @Override
  33.     public void doFilter(Request request, Response response, FilterChain chain) {
  34.         //第一次执行第一个filter，一次往下
  36.         //游标小于总数量filter一直往下获取执行
  37.         if(cursor < filtersChain.size()){
  38.             Filter filter = filtersChain.get(cursor);
  39.             cursor++;
  40.             //执行filter
  41.             filter.doFilter(request,response,chain);
  42.         }else {
  43.             //filter完了，该执行目标方法了
  44.             target.hello();
  45.         }
  48.     }
  49. }
  1. /**
  2.  * 1---2---3--my---3---2---1]
  3.  * 客户类（Client）角色
  4.  */
  5. public class MainTest {
  7.     public static void main(String[] args) {
  8.         FilterChain chain = new FilterChain();
  10.         //web.xml =- filter
  11.         HttpFilter filter = new HttpFilter();
  12.         CharacterFilter characterFilter = new CharacterFilter();
  13.         EncodingFilter encodingFilter = new EncodingFilter();
  14.         chain.addFilter(filter);
  15.         chain.addFilter(characterFilter);
  16.         chain.addFilter(encodingFilter);
  19.         chain.setTarget(new My());
  21.         //filter如何链式执行。
  23.         chain.doFilter(new Request("hello world"),
  24.                 new Response("adhkjasdhak"),chain);
  27.     }
  28. }

应用场景

  • Tomcat的Pipeline、Valve
  • Filter链
  • Aop责任链