客官，有过滤器有拦截器，要哪一款？

一、这两种有啥区别？

二、怎么搞一个拦截器呢？

1、首先，写一个拦截器

import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

@Component
public class MyInterCeptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        。。。为所欲为
        return true;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

2、spring boot项目注册这个拦截器

import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurationSupport;
import javax.annotation.Resource;

@Configuration
public class MyMvcConfig extends WebMvcConfigurationSupport {

    @Resource
    private MyInterCeptor myInterCeptor;

    @Override
    protected void addInterceptors(InterceptorRegistry registry) {
        // addPathPatterns("/**") 表示拦截所有的请求，
        // excludePathPatterns("/login", "/register") 表示除了登陆与注册之外，因为登陆注册不需要登陆也可以访问
        //注册自己的拦截器,并设置拦截路径，拦截多个可以全一个list集合
        registry.addInterceptor(myInterCeptor).addPathPatterns("/**");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

@Configuration这个注解会自动帮我们注册。

搞掂晒。

三、过滤器怎么搞？

1、过滤器

import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;

public class MyFilter implements Filter {
    @Override
    public void init(javax.servlet.FilterConfig filterConfig) throws ServletException {
        System.out.println("MyFilter.init");
        System.out.println("  过滤器名：" + filterConfig.getFilterName());
    }

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        // do something 处理request 或response
        System.out.println("MyFilter.doFilter");

        if (servletRequest instanceof HttpServletRequest) {
            System.out.println("  URL:" + ((HttpServletRequest)servletRequest).getRequestURL());
        }

        // 调用filter链中的下一个filter
        filterChain.doFilter(servletRequest,servletResponse);
    }

    @Override
    public void destroy() {
        System.out.println("MyFilter.destroy");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

2、注册过滤器

import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class FilterConfig {

    @Bean
    public FilterRegistrationBean registrationBean() {
        FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean(new MyFilter());
        filterRegistrationBean.addUrlPatterns("/*");
        return filterRegistrationBean;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

四、过滤器与拦截器谁先执行？

答案是过滤器先执行。

2023.03.28
据说，过滤器、拦截器、AOP三者功能类似，但各有优势，从过滤器》拦截器》切面，拦截规则越来越细致，执行顺序依次是过滤器、拦截器、切面。一般情况下数据被过滤的时机越早对服务的性能影响越小，因此我们在编写相对比较公用的代码时，优先考虑过滤器，然后是拦截器，最后是AOP。

AOP使用的主要是动态代理，过滤器使用的主要是函数回调；拦截器使用是反射机制。一个请求过来，先进行过滤器处理，看程序是否受理该请求。过滤器放过后，程序中的拦截器进行处理，处理完后进入被 AOP动态代理重新编译过的主要业务类进行处理。

Filter：和框架无关，过滤器拦截的是URL，可以控制最初的http请求，但是更细一点的类和方法控制不了。
Interceptor：拦截器拦截的也是URL，拦截器有三个方法，相对于过滤器更加细致，有被拦截逻辑执行前、后等。
AOP：面向切面拦截的是类的元数据（包、类、方法名、参数等）相对于拦截器更加细致，而且非常灵活，拦截器只能针对URL做拦截，而AOP针对具体的代码，能够实现更加复杂的业务逻辑。

参考文章：
Spring Boot – Spring AOP原理及简单实现