请求拦截之filter、interceptor、aop

最新推荐文章于 2024-08-29 17:15:40 发布
最新推荐文章于 2024-08-29 17:15:40 发布
阅读量452 收藏 1
点赞数
分类专栏： Java 文章标签： spring aop filter
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_55891090/article/details/114851546
版权

文章目录

1 场景

web程序中，对用户的请求，经常会对请求进行拦截处理，常用的处理方式如下：

  • Filter
  • Interceptor
  • AOP

本文基于SpringBoot的web程序，进行这三种拦截方式的说明。

2 区别

三种拦截方式的区别如下：

依赖Servlet容器Spring WebSpring
基于实现回调机制反射机制(AOP思想)动态代理
类别FilterInterceptorAOP
实现方式实现接口Filter实现接口HandlerInterceptor注解@Aspect
作用范围所有URL请求(可过滤)所有Controller的action
包括自己定义的和其他组件定义的		spring的bean(可过滤)
可操作数据原始Http请求信息：
ServletRequest request,
ServletResponse response		(1)Http请求信息：
HttpServletRequest request,
HttpServletResponse response,

(2)springMvc执行的方法信息：
HandlerMethod handlerMethod

(3)返回结果(执行Action方法后，不报错)：
ModelAndView modelAndView

(4)异常信息(执行Action方法后)：
Exception ex		请求参数
返回结果
异常信息
不可操作数据执行方法相关信息ResponseBody的返回结果http请求信息
相关方法doFilterpreHandle
postHandle
afterCompletion@		@Aspect
@Pointcut
@Before
@After
@Around
用途字符编码，
鉴权操作，
防重复提交
记录执行时间，
脱敏信息、
过滤敏感词、
多租户切换
…		字符编码
鉴权操作
防重复提交
异常记录
…		日志记录
异常记录
数据源切换
请求埋点
…

3 请求顺序

基于SpringBoot的web程序，Filter、Interceptor、Aop的请求顺序如下：

Filter->Interceptor->AOP->Controller

请求顺序.png

4 版本

4.1 maven依赖

Filter和Interceptor有spring-boot-starter-web依赖即可：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <version>2.2.9.RELEASE</version>
</dependency>

AOP依赖的aspectJ需要额外的maven依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
    <version>2.2.9.RELEASE</version>
</dependency>
4.2 测试Controller
package com.pdd.module.lanjie.controller;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.HashMap;
import java.util.Map;

@RestController
@RequestMapping("/my")
public class MyController {
    
    @RequestMapping("test")
    public Map<String,Object> test(String userName, String age) {
        String message = "[Controller Action]：userName=" + userName + "；age=" + age;
        System.out.println(message);
        Map<String,Object> map = new HashMap<>();
        map.put("success",true);
        map.put("message",message);
        return map;
    }
}

5 Filter代码实现

5.1 说明

（1）实现接口

实现接口：javax.servlet.Filter

（2）核心方法

public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException;
5.2 定义

（1） 定义Filter

package com.pdd.module.lanjie.filter;

import javax.servlet.*;
import java.io.IOException;
import java.util.Date;

/**
 * 计算执行时间Filter
 */
public class TimerFilter implements Filter {
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        long begin = new Date().getTime();
        System.out.println("[Filter-Time]：进入Filter");
        // 执行servlet方法（如拦截请求，不执行Servlet，可不执行此方法）
        chain.doFilter(request, response);
        long end = new Date().getTime();
        System.out.println("[Filter-Time]：结束Filter，共" + (end - begin) + "毫秒");
    }
}

（2）配置

package com.pdd.module.lanjie.filter.config;

import com.pdd.module.lanjie.filter.TimerFilter;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.Arrays;

@Configuration
public class WebFilterConfig {
    @Bean
    public FilterRegistrationBean timerFilter() {
        FilterRegistrationBean registrationBean = new FilterRegistrationBean();
        // 设置：实现类
        registrationBean.setFilter(new TimerFilter());
        // 设置：UrlPatterns
        registrationBean.setUrlPatterns(Arrays.asList("/*"));
        // 设置：优先级
        registrationBean.setOrder(1);
        return registrationBean;
    }
}
5.3 测试

（1）测试请求

http://localhost:8080/my/test?userName=张三&age=23

（2）输出结果

[Filter-Time]：进入Filter
[Controller Action]：userName=张三；age=23
[Filter-Time]：结束Filter，共90毫秒
5.4 配置顺序
// 设置：优先级
registrationBean.setOrder(1);

6 HandlerInterceptor代码实现

6.1 说明

（1）实现接口

实现接口：org.springframework.web.servlet.HandlerInterceptor

（2）核心方法

// 调用Controller方法之前
boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception;

// 调用Controller方法之后（不抛出异常）
void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,@Nullable ModelAndView modelAndView) throws Exception;

// 调用Controller方法之后（无论是否抛出异常）
void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler,@Nullable Exception ex) throws Exception;
6.2 定义

（1）定义Interceptor

package com.pdd.module.lanjie.interceptor;

import com.alibaba.fastjson.JSONObject;
import org.springframework.stereotype.Component;
import org.springframework.web.method.HandlerMethod;
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;

/**
 * 鉴权Interceptor
 */
@Component
public class AuthInterceptor implements HandlerInterceptor {
    
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("[Interceptor-auth]：进入preHandle");
        if (handler instanceof HandlerMethod) {
            HandlerMethod handlerMethod = (HandlerMethod) handler;
            System.out.println("[Interceptor-auth]：访问信息=" + handlerMethod.getShortLogMessage());
            // 获取head鉴权信息
            String sign = request.getHeader("sign");
            if (!"123456".equals(sign)) {
                // 鉴权不通过
                response.setCharacterEncoding("utf-8");
                response.setContentType("application/json; charset=utf-8");
                PrintWriter writer = response.getWriter();
                JSONObject jsonObject = new JSONObject();
                jsonObject.put("success", false);
                jsonObject.put("message", "鉴权失败");
                writer.write(jsonObject.toJSONString());
                writer.flush();
                writer.close();
                System.out.println("[Interceptor-auth]：----------鉴权不通过----------");
                System.out.println("[Interceptor-auth]：结束preHandle");
                return false;
            } else {
                // 鉴权通过
                System.out.println("[Interceptor-auth]：----------鉴权通过----------");
                System.out.println("[Interceptor-auth]：结束preHandle");
                return true;
            }
        }
        System.out.println("[Interceptor-auth]：结束preHandle");
        // 返回true为通过校验，返回false为不通过校验
        return true;
    }
    
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("[Interceptor-auth]：postHandle ModelAndView=" + JSONObject.toJSONString(modelAndView));
    }
    
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("[Interceptor-auth]：afterCompletion Exception=" + JSONObject.toJSONString(ex));
    }
}

（2）配置

package com.pdd.module.lanjie.interceptor.config;

import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

import javax.annotation.Resource;

/**
 * WEB统一配置
 */
@Component
public class GlobalWebMvcConfigurer implements WebMvcConfigurer {
    
    @Resource
    private HandlerInterceptor authInterceptor;
    
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        // 可按照顺序定义多个
        registry.addInterceptor(authInterceptor).addPathPatterns("/**");
        
        // 支持定义多个PathPattern和excludePathPatterns
        //registry.addInterceptor(xxxInterceptor).addPathPatterns("/xxx","/**").excludePathPatterns("/yyy","/zzz");
    }
}
6.3 测试
6.3.1 正向测试

（1）测试请求

http://localhost:8080/my/test?userName=张三&age=23

请求head：sign=123456

（2）输出结果

  • 控制台输出
[Interceptor-auth]：进入preHandle
[Interceptor-auth]：访问信息=com.pdd.module.lanjie.controller.MyController#test[2 args]
[Interceptor-auth]：----------鉴权通过----------
[Interceptor-auth]：结束preHandle
[Controller Action]：userName=张三；age=23
[Interceptor-auth]：postHandle ModelAndView=null
[Interceptor-auth]：afterCompletion Exception=null
  • 请求结果
{
    "success": true,
    "message": "[Controller Action]：userName=张三；age=23"
}
6.3.2 逆向测试

（1）测试请求

http://localhost:8080/my/test?userName=张三&age=23

请求head：无

（2）输出结果

  • 控制台输出
[Interceptor-auth]：进入preHandle
[Interceptor-auth]：访问信息=com.pdd.module.lanjie.controller.MyController#test[2 args]
[Interceptor-auth]：----------鉴权不通过----------
[Interceptor-auth]：结束preHandle
  • 请求结果
{
    "success": false,
    "message": "鉴权失败"
}
6.4 配置顺序
public void addInterceptors(InterceptorRegistry registry) {
    // 可按照顺序定义多个
    registry.addInterceptor(xxxInterceptor).addPathPatterns(xxx);
    registry.addInterceptor(yyyInterceptor).addPathPatterns(yyy);
}

7 AOP代码实现

7.1 说明

相关注解

org.aspectj.lang.annotation.Aspect
org.aspectj.lang.annotation.Pointcut
org.aspectj.lang.annotation.Before
org.aspectj.lang.annotation.After
org.aspectj.lang.annotation.Around
7.2 定义
import com.alibaba.fastjson.JSONObject;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

@Component
@Order(1)
@Aspect
public class LogAop {
    
    @Pointcut("execution(public * com.pdd..controller..*(..))")
    public void log() {
        
    }
    
    @Before("log()")
    public void doBefore(JoinPoint joinPoint) {
        System.out.println("[AOP-log]：Before");
    }
    
    @After("log()")
    public void doAfter(JoinPoint joinPoint) {
        System.out.println("[AOP-log]：After");
    }
    
    @Around("log()")
    public Object doAround(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("[AOP-log]：Around-进入");
        // 请求参数
        System.out.println("[AOP-log]：Around-请求参数="+ JSONObject.toJSONString(joinPoint.getArgs()));
        
        // 执行切面方法
        Object object = joinPoint.proceed();
        
        // 执行结果
        System.out.println("[AOP-log]：Around-执行结果="+ JSONObject.toJSONString(object));
        System.out.println("[AOP-log]：Around-结束");
        return object;
    }
    
}
7.3 测试

（1）测试请求

http://localhost:8080/my/test?userName=张三&age=23

（2）后台日志

[AOP-log]：Around-进入
[AOP-log]：Around-请求参数=["张三","23"]
[AOP-log]：Before
[Controller Action]：userName=张三；age=23
[AOP-log]：After
[AOP-log]：Around-执行结果={"success":true,"message":"[Controller Action]：userName=张三；age=23"}
[AOP-log]：Around-结束

（2）请求结果

{"success":true,"message":"[Controller Action]：userName=张三；age=23"}
7.4 配置顺序

通过spring注解org.springframework.core.annotation.Order，来定义顺序。

@Component
@Order(1)
@Aspect
public class LogAop {
	//......
}

8 汇总测试

同时打开上述的Filter，Interceptor，AOP，一起来拦截请求。

（1）测试请求

http://localhost:8080/my/test?userName=张三&age=23

请求head：sign=123456

（2）输出结果

  • 控制台输出
[Filter-Time]：进入Filter
[Interceptor-auth]：进入preHandle
[Interceptor-auth]：访问信息=com.pdd.module.lanjie.controller.MyController#test[2 args]
[Interceptor-auth]：----------鉴权通过----------
[Interceptor-auth]：结束preHandle
[AOP-log]：Around-进入
[AOP-log]：Around-请求参数=["张三","23"]
[AOP-log]：Before
[Controller Action]：userName=张三；age=23
[AOP-log]：After
[AOP-log]：Around-执行结果={"success":true,"message":"[Controller Action]：userName=张三；age=23"}
[AOP-log]：Around-结束
[Interceptor-auth]：postHandle ModelAndView=null
[Interceptor-auth]：afterCompletion Exception=null
[Filter-Time]：结束Filter，共326毫秒

将输出内容，进行标注，和3 请求顺序，部分讲解的一致。

1615296824839.png

  • 请求结果
{
    "success": true,
    "message": "[Controller Action]：userName=张三；age=23"
}
水煮鱼又失败了
关注
专栏目录
Spring HandlerInterceptor、Spring AOP、Servlet Filter 三者的区别及源码解析
u012200494的博客
07-25 569
Spring AOP在日常java开发中经常用到，那么作为Servlet Filter升级版 拦截器 他们之前有什么区别呢？
Spring 拦截器Interception 和 AOP 做全局处理的使用方式与使用场景分析
橘子汁的博客
08-06 1416
简介： Interceptor和aop：依赖spring框架，基于java反射和动态代理实现，只能拦截controller的请求，可以获取ioc容器中的bean 拦截顺序：Interception > AOP > 具体执行的方法 > AOP > @ControllerAdvice > Interception Interceptor Interceptor是依赖于Spring框架，是aop的一种表现，基于Java的动态代理实现的。 使用步骤： 声明拦截器的类：通过实现 Han
Spring：过滤器filter、拦截器interceptor、和AOP的区别与联系
热门推荐
琦彦
01-18 2万+
Filter过滤器 过滤器拦截web访问url地址。 严格意义上讲，filter只是适用于web中，依赖于Servlet容器，利用Java的回调机制进行实现。 Filter过滤器：和框架无关，可以控制最初的http请求，但是更细一点的类和方法控制不了。 过滤器可以拦截到方法的请求和响应(ServletRequest request, ServletResponse response)，并对...
Filter,Interceptor,AOP
花明的博客
04-20 462
一个请求先后经历Filter,Interceptor,AOP的过程： 一个请求过来 ，先进行过滤器处理，看程序是否受理该请求 。 过滤器放过后 ， 程序中的拦截器进行处理 处理完后进入被 AOP动态代理重新编译过的主要业务类进行处理 ===========before doFilter1 ===========before doFilter2 ===========HandlerInterc...
filter、interceptor、aop
liupeng_qwert的专栏
09-18 528
Filter interceptor aop 实现 高级servlet，依赖Web容器 Spring框架 拦截类型 只能拦截controller 只能拦截controller 可以拦截rpc调用 在哪配置 web.xml springMvc上下文 执行顺序 ...
Filter Interceptor Aop
qq_34253002的博客
11-12 585
过滤器 拦截器 AOP切面 拦截颗粒：过滤器 < 拦截器 < AOP切面 拦截顺序：过滤器 》拦截器 》AOP切面 过滤器 拦截URL,拦截的最前沿,适合公用性强的拦截逻辑,对服务性能影响最小[登录] 拦截器 拦截URL, AOP切面 拦截包、类、方法、参数 ...
浅谈SpringMVC的拦截器（Interceptor）和Servlet 的过滤器（Filter）的区别与联系 及SpringMVC 的配置文件
08-18
在本文中，我们将深入探讨SpringMVC的拦截器(Interceptor)和Servlet的过滤器(Filter)之间的差异和联系，以及如何配置SpringMVC的拦截器。理解这两者的区别对于开发高效且安全的Web应用程序至关重要。 首先，让我们...
拦截器（Interceptor）与过滤器（Filter）
最新发布
是木子啦~
08-29 800
拦截器是面向切面（AOP）编程中应用的一种统一处理方案，就是在你的Controller、Servie或者一个Method调用一个Method，或者在Method调用一个Method之后，统一的进行处理的方案，基于Java的反射机制。拦截器，在AOP（Aspect-Oriented Programming）中可以用于在某个方法或者字段被访问之前，进行拦截，然后在之前或者之后加入某些统一的处理方法。拦截是AOP的一种具象的实现方式。
过滤器（Filter）和 拦截器（Interceptor）的区别
m0_61601521的博客
02-19 596
拦截器 SpringMVC中的拦截器，相当于web开发中的过滤器Filter，用于对Controller进行预处理(前置增强)和后处理（后置增强） 多个拦截器形成的一条链，称为拦截器链（Interceptor chain） 当访问被拦截的（具体的目标Controller）方法时，拦截器链中的拦截器就会按照之前定义的顺序被调用 拦截器也是AOP思想的具体实现 拦截器，在进入 controller之前拦截。 实现HandlerIntercept
浅谈SpringMVC中Interceptor和Filter区别
08-26
浅谈SpringMVC中Interceptor和Filter区别 SpringMVC中Interceptor和Filter是两个重要的概念，它们都是用来处理...Interceptor主要用于拦截用户请求，进行处理，而Filter主要用于过滤字符编码、做一些业务逻辑判断。
SpringBoot中使用过滤器(Filter)和拦截器(Interceptor)案例
10-12
本案例主要想借助代码案例阐述以下技术实现及原理 1、在SpringBoot中如何实现自定义过滤器(Filter)和拦截器(Interceptor) 2、通过执行案例了解多个过滤器和拦截器的执行顺序 【本案例包含源码以及可执行的jar文件，源码文件建议使用IDEA进行导入查看学习，建议使用CURL命令进行URI请求。 在通过Google Chrome进行URI请求时Filter的doFilter中的输出(sout)语句会被打印两次，原因是Chrome在进行请求URI的时同时请求了http://localhost:8080/favicon.ico可以使用Charles (Web Debugging Proxy)工具进行拦截调试】 如有问题可留言。
聊聊 filter，interceptor,aop
weixin_30474613的博客
07-08 98
总结：filter,interceptor,aop,的思想其实都是对一些公用的东西的 抽取。 从范围来讲：filter 是最外层，对容器的 url 全部有用，如静态 文件，action 等，可获取容器的一些内容，只能用于Web程序中 是Servlet规范规定。 interceptor 只对 actio...
一篇文章说清楚Filter（过滤器）、Interceptor（拦截器）和AOP（切面儿）
weixin_50989469的博客
07-04 1477
Filter、Interceptor、AOP都是用于实现应用横切关注点的技术手段，通过这些技术，可以将横切关注点的代码从核心业务逻辑中解耦，使得代码更加清晰和可维护，同时也提高了代码的复用性。但是三者的应用场景还是有些区别的，Filter主要用于处理HTTP请求和响应，在Servlet容器中工作，可以实现如日志记录、安全性过滤、跨域请求处理等；Interceptor主要用于在Spring MVC中拦截方法调用，允许在方法执行前后添加额外逻辑，用于实现权限拦截、日志记录、事务管理等；
AOP（面向切面编程）、Filter（过虑器）、Interceptor（拦截器）
无知人生，记录点滴
05-07 1万+
AOP（面向切面编程）      面向切面编程（AOP是Aspect Oriented Program的首字母缩写） ，我们知道，面向对象的特点是继承、多态和封装。而封装就要求将功能分散到不同的对象中去，这在软件设计中往往称为职责分配。实际上也就是说，让不同的类设计不同的方法。这样代码就分散到一个个的类中去了。这样做的好处是降低了代码的复杂程度，使类可重用。      但是人们也发现，在分散代码的...
Filter、Interceptor、AOP 学习笔记
舟舟哥的博客
03-26 167
Filter、Interceptor、AOP 学习笔记 Filter过滤器 1、过滤器拦截web访问url地址。 2、严格意义上讲，filter只是适用于web中，依赖于Servlet容器，利用Java的回调机制进行实现。 3、Filter过滤器：和框架无关，可以控制最初的http请求，但是更细一点的类和方法控制不了。 4、过滤器可以拦截到方法的请求和响应(ServletRequest reque...
Filter、Interceptor、Aop实现与区别
xiunai78的专栏
07-01 527
AOP使用的主要是动态代理 ， 过滤器使用的主要是函数回调；拦截器使用是反射机制 。 一个请求过来 ，先进行过滤器处理，看程序是否受理该请求 。 过滤器放过后 ， 程序中的拦截器进行处理 ，处理完后进入 被 AOP动态代理重新编译过的主要业务类进行处理 。 Filter：和框架无关，可以控制最初的http请求，但是更细一点的类和方法控制不了。 Interceptor：可以控制请求的控制器和方法，但...
什么是Filter，什么是Interceptor,他们的区别是什么，和AOP又是什么关系？
IT修真院：初学者转行到互联网的聚集地
05-11 470
这里是修真院前端小课堂，每篇分享文从 【背景介绍】【知识剖析】【常见问题】【解决方案】【编码实战】【扩展思考】【更多讨论】【参考文献】 八个方面深度解析前端知识/技能，本篇分享的是： 【什么是Filter，什么是Interceptor,他们的区别是什么，和AOP又是什么关系？】 标题： 【修真院java 小课堂】什么是Filter，什么是Interceptor,他们的区别是什么，和A...
浅谈：Filter（过滤器）与Interceptor（拦截器）和Spring AOP的区别？
u013456370的专栏
04-02 9564
Filter过滤器：拦截web访问url地址。 Interceptor拦截器：拦截以 .action结尾的url，拦截Action的访问。 Spring AOP拦截器：只能拦截Spring管理Bean的访问（业务层Service）
Aop-代理对象调用方法的拦截处理
weixin_42145727的博客
02-25 397
Aop-代理对象调用方法的拦截处理
.Filter 、Interceptor、AOP的区别
04-14
Filter、Interceptor、AOP都是JavaEE中常用的处理请求的技术，它们的作用略有不同： Filter是JavaEE标准中javax.servlet.Filter接口的实现，它可以对请求进行预处理和后处理，常用于鉴权、日志、字符集等过滤。 ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值