自定义filter与interceptor

1.Filter

它依赖于servlet容器。它可以对几乎所有请求进行过滤。使用过滤器的目的，是用来做一些过滤操作，获取我们想要获取的数据，比如：对传入的request、response提前过滤掉一些信息，或者提前设置一些参数，然后再传入servlet或者Controller进行业务逻辑操作。

通常用的场景是：在过滤器中修改字符编码（CharacterEncodingFilter）、在过滤器中修改HttpServletRequest的一些参数（XSSFilter(自定义过滤器)），如：过滤低俗文字、危险字符等。

2.Interceptor

它依赖于web框架，在SpringMVC中就是依赖于SpringMVC框架。在实现上，基于Java的反射机制。

属于面向切面编程（AOP）的一种运用，就是在service或者一个方法前，调用一个方法，或者在方法后，调用一个方法，比如动态代理就是拦截器的简单实现，在调用方法前打印出字符串（或者做其它业务逻辑的操作），也可以在调用方法后打印出字符串，甚至在抛出异常的时候做业务逻辑的操作。

由于拦截器是基于web框架的调用，因此可以使用Spring的依赖注入（DI）进行一些业务操作，同时一个拦截器实例在一个controller生命周期之内可以多次调用。拦截器可以对静态资源的请求进行拦截处理。

3. 对比

1、Filter是基于函数回调（doFilter()方法）的，而Interceptor则是基于Java反射的（AOP思想）。

2、Filter依赖于Servlet容器，而Interceptor不依赖于Servlet容器。

3、Filter对几乎所有的请求起作用，而Interceptor只能对action请求起作用。

4、Interceptor可以访问Action的上下文，值栈里的对象，而Filter不能。

5、在action的生命周期里，Interceptor可以被多次调用，而Filter只能在容器初始化时调用一次。

6、Filter在过滤是只能对request和response进行操作，而interceptor可以对request、response、handler、modelAndView、exception进行操作。

4. 程序示例

kotlin 的springboot项目

4.1 Filter

import org.apache.catalina.connector.RequestFacade
import java.io.IOException
import javax.servlet.*
import javax.servlet.annotation.WebFilter

@WebFilter(urlPatterns = ["/test/*"])
class RootCustomerFilter : Filter {
    @Throws(IOException::class, ServletException::class)
    override fun doFilter(servletRequest: ServletRequest, servletResponse: ServletResponse, filterChain: FilterChain) {
        println(servletRequest.localAddr)
        println((servletRequest as RequestFacade).requestURI)
        filterChain.doFilter(servletRequest, servletResponse)
    }

    @Throws(ServletException::class)
    override fun init(filterConfig: FilterConfig) {
        super.init(filterConfig)
    }

    override fun destroy() {
        super.destroy()
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

这是一个自定义的filter，实现FIlter接口。在doFilter方法中进行处理，改变请求的内容。
除了要在类上添加@WebFilter注解，指定要过滤的路径外，还要在启动类配置注解@ServletComponentScan(basePackages = [“com.example.filterinterceptor.filter”])指定filter的位置，这样就可以使用到此filter。

4.2 Interceptor

import org.springframework.web.servlet.HandlerInterceptor
import org.springframework.web.servlet.ModelAndView
import java.lang.Exception
import javax.servlet.http.HttpServletRequest
import javax.servlet.http.HttpServletResponse

class CustomerInterceptor : HandlerInterceptor{

    override fun preHandle(request: HttpServletRequest, response: HttpServletResponse, handler: Any): Boolean {
        println("this is preHandle into ...")
        return super.preHandle(request, response, handler)
    }

    override fun postHandle(
        request: HttpServletRequest,
        response: HttpServletResponse,
        handler: Any,
        modelAndView: ModelAndView?
    ) {
        super.postHandle(request, response, handler, modelAndView)
    }

    override fun afterCompletion(
        request: HttpServletRequest,
        response: HttpServletResponse,
        handler: Any,
        ex: Exception?
    ) {
        super.afterCompletion(request, response, handler, ex)
    }
}
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
30
31

定义了拦截器之后，还需要配置：

import com.example.filterinterceptor.interceptor.CustomerInterceptor
import org.springframework.context.annotation.Configuration
import org.springframework.web.servlet.config.annotation.InterceptorRegistry
import org.springframework.web.servlet.config.annotation.WebMvcConfigurationSupport


@Configuration
class WebConfig: WebMvcConfigurationSupport() {

    override fun addInterceptors(registry: InterceptorRegistry) {
        super.addInterceptors(registry)

        val pathPatterns = "/test/**"

        val excludePathPatterns = "/api/**"

        registry.addInterceptor(CustomerInterceptor()).addPathPatterns(pathPatterns).excludePathPatterns(excludePathPatterns)
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

这样就可以使用此拦截器，对请求进行处理了。