SpringMVC源码总结（十一）mvc:interceptors拦截器介绍

最新推荐文章于 2024-03-18 21:51:20 发布
最新推荐文章于 2024-03-18 21:51:20 发布
阅读量8.9k 收藏 6
点赞数 2
分类专栏： SpringMvc 文章标签： spring mvc
本文章针对mvc:interceptors标签进行介绍，它的注册过程以及在访问时的拦截过程。 

首先说下接口HandlerInterceptor，它有如下三个方法：  
Java代码   收藏代码
  1. boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)  
  2.         throws Exception;  
  3.   
  4. void postHandle(  
  5.             HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView)  
  6.             throws Exception;  
  7.   
  8. void afterCompletion(  
  9.             HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)  
  10.             throws Exception;  


正常情况下，对于preHandle就是在在处理函数之前先执行，然后再执行处理函数，接着执行postHandle，最后再执行afterCompletion。afterCompletion无论是否出错是肯定要执行的，而postHandle则不是，不一定会执行。之后看源代码就知道他们的执行情况。 

AsyncHandlerInterceptor接口则增添了afterConcurrentHandlingStarted方法，对于此还未研究，先不讨论。 

HandlerInterceptorAdapter则默认实现了上述的接口，所以当我们仅仅要实现某个方法时，只需继承HandlerInterceptorAdapter，然后覆盖相应的方法。 

然后我们就写一个类继承HandlerInterceptorAdapter来进行实验：LoginInterceptor如下：  
Java代码   收藏代码
  1. @Override  
  2.     public boolean preHandle(HttpServletRequest request,  
  3.             HttpServletResponse response, Object handler) throws Exception {  
  4.         System.out.println("preHandle");  
  5.         return super.preHandle(request, response, handler);  
  6.     }  
  7.   
  8.     @Override  
  9.     public void postHandle(HttpServletRequest request,  
  10.             HttpServletResponse response, Object handler,  
  11.             ModelAndView modelAndView) throws Exception {  
  12.         System.out.println("postHandle");  
  13.         super.postHandle(request, response, handler, modelAndView);  
  14.     }  
  15.   
  16.     @Override  
  17.     public void afterCompletion(HttpServletRequest request,  
  18.             HttpServletResponse response, Object handler, Exception ex)  
  19.             throws Exception {  
  20.         System.out.println("afterCompletion");  
  21.         super.afterCompletion(request, response, handler, ex);  
  22.     }  
  23.   
  24.     @Override  
  25.     public void afterConcurrentHandlingStarted(HttpServletRequest request,  
  26.             HttpServletResponse response, Object handler) throws Exception {  
  27.         System.out.println("afterConcurrentHandlingStarted");  
  28.         super.afterConcurrentHandlingStarted(request, response, handler);  
  29.     }  

没有做具体的内容，仅仅是打印出一些信息，方便查看执行顺序。 
该接口的基本内容说完了，然后就看下它的配置说明：  
Java代码   收藏代码
  1. <mvc:interceptors path-matcher="xxx">  
  2.         <mvc:interceptor>  
  3.             <mvc:mapping path="xxx"/>  
  4.             <mvc:exclude-mapping path="xxxx"/>  
  5.             <bean class="xxxx"></bean>  
  6.         </mvc:interceptor>  
  7.         <bean class="com.lg.mvc.interceptor.LoginInterceptor" />  
  8.     </mvc:interceptors>  

其实在mvc:interceptors标签中，有两种类型的配置，一种直接配置一个bean（bean和ref归为一类）,另一种还要配置上拦截的路径和排除的路径。直接配置的bean那就代表对所有的请求进行拦截，而对于mvc:interceptor则代表有着更精细的控制。 

而mvc:interceptors的属性path-matcher则表示配置一个自定义的PathMatcher，它主要用来处理路径的匹配规则，默认采用的PathMatcher为AntPathMatcher，具有ant风格的路径规则，如?表示任何单字符，*表示0个或多个字符，**表示0个或多个目录。 
对于本工程来说具体的配置如下：  
Java代码   收藏代码
  1. <mvc:interceptors>  
  2.         <bean class="com.lg.mvc.interceptor.LoginInterceptor" />  
  3.     </mvc:interceptors>  

然后就进行源代码分析： 
如何来处理xml文件中所配置的这些HandlerInterceptor的呢？ 
对于mvc:interceptors的解析同样需要我们去看BeanDefinitionParser的实现类，最终会找到InterceptorsBeanDefinitionParser：  
Java代码   收藏代码
  1. public BeanDefinition parse(Element element, ParserContext parserContext) {  
  2.         CompositeComponentDefinition compDefinition = new CompositeComponentDefinition(element.getTagName(), parserContext.extractSource(element));  
  3.         parserContext.pushContainingComponent(compDefinition);  
  4. //判断是否自定义了PathMatcher  
  5.         RuntimeBeanReference pathMatcherRef = null;  
  6.         if (element.hasAttribute("path-matcher")) {  
  7.             pathMatcherRef = new RuntimeBeanReference(element.getAttribute("path-matcher"));  
  8.         }  
  9. //获取所有的interceptor，在这里我们可以看到所有的interceptor最终都会构建成一个  
  10. //MappedInterceptor  
  11.         List<Element> interceptors = DomUtils.getChildElementsByTagName(element, "bean", "ref", "interceptor");  
  12.         for (Element interceptor : interceptors) {  
  13.             RootBeanDefinition mappedInterceptorDef = new RootBeanDefinition(MappedInterceptor.class);  
  14.             mappedInterceptorDef.setSource(parserContext.extractSource(interceptor));  
  15.             mappedInterceptorDef.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);  
  16.   
  17.             ManagedList<String> includePatterns = null;  
  18.             ManagedList<String> excludePatterns = null;  
  19.             Object interceptorBean;  
  20.             if ("interceptor".equals(interceptor.getLocalName())) {  
  21.                 includePatterns = getIncludePatterns(interceptor, "mapping");  
  22.                 excludePatterns = getIncludePatterns(interceptor, "exclude-mapping");  
  23.                 Element beanElem = DomUtils.getChildElementsByTagName(interceptor, "bean", "ref").get(0);  
  24.                 interceptorBean = parserContext.getDelegate().parsePropertySubElement(beanElem, null);  
  25.             }  
  26.             else {  
  27.                 interceptorBean = parserContext.getDelegate().parsePropertySubElement(interceptor, null);  
  28.             }  
  29.             mappedInterceptorDef.getConstructorArgumentValues().addIndexedArgumentValue(0, includePatterns);  
  30.             mappedInterceptorDef.getConstructorArgumentValues().addIndexedArgumentValue(1, excludePatterns);  
  31.             mappedInterceptorDef.getConstructorArgumentValues().addIndexedArgumentValue(2, interceptorBean);  
  32.   
  33.             if (pathMatcherRef != null) {  
  34.                 mappedInterceptorDef.getPropertyValues().add("pathMatcher", pathMatcherRef);  
  35.             }  
  36.   
  37.             String beanName = parserContext.getReaderContext().registerWithGeneratedName(mappedInterceptorDef);  
  38.             parserContext.registerComponent(new BeanComponentDefinition(mappedInterceptorDef, beanName));  
  39.         }  
  40.   
  41.         parserContext.popAndRegisterContainingComponent();  
  42.         return null;  
  43.     }  

这里就引出来MappedInterceptor的结构类型：  
Java代码   收藏代码
  1. private final String[] includePatterns;  
  2.   
  3.     private final String[] excludePatterns;  
  4.   
  5.     private final HandlerInterceptor interceptor;  
  6.   
  7.     private PathMatcher pathMatcher;  

到这里就很明白了，虽然在mvc:interceptors标签中，配置interceptor形式不一样，但是最终都将以MappedInterceptor形式存储，同时来看下MappedInterceptor的match的方法：  
Java代码   收藏代码
  1. public boolean matches(String lookupPath, PathMatcher pathMatcher) {  
  2.         PathMatcher pathMatcherToUse = (this.pathMatcher != null) ? this.pathMatcher : pathMatcher;  
  3.         if (this.excludePatterns != null) {  
  4.             for (String pattern : this.excludePatterns) {  
  5.                 if (pathMatcherToUse.match(pattern, lookupPath)) {  
  6.                     return false;  
  7.                 }  
  8.             }  
  9.         }  
  10.         if (this.includePatterns == null) {  
  11.             return true;  
  12.         }  
  13.         else {  
  14.             for (String pattern : this.includePatterns) {  
  15.                 if (pathMatcherToUse.match(pattern, lookupPath)) {  
  16.                     return true;  
  17.                 }  
  18.             }  
  19.             return false;  
  20.         }  
  21.     }  

这里便是PathMatcher对于excludePatterns、includePatterns 的使用规则，同时表明本身的PathMatcher若为空，则使用外部传来的PathMatcher。 
至此解析mvc:interceptors标签的过程就完成了。它们最终会注册到ApplicationContext的上下文环境中，等待被使用。 

谁会是他们的使用者呢？我们慢慢来看： 
对于每一个请求，HandlerMapping都会找到对应的handler，并最终封装成一个HandlerExecutionChain，这个HandlerExecutionChain包含有handler和它对应的interceptors，HandlerExecutionChain如下：  
Java代码   收藏代码
  1. private final Object handler;  
  2.   
  3.     private HandlerInterceptor[] interceptors;  
  4.   
  5.     private List<HandlerInterceptor> interceptorList;  
  6.   
  7.     private int interceptorIndex = -1;  

既然是由HandlerMapping来产生的HandlerExecutionChain，则它需要为每一个它所管辖的handler来装配HandlerInterceptor。所以HandlerMapping必然是mvc:interceptors标签内容的使用者。 
使用者：AbstractHandlerMapping，它的属性有：  
Java代码   收藏代码
  1.        private PathMatcher pathMatcher = new AntPathMatcher();  
  2.   
  3. private final List<Object> interceptors = new ArrayList<Object>();  
  4.   
  5. private final List<HandlerInterceptor> adaptedInterceptors = new ArrayList<HandlerInterceptor>();  
  6.   
  7. private final List<MappedInterceptor> mappedInterceptors = new ArrayList<MappedInterceptor>();  

这里便可以看到，它所使用的默认的PathMatcher为AntPathMatcher。接下来我们看下AbstractHandlerMapping的初始化方法：  
Java代码   收藏代码
  1. protected void initApplicationContext() throws BeansException {  
  2.         extendInterceptors(this.interceptors);  
  3.         detectMappedInterceptors(this.mappedInterceptors);  
  4.         initInterceptors();  
  5.     }  

detectMappedInterceptors探测ApplicationContext中已经解析过的MappedInterceptor，如下：  
Java代码   收藏代码
  1. protected void detectMappedInterceptors(List<MappedInterceptor> mappedInterceptors) {  
  2.         mappedInterceptors.addAll(  
  3.                 BeanFactoryUtils.beansOfTypeIncludingAncestors(  
  4.                         getApplicationContext(), MappedInterceptor.class, true, false).values());  
  5.     }  

全部存放到AbstractHandlerMapping的mappedInterceptors属性上。 
然后我们继续看看在请求到来时的具体拦截过程：  
Java代码   收藏代码
  1. protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {  
  2.         HttpServletRequest processedRequest = request;  
  3.         HandlerExecutionChain mappedHandler = null;  
  4.         boolean multipartRequestParsed = false;  
  5.   
  6.         WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);  
  7.   
  8.         try {  
  9.             ModelAndView mv = null;  
  10.             Exception dispatchException = null;  
  11.   
  12.             try {  
  13.                 processedRequest = checkMultipart(request);  
  14.                 multipartRequestParsed = (processedRequest != request);  
  15.   
  16.                 // Determine handler for the current request.  
  17.                 mappedHandler = getHandler(processedRequest);  
  18. //略  
  19. }  

对于每个请求先找到对应的HandlerMapping，然后由这个handlerMapping来找到对应请求的handler，然后由handlerMapping自身的interceptor和这个handler来构建一个HandlerExecutionChain。代码如下：  
Java代码   收藏代码
  1. protected HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {  
  2.         for (HandlerMapping hm : this.handlerMappings) {  
  3.             if (logger.isTraceEnabled()) {  
  4.                 logger.trace(  
  5.                         "Testing handler map [" + hm + "] in DispatcherServlet with name '" + getServletName() + "'");  
  6.             }  
  7.             HandlerExecutionChain handler = hm.getHandler(request);  
  8.             if (handler != null) {  
  9.                 return handler;  
  10.             }  
  11.         }  
  12.         return null;  
  13.     }  

这里便是找到一个合适的HandlerMapping，继续看下hm.getHandler(request)这个方法。  
Java代码   收藏代码
  1. public final HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {  
  2.         Object handler = getHandlerInternal(request);  
  3.         if (handler == null) {  
  4.             handler = getDefaultHandler();  
  5.         }  
  6.         if (handler == null) {  
  7.             return null;  
  8.         }  
  9.         // Bean name or resolved handler?  
  10.         if (handler instanceof String) {  
  11.             String handlerName = (String) handler;  
  12.             handler = getApplicationContext().getBean(handlerName);  
  13.         }  
  14.         return getHandlerExecutionChain(handler, request);  
  15.     }  

这里便是找到对应请求的handler。getHandlerExecutionChain(handler, request)这里便是构建HandlerExecutionChain的地方：  
Java代码   收藏代码
  1. protected HandlerExecutionChain getHandlerExecutionChain(Object handler, HttpServletRequest request) {  
  2.         HandlerExecutionChain chain = (handler instanceof HandlerExecutionChain ?  
  3.                 (HandlerExecutionChain) handler : new HandlerExecutionChain(handler));  
  4.         chain.addInterceptors(getAdaptedInterceptors());  
  5.   
  6.         String lookupPath = this.urlPathHelper.getLookupPathForRequest(request);  
  7.         for (MappedInterceptor mappedInterceptor : this.mappedInterceptors) {  
  8.             if (mappedInterceptor.matches(lookupPath, this.pathMatcher)) {  
  9.                 chain.addInterceptor(mappedInterceptor.getInterceptor());  
  10.             }  
  11.         }  
  12.   
  13.         return chain;  
  14.     }  

对于我们关注的重点为它会遍历AbstarctHandlerMapping的mappedInterceptors属性，然后使用默认的pathMatcher，即AntPathMatcher来判断当前的请求是否符合拦截条件，若符合则将mappedInterceptor放进HandlerExecutionChain 中。 

至此一个HandlerExecutionChain便构建好了，包含一个handler和这个handler对应的interceptor。然后看下interceptor的执行过程：  
Java代码   收藏代码
  1. protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {  
  2.         HttpServletRequest processedRequest = request;  
  3.         HandlerExecutionChain mappedHandler = null;  
  4.         boolean multipartRequestParsed = false;  
  5.   
  6.         WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);  
  7.   
  8.         try {  
  9.             ModelAndView mv = null;  
  10.             Exception dispatchException = null;  
  11.   
  12.             try {  
  13.                 processedRequest = checkMultipart(request);  
  14.                 multipartRequestParsed = (processedRequest != request);  
  15.   
  16.                 // Determine handler for the current request.  
  17.                 mappedHandler = getHandler(processedRequest);  
  18.                 if (mappedHandler == null || mappedHandler.getHandler() == null) {  
  19.                     noHandlerFound(processedRequest, response);  
  20.                     return;  
  21.                 }  
  22.   
  23.                 // Determine handler adapter for the current request.  
  24.                 HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());  
  25.   
  26.                 // Process last-modified header, if supported by the handler.  
  27.                 String method = request.getMethod();  
  28.                 boolean isGet = "GET".equals(method);  
  29.                 if (isGet || "HEAD".equals(method)) {  
  30.                     long lastModified = ha.getLastModified(request, mappedHandler.getHandler());  
  31.                     if (logger.isDebugEnabled()) {  
  32.                         logger.debug("Last-Modified value for [" + getRequestUri(request) + "] is: " + lastModified);  
  33.                     }  
  34.                     if (new ServletWebRequest(request, response).checkNotModified(lastModified) && isGet) {  
  35.                         return;  
  36.                     }  
  37.                 }  
  38. //重点1 这里执行interceptor的preHandle方法  
  39.                 if (!mappedHandler.applyPreHandle(processedRequest, response)) {  
  40.                     return;  
  41.                 }  
  42. //这里执行处理函数  
  43.                 try {  
  44.                     // Actually invoke the handler.  
  45.                     mv = ha.handle(processedRequest, response, mappedHandler.getHandler());  
  46.                 }  
  47.                 finally {  
  48.                     if (asyncManager.isConcurrentHandlingStarted()) {  
  49.                         return;  
  50.                     }  
  51.                 }  
  52.   
  53.                 applyDefaultViewName(request, mv);  
  54. //重点2：这里执行interceptor的postHandle方法  
  55.                 mappedHandler.applyPostHandle(processedRequest, response, mv);  
  56.             }  
  57.             catch (Exception ex) {  
  58.                 dispatchException = ex;  
  59.             }  
  60. //重点3：这里执行interceptor的afterCompletion方法  
  61.             processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);  
  62.         }  
  63. //重点4：当出现异常时，仍然执行afterCompletion方法  
  64.         catch (Exception ex) {  
  65.             triggerAfterCompletion(processedRequest, response, mappedHandler, ex);  
  66.         }  
  67.         catch (Error err) {  
  68.             triggerAfterCompletionWithError(processedRequest, response, mappedHandler, err);  
  69.         }  
  70.         finally {  
  71.             if (asyncManager.isConcurrentHandlingStarted()) {  
  72.                 // Instead of postHandle and afterCompletion  
  73.                 mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);  
  74.                 return;  
  75.             }  
  76.             // Clean up any resources used by a multipart request.  
  77.             if (multipartRequestParsed) {  
  78.                 cleanupMultipart(processedRequest);  
  79.             }  
  80.         }  
  81.     }  

先看重点1：  
Java代码   收藏代码
  1. boolean applyPreHandle(HttpServletRequest request, HttpServletResponse response) throws Exception {  
  2.         if (getInterceptors() != null) {  
  3.             for (int i = 0; i < getInterceptors().length; i++) {  
  4.                 HandlerInterceptor interceptor = getInterceptors()[i];  
  5.                 if (!interceptor.preHandle(request, response, this.handler)) {  
  6.                     triggerAfterCompletion(request, response, null);  
  7.                     return false;  
  8.                 }  
  9.                 this.interceptorIndex = i;  
  10.             }  
  11.         }  
  12.         return true;  
  13.     }  

执行preHandle方法，一旦有一个preHandle返回false,则触发triggerAfterCompletion：  
Java代码   收藏代码
  1. void triggerAfterCompletion(HttpServletRequest request, HttpServletResponse response, Exception ex)  
  2.             throws Exception {  
  3.   
  4.         if (getInterceptors() == null) {  
  5.             return;  
  6.         }  
  7.         for (int i = this.interceptorIndex; i >= 0; i--) {  
  8.             HandlerInterceptor interceptor = getInterceptors()[i];  
  9.             try {  
  10.                 interceptor.afterCompletion(request, response, this.handler, ex);  
  11.             }  
  12.             catch (Throwable ex2) {  
  13.                 logger.error("HandlerInterceptor.afterCompletion threw exception", ex2);  
  14.             }  
  15.         }  
  16.     }  

看下这里的for循环的条件，从interceptorIndex开始到0，逆序执行interceptor.afterCompletion。 
重点2 postHandle：  
Java代码   收藏代码
  1. void applyPostHandle(HttpServletRequest request, HttpServletResponse response, ModelAndView mv) throws Exception {  
  2.         if (getInterceptors() == null) {  
  3.             return;  
  4.         }  
  5.         for (int i = getInterceptors().length - 1; i >= 0; i--) {  
  6.             HandlerInterceptor interceptor = getInterceptors()[i];  
  7.             interceptor.postHandle(request, response, this.handler, mv);  
  8.         }  
  9.     }  

这个没有什么特殊，preHandle只有参数HttpServletRequest和HttpServletResponse，而postHandle则加入了返回结果ModelAndView，我们可以对ModelAndView进行进一步的修改，此时的view（若有）还没有经过渲染。 
重点3 ：  
Java代码   收藏代码
  1. private void processDispatchResult(HttpServletRequest request, HttpServletResponse response,  
  2.             HandlerExecutionChain mappedHandler, ModelAndView mv, Exception exception) throws Exception {  
  3.   
  4.         boolean errorView = false;  
  5.   
  6.         if (exception != null) {  
  7.             if (exception instanceof ModelAndViewDefiningException) {  
  8.                 logger.debug("ModelAndViewDefiningException encountered", exception);  
  9.                 mv = ((ModelAndViewDefiningException) exception).getModelAndView();  
  10.             }  
  11.             else {  
  12.                 Object handler = (mappedHandler != null ? mappedHandler.getHandler() : null);  
  13.                 mv = processHandlerException(request, response, handler, exception);  
  14.                 errorView = (mv != null);  
  15.             }  
  16.         }  
  17.   
  18.         // Did the handler return a view to render?  
  19.         if (mv != null && !mv.wasCleared()) {  
  20.             render(mv, request, response);  
  21.             if (errorView) {  
  22.                 WebUtils.clearErrorRequestAttributes(request);  
  23.             }  
  24.         }  
  25.         else {  
  26.             if (logger.isDebugEnabled()) {  
  27.                 logger.debug("Null ModelAndView returned to DispatcherServlet with name '" + getServletName() +  
  28.                         "': assuming HandlerAdapter completed request handling");  
  29.             }  
  30.         }  
  31.   
  32.         if (WebAsyncUtils.getAsyncManager(request).isConcurrentHandlingStarted()) {  
  33.             // Concurrent handling started during a forward  
  34.             return;  
  35.         }  
  36.   
  37.         if (mappedHandler != null) {  
  38.             mappedHandler.triggerAfterCompletion(request, response, null);  
  39.         }  
  40.     }  

这里可以看到，如果有view，则渲染完成之后，才会执行triggerAfterCompletion，同时不再拥有对ModelAndView的处理（已经完成了渲染）。所以我们就可以看到当有view时，afterCompletion和postHandle的明显区别。 
重点4：当执行过程发生异常时，也会执行interceptor的afterCompletion方法。 
这里要做下说明，对于preHandler方法是获取不到处理函数的参数值的，如果想对处理函数的参数值进行拦截处理，则要使用Spring AOP。 
【SpringMVC笔记09】SpringMVC中的拦截器介绍
✅ Java 开发工程师，从事 Web 应用程序的研发，擅长 Spring、SpringBoot 等技术。 ✅ 热爱编程，业余时间学习新知识，通过 CSDN 记录学习心得和笔记内容。
07-12 569
目录一、SpringMVC拦截器1.1、什么是拦截器1.2、拦截器的使用（1）创建拦截器（2）创建控制器（3）注册拦截器（4）测试拦截器1.3、拦截器执行顺序（1）默认执行顺序（2）拦截器配置介绍（3）执行顺序流程图1.4、拦截器原理在说拦截器之前，我们先来回顾一下Servlet中的Filter过滤器组件。什么是Filter过滤器组件呢？？？从名称上面来看，大家可能会觉得这个过滤器组件是不是非常高大上，非常难理解呢，其实任何组件都是Java代码，它就是一个Java类一样，只不过这个Java类的作用是：在HT
springmvc--过滤器、拦截器:Interceptor
a18792721831的博客
03-19 653
springmvc--过滤器、拦截器:Interceptor1.如何写一个拦截器2.配置拦截器3.拦截器的执行顺序4.多个拦截器配置后执行的顺序5.例子5.1创建一个springmvc项目5.2导入jar包5.3配置web.xml5.4创建实体5.5创建自定义的拦截器5.6配置拦截器5.7创建controller5.8导入js5.9编写jsp5.10测试6.总结 1.如何写一个拦截器 1.实现H...
Spring参考手册 mvc:interceptors
Noday
07-02 8148
 This tag allows you to register custom HandlerInterceptors or WebRequestInterceptors that should be applied to all HandlerMapping beans. You can also restrict the URL paths specifc interceptors apply
Spring MVC拦截器（Interceptor）
helpluozhao123的博客
05-14 1511
在系统中，经常需要在处理用户请求之前和之后执行一些行为，例如检测用户的权限，或者将请求的信息记录到日志中，即平时所说的“权限检测”及“日志记录”。当然不仅仅这些，所以需要一种机制，拦截用户的请求，在请求的前后添加处理逻辑。 Spring MVC 提供了 Interceptor 拦截器机制，用于请求的预处理和后处理。 在开发一个网站时可能有这样的需求：某些页面只希望几个特定的用户浏览。对于这样的访问权限控制，应该如何实现呢？拦截器就可以实现上述需求。在 Struts2 框架中，拦截器是其重要的组成部分，Spr
mvc:interceptors
weixin_38820218的博客
10-24 770
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p" xmlns:context="http://www.springframework.org/schema/context" xmlns:dubbo="http://code.alibaba
【SpringMVC】拦截器（interceptors）
✈ 正在努力 の 寒江（StudiousTiger) ✌ 呐 ✈
07-09 882
文章目录一、什么是拦截器二、拦截器的使用第一步：实现HandlerInterceptor接口第二步：实现方法第三步：配置三、解决因配置了拦截器，导致静态资源失效的问题四、你可能会遇到的问题 一、什么是拦截器 原理图： 如上图所示，配置了拦截器之后，我们的Controller在被访问前，会先被拦截器中的preHandle()方法进行拦截，Controller在被访问后会被拦截器的postHandler()进行拦截，最后还会被拦截器的afterCompletion()方法处理。 在springmvc中，
springMVC及springBoot配置拦截器
kobeandonear的博客
06-22 334
springMVC及springBoot配置拦截器及源码解析
SpringMVC拦截器源码.rar
07-06
在SpringMVC的配置中，我们可以通过`<mvc:interceptors>`标签来声明和配置拦截器。每个拦截器由`<mvc:interceptor>`标签定义，并通过`<mvc:mapping>`指定拦截的URL模式。例如： ```xml <mvc:interceptors> <mvc:...
day7:SpringMVC拦截器interceptor
卓汶的博客
07-18 236
SpringMVC的拦截器类似于Servlet开发中的过滤器Filter，用于对处理器进行预处理和后处理,即对访问一些资源和方法时进行相应的干预。如未登录需要访问内部数据时，可以进行拦截并跳转到登录页面，可以使用拦截器来完成。将拦截器按一定的顺序联结成一条链，这条链称为。在访问被拦截的方法或字段时，拦截器链中的拦截器就会按其之前定义的顺序被调用。拦截器也是AOP思想的具体实现。......
spring mvc xml配置拦截器
08-05
下面将详细介绍创建和配置Spring MVC拦截器的步骤。 1. **创建自定义拦截器** 首先，我们需要创建一个实现`HandlerInterceptor`接口的类。这个接口包含三个方法： - `preHandle(HttpServletRequest request, ...
springMVC拦截器Interceptor
这里是火火火的世界
12-19 1124
Interceptor拦截器的基本使用方法;Interceptor拦截器的执行流程;使用Interceptor拦截器检验用户是否已经登录 程序首先执行拦截器类中的preHandle方法，如果该方法的返回值是true，则程序会继续向下执行处理器中的方法，否则不会再向下执行，在业务控制器Controller处理完请求后，会继续执行postHandle方法，而后会通过DispatcherServlet向客户端返回响应，
MVC拦截器
weixin_42206447的博客
03-01 241
继承ActionFilterAttribute的类 using Common; using System; using System.Collections.Generic; using System.Linq; using System.Web; using System.Web.Mvc; namespace WebCJFZ.App_Start { public class Login...
SpringMVC的拦截器（Interceptor）
coderge's CSDN Blog.
05-18 4638
在这个方法中可以通过返回值来决定是否要进行放行，我们可以把业务逻辑放在该方法中，如果满足业务则返回true放行，不满足则返回false拦截。方法，如果返回true,则代表放行，会执行原始Controller类中要请求的方法，如果返回false，则代表拦截，后面的就不会再执行了。(7)如果满足规则，则进行处理，找到其对应的controller类中的方法进行执行,完成后返回结果。拦截器执行的顺序是和配置顺序有关。(5)在找到具体的方法之前，我们可以去配置过滤器(可以配置多个)，按照顺序进行执行。
Spring MVC 拦截器Interceptor
weixin_43973161的博客
08-18 592
拦截器和过滤器它的作用是非常相似的，都是对于请求的拦截，但是他们底层的实现逻辑是不同的，interceptor是SpringMVC的标准组件，interceptor对象在被创建了以后是运行在Spring IOC容器中的，而filter呢，它则是J2EE的标准组件，是J2EE的标准，作为filter是由不同的第三方容器厂商所实现的，所以他们两个虽然作用相似，但底层的实现逻辑是截然不同的。如果前面的拦截器中断了，return false，那么后面的拦截器不会执行，直接返回结果。使用日志来保存访问记录信息。...
【SpringMVC】SpringMVC之拦截器Interceptor
HXY19的博客
11-07 1578
这里对于SpringMVC的拦截器进行了一番个人的理解，其中也有源码讲解内部多拦截器的执行顺序是如何的
SpringMVC：拦截器
蒟蒻码农的博客
03-31 532
SpringMVC提供了拦截器机制，它允许目标方法运行前进行一些拦截工作，或者在目标方法运行之后进行一些处理。 拦截器类似于JavaWeb的Filter 拦截器：HandlerInterceptor 1.preHandle方法：在目标方法执行之前调用，返回值为boolean。 返回true，放行 返回false，不放行 2.postHandle方法：在目标方法执行之后调用 3.a...
springMVC之mvc:interceptors拦截器的用法
Gavid0124的专栏
04-24 2159
springMVC之mvc:interceptors拦截器的用法
【Spring MVC】Spring MVC拦截器（Interceptor）
最新发布
小七的博客
03-18 2310
本文将带你详细了解Spring MVC拦截器的执行顺序、底层原理以及生产应用。
关于<mvc:interceptors>元素
06-11
`<mvc:interceptors>` 是 SpringMVC 配置文件中的一个元素，用于配置 SpringMVC 拦截器。 该元素需要在 SpringMVC 的配置文件中进行配置，通常为 `springmvc-servlet.xml`。在该元素中可以配置多个拦截器，每个拦截...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值