Spring两种拦截器类型介绍

痛定思痛。 2022-12-21 00:43 137阅读 0赞

## 1.分类 ##

HandlerInterceptor：  
拦截请求地址，比后者先执行。类似过滤器。

MethodInterceptor：  
拦截指定类型的方法，通过动态代理模式实现。

## 2.HandlerInterceptor ##

### 1）拦截器 ###

![在这里插入图片描述][20201113105547963.png_pic_center]  
实现一个HandlerInterceptor拦截器可以直接实现HandlerInterceptor接口，也可以继承HandlerInterceptorAdapter类。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTAwNjY5MzQ_size_16_color_FFFFFF_t_70_pic_center]

### 2）拦截器链 ###

提供了添加拦截器方法，以及遍历执行拦截器接口几个方法的实现。

public class HandlerExecutionChain { 
    
      private final Object handler;
    
      private HandlerInterceptor[] interceptors;
    
      private List<HandlerInterceptor> interceptorList;
    
      //添加拦截器
      public void addInterceptor(HandlerInterceptor interceptor) { 
        initInterceptorList().add(interceptor);
      }
    
      public void addInterceptors(HandlerInterceptor... interceptors) { 
        if (!ObjectUtils.isEmpty(interceptors)) { 
          CollectionUtils.mergeArrayIntoCollection(interceptors, initInterceptorList());
        }
      }
    
    
      //
      boolean applyPreHandle(HttpServletRequest request, HttpServletResponse response) throws Exception { 
        HandlerInterceptor[] interceptors = getInterceptors();
        if (!ObjectUtils.isEmpty(interceptors)) { 
          for (int i = 0; i < interceptors.length; i++) { 
            HandlerInterceptor interceptor = interceptors[i];
            if (!interceptor.preHandle(request, response, this.handler)) { 
              triggerAfterCompletion(request, response, null);
              return false;
            }
            this.interceptorIndex = i;
          }
        }
        return true;
      }
    
      void applyPostHandle(HttpServletRequest request, HttpServletResponse response, ModelAndView mv) throws Exception { 
        HandlerInterceptor[] interceptors = getInterceptors();
        if (!ObjectUtils.isEmpty(interceptors)) { 
          for (int i = interceptors.length - 1; i >= 0; i--) { 
            HandlerInterceptor interceptor = interceptors[i];
            interceptor.postHandle(request, response, this.handler, mv);
          }
        }
      }
    
      void triggerAfterCompletion(HttpServletRequest request, HttpServletResponse response, Exception ex)
          throws Exception { 
    
        HandlerInterceptor[] interceptors = getInterceptors();
        if (!ObjectUtils.isEmpty(interceptors)) { 
          for (int i = this.interceptorIndex; i >= 0; i--) { 
            HandlerInterceptor interceptor = interceptors[i];
            try { 
              interceptor.afterCompletion(request, response, this.handler, ex);
            }
            catch (Throwable ex2) { 
              logger.error("HandlerInterceptor.afterCompletion threw exception", ex2);
            }
          }
        }
      }
      
      void applyAfterConcurrentHandlingStarted(HttpServletRequest request, HttpServletResponse response) { 
        HandlerInterceptor[] interceptors = getInterceptors();
        if (!ObjectUtils.isEmpty(interceptors)) { 
          for (int i = interceptors.length - 1; i >= 0; i--) { 
            if (interceptors[i] instanceof AsyncHandlerInterceptor) { 
              try { 
                AsyncHandlerInterceptor asyncInterceptor = (AsyncHandlerInterceptor) interceptors[i];
                asyncInterceptor.afterConcurrentHandlingStarted(request, response, this.handler);
              }
              catch (Throwable ex) { 
                logger.error("Interceptor [" + interceptors[i] + "] failed in afterConcurrentHandlingStarted", ex);
              }
            }
          }
        }
      }
    }

### 3）调用逻辑 ###

DispatcherServlet中的doService()调用doDispatch()。

protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception { 
        HttpServletRequest processedRequest = request;
        HandlerExecutionChain mappedHandler = null;
        boolean multipartRequestParsed = false;
    
        WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
    
        try { 
          ModelAndView mv = null;
          Exception dispatchException = null;
    
          try { 
            processedRequest = checkMultipart(request);
            multipartRequestParsed = (processedRequest != request);
    
            // Determine handler for the current request.
            mappedHandler = getHandler(processedRequest);
            if (mappedHandler == null || mappedHandler.getHandler() == null) { 
              noHandlerFound(processedRequest, response);
              return;
            }
    
            // Determine handler adapter for the current request.
            HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
    
            // Process last-modified header, if supported by the handler.
            String method = request.getMethod();
            boolean isGet = "GET".equals(method);
            if (isGet || "HEAD".equals(method)) { 
              long lastModified = ha.getLastModified(request, mappedHandler.getHandler());
              if (logger.isDebugEnabled()) { 
                logger.debug("Last-Modified value for [" + getRequestUri(request) + "] is: " + lastModified);
              }
              if (new ServletWebRequest(request, response).checkNotModified(lastModified) && isGet) { 
                return;
              }
            }
    
            if (!mappedHandler.applyPreHandle(processedRequest, response)) { 
              return;
            }
    
            // Actually invoke the handler.
            mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
    
            if (asyncManager.isConcurrentHandlingStarted()) { 
              return;
            }
    
            applyDefaultViewName(processedRequest, mv);
            mappedHandler.applyPostHandle(processedRequest, response, mv);
          }
          catch (Exception ex) { 
            dispatchException = ex;
          }
          catch (Throwable err) { 
            // As of 4.3, we're processing Errors thrown from handler methods as well,
            // making them available for @ExceptionHandler methods and other scenarios.
            dispatchException = new NestedServletException("Handler dispatch failed", err);
          }
          processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
        }
        catch (Exception ex) { 
          triggerAfterCompletion(processedRequest, response, mappedHandler, ex);
        }
        catch (Throwable err) { 
          triggerAfterCompletion(processedRequest, response, mappedHandler,
              new NestedServletException("Handler processing failed", err));
        }
        finally { 
          if (asyncManager.isConcurrentHandlingStarted()) { 
            // Instead of postHandle and afterCompletion
            if (mappedHandler != null) { 
              mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);
            }
          }
          else { 
            // Clean up any resources used by a multipart request.
            if (multipartRequestParsed) { 
              cleanupMultipart(processedRequest);
            }
          }
        }
      }

通过HandlerMapping取得拦截器链HandlerExecutionChain。

protected HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception { 
    		for (HandlerMapping hm : this.handlerMappings) { 
    			if (logger.isTraceEnabled()) { 
    				logger.trace(
    						"Testing handler map [" + hm + "] in DispatcherServlet with name '" + getServletName() + "'");
    			}
    			HandlerExecutionChain handler = hm.getHandler(request);
    			if (handler != null) { 
    				return handler;
    			}
    		}
    		return null;
    	}

执行完applyPreHandler()后，进行核心方法。

ModelAndView mv = null;
    HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
    ......
    mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
    applyDefaultViewName(processedRequest, mv);

## 3.MethodInterceptor ##

实现MethodInterceptor大致两种方式：接口和AspectJ注解。

### 1）重要接口类 ###

在AOP中，所有的Advice最终都要转化成MethodInterceptor。

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

public interface MethodInterceptor extends Interceptor { 
        Object invoke(MethodInvocation var1) throws Throwable;
    }

![在这里插入图片描述][20201113105224414.png_pic_center]

public interface MethodInvocation extends Invocation { 
        Method getMethod();
    }
    public interface Invocation extends Joinpoint { 
        Object[] getArguments();
    }
    
    public interface Joinpoint { 
        Object proceed() throws Throwable;
    
        Object getThis();
    
        AccessibleObject getStaticPart();
    }

### 2）应用 ###

在实际业务开发中，使用注解会比较方便。这块内容涉及到AOP的内容，会放在下篇介绍。

## 4.小结 ##

拦截器，实现统一拦截处理，可以是请求地址、方法等。与之前介绍的过滤器不同，拦截器是Spring的内容。

凡是有利有弊，是否使用拦截器，是拦截请求还是拦截方法，拦截器是否有先后顺序限制等，都是要考虑的问题。过度追求灵活可配，可能带来性能问题。

[20201113105547963.png_pic_center]: /images/20221120/fee689409cb44f45a43535c9a468c3d8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTAwNjY5MzQ_size_16_color_FFFFFF_t_70_pic_center]: /images/20221120/4d5dc20c45574ef7b3cea696172e86c1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTAwNjY5MzQ_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221120/79f31e99bf07498185188f58cbcef143.png
[20201113105224414.png_pic_center]: /images/20221120/a91f898ad0144c6c81d5b2c1de6a3e57.png