过滤器(filter)和拦截器(Interceptor)的区别以及使用场景

最新推荐文章于 2024-10-03 19:16:24 发布

JavaNice哥

最新推荐文章于 2024-10-03 19:16:24 发布

阅读量2.3k

点赞数 8

分类专栏： java 文章标签： jvm java

本文链接：https://blog.csdn.net/itscholar001/article/details/139347835

版权

java 专栏收录该内容

64 篇文章 3 订阅

订阅专栏

区别

1. 实现原理不同

过滤器和拦截器底层实现方式不相同，过滤器是基于函数回调的，拦截器则是基于Java的反射机制（动态代理）实现的。

2. 使用范围不同

过滤器实现的是 javax.servlet.Filter 接口，而这个接口是在Servlet规范中定义的，也就是说过滤器Filter 的使用要依赖于Tomcat等容器，导致它只能在web程序中使用。

而拦截器是一个Spring组件，并由Spring容器管理，并不依赖Tomcat等容器，是可以单独使用的。不仅能应用在web程序中，也可以用于Application、Swing等程序中。

3. 触发时机不同

过滤器和拦截器的触发时机不同。

如上图所示，过滤器Filter是在请求进入容器后，但在进入servlet之前进行预处理，请求结束是在servlet处理完以后。

拦截器 Interceptor 是在请求进入servlet后，在进入Controller之前进行预处理的，Controller 中渲染了对应的视图之后请求结束。

4. 拦截的请求范围不同

Filter对所有访问进行增强，Interceptor仅针对SpringMVC的访问进行增强。

0x02 使用场景

过滤器对所有请求都生效，更加适合做一些通用功能。

拦截器可以细粒度地控制拦截路径，适合做一些偏重业务地功能。

1. 过滤器使用场景

spring security就是使用的过滤器，因为作为一个通用的安全框架不应该耦合其他web框架的元素。很显然拦截器是spring mvc或struts等框架提供的，如果基于拦截器势必耦合这些框架，就做不到通用了。

2. 拦截器使用场景

mybatis plus的分页查询就是基于拦截器实现的。

示例代码

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
   <modelVersion>4.0.0</modelVersion>

   <groupId>top.lrshuai.fli</groupId>
   <artifactId>fli</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>

   <name>springboot-filter-listener-interceptor</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.6.RELEASE</version>
      <relativePath/> <!-- lookup parent from repository -->
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
   </properties>

   <dependencies>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter</artifactId>
      </dependency>
      
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-web</artifactId>
      </dependency>

      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
      </dependency>
      
      <!-- 热部署 -->
      <dependency>  
          <groupId>org.springframework.boot</groupId>  
          <artifactId>spring-boot-devtools</artifactId>  
          <!-- optional=true,依赖不会传递，该项目依赖devtools；之后依赖myboot项目的项目如果想要使用devtools，需要重新引入 -->  
          <optional>true</optional>
      </dependency> 
      
   </dependencies>

   <build>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>
   </build>


</project>

package top.lrshuai.fli;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.web.servlet.ServletComponentScan;

/**
 * @ServletComponentScan 扫描我们自定义的servlet
 * @author tyro
 *
 */
@ServletComponentScan
@SpringBootApplication
public class SpringbootFilterListenerInterceptorApplication {

   public static void main(String[] args) {
      SpringApplication.run(SpringbootFilterListenerInterceptorApplication.class, args);
   }
}

package top.lrshuai.fli.controller;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

@RestController
public class TestController {

   @RequestMapping("/test")
   public String test(){
      System.out.println("这是test请求里面的方法");
      return "this is test page";
   }
   
   @RequestMapping("/login")
   public String login(){
      System.out.println("这是在login方法里创建一个session试试");
      ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes())
      .getRequest().getSession().setAttribute("user", "auth");
      
      return "login success";
   }
   
   @RequestMapping("/logout")
   public String logout(){
      System.out.println("这是在logout方法里销毁session试试");
      ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes())
      .getRequest().getSession().removeAttribute("user");
      ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes())
      .getRequest().getSession().invalidate();
      
      return "logout success";
   }
}

package top.lrshuai.fli.filter;

import java.io.IOException;

import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.annotation.WebFilter;


/**
 * 
 * 使用注解标注过滤器
 * @WebFilter将一个实现了javax.servlet.Filter接口的类定义为过滤器
 * 属性filterName 声明过滤器的名称,可选
 * 属性urlPatterns指定要过滤 的URL模式,这是一个数组参数，可以指定多个。也可使用属性value来声明.(指定要过滤的URL模式是必选属性)
 */
@WebFilter(filterName="myFilter",urlPatterns={"/*"})
public class MyFilter implements Filter{

   @Override
   public void destroy() {
      System.out.println("myfilter 的 销毁方法");
   }

   @Override
   public void doFilter(ServletRequest arg0, ServletResponse arg1, FilterChain chain)
         throws IOException, ServletException {
      System.out.println("myfilter 的 过滤方法。这里可以执行过滤操作");
      //继续下一个拦截器
      chain.doFilter(arg0, arg1);
   }

   @Override
   public void init(FilterConfig arg0) throws ServletException {
      System.out.println("myfilter 的 初始化方法");
   }

}

package top.lrshuai.fli.interceptor;

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

import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
/**
 * 可以验证用户是否登录来拦截，没登陆返回false
 * @author tyro
 *
 */
public class LoginInterceptor implements HandlerInterceptor{

   @Override
   public void afterCompletion(HttpServletRequest arg0, HttpServletResponse arg1, Object arg2, Exception arg3)
         throws Exception {
      System.out.println("LoginInterceptor 在整个请求结束之后被调用，也就是在DispatcherServlet 渲染了对应的视图之后执行（主要是用于进行资源清理工作）");
   }

   @Override
   public void postHandle(HttpServletRequest arg0, HttpServletResponse arg1, Object arg2, ModelAndView arg3)
         throws Exception {
      System.out.println("LoginInterceptor  请求处理之后进行调用，但是在视图被渲染之前（Controller方法调用之后）");
   }

   @Override
   public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object arg2) throws Exception {
      System.out.println("LoginInterceptor 在请求处理之前进行调用（Controller方法调用之前） 这里是拦截的操作");
      String user = (String) request.getSession().getAttribute("user");
      System.out.println("user="+user);
      if(null == user || "".equals(user)){
         response.setContentType("text/html;charset=utf-8");
         response.getWriter().println("你没登陆，请去登录页面：<a href='http://localhost:8080/login'>登录</a>。");
         return false;
      }
      return true;
   }

}

package top.lrshuai.fli.interceptor;

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

import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

public class MyInterceptor implements HandlerInterceptor{

   @Override
   public void afterCompletion(HttpServletRequest arg0, HttpServletResponse arg1, Object arg2, Exception arg3)
         throws Exception {
      System.out.println("MyInterceptor 在整个请求结束之后被调用，也就是在DispatcherServlet 渲染了对应的视图之后执行（主要是用于进行资源清理工作）");
   }

   @Override
   public void postHandle(HttpServletRequest arg0, HttpServletResponse arg1, Object arg2, ModelAndView arg3)
         throws Exception {
      System.out.println("MyInterceptor  请求处理之后进行调用，但是在视图被渲染之前（Controller方法调用之后）");     
   }

   @Override
   public boolean preHandle(HttpServletRequest arg0, HttpServletResponse arg1, Object arg2) throws Exception {
      System.out.println("MyInterceptor 在请求处理之前进行调用（Controller方法调用之前）这里是拦截的操作");
      return true;
   }

}

package top.lrshuai.fli.interceptor;

import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;

@Configuration
public class WebConfigurer extends WebMvcConfigurerAdapter {

   @Override
   public void addInterceptors(InterceptorRegistry registry) {
       // addPathPatterns 用于添加拦截规则
      // excludePathPatterns 排除拦截
      registry.addInterceptor(new LoginInterceptor()).addPathPatterns("/**").excludePathPatterns("/login");
      registry.addInterceptor(new MyInterceptor()).addPathPatterns("/**");
      super.addInterceptors(registry);
   }
}

package top.lrshuai.fli.listener;

import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
import javax.servlet.annotation.WebListener;

@WebListener
public class ServletListener implements ServletContextListener{

   @Override
   public void contextDestroyed(ServletContextEvent arg0) {
      System.out.println("servlet 销毁时调用");
   }

   @Override
   public void contextInitialized(ServletContextEvent arg0) {
      System.out.println("servlet 初始化时调用");
   }

}

package top.lrshuai.fli.listener;

import javax.servlet.annotation.WebListener;
import javax.servlet.http.HttpSessionEvent;
import javax.servlet.http.HttpSessionListener;

@WebListener
public class SessionListener implements HttpSessionListener{

   @Override
   public void sessionCreated(HttpSessionEvent arg0) {
      System.out.println("监听 创建session");
   }

   @Override
   public void sessionDestroyed(HttpSessionEvent arg0) {
      System.out.println("监听 销毁session");
   }

}