Spring filter和拦截器的区别和执行顺序

Posted

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Spring filter和拦截器的区别和执行顺序相关的知识，希望对你有一定的参考价值。

1.Filter过滤器只过滤jsp文件不过滤action请求解决方案


解决办法：在web.xml中将filter的配置放在struts2配置的前面。


2.拦截器与Filter的区别


spring的拦截器与Servlet的Filter有相似之处，比如二者都是AOP编程思想的体现，都能实现权限检查、日志记录等。不同的是：


使用范围不同：Filter是Servlet规范规定的，只能用于Web程序中。而拦截器既可以用于Web程序，也可以用于Application、Swing程序中。


规范不同：Filter是在Servlet规范中定义的，是Servlet容器支持的。而拦截器是在Spring容器内的，是Spring框架支持的。


使用的资源不同：同其他的代码块一样，拦截器也是一个Spring的组件，归Spring管理，配置在Spring文件中，因此能使用Spring里的任何资源、对象，例如Service对象、数据源、事务管理等，通过IoC注入到拦截器即可；而Filter则不能。


深度不同：Filter在只在Servlet前后起作用。而拦截器能够深入到方法前后、异常抛出前后等，因此拦截器的使用具有更大的弹性。所以在Spring构架的程序中，要优先使用拦截器。


实际上Filter和Servlet极其相似，区别只是Filter不能直接对用户生成响应。实际上Filter里doFilter()方法里的代码就是从多个Servlet的service()方法里抽取的通用代码，通过使用Filter可以实现更好的复用。


filter是一个可以复用的代码片段，可以用来转换HTTP请求、响应和头信息。Filter不像Servlet，它不能产生一个请求或者响应，它只是修改对某一资源的请求，或者修改从某一的响应。


JSR中说明的是，按照多个匹配的Filter，是按照其在web.xml中配置的顺序来执行的。


所以这也就是，把自己的Filter或者其他的Filter（比如UrlRewrite的Filter）放在Struts的DispatcherFilter的前面的原因。因为，它们需要在请求被Struts2框架处理之前，做一些前置的工作。


当Filter被调用，并且进入了Struts2的DispatcherFilter中后，Struts2会按照在Action中配置的InterceptorStack中的Interceptor的顺序，来调用Interceptor。


3.servlet、filter、interceptor的执行顺序

@Override    
    public void doFilter(ServletRequest servletrequest,    
            ServletResponse servletresponse, FilterChain filterchain)    
            throws IOException, ServletException     
        System.out.println("in  filter 1.");    
        filterchain.doFilter(servletrequest, servletresponse);    
        System.out.println("outing filter 1");    
    

interceptor代码：

public String intercept(ActionInvocation actioninvocation) throws Exception     
    System.out.println("in logininterceptor");    
    String result=actioninvocation.invoke();    
    System.out.println("outing logininterceptor");    
    return result;    

action代码：

@Override      
public String execute() throws Exception       
    System.out.println("in loginaciton");    
    ActionContext context=ActionContext.getContext();    
    Map<String, Object> session=context.getSession();     
    session.put("userName", userName);      
        
    /* HttpServletRequest request = ServletActionContext.getRequest();  
    HttpSession session = request.getSession();  
    session.putValue("userName", userName);*/    
    System.out.println("outing loginaciton");    
    return SUCCESS;      

jsp代码：

<script type="text/javascript">       
   function submitForm()    
      document.getElementById("form1").submit();     
       
</script>    
    
</head>    
     
 <body>    
   This is Login page. <br>    
   <form action="<%=path %>/login2.action" method="post" id="form1" name="form1">    
      UserName:<input type="text" id="userName" name="userName"/><input type="button" value="submit" onclick="submitForm()" id="submit1" />    
   </form>    
 </body>

struts.xml

<struts>    
<package name="default" extends="struts-default" namespace="/">      
             
        <interceptors>    
            <interceptor name="MyInterceptor" class="Login.LoginInterceptor"></interceptor>    
            <interceptor-stack name="myInterceptorStack">    
                <interceptor-ref name="MyInterceptor"/>    
                <interceptor-ref name="defaultStack"/>    
            </interceptor-stack>    
        </interceptors>    
             
        <action name="login2" class="Login.LoginAction">      
                <result name="success">      
                   /Login/success.jsp      
                </result>    
                <interceptor-ref name="myInterceptorStack"></interceptor-ref>    
        </action>      
     
</package>    
</struts>

console:

in  filter 1.  
in logininterceptor  
in loginaciton  
outing loginaciton  
outing logininterceptor  
outing filter 1

3.servlet、filter的执行顺序

servlet代码：

public void init() throws ServletException      
    System.out.println("servlet初始化");    
     
    
public void doPost(HttpServletRequest request, HttpServletResponse response)            
throws ServletException, IOException      
    System.out.println("in servlet");    
    response.setContentType("text/html");     
    PrintWriter out = response.getWriter();     
    out.println("<!DOCTYPE HTML PUBLIC \\"-//W3C//DTD HTML 4.01 Transitional//EN\\">");     
    out.println("<HTML>");     
    out.println("    <HEAD><TITLE>A Servlet</TITLE></HEAD>");     
    out.println("    <BODY>");     
    out.print("        This is ");     
    out.print(this.getClass());     
    out.println(", using the POST method");          
         
    out.println("<br>");     
    String x = request.getParameter("x");     
    String y = request.getParameter("y");     
    out.println("x="+x);     
    out.println("<br>");     
    out.println("y="+y);     
    out.println("<br>");     
         
    out.println("    </BODY>");     
    out.println("</HTML>");     
    out.flush();     
    out.close();     
    System.out.println("outing servlet");    
       
   
public void destroy()          
    System.out.println("servlet销毁");    
    super.destroy();    

console:

servlet初始化  
in  filter 1.  
in servlet  
before HttpServletRequest  
after HttpServletRequest  
outing servlet  
outing filter 1  
当tomcat容器停止的时候，输出:servlet销毁

 参考技术A 在web.xml中将filter的配置放在struts2配置的前面。 参考技术B 在web.xml中将filter的配置放在struts2配置的前面。

java中过滤器和拦截器的区别

区别

1.使用范围和规范不同

  • filter是servlet规范规定的,只能用在web程序中.
  • 拦截器即可以用在web程序中, 也可以用于application, swing程序中, 是Spring容器内的, 是Spring框架支持的

2.触发时机不同

顺序: Filter-->Servlet-->Interceptor-->Controller

  • 过滤器是在请求进入容器后，但请求进入servlet之前进行预处理的。请求结束返回也是，是在servlet处理完后，返回给前端之前过滤器处理。
  • 拦截器是方法到达Controller层之前生效的

3.过滤器的实现基于回调函数。而拦截器（代理模式）的实现基于反射，代理分静态代理和动态代理，动态代理是拦截器的简单实现。

何时使用拦截器？何时使用过滤器？

  • 如果是非spring项目，那么拦截器不能用，只能使用过滤器。
  • 如果是处理controller前后，既可以使用拦截器也可以使用过滤器。
  • 如果是处理dispaterServlet前后，只能使用过滤器。

4.在action的生命周期中，拦截器可以多次被调用，而过滤器只能在容器初始化时被调用一次。

5.拦截器可以访问action上下文、值栈里的对象，而过滤器不能访问。

6.拦截器只能对action请求起作用，而过滤器则可以对几乎所有的请求起作用。

7.拦截器可以获取IOC容器中的各个bean，而过滤器就不行，在拦截器里注入一个service，可以调用业务逻辑。

SpringBoot使用过滤器

两种方式：
1、使用spring boot提供的FilterRegistrationBean注册Filter
2、使用原生servlet注解定义Filter
两种方式的本质都是一样的，都是去FilterRegistrationBean注册自定义Filter

封装Filter

package com.theeternity.common.baseFilter;

import javax.servlet.Filter;

/**
 * @program: ApiBoot
 * @description: 封装Filter
 * @author: TheEternity Zhang
 * @create: 2019-02-17 13:08
 */
public interface MappingFilter extends Filter {
    String[] addUrlPatterns();

    int order();
}

自定义Filter

package com.theeternity.beans.filterConfig;

import com.theeternity.common.baseFilter.MappingFilter;
import lombok.extern.slf4j.Slf4j;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import javax.servlet.*;
import javax.servlet.FilterConfig;
import java.io.IOException;

/**
 * @program: ApiBoot
 * @description: 权限过滤器
 * @author: TheEternity Zhang
 * @create: 2019-02-17 13:14
 */
public class AuthFilter implements MappingFilter {

    @Override
    public String[] addUrlPatterns() {
        return new String[]{"/*"};
    }

    @Override
    public int order() {
        return 0;
    }

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {

    }

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        filterChain.doFilter(servletRequest,servletResponse);
    }

    @Override
    public void destroy() {

    }

}

注册过滤器

package com.theeternity.beans.filterConfig;

import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
/**
 * @program: ApiBoot
 * @description: 注册过滤器
 * @author: TheEternity Zhang
 * @create: 2019-02-17 13:10
 */
@Configuration
public class FilterConfig {

    @Bean
    public FilterRegistrationBean registFilter() {
        FilterRegistrationBean registration = new FilterRegistrationBean();
        AuthFilter authFilter=new AuthFilter();
        registration.setFilter(authFilter);
        registration.addUrlPatterns(authFilter.addUrlPatterns());
        registration.setOrder(authFilter.order());
        registration.setName("AuthFilter");
        return registration;
    }
}

SpringBoot使用拦截器

封装Interceptor

package com.theeternity.common.baseInterceptor;

import org.springframework.web.servlet.HandlerInterceptor;

/**
 * @program: ApiBoot
 * @description: 封装Interceptor
 * @author: TheEternity Zhang
 * @create: 2019-02-15 17:49
 */
public interface MappingInterceptor extends HandlerInterceptor {
    String[] addPathPatterns();

    String[] excludePathPatterns();

    int order();
}

自定义Interceptor

package com.theeternity.beans.interceptorConfig;

import com.theeternity.common.baseInterceptor.MappingInterceptor;
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.ModelAndView;

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

/**
 * @program: BoxApi
 * @description: 跨域拦截器
 * @author: tonyzhang
 * @create: 2018-12-21 14:44
 */
@Component
public class CrossOriginInterceptor implements MappingInterceptor {

    @Override
    public String[] addPathPatterns() {
        return new String[]{"/**"};
    }

    @Override
    public String[] excludePathPatterns() {
        return new String[0];
    }

    @Override
    public int order() {
        return 0;
    }

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        logger.info("允许的头信息"+request.getHeader("Origin"));
        response.setHeader("Access-Control-Allow-Origin", "*");
        response.setHeader("Access-Control-Allow-Methods", "*");
        response.setHeader("Access-Control-Max-Age", "3600");
        response.setHeader("Access-Control-Allow-Headers", "Origin, X-Requested-With, Content-Type, Accept");
        //是否允许浏览器携带用户身份信息（cookie）
        response.setHeader("Access-Control-Allow-Credentials","true");
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {

    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler,Exception ex) throws Exception {

    }
}

注册Interceptor

package com.theeternity.beans.interceptorConfig;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

/**
 * @program: ApiBoot
 * @description: 拦截器注册
 * @author: TheEternity Zhang
 * @create: 2019-02-15 17:55
 */
@Configuration
public class InterceptorConfig implements WebMvcConfigurer {

    @Autowired
    private CrossOriginInterceptor crossOriginInterceptor;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
registry.addInterceptor(crossOriginInterceptor).addPathPatterns(crossOriginInterceptor.addPathPatterns());

    }
}

站在巨人的肩膀上摘苹果:

https://blog.csdn.net/heweimingming/article/details/79993591

https://www.jianshu.com/p/7bd0cad17f23

以上是关于Spring filter和拦截器的区别和执行顺序的主要内容，如果未能解决你的问题，请参考以下文章

Spring filter和拦截器的区别和执行顺序

拦截器(Interceptor)和过滤器(Filter)的区别和执行顺序)

拦截器（Interceptor）和过滤器（Filter）的执行顺序和区别

拦截器（Interceptor）和过滤器（Filter）的执行顺序和区别

过滤器（Filter）和拦截器（Interceptor）的执行顺序和区别

spring中过滤器（filter）、拦截器（interceptor）和切面（aop）的执行顺序