Interceptor拦截器
Interceptor拦截器的作用类似于Filter过滤器，例如：可以用来拦截用户请求，并作相应的拦截处理。不同之处在于：过滤器依赖Servlet容器，可以拦截用户的全部请求；拦截器是SpringMVC的，它不依赖于servlet容器，由Spring容器进行初始化，可以通过相应的配置，拦截更细粒度的一组请求。
1. SpringMVC执行流程
拦截器是依赖于SpringMVC的，SpringMVC框架是高度可配置的，无论其视图技术（如 JSP、FreeMarker、Thymeleaf等）选择何种，SpringMVC的执行流程图大抵是相同的。
执行流程为：
[1] 用户触发某个请求路径，通过浏览器发起一个HTTP Request请求，该请求会被提交至DispatcherServlet前端控制器；
[2] 由DispatcherServlet前端控制器请求一个或者多个HandlerMapping（处理器映射器），并返回一个Handler执行链（HandlerExecutionChain）；
[3] DispatcherServlet前端控制器将HandlerMapping处理器映射器返回的执行链中包含的Handler信息发送给HandlerAdapter处理器适配器；
[4] HandlerAdapter处理器适配器根据Handler信息找到并执行相应的Handler处理器（即：项目中的Controller层中的控制器）；
[5] Handler处理器执行完毕后，会返回给HandlerAdapter处理器适配器一个ModelAndView对象（SpringMVC的底层对象，封装了Model数据模型和View视图信息）；
[6] HandlerAdapter处理器适配器接收到ModelAndView对象后，将其返回给DispatcherServlet前端控制器；
[7] DispatcherServlet前端控制器接收到ModelAndView对象后，回请求ViewResolver视图解析器对视图进行解析；
[8] ViewResolver视图解析器根据View匹配到相应的视图结果，并返回给DispatcherServlet前端控制器；
[9] DispatcherServlet 接收到具体的 View 视图后，进行视图渲染，将 Model 中的模型数据填充到 View 视图中的 request 域，生成最终的 View（视图）；
[10] 视图会被响应给浏览器客户端，并进行渲染。
2. 拦截器
2.1 作用位置
拦截器主要用于拦截用户请求并作相应的处理，那么其拦截位置必定是在HTTP请求到达DispatcherServlet前端控制器之后、将处理结果响应给浏览器之前。
查看DispatcherServlet前端控制器的继承结构，会看到它其实是HttpServlet的一个子类，其职责如下：
Central dispatcher for HTTP request handlers/controllers, e.g. for web UI controllers or HTTP-based remote service exporters. Dispatches to registered handlers for processing a web request, providing convenient mapping and exception handling facilities.
是http请求处理器/控制器的中央调度器，例如：Web UI控制器或者HTTP远程服务的出口。用于分发web请求到已经注册过的处理器进行处理，并提供方便的映射和异常处理机制。
2.2 HandlerInterceptor接口与拦截器实现
2.2.1 HandlerInterceptor拦截器方法调用时机
可以通过实现HandlerInterceptor接口、实现HandlerInterceptor接口自接口、继承HandlerInterceptor接口子类定义一个SpringMVC拦截器。
HandlerInterceptor接口中定义了如下三个default方法，实现子类通过重写相应的方法，在特定的执行流程发生时，执行用户请求的拦截动作，并完成相应的处理操作。
/*Intercept the execution of a handler. Called after HandlerMapping determined an
appropriate handler object, but before HandlerAdapter invokes the handler.
DispatcherServlet processes a handler in an execution chain, consisting of any number
of interceptors, with the handler itself at the end. With this method, each interceptor
can post-process an execution,getting applied in inverse order of the execution chain.
*/
|拦截时机：HandlerMapping处理器映射器匹配到对应的Handler处理器对象，但是还未被HandlerAdapter处理器适配器调用之前发生作用。
|处理执行链中包含的Handler处理器对象。
|作用方式：通过preHandle()这个方法，每一个拦截器对象可以对request代表的HTTP请求对象进行拦截处理，并响应一个自定义HTTP响应消息给浏览器客户端。
default boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
//空方法
return true;
}
/*
Intercept the execution of a handler. Called after HandlerAdapter actually
invoked the handler, but before the DispatcherServlet renders the view.
Can expose additional model objects to the view via the given ModelAndView.
*/
|拦截时机：在HandlerAdapter 处理器适配器调用handler处理器（即Controller控制器）之后，在DispatcherServlet前端控制器借助ViewResolver视图解析器获取到ModelAndView对象后，但是View视图还未被渲染之前。此时：最终的View视图还未被响应给浏览器客户端。
|作用方式：逆序处理执行链对应的请求对象
default void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,@Nullable ModelAndView modelAndView) throws Exception {
//空方法
}
/*
Callback after completion of request processing, that is, after rendering
the view. Will be called on any outcome of handler execution, thus allows
for proper resource cleanup.
*/
|拦截时机：在HTTP请求处理完毕，即：View视图被渲染给客户端浏览器之后被调用
|作用方式：在执行链对象内部调用，允许做一些适当的资源清理操作。
default void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler,
@Nullable Exception ex) throws Exception {
}
2.2.2 通过实现HandlerInterceptor接口定义拦截器
通过实现HandlerInterceptor接口中的3个default方法，可以自定义拦截器。
在SpringBoot中，HandlerInterceptor 拦截器接口对象交由Spring容器管理，因此需要通过@Component注解进行标注。定义一个拦截器方式如下：
//注解-将拦截器交由Spring容器管理
@Component
public class SelfInterceptor implements HandlerInterceptor {
//methods
/**
* 关于HandlerInterceptor接口
* 实现此接口的子类,可以自定义执行链的处理.
* 当前Web应用可以注册任意数量的自定义拦截器,每一个拦截器都可以用于处理一组特定的请求.
* 这种方式实现的拦截器,无需改动处理器(控制器层)的具体实现.
* Workflow interface that allows for customized handler execution chains.
* Applications can register any number of existing or custom interceptors
* for certain groups of handlers, to add common preprocessing behavior
* without needing to modify each handler implementation.
*/
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
System.out.println("接收请求路径时处理:"+request.getRequestURI());
return false;
}
@Override
public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
System.out.println("响应请求路径前处理:"+request.getRequestURI());
}
@Override
public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
System.out.println("响应请求路径后处理:"+request.getRequestURI());
}
}
2.2.3 WebMvcConfigurer接口与拦截器注册
通过实现HandlerInterceptor接口，配合@Component固然可以自定义一个拦截器，并将其交由Spring容器进行管理，但是并未告诉Spring容器何时调用这个拦截器对象、也没有明确这个拦截器对象用来拦截或者不拦截哪些HTTP请求。
这就需要通过实现WebMvcConfigurer接口，配合@Configuration注解，对拦截器进行注册。
2.2.3.1 WebMvcConfigurer接口介绍
实现WebMvcConfigurer接口的子类,可以基于@EnableWebMvc注解,通过重写接口中的default方法,来修改SpringMVC的默认配置。
这些默认配置例如：
PathMatch路径匹配、AsyncSupport-异步请求支持、
DefaultServletHandling-处理Servlet容器未处理的所有url请求、
addFormatters-Converter和Formatter转换器定制、
addCorsMappings-全局跨域请求处理
configureViewResolvers-视图解析器定制、
getValidator-验证器、
addInterceptors-添加拦截器等等,
每一类配置都对应着一个default方法,因此：根据实际需求,重写对应的default方法即可
2.2.3.2 通过实现WebMvcConfigurer接口注册拦截器
package com.xwd.config;
import com.xwd.interceptor.SelfInterceptor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.*;
/**
* @ClassName InterceptorConfig-拦截器配置
* @Description: com.xwd.config
* @Auther: xiwd
* @version: 1.0
*/
@Configuration
public class InterceptorConfig implements WebMvcConfigurer {
//properties
@Autowired
private SelfInterceptor selfInterceptor;
//methods
/**
* 注册拦截器
* 重写addInterceptors()方法
*/
@Override
public void addInterceptors(InterceptorRegistry registry) {
/* public InterceptorRegistration addInterceptor(HandlerInterceptor interceptor)
* 参数类型HandlerInterceptor-将Spring IOC管理的自定义拦截器实例放入即可
* /** 表示拦截所有路径(多重子路径)
* */
InterceptorRegistration interceptorRegistration = registry.addInterceptor(selfInterceptor).addPathPatterns("/**").excludePathPatterns("/student/test");
}
}
2.2.3.3 通过实现WebMvcConfigurer接口配置跨域访问
package com.xwd.config;
import com.xwd.interceptor.SelfInterceptor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.*;
/**
* @ClassName InterceptorConfig-拦截器配置
* @Description: com.xwd.config
* @Auther: xiwd
* @version: 1.0
*/
@Configuration
public class InterceptorConfig implements WebMvcConfigurer {
//methods
/**
* 跨域访问配置
* @param registry
*/
@Override
public void addCorsMappings(CorsRegistry registry){
registry.addMapping("/**")
.allowedOrigins("*")
.allowedMethods("GET", "HEAD", "POST", "PUT", "DELETE", "OPTIONS")
.maxAge(3600)
.allowedHeaders("*");
}
}
2.3 HandlerInterceptor接口如何产生作用？
HandlerInterceptor接口中的3个方法如何产生作用？
先看一下HandlerExecutionChain执行链类。
2.3.1 HandlerExecutionChain执行链对象与HandlerInterceptor拦截器
Handler execution chain, consisting of handler object and any handler interceptors.Returned by HandlerMapping’s getHandler method.
HandlerExecutionChain执行链对象与拦截器关系如下：
HandlerExecutionChain执行链对象是由一个Handler处理器对象和多个Interceptor拦截器对象组成的。
2.3.2 HandlerInterceptor拦截器的接口方法调用
此外，HandlerInterceptor拦截器的接口方法是通过HandlerExecutionChain执行链对象内部的三个成员方法所调用的，这3个成员方法分别如下：
[1] boolean applyPreHandle(HttpServletRequest request, HttpServletResponse response)
[2] void applyPostHandle(HttpServletRequest request, HttpServletResponse response, @Nullable ModelAndView mv)
[3] void triggerAfterCompletion(HttpServletRequest request, HttpServletResponse response, @Nullable Exception ex)。
在这三个方法内部，通过遍历HandlerExecutionChain执行链对象内部持有的多个拦截器，分别对preHandle、postHandle、afterCompletion方法进行调用。
/**
* Apply preHandle methods of registered interceptors.
* @return {@code true} if the execution chain should proceed with the
* next interceptor or the handler itself. Else, DispatcherServlet assumes
* that this interceptor has already dealt with the response itself.
*/
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;
}
/**
* Apply postHandle methods of registered interceptors.
*/
void applyPostHandle(HttpServletRequest request, HttpServletResponse response, @Nullable 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);
}
}
}
/**
* Trigger afterCompletion callbacks on the mapped HandlerInterceptors.
* Will just invoke afterCompletion for all interceptors whose preHandle invocation
* has successfully completed and returned true.
*/
void triggerAfterCompletion(HttpServletRequest request, HttpServletResponse response, @Nullable 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);
}
}
}
}
2.3.3 如何获取HandlerExecutionChain执行链对象?
那么，HandlerExecutionChain执行链对象是如何从HandlerMapping处理器映射器返回到DispatcherServlet前端控制器的呢？
在解释之前，先看一下DispatcherServlet前端控制器是如何分发HTTP请求的。
SpringMVC的前端控制器DispatcherServlet类中包含一个doDispatch()方法，该方法可以负责HTTP请求到Handler处理器的实际调度，所有的HTTP方法都会被此方法处理，并由HandlerAdapters 处理器适配器或者handler处理器自己决定可接收的HTTP请求。
代码如下：当前仅需要关注如下几点,
[1] 获取HandlerExecutionChain 执行链对象的方法，DispatcherServlet的doDispatch()方法中，会调用 另一个成员方法getHandler(processedRequest)方法，其中：processedRequest就是HttpServletRequest 对象；
[2] 成员方法getHandler()方法内部通过一个for循环，来遍历内部持有的HandlerMapping列表，调用HandlerMapping处理器映射器的getHandler()方法获取一个HandlerExecutionChain执行链对象，并将其返回；
[3] HandlerMapping处理器映射器的的getHandler()方法作用： Return a handler and any interceptors for this request.将当前HTTP请求封装过来的HttpServletRequest对象作为参数接收，找到它对应的处理器或者拦截器对象，将其返回。
doDispatch()方法大致的执行流程已给出注释。
protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
//HttpServletRequest对象
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.
//调用getHandler()方法，内部借助HandlerMappings处理器映射器对象获取执行链对象
mappedHandler = getHandler(processedRequest);
//如果执行链为空-调用noHandlerFound()
if (mappedHandler == null) {
noHandlerFound(processedRequest, response);
return;
}
// mappedHandler.getHandler()-获取Handler处理器对象
// 将Handler处理器对象交由HandlerAdapter处理器适配器
HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
// Process last-modified header, if supported by the handler.
//获取HTTP请求方式，例如：GET, POST, or PUT等
String method = request.getMethod();
//根据请求方式来做进一步处理
boolean isGet = "GET".equals(method);
if (isGet || "HEAD".equals(method)) {
long lastModified = ha.getLastModified(request, mappedHandler.getHandler());
//为当前的request, response对——创建ServletWebRequest对象
if (new ServletWebRequest(request, response).checkNotModified(lastModified) && isGet) {
return;
}
}
//判断执行链对象是否需要处理下一个Handler或者Interceptor
if (!mappedHandler.applyPreHandle(processedRequest, response)) {
return;
}
// Actually invoke the handler.
//通过HandlerAdapter 处理器适配器调用handle()方法，实际调用handler处理器（controller控制器），对request请求进行处理，并由Handler处理器返回一个ModelAndView对象
mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
if (asyncManager.isConcurrentHandlingStarted()) {
return;
}
//将ModelAndView对象应用到当前request对象上
applyDefaultViewName(processedRequest, mv);
//通过执行链调用applyPostHandle，内部调用HandlerInterceptor接口的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) {
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);
}
}
}
}
/**
* Return the HandlerExecutionChain for this request.
* <p>Tries all handler mappings in order.
* @param request current HTTP request
* @return the HandlerExecutionChain, or {@code null} if no handler could be found
*/
@Nullable
protected HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
if (this.handlerMappings != null) {
for (HandlerMapping mapping : this.handlerMappings) {
HandlerExecutionChain handler = mapping.getHandler(request);
if (handler != null) {
return handler;
}
}
}
return null;
}
2.3.4 总结
DispatcherServlet前端控制器接收到HandlerMapping处理器映射器返回的一个执行链HandlerExecutionChain对象（该对象是在前端控制器的doPost（）->getHandler（）方法中，通过遍历HandlerMapping列表，由列表元素调用getHandler()方法返回），HandlerExecutionChain包含多个Handler处理器对象和一组拦截器interceptor对象。
DispatcherServlet在获取到执行链对象之后，就可以通过执行链中的三个成员方法：applyPreHandle、applyPostHandle、triggerAfterCompletion，对拦截器对象（即：HandlerInterceptor接口实例）被重写的接口方法发起调用，对HTTP请求进行拦截操作。而接口方法被调用的时机，在2.2中已经介绍过。
3. 拦截器
基于以上认知，可以知道：HandlerInterceptor拦截器接口隶属于SpringMVC的一部分，无论是在基于Spring，还是Spring Boot搭建的web项目中，都可以进行配置使用。
其使用流程如下：
[1] 通过实现HandlerInterceptor接口定义拦截器；
[2] 将HandlerInterceptor拦截器交由Spring容器管理；
[3] 注册HandlerInterceptor拦截器，明确拦截器可以拦截哪一类HTTP请求。
3.1 Spring+Spring MVC拦截器实现
以Spring+Spring MVC项目为例，进行拦截器实现。
3.1.1 案例：基于token进行接口访问拦截
在前后端分离的项目中，例如前端通过Vue技术栈+Axios开发，而Axios默认是无状态的，后端无法通过HttpSession记录用户登陆状态，从而判断用户是否可以执行某些请求操作。此时，就需要通过使用一些特殊方法记录用户登陆状态，而jwt就是一种实现方式。
jwt官方地址：点击此处。
JWT，全称为：JSON Web Token，基于JSON对象，定义了一种轻量级的、自包含（self-contained）方式的安全信息传输方式。通过数字签名，这种JSON信息可以进行验证，从而用于实现权限控制（Authorization）或者信息交换（Information Exchange）。
JSON Web Token由三部分组成：header-头部、payload-载荷、Signature-签名，各部分之间通过.点进行分隔，例如：
eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJleHAiOjE2NDg3NTEyNDcsImVtYWlsIjoiWHdkOTQ5MjY0QDE2My5jb20ifQ.F_zCAasNiBdbVaVg3eKo3I5NIFTzh_mErDeJOhQhP5o
更多介绍可以查看官网介绍。
基于token进行接口访问拦截，需要通过定义拦截器，利用jwt（JSON Web Token）技术，基于token进行用户后端接口访问权限的认证。
对于没有携带token值的HTTP请求，默认拒绝该请求；对于携带token值的HTTP请求，接受并进行相应的处理操作。
3.1.2 引入jwt依赖
先在pom.xml中引入jwt依赖。
<!--JWT-->
<dependency>
<groupId>com.auth0</groupId>
<artifactId>java-jwt</artifactId>
<version>3.18.3</version>
</dependency>
3.1.3 编写jwt工具类
先在pom.xml中引入jwt依赖。
package com.xwd.util;
import com.auth0.jwt.JWT;
import com.auth0.jwt.JWTCreator;
import com.auth0.jwt.algorithms.Algorithm;
import com.auth0.jwt.interfaces.DecodedJWT;
import java.util.Calendar;
import java.util.HashMap;
import java.util.Map;
/**
* @ClassName JWTUtil
* @Description: com.xwd.util
* @Auther: xiwd
* @version: 1.0
*/
public class JWTUtil {
//properties
private static final String SIGN="eyJwc3dkIjoiWQiOiJyb290In0!@ds";
//methods
/**
* 根据传入信息生成Token
* header.payload.Signature
* @param mapinfo 携带用户信息的map集合
*/
public static String genereteToken(Map<String,String> mapinfo){
Calendar instance = Calendar.getInstance();
//有效期为3小时
instance.add(Calendar.MINUTE,60*3);
//map用户存储claim——声明的信息
Map<String,Object> map=new HashMap<>();
//生成token
JWTCreator.Builder builder = JWT.create();
//添加payload
mapinfo.forEach((k,v)->{
builder.withClaim(k,v);
});
//指定令牌过期时间
builder.withExpiresAt(instance.getTime());
//指定算法-生成token
String token = builder.sign(Algorithm.HMAC256(SIGN));
return token;
}
/**
* 验证token的合法性
* @param token token令牌值
* throw 抛出异常-表示验证失败
*/
public synchronized static void decodeToken(String token){
JWT.require(Algorithm.HMAC256(SIGN)).build().verify(token);
}
/**
* 获取token信息的方法
* @param token token令牌值
* @return DecodedJWT对象
* throw 抛出异常-表示验证失败
*/
public synchronized static DecodedJWT getTokenInfo(String token){
DecodedJWT decodedJWT = JWT.require(Algorithm.HMAC256(SIGN)).build().verify(token);
return decodedJWT;
}
}
3.1.4 使用Jwt工具类
在用户登录时，自动生成一个token值信息，将其返回给前端，保存到localStorage中，之后每次向后端发起请求时，将其添加到请求头中，以便于后端验证。
@RequestMapping(value = "/POST/login",method = RequestMethod.POST)
@ResponseBody
public Map<String, Object> login(@RequestParam(value = "uname")String username,
@RequestParam(value = "pswd")String password){
System.out.println("login");
Map<String,Object> resMap=new HashMap<>();
//判断用户名和密码是否为空
if (StrUtil.isEmpty(username)||StrUtil.isEmpty(password)){
resMap.put("state",0);
resMap.put("msg","登陆失败-信息填写不完整");
return resMap;
}
//查询符合条件的用户是否存在
User user = userService.selectUser(username, password);
if(user==null){
resMap.put("state",-1);
resMap.put("msg","登陆失败-账户或密码错误");
return resMap;
}
//判断当前账户是否可用
if (user.getState()!=0){
//登录成功，创建Token值
HashMap<String, String> map = new HashMap<>();
map.put("email",username);
//调用jwt工具类，生成token
String token = JWTUtil.genereteToken(map);
resMap.put("state",1);
resMap.put("msg","登陆成功");
resMap.put("token",token);
resMap.put("user",username);
return resMap;
}else {
//state==0,表示[账户禁用]
resMap.put("state",-2);
resMap.put("msg","登陆失败,账户不存在被禁用!");
return resMap;
}
}
3.1.5 定义拦截器
通过实现HandlerInterceptor 接口，自定义拦截器。
package com.xwd.interceptor;
import com.auth0.jwt.exceptions.AlgorithmMismatchException;
import com.auth0.jwt.exceptions.SignatureVerificationException;
import com.auth0.jwt.exceptions.TokenExpiredException;
import com.auth0.jwt.interfaces.DecodedJWT;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.xwd.util.JWTUtil;
import org.springframework.web.servlet.DispatcherServlet;
import org.springframework.web.servlet.HandlerExecutionChain;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.PrintWriter;
import java.util.HashMap;
import java.util.Map;
/**
* @ClassName JWTInterceptor
* @Description: com.xwd.interceptor
* @Auther: xiwd
* @version: 1.0
*/
public class JWTInterceptor implements HandlerInterceptor {
//methods
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
//获取HttpServletRequest请求头中携带的token信息
String token = request.getHeader("token");
Map<String,Object> infoMap = new HashMap<>();
try{
//token验证
DecodedJWT tokenInfo = JWTUtil.getTokenInfo(token);
//添加返回信息
infoMap.put("state",true);
infoMap.put("msg","验证成功");
return true;
}catch (SignatureVerificationException e){
e.printStackTrace();
infoMap.put("msg","无效签名");
infoMap.put("state",false);
}catch (TokenExpiredException e){
infoMap.put("msg","token已过期");
infoMap.put("state",false);
}catch (AlgorithmMismatchException e){
infoMap.put("msg","算法不一致");
infoMap.put("state",false);
}catch (Exception e){
infoMap.put("msg","无效签名");
infoMap.put("state",false);
}
//将Map转为JSON返回给前端
ObjectMapper objectMapper = new ObjectMapper();
String mapInfoJson = objectMapper.writeValueAsString(infoMap);
response.setContentType("application/json;charset=UTF-8");
response.setCharacterEncoding("UTF-8");
PrintWriter writer = response.getWriter();
writer.write(mapInfoJson);
return false;
}
}
3.1.6 配置拦截器
在springMVC-context.xml配置文件中配置拦截器。
<!--拦截器配置-->
<mvc:interceptors>
<!-- 拦截除了用户注册/登录、发送邮箱验证码之外的——所有请求-->
<mvc:interceptor>
<mvc:mapping path="/**"/>
<mvc:exclude-mapping path="/user/POST/register"/>
<mvc:exclude-mapping path="/user/POST/login"/>
<mvc:exclude-mapping path="/sender/GET/email"/>
<mvc:exclude-mapping path="/**/*.js"/>
<mvc:exclude-mapping path="/upload/**"/>
<bean class="com.xwd.interceptor.JWTInterceptor"></bean>
</mvc:interceptor>
</mvc:interceptors>
3.1.7 前端请求头添加token信息
如果为Vue+Axios，可以通过Axios配置拦截器，为每次的HTTP请求头加上本地存储的token信息，交由后端的HandlerInterceptor拦截器实现子类JWTInterceptor 进行token校验。
Axios拦截器介绍：官网地址，主要是在每一个请求或响应被 then 或 catch 处理前拦截它们。 示例如下：
// 添加请求拦截器
axios.interceptors.request.use(function (config) {
// 在发送请求之前做些什么
return config;
}, function (error) {
// 对请求错误做些什么
return Promise.reject(error);
});
// 添加响应拦截器
axios.interceptors.response.use(function (response) {
// 对响应数据做点什么
return response;
}, function (error) {
// 对响应错误做点什么
return Promise.reject(error);
});
自定义前端拦截器，可以在main.js文件中添加如下代码：
import axios from 'axios'
// Vue.prototype.$axios = axios
axios.defaults.baseURL = 'http://localhost:8010/stasys_v3/'
//axios-添加请求拦截器interpetor
axios.interceptors.request.use(
function(config) {
//在发送请求之前,从localStorage获取token
var token = localStorage.getItem('token')
//判断token是否为空
if (token && token != '') {
//不为空则添加token信息到请求头
config.headers['token'] = token
}
return config
},
function(err) {
//错误处理
return Promise.reject(err)
}
)
//挂载axios
Vue.prototype.$axios = axios
也可以基于token为router路由配置导航守卫，在页面跳转时进行安全验证，这个看自己的需求。
3.1 SpringBoot 拦截器实现
参见2.2.3部分的举例即为SpringBoot中拦截器的简单实现。
1558
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
