先上代码：

// 给axios配置响应拦截器
axios.interceptors.response.use(
  function(response) {
    // 当返回状态码表示token值无效时
    if (response.data.code === 4002) {
      Vue.prototype.$message.error('登录已过期，请重新登录')
      router.replace('/login')
    } else {
    // 其他情况
      return response.data
    }
  },
  function(error) {
    // 对响应错误做点什么
    return Promise.reject(error)
  }
)

最开始我的想法是在vue的main.js中直接使用this.$routers，但是在网上看了很多例子，实验无果。

因为此时的this我打印出来是undefined，所以this.$message和this.$router都不能用。

关于登录失效的提示，可以使用Vue.prototype.$message，
跳转的话，可以使用router.replace(’/login’)

值得注意的是，如果你在请求失败的代码中写了this.$message.error(‘错误信息’)，那么 return response.data也会返回一个打印的错误，此时不会显示Vue.prototype.$message.error(‘登录已过期，请重新登录’)，优先显示请求失败的代码中写了this.$message.error(‘错误信息’)

所以要写if else判断，当后端返回状态码是4002（tooken有误）时，不返回后端响应的数据，只触发 Vue.prototype.$message.error(‘登录已过期，请重新登录’)和router.replace(’/login’)即可。

而其他情况的时候，直接返回后端相应的数据即可。

1、拦截器简介

• 拦截器：Intercepor拦截器是Handler（Controller）的拦路虎；在用户发起请求时如果请求的Controller下存在拦截器，那么拦截器会对一些请求进行拦截… 总而言之拦截器是围绕Controller做出的一些处理！

• 拦截器的作用：

  1. 拦截用户的请求，可以预先对请求做出处理；根据结果决定是否执行Controller。

  2. 如果拦截器执行，那么拦截器在Controller执行完成返回给DispatcherServlet前端控制器之前可以将执行返回的结果进行一些修改。

  3. 如果拦截器执行，在请求响应完成之后；此时拦截器依然可以做出一些修尾的工作，例如清理Session…

  4. 根据上述的描述，可以认为拦截器亦可以将Controller共同的功能定义到拦截器中！

• 拦截器特点：

  1. 拦截器可以分为MVC框架自带的拦截器和程序员自定义拦截器。

  2. 一个Controller可以有0个、若干个拦截器的存在。

  3. 拦截器测试拦截用户的请求Controller

• 拦截器思想：可以很容易 “猜到” 拦截器的核心思想就是aop；拦截器接口一共就三个方法，三个方法在aop中分别是不同的增强方式实现！

2、拦截器执行流程

前言：

• 首先明白JSP、Servlet是同一个东西、JSP最后也会转化为Servlet只不过是由Tomocat服务器做的。

• SpringMVC中有且只有一个Servlet：前端控制器DispatcherServlet；而Controller只是一个Bean对象与Servlet没有半毛钱关系！

1. 用户发起请求无论是访问Controller、还是JSP页面、还是Servlet都会经过Filter过滤器，因为访问Controller同样是需要经过DispatcherServlet的！它是MVC架构中的唯一一个Servlet。

2. 此时Filter过滤器会处理一些东西：典型的设置编码集防止乱码、也可能会过滤一些垃圾请求（不在配置的URL之中）

3. 现在假设用户请求的是Controller，那么一定会经过DispatcherServlet调度分发；此时这一步是非常重要的：

   • DispatcherServlet先交给HandlerMapping进行解析URI

   • 其次HandlerMapping找到对应的Handler（Controller）之后，将该Handler下对应的MVC拦截器组成一个拦截器执行链，并且打包上Handler形成处理器执行器HandlerExcution，最后重新交给DispatcherServlet

   • DispatcherServlet现在手握处理器执行器HandlerExcution，将其找到适配的处理器适配器HandlerAdapter，由它完成一些解析参数…

   • 处理器适配器解析完成之后，到此拦截器开始工作！

4. 上面说过所有的拦截器组合成一个执行链，按照拦截器配置的顺序进行执行！其中拦截器中有个方法preHandler中是返回值极为重要：

   • 返回值为true：放行继续执行下一个拦截器，或者是最后一个拦截器通过开始执行controller

   • 返回值为false：拦截器是一个执行链，无论有几个拦截器，只要有一个拦截器返回值为false，将会直接拦截那么controller就无法执行。

5. 如果preHandler的返回值是true，那么Controller执行完毕之后将会按照相反的顺序执行postHandler方法执行；可以将ModeAndView进行修改！

6. 最后交给DispatcherServlet进行视图解析，最后完成响应！

3、拦截器的使用

拦截器是SpringMVC提供的一个接口，当需要用到拦截器时需要实现HandlerInterceptor接口、并且在配置文件中声明拦截器；有点Spring声明式事务的感觉！该接口下主要有3个方法，分别是不同的执行顺序。

public interface HandlerInterceptor {

	default boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
			throws Exception {

		return true;
	}

	default void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
			@Nullable ModelAndView modelAndView) throws Exception {
	}

	
	default void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler,
			@Nullable Exception ex) throws Exception {
	}
}

3.1、preHandle方法

• 这是拦截器最核心的方法，该方法直接决定整个请求的拦截与否；后序另外两个方法是否执行也与它的返回值有关联！

• 作用：既然是前置拦截、那么可以常常被用来做权限拦截、session是否合法的检查…

/**
 *
 *  preHandler： 预先处理的请求方法
 *  Object handler : 被拦截的控制器对象（Controller）
 *  返回值: boolean
 *  true: 放行     false: 驳回
 *  特点：
 *  1. 预处理方法它的执行时间: 在控制器方法之前先执行的。
 *  2. 可以对请求做处理, 可以做登录的检查、权限的判断、 统计数据...
 *  3. 决定请求是否执行。
 */
@Override
public boolean preHandle(HttpServletRequest req, HttpServletResponse resp, Object handler) throws Exception {
    System.out.println("===========preHandle处理前!===========");
    return true;
}

3.2、postHandle方法

• postHandle属于后置的方法当controller处理完毕之后（前提是preHandle放行）；因为拿到的ModelAndView对象，所以可以进行一些数据的更改，可以将它看做小controller（二次处理）

• 作用：修改请求的结果、响应的视图对象…

/**
 *  postHandler: controller执行后返回处理的方法
 *  Object handler: 被拦截的控制器对象（Controller）
 *  参数：mv控制器方法的返回值（响应的结果）
 *
 *  特点:
 *  1. 在控制器方法之后执行的。
 *  2. 能获取到控制器放的执行结果，可以修改原来的数据、视图...
 *  3. 可以对请求进行二次处理。
 *
 */

@Override
public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView mv) throws Exception {
    System.out.println("===========postHandle处理后!===========");
}

3.3、afterCompletion方法

• 该方法是整个请求 - 响应一体完成之后才进行执行，可以进行一些修尾的工作。

• 作用：例如当用户成功修改密码之后，可以在这里将其session过期一下使其重新登录。（个人想法）

/**
 *   Object handler: 被拦截的控制器对象（Controller）
 *   Exception ex : 异常对象
 *
 *   特点:
 *   1. 在请求-响应完成后进行执行
 *   2. 进行一些清理工作、释放内存、清理临时变量。
 *
 */

@Override
public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
    System.out.println("===========afterCompletion清理!===========");
}

3.4、拦截器的声明

不仅仅需要实现HanlderInterceptor接口，重写这几个方法还需要在配置文件中进行声明拦截器；此时只是定义了一个拦截器，需要使用的时候还需要针对拦截器进行指定拦截哪些controller。

<!-- 声明拦截器 -->
<mvc:interceptors>
    <mvc:interceptor>
        <!-- 拦截所有的controler -->
        <mvc:mapping path="/**"/>
        <!-- 使用哪些拦截器进行拦截-->
        <bean class="com.Interceptor.MyInterceptor"/>
    </mvc:interceptor>
    <mvc:interceptor>
    	<!-- 拦截user/tomain请求-->
        <mvc:mapping path="/user/tomain"/>
        <bean class="com.Interceptor.LoginInterceptor"/>
    </mvc:interceptor>
</mvc:interceptors>

4、多个拦截器组合

当出现多个拦截器时执行顺序里面大有文章，大概有以下几点：

• 每个拦截器的prehandle都能直接决定整个请求的成功与否，只要有一个返回值是false那么controller都无法执行。

• 多个拦截器是组合成一条拦截器执行链，按照配置文件声明的顺序进行执行。（准确的说并不是每个方法都是这样）

• preHandle方法是按照声明的顺序执行的，postHandle方法是按照声明的顺序逆序执行，根据上图也能够容易理解（就近原则）

• afterCompletion方法比较特殊，它需要preHandle执行才有可能执行；这个和多拦截的顺序有关系！

4.1、定义两个拦截器

按照顺序先声明A、再声明B拦截器；执行顺序是跟这里直接挂钩的！

<!-- 声明拦截器 -->
<mvc:interceptors>
    <mvc:interceptor>
        <!-- A拦截器 -->
        <mvc:mapping path="/**"/>
        <bean class="com.Interceptor.InterceptorA"/>
    </mvc:interceptor>
    <mvc:interceptor>
        <!-- B拦截器 -->
        <mvc:mapping path="/**"/>
        <bean class="com.Interceptor.InterceptorB"/>
    </mvc:interceptor>
</mvc:interceptors>

4.2、同时返回true

结论：可以看到preHandle根据定义顺序执行，而postHandle是恰好相反的；afterCompletion方法正常情况下也是倒序执行

4.3、同时返回false

A拦截器先执行的，由于没有放行所以B拦截器无论是否为true都没有机会执行！

结论：每个拦截器都有一票否决权利，直接决定拦截与否；而afterCompletion无法执行是因为preHandle没有返回true导致。

4.4、A返回true，B返回false

A成功执行preHandle，而B的preHandle返回false同样是一票否决请求的成功；

结论：afterCompletion执行需要preHandle先执行；可以不执行postHandle。

4.5、A返回false，B返回true

结论：与上面相同

5、拦截器的执行顺序

要了解拦截器的执行顺序首先要知道拦截器是如何组合生成的，其次需要了解拦截器的执行链；组合拦截器执行链的过程会使用HandlerExecutionChain类，将所有的拦截器加入其中。

public class HandlerExecutionChain {
	//处理器controller
	private final Object handler;	
			
	//拦截器数组
	private final List<HandlerInterceptor> interceptorList = new ArrayList<>();	

	//获取执行链中的handler处理器
	public Object getHandler() {
		return this.handler;
	}
	
	/**
	 * postHandle执行
	 */
	boolean applyPreHandle(HttpServletRequest request, HttpServletResponse response) throws Exception {
		for (int i = 0; i < this.interceptorList.size(); i++) {
			HandlerInterceptor interceptor = this.interceptorList.get(i);
			if (!interceptor.preHandle(request, response, this.handler)) {
				triggerAfterCompletion(request, response, null);
				return false;
			}
			this.interceptorIndex = i;
		}
		return true;
	}

	/**
	 * postHandle执行
	 */
	void applyPostHandle(HttpServletRequest request, HttpServletResponse response, @Nullable ModelAndView mv)
			throws Exception {

		for (int i = this.interceptorList.size() - 1; i >= 0; i--) {
			HandlerInterceptor interceptor = this.interceptorList.get(i);
			interceptor.postHandle(request, response, this.handler, mv);
		}
	}

	/**
	 * AfterCompletion执行
	 */
	void triggerAfterCompletion(HttpServletRequest request, HttpServletResponse response, @Nullable Exception ex) {
		for (int i = this.interceptorIndex; i >= 0; i--) {
			HandlerInterceptor interceptor = this.interceptorList.get(i);
			try {
				interceptor.afterCompletion(request, response, this.handler, ex);
			}
			catch (Throwable ex2) {
				logger.error("HandlerInterceptor.afterCompletion threw exception", ex2);
			}
		}
	}
}

保证顺序的机制特别简单，就是一个数组的顺序、逆序遍历。

1.认识拦截器

在SpringMVC中，存在与Servlet中的过滤器（Filter）类似并且功能功能更加强大的拦截器（Interceptor）。它主要用于拦截用户请求并作相应的操作。可以简单理解为Spring中AOP的思想实现。在SpringMVC中，拦截器（HandlerInterceptor）是一个接口，我们使用时可以通过重写接口方法来完成我们想要做的事情。

public interface HandlerInterceptor {
    
    /*
    在控制器方法执行前运行该方法，返回值表示是否中断后续操作
    返回值：	true：继续向下执行
    		   false：会中断后续的所有操作（包括调用下一个拦截器和控制器类中的方法执行等）。
    */
	default boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
			throws Exception {

		return true;
	}
    
    
	/*
	在控制器方法执行后，视图解析之前运行该方法
	*/
	default void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
			@Nullable ModelAndView modelAndView) throws Exception {
	}

    /*
    该方法会在整个请求完成，即视图渲染结束之后执行。可以通过此方法实现一些资源清理、记录日志信息等工作。
    */
	default void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler,
			@Nullable Exception ex) throws Exception {
	}

}

2.配置拦截器

2.1 编写自己的拦截器

public class MyFirstHandlerInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("MyFirstHandlerInterceptor----preHandle");
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("MyFirstHandlerInterceptor----postHandle");
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("MyFirstHandlerInterceptor----afterCompletion");
    }
}

2.2 编写请求处理方法

@RequestMapping("/test11")
@ResponseBody
public String test11() {
    System.out.println("方法执行");
    return "success";
}

2.3 在SpringMVC.xml中注册我们的拦截器

<mvc:interceptors>
    <!--        方法一：给某些请求配置拦截器-->
    <mvc:interceptor>
        <mvc:mapping path="/test0*"/> 
        <mvc:exclude-mapping path="/test1*"/>
        <bean class="com.shang.HandlerInterceptor.MyFirstHandlerInterceptor"></bean>
    </mvc:interceptor>

    <!--        方法二：全部都进行配置-->
    <bean class="com.shang.HandlerInterceptor.MyFirstHandlerInterceptor"></bean>
</mvc:interceptors>

• < mvc:interceptors > 元素用于配置一组拦截器，基子元素的bean中定义的是全局拦截器，他会拦截所有的请求
• < mvc:interceptor >元素定义的是指定路径的拦截器
  • < mvc:mapping path= >指定拦截器作用的路径。”/**”表示拦截所有路径，“/test1 *” 表示拦截所有以 “/test1 *” 结尾的路径
  • < mvc:exclude-mapping path= > 指定拦截不包括那些路径

2.4 结果测试

3.多个拦截器执行顺序

定义两个拦截器，在SpringMVC.xml中如下配置

MyFirstHandlerInterceptor

public class MyFirstHandlerInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("MyFirstHandlerInterceptor----preHandle");
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("MyFirstHandlerInterceptor----postHandle");
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("MyFirstHandlerInterceptor----afterCompletion");
    }
}

MySecondHandlerInterceptor.java

public class MySecondHandlerInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("MySecondHandlerInterceptor----preHandle");
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("MySecondHandlerInterceptor----postHandle");
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("MySecondHandlerInterceptor----afterCompletion");
    }
}

SpringMVC.xml

    <mvc:interceptors>
<!--        方法一：给某些请求配置拦截器-->
        <mvc:interceptor>
            <mvc:mapping path="/test*"/>
            <bean class="com.shang.HandlerInterceptor.MyFirstHandlerInterceptor"></bean>
        </mvc:interceptor>

<!--        方法二：全部都进行配置-->
        <bean class="com.shang.HandlerInterceptor.MySecondHandlerInterceptor"></bean>
    </mvc:interceptors>

3.1 每个拦截器全部放行

运行结果如下

我们通过输出可以看出，在SpringMVC.xml中进行配置的顺序就是我们拦截器执行的顺序,在退出控制器方法执行后,拦截器安装之前的顺序逆序退出,用符号来表示一下,就是这样的:

{ [ * ] }

3.2 第二个拦截器不放行

将MySecondHandlerInterceptor中的preHandle返回改为false

两个拦截器的perHandle执行了,但是我们可以看见MyFirstHandlerInterceptor的afterCompletion方法也执行了.且方法不执行,那这是为什么呢?

4.拦截器源码解析

在所有的请求发送过来时,都会执行DispatcherServlet.doDispatch方法,我们从这个方法开始了解拦截器的执行过程.

4.1 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) {
					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 = HttpMethod.GET.matches(method);
				if (isGet || HttpMethod.HEAD.matches(method)) {
					long lastModified = ha.getLastModified(request, mappedHandler.getHandler());
					if (new ServletWebRequest(request, response).checkNotModified(lastModified) && isGet) {
						return;
					}
				}

                //这里执行拦截器的preHandle方法,且这里传入的是一个拦截器链,如果返回false,不执行下面的方法,直接跳到finally处
				if (!mappedHandler.applyPreHandle(processedRequest, response)) {
					return;
				}

				// Actually invoke the handler. 真正执行执行器方法返回ModelAndView对象
				mv = ha.handle(processedRequest, response, mappedHandler.getHandler());

				if (asyncManager.isConcurrentHandlingStarted()) {
					return;
				}

				applyDefaultViewName(processedRequest, mv);
                //这里执行拦截器链的postHandle的方法,逆序执行
				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) {
            //处理异常,在preHandle的控制中,返回false,就会执行.
			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);
				}
			}
		}
	}

4.2 applyPreHandle方法

boolean applyPreHandle(HttpServletRequest request, HttpServletResponse response) throws Exception {
    //对拦截器链进行遍历执行
    for (int i = 0; i < this.interceptorList.size(); i++) {
        HandlerInterceptor interceptor = this.interceptorList.get(i);
        //如果preHandle返回值为false,退出方法执行
        if (!interceptor.preHandle(request, response, this.handler)) {
            triggerAfterCompletion(request, response, null);
            return false;
        }
        //记录执行到第几个拦截器链
        this.interceptorIndex = i;
    }
    return true;
}

4.3 applyPostHandle方法

void applyPostHandle(HttpServletRequest request, HttpServletResponse response, @Nullable ModelAndView mv)
    throws Exception {

    //从循环可以看出,为什么拦截器执行是逆序的
    for (int i = this.interceptorList.size() - 1; i >= 0; i--) {
        HandlerInterceptor interceptor = this.interceptorList.get(i);
        interceptor.postHandle(request, response, this.handler, mv);
    }
}

4.4 triggerAfterCompletion方法

void triggerAfterCompletion(HttpServletRequest request, HttpServletResponse response, @Nullable Exception ex) {
    //这里就解释了为什么第二个拦截器挂了,第一个拦截器的afterCompletion方法还可以运行.
    //4.2-4.4的这些方法都存在于一个类中,interceptorIndex记录了最后执行到的拦截器
    for (int i = this.interceptorIndex; i >= 0; i--) {
        HandlerInterceptor interceptor = this.interceptorList.get(i);
        try {
            interceptor.afterCompletion(request, response, this.handler, ex);
        }
        catch (Throwable ex2) {
            logger.error("HandlerInterceptor.afterCompletion threw exception", ex2);
        }
    }
}