SpringBoot之拦截器Interceptor详解及登录校验

我就是我 2024-03-23 14:40 81阅读 0赞

**目录**

1.快速入门

2.Interceptor详解

2.1 拦截路径

2.2 执行流程

3.登录校验- Interceptor

--------------------

### 1.快速入门 ###

什么是拦截器？

*  是一种动态拦截方法调用的机制，类似于过滤器。
 *  拦截器是Spring框架中提供的，用来动态拦截控制器方法的执行。

拦截器的作用：

*  拦截请求，在指定方法调用前后，根据业务需要执行预先设定的代码。

在拦截器当中，我们通常也是做一些通用性的操作，比如：我们可以通过拦截器来拦截前端发起的请求，将登录校验的逻辑全部编写在拦截器当中。在校验的过程当中，如发现用户登录了(携带JWT令牌且是合法令牌)，就可以直接放行，去访问spring当中的资源。如果校验时发现并没有登录或是非法令牌，就可以直接给前端响应未登录的错误信息。

下面我们通过快速入门程序，来学习下拦截器的基本使用。拦截器的使用步骤和过滤器类似，也分为两步：

1.  定义拦截器
2.  注册配置拦截器

**自定义拦截器：**实现HandlerInterceptor接口，并重写其所有方法

//自定义拦截器
    @Component
    public class LoginCheckInterceptor implements HandlerInterceptor {
        //目标资源方法执行前执行。 返回true：放行    返回false：不放行
        @Override
        public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
            System.out.println("preHandle .... ");
            
            return true; //true表示放行
        }
    
        //目标资源方法执行后执行
        @Override
        public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
            System.out.println("postHandle ... ");
        }
    
        //视图渲染完毕后执行，最后执行
        @Override
        public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
            System.out.println("afterCompletion .... ");
        }
    }

> 注意：
> 
> preHandle方法：目标资源方法执行前执行。 返回true：放行 返回false：不放行
> 
> postHandle方法：目标资源方法执行后执行
> 
> afterCompletion方法：视图渲染完毕后执行，最后执行

**注册配置拦截器**：实现WebMvcConfigurer接口，并重写addInterceptors方法

@Configuration  
    public class WebConfig implements WebMvcConfigurer {
    
        //自定义的拦截器对象
        @Autowired
        private LoginCheckInterceptor loginCheckInterceptor;
    
        
        @Override
        public void addInterceptors(InterceptorRegistry registry) {
           //注册自定义拦截器对象
            registry.addInterceptor(loginCheckInterceptor).addPathPatterns("/**");//设置拦截器拦截的请求路径（ /** 表示拦截所有请求）
        }
    }

重新启动SpringBoot服务，打开postman测试：

![ea4d21dcebe3485295430ae9aea71a79.png][]

接下来我们再来做一个测试：将拦截器中返回值改为false

使用postman，再次点击send发送请求后，没有响应数据，说明请求被拦截了没有放行

![983ca2933a7348a7957a1bb1122d0e1f.png][]

### 2.Interceptor详解 ###

拦截器的入门程序完成之后，接下来我们来介绍拦截器的使用细节。拦截器的使用细节我们主要介绍两个部分：

1.  拦截器的拦截路径配置
2.  拦截器的执行流程

#### 2.1 拦截路径 ####

首先我们先来看拦截器的拦截路径的配置，在注册配置拦截器的时候，我们要指定拦截器的拦截路径，通过`addPathPatterns("要拦截路径")`方法，就可以指定要拦截哪些资源。

在入门程序中我们配置的是`/**`，表示拦截所有资源，而在配置拦截器时，不仅可以指定要拦截哪些资源，还可以指定不拦截哪些资源，只需要调用`excludePathPatterns("不拦截路径")`方法，指定哪些资源不需要拦截。

@Configuration  
    public class WebConfig implements WebMvcConfigurer {
    
        //拦截器对象
        @Autowired
        private LoginCheckInterceptor loginCheckInterceptor;
    
        @Override
        public void addInterceptors(InterceptorRegistry registry) {
            //注册自定义拦截器对象
            registry.addInterceptor(loginCheckInterceptor)
                    .addPathPatterns("/**")//设置拦截器拦截的请求路径（ /** 表示拦截所有请求）
                    .excludePathPatterns("/login");//设置不拦截的请求路径
        }
    }

在拦截器中除了可以设置`/**`拦截所有资源外，还有一些常见拦截路径设置：

<table> 
 <thead> 
  <tr> 
   <th>拦截路径</th> 
   <th>含义</th> 
   <th>举例</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>/*</td> 
   <td>一级路径</td> 
   <td>能匹配/depts，/emps，/login，不能匹配 /depts/1</td> 
  </tr> 
  <tr> 
   <td>/**</td> 
   <td>任意级路径</td> 
   <td>能匹配/depts，/depts/1，/depts/1/2</td> 
  </tr> 
  <tr> 
   <td>/depts/*</td> 
   <td>/depts下的一级路径</td> 
   <td>能匹配/depts/1，不能匹配/depts/1/2，/depts</td> 
  </tr> 
  <tr> 
   <td>/depts/**</td> 
   <td>/depts下的任意级路径</td> 
   <td>能匹配/depts，/depts/1，/depts/1/2，不能匹配/emps/1</td> 
  </tr> 
 </tbody> 
</table>

下面主要来演示下`/**`与`/*`的区别：

*  修改拦截器配置，把拦截路径设置为`/*`

@Configuration 
    public class WebConfig implements WebMvcConfigurer {
    
        //拦截器对象
        @Autowired
        private LoginCheckInterceptor loginCheckInterceptor;
    
        @Override
        public void addInterceptors(InterceptorRegistry registry) {
           //注册自定义拦截器对象
            registry.addInterceptor(loginCheckInterceptor)
                    .addPathPatterns("/*")
                    .excludePathPatterns("/login");//设置不拦截的请求路径
        }
    }

使用postman测试：[http://localhost:8080/emps/1][http_localhost_8080_emps_1]

![be1f0768413f44359fd5e03422c78635.png][]

控制台没有输出拦截器中的日志信息，说明`/*`没有匹配到拦截路径`/emp/1` 。

![17a3914bd8ee447592a04b2e300a39b2.png][]

#### 2.2 执行流程 ####

介绍完拦截路径的配置之后，接下来我们再来介绍拦截器的执行流程。通过执行流程，大家就能够清晰的知道过滤器与拦截器的执行时机。

![f0af41c634cf45b1bc24593bec4f59fd.png][]

*  当我们打开浏览器来访问部署在web服务器当中的web应用时，此时我们所定义的过滤器会拦截到这次请求。拦截到这次请求之后，它会先执行放行前的逻辑，然后再执行放行操作。而由于我们当前是基于springboot开发的，所以放行之后是进入到了spring的环境当中，也就是要来访问我们所定义的controller当中的接口方法。
 *  Tomcat并不识别所编写的Controller程序，但是它识别Servlet程序，所以在Spring的Web环境中提供了一个非常核心的Servlet：DispatcherServlet（前端控制器），所有请求都会先进行到DispatcherServlet，再将请求转给Controller。
 *  当我们定义了拦截器后，会在执行Controller的方法之前，请求被拦截器拦截住。执行`preHandle()`方法，这个方法执行完成后需要返回一个布尔类型的值，如果返回true，就表示放行本次操作，才会继续访问controller中的方法；如果返回false，则不会放行（controller中的方法也不会执行）。
 *  在controller当中的方法执行完毕之后，再回过来执行`postHandle()`这个方法以及`afterCompletion()` 方法，然后再返回给DispatcherServlet，最终再来执行过滤器当中放行后的这一部分逻辑的逻辑。执行完毕之后，最终给浏览器响应数据。

接下来我们就来演示下过滤器和拦截器同时存在的执行流程：

*  开启LoginCheckInterceptor拦截器

@Component
    public class LoginCheckInterceptor implements HandlerInterceptor {
        @Override
        public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
            System.out.println("preHandle .... ");
            
            return true; //true表示放行
        }
    
        @Override
        public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
            System.out.println("postHandle ... ");
        }
    
        @Override
        public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
            System.out.println("afterCompletion .... ");
        }
    }

@Configuration  
    public class WebConfig implements WebMvcConfigurer {
    
        //拦截器对象
        @Autowired
        private LoginCheckInterceptor loginCheckInterceptor;
    
        @Override
        public void addInterceptors(InterceptorRegistry registry) {
            //注册自定义拦截器对象
            registry.addInterceptor(loginCheckInterceptor)
                    .addPathPatterns("/**")//拦截所有请求
                    .excludePathPatterns("/login");//不拦截登录请求
        }
    }

*  开启DemoFilter过滤器

@WebFilter(urlPatterns = "/*") 
    public class DemoFilter implements Filter {
        @Override
        public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
            System.out.println("DemoFilter   放行前逻辑.....");
    
            //放行请求
            filterChain.doFilter(servletRequest,servletResponse);
    
            System.out.println("DemoFilter   放行后逻辑.....");
        }
    }

重启SpringBoot服务后，清空日志，打开Postman，测试查询部门：

![9fbba50fadb44c7385141cdca8646fb8.png][]

![2bd0ce19162949e1956da928e1561377.png][]

以上就是拦截器的执行流程。通过执行流程分析，大家应该已经清楚了过滤器和拦截器之间的区别，其实它们之间的区别主要是两点：

*  接口规范不同：过滤器需要实现Filter接口，而拦截器需要实现HandlerInterceptor接口。
 *  拦截范围不同：过滤器Filter会拦截所有的资源，而Interceptor只会拦截Spring环境中的资源。

### 3.登录校验- Interceptor ###

登录校验的业务逻辑以及操作步骤我们前面已经分析过了，和登录校验Filter过滤器当中的逻辑是完全一致的。现在我们只需要把这个技术方案由原来的过滤器换成拦截器interceptor就可以了。

**登录校验拦截器**

//自定义拦截器
    @Component //当前拦截器对象由Spring创建和管理
    @Slf4j
    public class LoginCheckInterceptor implements HandlerInterceptor {
        //前置方式
        @Override
        public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
            System.out.println("preHandle .... ");
            //1.获取请求url
            //2.判断请求url中是否包含login，如果包含，说明是登录操作，放行
    
            //3.获取请求头中的令牌（token）
            String token = request.getHeader("token");
            log.info("从请求头中获取的令牌：{}",token);
    
            //4.判断令牌是否存在，如果不存在，返回错误结果（未登录）
            if(!StringUtils.hasLength(token)){
                log.info("Token不存在");
    
                //创建响应结果对象
                Result responseResult = Result.error("NOT_LOGIN");
                //把Result对象转换为JSON格式字符串 (fastjson是阿里巴巴提供的用于实现对象和json的转换工具类)
                String json = JSONObject.toJSONString(responseResult);
                //设置响应头（告知浏览器：响应的数据类型为json、响应的数据编码表为utf-8）
                response.setContentType("application/json;charset=utf-8");
                //响应
                response.getWriter().write(json);
    
                return false;//不放行
            }
    
            //5.解析token，如果解析失败，返回错误结果（未登录）
            try {
                JwtUtils.parseJWT(token);
            }catch (Exception e){
                log.info("令牌解析失败!");
    
                //创建响应结果对象
                Result responseResult = Result.error("NOT_LOGIN");
                //把Result对象转换为JSON格式字符串 (fastjson是阿里巴巴提供的用于实现对象和json的转换工具类)
                String json = JSONObject.toJSONString(responseResult);
                //设置响应头
                response.setContentType("application/json;charset=utf-8");
                //响应
                response.getWriter().write(json);
    
                return false;
            }
    
            //6.放行
            return true;
        }

**注册配置拦截器**

@Configuration  
    public class WebConfig implements WebMvcConfigurer {
        //拦截器对象
        @Autowired
        private LoginCheckInterceptor loginCheckInterceptor;
    
        @Override
        public void addInterceptors(InterceptorRegistry registry) {
           //注册自定义拦截器对象
            registry.addInterceptor(loginCheckInterceptor)
                    .addPathPatterns("/**")
                    .excludePathPatterns("/login");
        }
    }

**JWT工具类**

public class JwtUtils {
    
        private static String signKey = "itheima";//签名密钥
        private static Long expire = 43200000L; //有效时间
    
        /**
         * 生成JWT令牌
         * @param claims JWT第二部分负载 payload 中存储的内容
         * @return
         */
        public static String generateJwt(Map<String, Object> claims){
            String jwt = Jwts.builder()
                    .addClaims(claims)//自定义信息（有效载荷）
                    .signWith(SignatureAlgorithm.HS256, signKey)//签名算法（头部）
                    .setExpiration(new Date(System.currentTimeMillis() + expire))//过期时间
                    .compact();
            return jwt;
        }
    
        /**
         * 解析JWT令牌
         * @param jwt JWT令牌
         * @return JWT第二部分负载 payload 中存储的内容
         */
        public static Claims parseJWT(String jwt){
            Claims claims = Jwts.parser()
                    .setSigningKey(signKey)//指定签名密钥
                    .parseClaimsJws(jwt)//指定令牌Token
                    .getBody();
            return claims;
        }
    }

[ea4d21dcebe3485295430ae9aea71a79.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/2a9e475d12ce476999ed94f3378b1436.png
[983ca2933a7348a7957a1bb1122d0e1f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/7d7a974d031745cd90a9eaa6765b5fe6.png
[http_localhost_8080_emps_1]: http://localhost:8080/emps/1
[be1f0768413f44359fd5e03422c78635.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/d09d7c7333794d80894ae5cf41ccd1be.png
[17a3914bd8ee447592a04b2e300a39b2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/121acc211d5a4d248ca5e0f5719122a3.png
[f0af41c634cf45b1bc24593bec4f59fd.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/c416a3feda644951a6eb62af33f2e101.png
[9fbba50fadb44c7385141cdca8646fb8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/0066c9dd9ce841e8b252a42fb42bcc7a.png
[2bd0ce19162949e1956da928e1561377.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/df62a15dad4f44b29b71576d675661cb.png